//-----------------------------------------------------------------------------
//
//  $Logfile:: /Quake 2 Engine/Sin/code/game/scriptvariable.cpp               $
// $Revision:: 31                                                             $
//   $Author:: Aldie                                                          $
//     $Date:: 11/13/98 6:17p                                                 $
//
// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// $Log:: /Quake 2 Engine/Sin/code/game/scriptvariable.cpp                    $
//
// 31    11/13/98 6:17p Aldie
// Change str functions to be case insensitive
//
// 30    9/24/98 1:48a Jimdose
// Found source of memory leak.  Made ClearList delete each variable as it
// removes it.
//
// 29    9/21/98 4:21p Markd
// Put in archive functions and rewrote all archive routines
//
// 28    8/21/98 1:45a Markd
// Fixed Vector bug
//
// 27    8/20/98 6:09p Markd
// Added ToForward, ToRight, To Up for angle vectors
//
// 26    8/20/98 5:35p Markd
// Added cross product, dot product and length
//
// 25    8/20/98 4:31p Markd
// Added vector support
//
// 24    8/07/98 5:43p Jimdose
// Added isVariableCommand
//
// 23    8/06/98 5:19p Jimdose
// VarProcessCommand now uses ScriptThread's ProcessCommandFromEvent
//
// 22    7/26/98 10:43a Markd
// fixed archiving of scriptvariables
//
// 21    7/26/98 5:32a Markd
// Put in archive functions
//
// 20    7/24/98 4:52p Jimdose
// Added getcvar command to script
//
// 19    7/02/98 3:04p Jimdose
// Made append functions use str instead of char array
//
// 18    6/30/98 6:07p Jimdose
// Added versions of CreateVariable that accept Entity *'s and Vectors
// Added SetVariable with variations
//
// 17    6/27/98 4:24p Aldie
// Put an error check in coninput
//
// 16    6/18/98 8:47p Jimdose
// Added better event error handling
// Added source info to events
//
// 15    6/17/98 3:03p Markd
// Changed NumArgs back to previous behavior
//
// 14    6/10/98 7:53p Markd
// Made NumArgs behave correctly like argc
//
// 13    5/24/98 5:25p Jimdose
// Changed char *'s to const char *'s
//
// 12    4/20/98 6:04p Jimdose
// No longer round down value.
//
// 11    4/18/98 6:11p Aldie
// Added randomfloat, randomint, div, and mod.
//
// 10    3/27/98 6:25p Aldie
// Added coninput
//
// 9     3/24/98 8:54p Jimdose
// Added thread management script commands
//
// 8     3/23/98 1:31p Jimdose
// Revamped event and command system
//
// 7     3/02/98 8:49p Jimdose
// Changed the classid parameter of CLASS_DECLARATION to a quoted string so
// that you could have a NULL classid.
//
// 6     2/17/98 7:03p Jimdose
// Added ClearList
// Floats are rounded down to the nearest hundredth
//
// 5     2/03/98 10:47a Jimdose
// Updated to work with Quake 2 engine
//
// 3     11/23/97 3:11p Jimdose
// Mark: checked in to compile stuff
//
// 2     11/07/97 6:35p Jimdose
// Created file
//
// DESCRIPTION:
// Dynamic variable list for scripts.
//

#include "g_local.h"
#include "class.h"
#include "scriptvariable.h"
#include "scriptmaster.h"

