//-----------------------------------------------------------------------------
//
//  $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 ( ScriptVariable::Responses[ i ].event->getName() == name )
			{
			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 = atof( 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,
	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;

	newstring = string + ev->GetString( 1 );
	setStringValue( newstring.c_str() );
	}

void ScriptVariable::Var_AppendInt
	(
	Event *ev
	)

	{
	str newstring;

	newstring = string + va( "%d", ev->GetInteger( 1 ) );
	setStringValue( newstring.c_str() );
	}

void ScriptVariable::Var_AppendFloat
	(
	Event *ev
	)

	{
	str newstring;

	newstring = string + 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
	)

	{
   str varname;
   ScriptVariable *var;
   
	varname = str( "console." ) + 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 ( stricmp( stringValue(), ev->GetString( 1 ) ) == 0 )
		{
		VarProcessCommand( ev, 2 );
		}
	}

void ScriptVariable::Var_IfStrNotEqual
	(
	Event *ev
	)

	{
	if ( 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
	)

	{
	setVectorValue( vectorValue().normalize() );
	}

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 );
   }