Event EV_Var_Append( "append" );
Event EV_Var_AppendInt( "appendint" );
Event EV_Var_AppendFloat( "appendfloat" );
Event EV_Var_String( "string" );
Event EV_Var_ConInput( "coninput" );
Event EV_Var_RandomFloat( "randomfloat" );
Event EV_Var_RandomInteger( "randomint" );
Event EV_Var_Equals( "=" );
Event EV_Var_PlusEquals( "+=" );
Event EV_Var_MinusEquals( "-=" );
Event EV_Var_TimesEquals( "*=" );
Event EV_Var_DivideEquals( "/=" );
Event EV_Var_Div( "div" );
Event EV_Var_Mod( "mod" );
Event EV_Var_IfEqual( "ifequal" );
Event EV_Var_IfNotEqual( "ifnotequal" );
Event EV_Var_IfGreater( "ifgreater" );
Event EV_Var_IfGreaterEqual( "ifgreaterequal" );
Event EV_Var_IfLess( "ifless" );
Event EV_Var_IfLessEqual( "iflessequal" );
Event EV_Var_IfStrEqual( "ifstrequal" );
Event EV_Var_IfStrNotEqual( "ifstrnotequal" );
Event EV_Var_IfThreadActive( "ifthreadactive" );
Event EV_Var_IfThreadNotActive( "ifthreadnotactive" );
Event EV_Var_GetCvar( "getcvar" );
Event EV_Var_Vector( "vector" );
Event EV_Var_VectorIfEqual( "vector_ifequal" );
Event EV_Var_VectorIfNotEqual( "vector_ifnotequal" );
Event EV_Var_VectorAdd( "vector_add" );
Event EV_Var_VectorSubtract( "vector_subtract" );
Event EV_Var_VectorScale( "vector_scale" );
Event EV_Var_VectorDotProduct( "vector_dot" );
Event EV_Var_VectorCrossProduct( "vector_cross" );
Event EV_Var_VectorNormalize( "vector_normalize" );
Event EV_Var_VectorLength( "vector_length" );
Event EV_Var_VectorGetX( "vector_x" );
Event EV_Var_VectorGetY( "vector_y" );
Event EV_Var_VectorGetZ( "vector_z" );
Event EV_Var_VectorSetX( "vector_setx" );
Event EV_Var_VectorSetY( "vector_sety" );
Event EV_Var_VectorSetZ( "vector_setz" );
Event EV_Var_AnglesToForward( "angles_toforward" );
Event EV_Var_AnglesToRight( "angles_toright" );
Event EV_Var_AnglesToUp( "angles_toup" );

static void VarProcessCommand( Event* ev, int arg )
{
	ScriptThread* thread;

	thread = ev->GetThread();
	if( thread )
	{
		thread->ProcessCommandFromEvent( ev, arg );
	}
}

ResponseDef ScriptVariable::Responses[] =
{
	{ &EV_Var_Append, ( Response )& ScriptVariable::Var_Append },
	{ &EV_Var_AppendInt, ( Response )& ScriptVariable::Var_AppendInt },
	{ &EV_Var_AppendFloat, ( Response )& ScriptVariable::Var_AppendFloat },
	{ &EV_Var_String, ( Response )& ScriptVariable::Var_String },
	{ &EV_Var_ConInput, ( Response )& ScriptVariable::Var_ConInput },
	{ &EV_Var_RandomFloat, ( Response )& ScriptVariable::Var_RandomFloat },
	{ &EV_Var_RandomInteger, ( Response )& ScriptVariable::Var_RandomInteger },
	{ &EV_Var_Equals, ( Response )& ScriptVariable::Var_Equals },
	{ &EV_Var_PlusEquals, ( Response )& ScriptVariable::Var_PlusEquals },
	{ &EV_Var_MinusEquals, ( Response )& ScriptVariable::Var_MinusEquals },
	{ &EV_Var_TimesEquals, ( Response )& ScriptVariable::Var_TimesEquals },
	{ &EV_Var_DivideEquals, ( Response )& ScriptVariable::Var_DivideEquals },
	{ &EV_Var_Div, ( Response )& ScriptVariable::Var_Div },
	{ &EV_Var_Mod, ( Response )& ScriptVariable::Var_Mod },
	{ &EV_Var_IfEqual, ( Response )& ScriptVariable::Var_IfEqual },
	{ &EV_Var_IfNotEqual, ( Response )& ScriptVariable::Var_IfNotEqual },
	{ &EV_Var_IfGreater, ( Response )& ScriptVariable::Var_IfGreater },
	{ &EV_Var_IfGreaterEqual, ( Response )& ScriptVariable::Var_IfGreaterEqual },
	{ &EV_Var_IfLess, ( Response )& ScriptVariable::Var_IfLess },
	{ &EV_Var_IfLessEqual, ( Response )& ScriptVariable::Var_IfLessEqual },
	{ &EV_Var_IfStrEqual, ( Response )& ScriptVariable::Var_IfStrEqual },
	{ &EV_Var_IfStrNotEqual, ( Response )& ScriptVariable::Var_IfStrNotEqual },
	{ &EV_Var_IfThreadActive, ( Response )& ScriptVariable::Var_IfThreadActive },
	{ &EV_Var_IfThreadNotActive, ( Response )& ScriptVariable::Var_IfThreadNotActive },
	{ &EV_Var_GetCvar, ( Response )& ScriptVariable::Var_GetCvar },
	{ &EV_Var_Vector, ( Response )& ScriptVariable::Var_Vector },
	{ &EV_Var_VectorAdd, ( Response )& ScriptVariable::Var_Vector_Add },
	{ &EV_Var_VectorSubtract, ( Response )& ScriptVariable::Var_Vector_Subtract },
	{ &EV_Var_VectorScale, ( Response )& ScriptVariable::Var_Vector_Scale },
	{ &EV_Var_VectorNormalize, ( Response )& ScriptVariable::Var_Vector_Normalize },
	{ &EV_Var_VectorGetX, ( Response )& ScriptVariable::Var_Vector_GetX },
	{ &EV_Var_VectorGetY, ( Response )& ScriptVariable::Var_Vector_GetY },
	{ &EV_Var_VectorGetZ, ( Response )& ScriptVariable::Var_Vector_GetZ },
	{ &EV_Var_VectorSetX, ( Response )& ScriptVariable::Var_Vector_SetX },
	{ &EV_Var_VectorSetY, ( Response )& ScriptVariable::Var_Vector_SetY },
	{ &EV_Var_VectorSetZ, ( Response )& ScriptVariable::Var_Vector_SetZ },
	{ &EV_Var_VectorIfEqual, ( Response )& ScriptVariable::Var_Vector_IfEqual },
	{ &EV_Var_VectorIfNotEqual, ( Response )& ScriptVariable::Var_Vector_IfNotEqual },
	{ &EV_Var_VectorDotProduct, ( Response )& ScriptVariable::Var_Vector_DotProduct },
	{ &EV_Var_VectorCrossProduct, ( Response )& ScriptVariable::Var_Vector_CrossProduct },
	{ &EV_Var_VectorLength, ( Response )& ScriptVariable::Var_Vector_Length },
	{ &EV_Var_AnglesToForward, ( Response )& ScriptVariable::Var_Angles_ToForward },
	{ &EV_Var_AnglesToRight, ( Response )& ScriptVariable::Var_Angles_ToRight },
	{ &EV_Var_AnglesToUp, ( Response )& ScriptVariable::Var_Angles_ToUp },
	{ NULL, NULL }
};

CLASS_DECLARATION( Listener, ScriptVariable, NULL );

ScriptVariable::ScriptVariable()
{
	value = 0;
}

qboolean ScriptVariable::isVariableCommand( const char* name )
{
	int i;

	for( i = 0; ScriptVariable::Responses[ i ].event != NULL; i++ )
	{
		if( name != NULL && strcmp( ScriptVariable::Responses[ i ].event->getName(), name ) == 0 )
		{
			return true;
		}
	}

	return false;
}


void ScriptVariable::setName( const char* newname )
{
	name = newname;
}

const char* ScriptVariable::getName( void )
{
	return name.c_str();
}

const char* ScriptVariable::stringValue( void )
{
	return string.c_str();
}

void ScriptVariable::setString( const char* value )
{
	string = value;
}

void ScriptVariable::setStringValue( const char* newvalue )
{
	setString( newvalue );
	value = Sinatof( string.c_str() );
}

int ScriptVariable::intValue( void )
{
	return ( int )value;
}

void ScriptVariable::setIntValue( int newvalue )
{
	char text[ 128 ];

	value = ( float )newvalue;
	sprintf( text, "%d", newvalue );
	setString( text );
}

float ScriptVariable::floatValue( void )
{
	return value;
}

void ScriptVariable::setFloatValue( float newvalue )
{
	char text[ 128 ];

	value = newvalue;
	sprintf( text, "%f", newvalue );
	setString( text );
}

void ScriptVariable::setVectorValue( Vector newvector )
{
	char text[ 128 ];

	vec = newvector;
	sprintf( text, "(%f %f %f)", newvector.x, newvector.y, newvector.z );
	setString( text );
}

Vector ScriptVariable::vectorValue( void )
{
	return vec;
}

CLASS_DECLARATION( Class, ScriptVariableList, NULL );

ResponseDef ScriptVariableList::Responses[] =
{
	{ NULL, NULL }
};

ScriptVariableList::ScriptVariableList()
{}

ScriptVariableList::~ScriptVariableList()
{
	ClearList();
}


void ScriptVariableList::ClearList( void )
{
	int i;
	int num;
	ScriptVariable* var;

	num = NumVariables();
	for( i = num; i > 0; i-- )
	{
		var = GetVariable( i );
		RemoveVariable( var );
		delete var;
	}

	list.FreeObjectList();
}

void ScriptVariableList::AddVariable( ScriptVariable* var )
{
	if( VariableExists( var->getName() ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", var->getName() );
		return;
	}

	list.AddObject( var );
}

ScriptVariable* ScriptVariableList::CreateVariable( const char* name, float value )
{
	ScriptVariable* var;

	if( VariableExists( name ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", name );
		return GetVariable( name );
	}

	var = new ScriptVariable;
	var->setName( name );
	var->setFloatValue( value );
	list.AddObject( var );

	return var;
}

ScriptVariable* ScriptVariableList::CreateVariable( const char* name, int value )
{
	ScriptVariable* var;

	if( VariableExists( name ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", name );
		return GetVariable( name );
	}

	var = new ScriptVariable;
	var->setName( name );
	var->setIntValue( value );
	list.AddObject( var );

	return var;
}

ScriptVariable* ScriptVariableList::CreateVariable( const char* name, const char* text )
{
	ScriptVariable* var;

	if( VariableExists( name ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", name );
		return GetVariable( name );
	}

	var = new ScriptVariable;
	var->setName( name );
	var->setStringValue( text );
	list.AddObject( var );

	return var;
}

ScriptVariable* ScriptVariableList::CreateVariable( const char* name, Entity* ent )
{
	ScriptVariable* var;

	assert( ent );

	if( VariableExists( name ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", name );
		return GetVariable( name );
	}

	var = new ScriptVariable;
	var->setName( name );
	list.AddObject( var );

	if( !ent )
	{
		warning( "SetVariable", "Null entity\n" );

		// use the world
		var->setStringValue( "*0" );
	}
	else
	{
		var->setStringValue( va( "*%d", ent->entnum ) );
	}

	return var;
}

ScriptVariable* ScriptVariableList::CreateVariable( const char* name, Vector& vec )
{
	ScriptVariable* var;

	if( VariableExists( name ) )
	{
		warning( "AddVariable", "Variable %s already exists.\n", name );
		return GetVariable( name );
	}

	var = new ScriptVariable;
	var->setName( name );
	var->setStringValue( va( "(%f %f %f)", vec.x, vec.y, vec.z ) );
	list.AddObject( var );

	return var;
}

void ScriptVariableList::RemoveVariable( ScriptVariable* var )
{
	if( !list.ObjectInList( var ) )
	{
		warning( "RemoveVariable", "Variable %s does not exist.\n", var->getName() );
		return;
	}

	list.RemoveObject( var );
}

void ScriptVariableList::RemoveVariable( const char* name )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		warning( "RemoveVariable", "Variable %s does not exist.\n", name );
		return;
	}

	RemoveVariable( var );
}

qboolean ScriptVariableList::VariableExists( const char* name )
{
	int i;
	int num;
	ScriptVariable* var;

	num = list.NumObjects();
	for( i = 1; i <= num; i++ )
	{
		var = list.ObjectAt( i );
		if( !strcmp( var->getName(), name ) )
		{
			return true;
		}
	}

	return false;
}

ScriptVariable* ScriptVariableList::GetVariable( const char* name )
{
	int i;
	int num;
	ScriptVariable* var;

	num = list.NumObjects();
	for( i = 1; i <= num; i++ )
	{
		var = list.ObjectAt( i );
		if( !strcmp( var->getName(), name ) )
		{
			return var;
		}
	}

	return NULL;
}

int ScriptVariableList::NumVariables( void )
{
	return list.NumObjects();
}

ScriptVariable* ScriptVariableList::GetVariable( int num )
{
	return list.ObjectAt( num );
}

ScriptVariable* ScriptVariableList::SetVariable( const char* name, float value )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		var = new ScriptVariable;
		var->setName( name );
		list.AddObject( var );
	}

	var->setFloatValue( value );

	return var;
}

ScriptVariable* ScriptVariableList::SetVariable( const char* name, int value )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		var = new ScriptVariable;
		var->setName( name );
		list.AddObject( var );
	}

	var->setIntValue( value );

	return var;
}

ScriptVariable* ScriptVariableList::SetVariable( const char* name, const char* text )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		var = new ScriptVariable;
		var->setName( name );
		list.AddObject( var );
	}

	var->setStringValue( text );

	return var;
}

ScriptVariable* ScriptVariableList::SetVariable( const char* name, Entity* ent )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		var = new ScriptVariable;
		var->setName( name );
		list.AddObject( var );
	}

	if( !ent )
	{
		// use the world
		var->setStringValue( "*0" );
	}
	else
	{
		var->setStringValue( va( "*%d", ent->entnum ) );
	}

	return var;
}

ScriptVariable* ScriptVariableList::SetVariable( const char* name, const Vector& vec )
{
	ScriptVariable* var;

	var = GetVariable( name );
	if( !var )
	{
		var = new ScriptVariable;
		var->setName( name );
		list.AddObject( var );
	}

	var->setStringValue( va( "(%f %f %f)", vec.x, vec.y, vec.z ) );

	return var;
}

//****************************************************************************************
//
// Variable commands
//
//****************************************************************************************

void ScriptVariable::Var_Append( Event* ev )
{
	str newstring( string );
	newstring += ev->GetString( 1 );
	setStringValue( newstring.c_str() );
}

void ScriptVariable::Var_AppendInt( Event* ev )
{
	str newstring( string );
	newstring += va( "%d", ev->GetInteger( 1 ) );
	setStringValue( newstring.c_str() );
}

void ScriptVariable::Var_AppendFloat( Event* ev )
{
	str newstring( string );
	newstring += va( "%f", ev->GetFloat( 1 ) );
	setStringValue( newstring.c_str() );
}

void ScriptVariable::Var_String( Event* ev )
{
	setStringValue( ev->GetString( 1 ) );
}


void ScriptVariable::Var_ConInput( Event* ev )
{
	ScriptVariable* var;
	str varname( "console." );
	varname += ev->GetString( 1 );
	var = Director.GetExistingVariable( varname.c_str() );
	if( !var )
	{
		warning( "Var_ConInput", "Variable %s does not exist yet.\n", varname.c_str() );
		return;
	}
	setStringValue( var->stringValue() );
}

void ScriptVariable::Var_RandomFloat( Event* ev )
{
	setFloatValue( G_Random( ev->GetFloat( 1 ) ) );
}

void ScriptVariable::Var_RandomInteger( Event* ev )
{
	setIntValue( G_Random( ev->GetInteger( 1 ) ) );
}


void ScriptVariable::Var_Equals( Event* ev )
{
	setFloatValue( ev->GetFloat( 1 ) );
}

void ScriptVariable::Var_PlusEquals( Event* ev )
{
	setFloatValue( floatValue() + ev->GetFloat( 1 ) );
}

void ScriptVariable::Var_MinusEquals( Event* ev )
{
	setFloatValue( floatValue() - ev->GetFloat( 1 ) );
}

void ScriptVariable::Var_TimesEquals( Event* ev )
{
	setFloatValue( floatValue() * ev->GetFloat( 1 ) );
}

void ScriptVariable::Var_DivideEquals( Event* ev )
{
	setFloatValue( floatValue() / ev->GetFloat( 1 ) );
}

void ScriptVariable::Var_Div( Event* ev )
{
	setIntValue( floatValue() / ev->GetInteger( 1 ) );
}

void ScriptVariable::Var_Mod( Event* ev )
{
	setIntValue( intValue() % ev->GetInteger( 1 ) );
}


void ScriptVariable::Var_IfEqual( Event* ev )
{
	if( floatValue() == ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfNotEqual( Event* ev )
{
	if( floatValue() != ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfGreater( Event* ev )
{
	if( floatValue() > ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfGreaterEqual( Event* ev )
{
	if( floatValue() >= ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfLess( Event* ev )
{
	if( floatValue() < ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfLessEqual( Event* ev )
{
	if( floatValue() <= ev->GetFloat( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfStrEqual( Event* ev )
{
	if( Q_stricmp( stringValue(), ev->GetString( 1 ) ) == 0 )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfStrNotEqual( Event* ev )
{
	if( Q_stricmp( stringValue(), ev->GetString( 1 ) ) != 0 )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_IfThreadActive( Event* ev )
{
	ScriptThread* thread;

	thread = Director.GetThread( intValue() );
	if( thread )
	{
		VarProcessCommand( ev, 1 );
	}
}

void ScriptVariable::Var_IfThreadNotActive( Event* ev )
{
	ScriptThread* thread;

	thread = Director.GetThread( intValue() );
	if( !thread )
	{
		VarProcessCommand( ev, 1 );
	}
}

void ScriptVariable::Var_GetCvar( Event* ev )
{
	cvar_t* var;

	var = gi.cvar( ev->GetString( 1 ), "", 0 );
	setStringValue( var->string );
}

void ScriptVariable::Var_Vector( Event* ev )
{
	setVectorValue( ev->GetVector( 1 ) );
}

void ScriptVariable::Var_Vector_Add( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec += ev->GetVector( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_Subtract( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec -= ev->GetVector( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_Scale( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec = tempvec * ev->GetFloat( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_Normalize( Event* ev )
{
	vectorValue().normalize();
	setVectorValue( vectorValue() );
}

void ScriptVariable::Var_Vector_GetX( Event* ev )
{
	setFloatValue( ev->GetVector( 1 ).x );
}

void ScriptVariable::Var_Vector_GetY( Event* ev )
{
	setFloatValue( ev->GetVector( 1 ).y );
}

void ScriptVariable::Var_Vector_GetZ( Event* ev )
{
	setFloatValue( ev->GetVector( 1 ).z );
}

void ScriptVariable::Var_Vector_SetX( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec.x = ev->GetFloat( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_SetY( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec.y = ev->GetFloat( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_SetZ( Event* ev )
{
	Vector tempvec;

	tempvec = vectorValue();
	tempvec.z = ev->GetFloat( 1 );
	setVectorValue( tempvec );
}

void ScriptVariable::Var_Vector_IfEqual( Event* ev )
{
	if( vectorValue() == ev->GetVector( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_Vector_IfNotEqual( Event* ev )
{
	if( vectorValue() != ev->GetVector( 1 ) )
	{
		VarProcessCommand( ev, 2 );
	}
}

void ScriptVariable::Var_Vector_DotProduct( Event* ev )
{
	Vector vec1, vec2;

	vec1 = ev->GetVector( 1 );
	vec2 = ev->GetVector( 2 );
	setFloatValue( vec1 * vec2 );
}

void ScriptVariable::Var_Vector_Length( Event* ev )
{
	setFloatValue( ev->GetVector( 1 ).length() );
}

void ScriptVariable::Var_Vector_CrossProduct( Event* ev )
{
	Vector vec1, vec2, cross;

	vec1 = ev->GetVector( 1 );
	vec2 = ev->GetVector( 2 );
	cross.CrossProduct( vec1, vec2 );
	setVectorValue( cross );
}

void ScriptVariable::Var_Angles_ToForward( Event* ev )
{
	Vector forward;

	ev->GetVector( 1 ).AngleVectors( &forward, NULL, NULL );
	setVectorValue( forward );
}

void ScriptVariable::Var_Angles_ToRight( Event* ev )
{
	Vector right;

	ev->GetVector( 1 ).AngleVectors( NULL, &right, NULL );
	setVectorValue( right );
}

void ScriptVariable::Var_Angles_ToUp( Event* ev )
{
	Vector up;

	ev->GetVector( 1 ).AngleVectors( NULL, NULL, &up );
	setVectorValue( up );
}
