DOOM-3-BFG

GameEdit.cpp (27693B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #include "../idlib/precompiled.h"
 #pragma hdrstop
 
 #include "Game_local.h"
 
 
 /*
 ===============================================================================
 
 	Ingame cursor.
 
 ===============================================================================
 */
 
 CLASS_DECLARATION( idEntity, idCursor3D )
 END_CLASS
 
 /*
 ===============
 idCursor3D::idCursor3D
 ===============
 */
 idCursor3D::idCursor3D() {
 	draggedPosition.Zero();
 }
 
 /*
 ===============
 idCursor3D::~idCursor3D
 ===============
 */
 idCursor3D::~idCursor3D() {
 }
 
 /*
 ===============
 idCursor3D::Spawn
 ===============
 */
 void idCursor3D::Spawn() {
 }
 
 /*
 ===============
 idCursor3D::Present
 ===============
 */
 void idCursor3D::Present() {
 	// don't present to the renderer if the entity hasn't changed
 	if ( !( thinkFlags & TH_UPDATEVISUALS ) ) {
 		return;
 	}
 	BecomeInactive( TH_UPDATEVISUALS );
 
 	const idVec3 &origin = GetPhysics()->GetOrigin();
 	const idMat3 &axis = GetPhysics()->GetAxis();
 	gameRenderWorld->DebugArrow( colorYellow, origin + axis[1] * -5.0f + axis[2] * 5.0f, origin, 2 );
 	gameRenderWorld->DebugArrow( colorRed, origin, draggedPosition, 2 );
 }
 
 /*
 ===============
 idCursor3D::Think
 ===============
 */
 void idCursor3D::Think() {
 	if ( thinkFlags & TH_THINK ) {
 		drag.Evaluate( gameLocal.time );
 	}
 	Present();
 }
 
 
 /*
 ===============================================================================
 
 	Allows entities to be dragged through the world with physics.
 
 ===============================================================================
 */
 
 #define MAX_DRAG_TRACE_DISTANCE			2048.0f
 
 /*
 ==============
 idDragEntity::idDragEntity
 ==============
 */
 idDragEntity::idDragEntity() {
 	cursor = NULL;
 	Clear();
 }
 
 /*
 ==============
 idDragEntity::~idDragEntity
 ==============
 */
 idDragEntity::~idDragEntity() {
 	StopDrag();
 	selected = NULL;
 	delete cursor;
 	cursor = NULL;
 }
 
 
 /*
 ==============
 idDragEntity::Clear
 ==============
 */
 void idDragEntity::Clear() {
 	dragEnt			= NULL;
 	joint			= INVALID_JOINT;
 	id				= 0;
 	localEntityPoint.Zero();
 	localPlayerPoint.Zero();
 	bodyName.Clear();
 	selected		= NULL;
 }
 
 /*
 ==============
 idDragEntity::StopDrag
 ==============
 */
 void idDragEntity::StopDrag() {
 	dragEnt = NULL;
 	if ( cursor ) {
 		cursor->BecomeInactive( TH_THINK );
 	}
 }
 
 /*
 ==============
 idDragEntity::Update
 ==============
 */
 void idDragEntity::Update( idPlayer *player ) {
 	idVec3 viewPoint, origin;
 	idMat3 viewAxis, axis;
 	trace_t trace;
 	idEntity *newEnt = NULL;
 	idAngles angles;
 	jointHandle_t newJoint = INVALID_JOINT;
 	idStr newBodyName;
 
 	player->GetViewPos( viewPoint, viewAxis );
 
 	// if no entity selected for dragging
     if ( !dragEnt.GetEntity() ) {
 
 		if ( player->usercmd.buttons & BUTTON_ATTACK ) {
 
 			gameLocal.clip.TracePoint( trace, viewPoint, viewPoint + viewAxis[0] * MAX_DRAG_TRACE_DISTANCE, (CONTENTS_SOLID|CONTENTS_RENDERMODEL|CONTENTS_BODY), player );
 			if ( trace.fraction < 1.0f ) {
 
 				newEnt = gameLocal.entities[ trace.c.entityNum ];
 				if ( newEnt ) {
 
 					if ( newEnt->GetBindMaster() ) {
 						if ( newEnt->GetBindJoint() ) {
 							trace.c.id = JOINT_HANDLE_TO_CLIPMODEL_ID( newEnt->GetBindJoint() );
 						} else {
 							trace.c.id = newEnt->GetBindBody();
 						}
 						newEnt = newEnt->GetBindMaster();
 					}
 
 					if ( newEnt->IsType( idAFEntity_Base::Type ) && static_cast<idAFEntity_Base *>(newEnt)->IsActiveAF() ) {
 						idAFEntity_Base *af = static_cast<idAFEntity_Base *>(newEnt);
 
 						// joint being dragged
 						newJoint = CLIPMODEL_ID_TO_JOINT_HANDLE( trace.c.id );
 						// get the body id from the trace model id which might be a joint handle
 						trace.c.id = af->BodyForClipModelId( trace.c.id );
 						// get the name of the body being dragged
 						newBodyName = af->GetAFPhysics()->GetBody( trace.c.id )->GetName();
 
 					} else if ( !newEnt->IsType( idWorldspawn::Type ) ) {
 
 						if ( trace.c.id < 0 ) {
 							newJoint = CLIPMODEL_ID_TO_JOINT_HANDLE( trace.c.id );
 						} else {
 							newJoint = INVALID_JOINT;
 						}
 						newBodyName = "";
 
 					} else {
 
 						newJoint = INVALID_JOINT;
 						newEnt = NULL;
 					}
 				}
 				if ( newEnt ) {
 					dragEnt = newEnt;
 					selected = newEnt;
 					joint = newJoint;
 					id = trace.c.id;
 					bodyName = newBodyName;
 
 					if ( !cursor ) {
 						cursor = ( idCursor3D * )gameLocal.SpawnEntityType( idCursor3D::Type );
 					}
 
 					idPhysics *phys = dragEnt.GetEntity()->GetPhysics();
 					localPlayerPoint = ( trace.c.point - viewPoint ) * viewAxis.Transpose();
 					origin = phys->GetOrigin( id );
 					axis = phys->GetAxis( id );
 					localEntityPoint = ( trace.c.point - origin ) * axis.Transpose();
 
 					cursor->drag.Init( g_dragDamping.GetFloat() );
 					cursor->drag.SetPhysics( phys, id, localEntityPoint );
 					cursor->Show();
 
 					if ( phys->IsType( idPhysics_AF::Type ) ||
 							phys->IsType( idPhysics_RigidBody::Type ) ||
 								phys->IsType( idPhysics_Monster::Type ) ) {
 						cursor->BecomeActive( TH_THINK );
 					}
 				}
 			}
 		}
 	}
 
 	// if there is an entity selected for dragging
 	idEntity *drag = dragEnt.GetEntity();
 	if ( drag ) {
 
 		if ( !( player->usercmd.buttons & BUTTON_ATTACK ) ) {
 			StopDrag();
 			return;
 		}
 
 		cursor->SetOrigin( viewPoint + localPlayerPoint * viewAxis );
 		cursor->SetAxis( viewAxis );
 
 		cursor->drag.SetDragPosition( cursor->GetPhysics()->GetOrigin() );
 
 		renderEntity_t *renderEntity = drag->GetRenderEntity();
 		idAnimator *dragAnimator = drag->GetAnimator();
 
 		if ( joint != INVALID_JOINT && renderEntity != NULL && dragAnimator != NULL ) {
 			dragAnimator->GetJointTransform( joint, gameLocal.time, cursor->draggedPosition, axis );
 			cursor->draggedPosition = renderEntity->origin + cursor->draggedPosition * renderEntity->axis;
 			gameRenderWorld->DrawText( va( "%s\n%s\n%s, %s", drag->GetName(), drag->GetType()->classname, dragAnimator->GetJointName( joint ), bodyName.c_str() ), cursor->GetPhysics()->GetOrigin(), 0.1f, colorWhite, viewAxis, 1 );
 		} else {
 			cursor->draggedPosition = cursor->GetPhysics()->GetOrigin();
 			gameRenderWorld->DrawText( va( "%s\n%s\n%s", drag->GetName(), drag->GetType()->classname, bodyName.c_str() ), cursor->GetPhysics()->GetOrigin(), 0.1f, colorWhite, viewAxis, 1 );
 		}
 	}
 
 	// if there is a selected entity
 	if ( selected.GetEntity() && g_dragShowSelection.GetBool() ) {
 		// draw the bbox of the selected entity
 		renderEntity_t *renderEntity = selected.GetEntity()->GetRenderEntity();
 		if ( renderEntity ) {
 			gameRenderWorld->DebugBox( colorYellow, idBox( renderEntity->bounds, renderEntity->origin, renderEntity->axis ) );
 		}
 	}
 }
 
 /*
 ==============
 idDragEntity::SetSelected
 ==============
 */
 void idDragEntity::SetSelected( idEntity *ent ) {
 	selected = ent;
 	StopDrag();
 }
 
 /*
 ==============
 idDragEntity::DeleteSelected
 ==============
 */
 void idDragEntity::DeleteSelected() {
 	delete selected.GetEntity();
 	selected = NULL;
 	StopDrag();
 }
 
 /*
 ==============
 idDragEntity::BindSelected
 ==============
 */
 void idDragEntity::BindSelected() {
 	int num, largestNum;
 	idLexer lexer;
 	idToken type, bodyName;
 	idStr key, value, bindBodyName;
 	const idKeyValue *kv;
 	idAFEntity_Base *af;
 
 	af = static_cast<idAFEntity_Base *>(dragEnt.GetEntity());
 
 	if ( !af || !af->IsType( idAFEntity_Base::Type ) || !af->IsActiveAF() ) {
 		return;
 	}
 
 	bindBodyName = af->GetAFPhysics()->GetBody( id )->GetName();
 	largestNum = 1;
 
 	// parse all the bind constraints
 	kv = af->spawnArgs.MatchPrefix( "bindConstraint ", NULL );
 	while ( kv ) {
 		key = kv->GetKey();
 		key.Strip( "bindConstraint " );
 		if ( sscanf( key, "bind%d", &num ) ) {
 			if ( num >= largestNum ) {
 				largestNum = num + 1;
 			}
 		}
 
 		lexer.LoadMemory( kv->GetValue(), kv->GetValue().Length(), kv->GetKey() );
 		lexer.ReadToken( &type );
 		lexer.ReadToken( &bodyName );
 		lexer.FreeSource();
 
 		// if there already exists a bind constraint for this body
 		if ( bodyName.Icmp( bindBodyName ) == 0 ) {
 			// delete the bind constraint
 			af->spawnArgs.Delete( kv->GetKey() );
 			kv = NULL;
 		}
 
 		kv = af->spawnArgs.MatchPrefix( "bindConstraint ", kv );
 	}
 
 	sprintf( key, "bindConstraint bind%d", largestNum );
 	sprintf( value, "ballAndSocket %s %s", bindBodyName.c_str(), af->GetAnimator()->GetJointName( joint ) );
 
 	af->spawnArgs.Set( key, value );
 	af->spawnArgs.Set( "bind", "worldspawn" );
 	af->Bind( gameLocal.world, true );
 }
 
 /*
 ==============
 idDragEntity::UnbindSelected
 ==============
 */
 void idDragEntity::UnbindSelected() {
 	const idKeyValue *kv;
 	idAFEntity_Base *af;
 
 	af = static_cast<idAFEntity_Base *>(selected.GetEntity());
 
 	if ( !af || !af->IsType( idAFEntity_Base::Type ) || !af->IsActiveAF() ) {
 		return;
 	}
 
 	// unbind the selected entity
 	af->Unbind();
 
 	// delete all the bind constraints
 	kv = selected.GetEntity()->spawnArgs.MatchPrefix( "bindConstraint ", NULL );
 	while ( kv ) {
 		selected.GetEntity()->spawnArgs.Delete( kv->GetKey() );
 		kv = selected.GetEntity()->spawnArgs.MatchPrefix( "bindConstraint ", NULL );
 	}
 
 	// delete any bind information
 	af->spawnArgs.Delete( "bind" );
 	af->spawnArgs.Delete( "bindToJoint" );
 	af->spawnArgs.Delete( "bindToBody" );
 }
 
 
 /*
 ===============================================================================
 
 	Handles ingame entity editing.
 
 ===============================================================================
 */
 
 /*
 ==============
 idEditEntities::idEditEntities
 ==============
 */
 idEditEntities::idEditEntities() {
 	selectableEntityClasses.Clear();
 	nextSelectTime = 0;
 }
 
 /*
 =============
 idEditEntities::SelectEntity
 =============
 */
 bool idEditEntities::SelectEntity( const idVec3 &origin, const idVec3 &dir, const idEntity *skip ) {
 	idVec3		end;
 	idEntity	*ent;
 
 	if ( !g_editEntityMode.GetInteger() || selectableEntityClasses.Num() == 0 ) {
 		return false;
 	}
 
 	if ( gameLocal.time < nextSelectTime ) {
 		return true;
 	}
 	nextSelectTime = gameLocal.time + 300;
 
 	end = origin + dir * 4096.0f;
 
 	ent = NULL;
 	for ( int i = 0; i < selectableEntityClasses.Num(); i++ ) {
 		ent = gameLocal.FindTraceEntity( origin, end, *selectableEntityClasses[i].typeInfo, skip );
 		if ( ent ) {
 			break;
 		}
 	}
 	if ( ent ) {
 		ClearSelectedEntities();
 		if ( EntityIsSelectable( ent ) ) {
 			AddSelectedEntity( ent );
 			gameLocal.Printf( "entity #%d: %s '%s'\n", ent->entityNumber, ent->GetClassname(), ent->name.c_str() );
 			ent->ShowEditingDialog();
 			return true;
 		}
 	}
 	return false;
 }
 
 /*
 =============
 idEditEntities::AddSelectedEntity
 =============
 */
 void idEditEntities::AddSelectedEntity(idEntity *ent) {
 	ent->fl.selected = true;
 	selectedEntities.AddUnique(ent);
 }
 
 /*
 ==============
 idEditEntities::RemoveSelectedEntity
 ==============
 */
 void idEditEntities::RemoveSelectedEntity( idEntity *ent ) {
     if ( selectedEntities.Find( ent ) ) {
 		selectedEntities.Remove( ent );
 	}
 }
 
 /*
 =============
 idEditEntities::ClearSelectedEntities
 =============
 */
 void idEditEntities::ClearSelectedEntities() {
 	int i, count;
 
 	count = selectedEntities.Num();
 	for ( i = 0; i < count; i++ ) {
 		selectedEntities[i]->fl.selected = false;
 	}
 	selectedEntities.Clear();
 }
 
 
 /*
 =============
 idEditEntities::EntityIsSelectable
 =============
 */
 bool idEditEntities::EntityIsSelectable( idEntity *ent, idVec4 *color, idStr *text ) {
 	for ( int i = 0; i < selectableEntityClasses.Num(); i++ ) {
 		if ( ent->GetType() == selectableEntityClasses[i].typeInfo ) {
 			if ( text ) {
 				*text = selectableEntityClasses[i].textKey;
 			}
 			if ( color ) {
 				if ( ent->fl.selected ) {
 					*color = colorRed;
 				} else {
 					switch( i ) {
 					case 1 :
 						*color = colorYellow;
 						break;
 					case 2 :
 						*color = colorBlue;
 						break;
 					default:
 						*color = colorGreen;
 					}
 				}
 			}
 			return true;
 		}
 	}
 	return false;
 }
 
 /*
 =============
 idEditEntities::DisplayEntities
 =============
 */
 void idEditEntities::DisplayEntities() {
 	idEntity *ent;
 
 	if ( !gameLocal.GetLocalPlayer() ) {
 		return;
 	}
 
 	selectableEntityClasses.Clear();
 	selectedTypeInfo_t sit;
 
 	switch( g_editEntityMode.GetInteger() ) {
 		case 1:
 			sit.typeInfo = &idLight::Type;
 			sit.textKey = "texture";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 2:
 			sit.typeInfo = &idSound::Type;
 			sit.textKey = "s_shader";
 			selectableEntityClasses.Append( sit );
 			sit.typeInfo = &idLight::Type;
 			sit.textKey = "texture";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 3:
 			sit.typeInfo = &idAFEntity_Base::Type;
 			sit.textKey = "articulatedFigure";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 4:
 			sit.typeInfo = &idFuncEmitter::Type;
 			sit.textKey = "model";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 5:
 			sit.typeInfo = &idAI::Type;
 			sit.textKey = "name";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 6:
 			sit.typeInfo = &idEntity::Type;
 			sit.textKey = "name";
 			selectableEntityClasses.Append( sit );
 			break;
 		case 7:
 			sit.typeInfo = &idEntity::Type;
 			sit.textKey = "model";
 			selectableEntityClasses.Append( sit );
 			break;
 		default:
 			return;
 	}
 
 	idBounds viewBounds( gameLocal.GetLocalPlayer()->GetPhysics()->GetOrigin() );
 	idBounds viewTextBounds( gameLocal.GetLocalPlayer()->GetPhysics()->GetOrigin() );
 	idMat3 axis = gameLocal.GetLocalPlayer()->viewAngles.ToMat3();
 
 	viewBounds.ExpandSelf( 512 );
 	viewTextBounds.ExpandSelf( 128 );
 
 	idStr textKey;
 
 	for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
 
 		idVec4 color;
 
 		textKey = "";
 		if ( !EntityIsSelectable( ent, &color, &textKey ) ) {
 			continue;
 		}
 
 		bool drawArrows = false;
 		if ( ent->GetType() == &idAFEntity_Base::Type ) {
 			if ( !static_cast<idAFEntity_Base *>(ent)->IsActiveAF() ) {
 				continue;
 			}
 		} else if ( ent->GetType() == &idSound::Type ) {
 			if ( ent->fl.selected ) {
 				drawArrows = true;
 			}
 			const idSoundShader * ss = declManager->FindSound( ent->spawnArgs.GetString( textKey ) );
 			if ( ss->HasDefaultSound() || ss->base->GetState() == DS_DEFAULTED ) {
 				color.Set( 1.0f, 0.0f, 1.0f, 1.0f );
 			}
 		} else if ( ent->GetType() == &idFuncEmitter::Type ) {
 			if ( ent->fl.selected ) {
 				drawArrows = true;
 			}
 		}
 
 		if ( !viewBounds.ContainsPoint( ent->GetPhysics()->GetOrigin() ) ) {
 			continue;
 		}
 
 		gameRenderWorld->DebugBounds( color, idBounds( ent->GetPhysics()->GetOrigin() ).Expand( 8 ) );
 		if ( drawArrows ) {
 			idVec3 start = ent->GetPhysics()->GetOrigin();
 			idVec3 end = start + idVec3( 1, 0, 0 ) * 20.0f;
 			gameRenderWorld->DebugArrow( colorWhite, start, end, 2 );
 			gameRenderWorld->DrawText( "x+", end + idVec3( 4, 0, 0 ), 0.15f, colorWhite, axis );
 			end = start + idVec3( 1, 0, 0 ) * -20.0f;
 			gameRenderWorld->DebugArrow( colorWhite, start, end, 2 );
 			gameRenderWorld->DrawText( "x-", end + idVec3( -4, 0, 0 ), 0.15f, colorWhite, axis );
 			end = start + idVec3( 0, 1, 0 ) * +20.0f;
 			gameRenderWorld->DebugArrow( colorGreen, start, end, 2 );
 			gameRenderWorld->DrawText( "y+", end + idVec3( 0, 4, 0 ), 0.15f, colorWhite, axis );
 			end = start + idVec3( 0, 1, 0 ) * -20.0f;
 			gameRenderWorld->DebugArrow( colorGreen, start, end, 2 );
 			gameRenderWorld->DrawText( "y-", end + idVec3( 0, -4, 0 ), 0.15f, colorWhite, axis );
 			end = start + idVec3( 0, 0, 1 ) * +20.0f;
 			gameRenderWorld->DebugArrow( colorBlue, start, end, 2 );
 			gameRenderWorld->DrawText( "z+", end + idVec3( 0, 0, 4 ), 0.15f, colorWhite, axis );
 			end = start + idVec3( 0, 0, 1 ) * -20.0f;
 			gameRenderWorld->DebugArrow( colorBlue, start, end, 2 );
 			gameRenderWorld->DrawText( "z-", end + idVec3( 0, 0, -4 ), 0.15f, colorWhite, axis );
 		}
 
 		if ( textKey.Length() ) {
 			const char *text = ent->spawnArgs.GetString( textKey );
 			if ( viewTextBounds.ContainsPoint( ent->GetPhysics()->GetOrigin() ) ) {
 				gameRenderWorld->DrawText( text, ent->GetPhysics()->GetOrigin() + idVec3(0, 0, 12), 0.25, colorWhite, axis, 1 );
 			}
 		}
 	}
 }
 
 
 /*
 ===============================================================================
 
 	idGameEdit
 
 ===============================================================================
 */
 
 idGameEdit			gameEditLocal;
 idGameEdit *		gameEdit = &gameEditLocal;
 
 
 /*
 =============
 idGameEdit::GetSelectedEntities
 =============
 */
 int idGameEdit::GetSelectedEntities( idEntity *list[], int max ) {
 	int num = 0;
 	idEntity *ent;
 
 	for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
 		if ( ent->fl.selected ) {
 			list[num++] = ent;
 			if ( num >= max ) {
 				break;
 			}
 		}
 	}
 	return num;
 }
 
 /*
 =============
 idGameEdit::TriggerSelected
 =============
 */
 void idGameEdit::TriggerSelected() {
 	idEntity *ent;
 	for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
 		if ( ent->fl.selected ) {
 			ent->ProcessEvent( &EV_Activate, gameLocal.GetLocalPlayer() );
 		}
 	}
 }
 
 /*
 ================
 idGameEdit::ClearEntitySelection
 ================
 */
 void idGameEdit::ClearEntitySelection() {
 	idEntity *ent;
 
 	for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
 		ent->fl.selected = false;
 	}
 	gameLocal.editEntities->ClearSelectedEntities();
 }
 
 /*
 ================
 idGameEdit::AddSelectedEntity
 ================
 */
 void idGameEdit::AddSelectedEntity( idEntity *ent ) {
 	if ( ent ) {
 		gameLocal.editEntities->AddSelectedEntity( ent );
 	}
 }
 
 /*
 ================
 idGameEdit::FindEntityDefDict
 ================
 */
 const idDict *idGameEdit::FindEntityDefDict( const char *name, bool makeDefault ) const {
 	return gameLocal.FindEntityDefDict( name, makeDefault );
 }
 
 /*
 ================
 idGameEdit::SpawnEntityDef
 ================
 */
 void idGameEdit::SpawnEntityDef( const idDict &args, idEntity **ent ) {
 	gameLocal.SpawnEntityDef( args, ent );
 }
 
 /*
 ================
 idGameEdit::FindEntity
 ================
 */
 idEntity *idGameEdit::FindEntity( const char *name ) const {
 	return gameLocal.FindEntity( name ); 
 }
 
 /*
 =============
 idGameEdit::GetUniqueEntityName
 
 generates a unique name for a given classname
 =============
 */
 const char *idGameEdit::GetUniqueEntityName( const char *classname ) const {
 	int			id;
 	static char	name[1024];
 
 	// can only have MAX_GENTITIES, so if we have a spot available, we're guaranteed to find one
 	for( id = 0; id < MAX_GENTITIES; id++ ) {
 		idStr::snPrintf( name, sizeof( name ), "%s_%d", classname, id );
 		if ( !gameLocal.FindEntity( name ) ) {
 			return name;
 		}
 	}
 
 	// id == MAX_GENTITIES + 1, which can't be in use if we get here
 	idStr::snPrintf( name, sizeof( name ), "%s_%d", classname, id );
 	return name;
 }
 
 /*
 ================
 idGameEdit::EntityGetOrigin
 ================
 */
 void  idGameEdit::EntityGetOrigin( idEntity *ent, idVec3 &org ) const {
 	if ( ent ) {
 		org = ent->GetPhysics()->GetOrigin();
 	}
 }
 
 /*
 ================
 idGameEdit::EntityGetAxis
 ================
 */
 void idGameEdit::EntityGetAxis( idEntity *ent, idMat3 &axis ) const {
 	if ( ent ) {
 		axis = ent->GetPhysics()->GetAxis();
 	}
 }
 
 /*
 ================
 idGameEdit::EntitySetOrigin
 ================
 */
 void idGameEdit::EntitySetOrigin( idEntity *ent, const idVec3 &org ) {
 	if ( ent ) {
 		ent->SetOrigin( org );
 	}
 }
 
 /*
 ================
 idGameEdit::EntitySetAxis
 ================
 */
 void idGameEdit::EntitySetAxis( idEntity *ent, const idMat3 &axis ) {
 	if ( ent ) {
 		ent->SetAxis( axis );
 	}
 }
 
 /*
 ================
 idGameEdit::EntitySetColor
 ================
 */
 void idGameEdit::EntitySetColor( idEntity *ent, const idVec3 color ) {
 	if ( ent ) {
 		ent->SetColor( color );
 	}
 }
 
 /*
 ================
 idGameEdit::EntityTranslate
 ================
 */
 void idGameEdit::EntityTranslate( idEntity *ent, const idVec3 &org ) {
 	if ( ent ) {
 		ent->GetPhysics()->Translate( org );
 	}
 }
 
 /*
 ================
 idGameEdit::EntityGetSpawnArgs
 ================
 */
 const idDict *idGameEdit::EntityGetSpawnArgs( idEntity *ent ) const {
 	if ( ent ) {
 		return &ent->spawnArgs;
 	}
 	return NULL;
 }
 
 /*
 ================
 idGameEdit::EntityUpdateChangeableSpawnArgs
 ================
 */
 void idGameEdit::EntityUpdateChangeableSpawnArgs( idEntity *ent, const idDict *dict ) {
 	if ( ent ) {
 		ent->UpdateChangeableSpawnArgs( dict );
 	}
 }
 
 /*
 ================
 idGameEdit::EntityChangeSpawnArgs
 ================
 */
 void idGameEdit::EntityChangeSpawnArgs( idEntity *ent, const idDict *newArgs ) {
 	if ( ent ) {
 		for ( int i = 0 ; i < newArgs->GetNumKeyVals () ; i ++ ) {
 			const idKeyValue *kv = newArgs->GetKeyVal( i );
 	        
 			if ( kv->GetValue().Length() > 0 ) {
 				ent->spawnArgs.Set ( kv->GetKey() ,kv->GetValue() );
 			} else {
 				ent->spawnArgs.Delete ( kv->GetKey() );
 			}
 		}
 	}
 }
 
 /*
 ================
 idGameEdit::EntityUpdateVisuals
 ================
 */
 void idGameEdit::EntityUpdateVisuals( idEntity *ent ) {
 	if ( ent ) {
 		ent->UpdateVisuals();
 	}
 }
 
 /*
 ================
 idGameEdit::EntitySetModel
 ================
 */
 void idGameEdit::EntitySetModel( idEntity *ent, const char *val ) {
 	if ( ent ) {
 		ent->spawnArgs.Set( "model", val );
 		ent->SetModel( val );
 	}
 }
 
 /*
 ================
 idGameEdit::EntityStopSound
 ================
 */
 void idGameEdit::EntityStopSound( idEntity *ent ) {
 	if ( ent ) {
 		ent->StopSound( SND_CHANNEL_ANY, false );
 	}
 }
 
 /*
 ================
 idGameEdit::EntityDelete
 ================
 */
 void idGameEdit::EntityDelete( idEntity *ent ) {
 	delete ent;
 }
 
 /*
 ================
 idGameEdit::PlayerIsValid
 ================
 */
 bool idGameEdit::PlayerIsValid() const {
 	return ( gameLocal.GetLocalPlayer() != NULL );
 }
 
 /*
 ================
 idGameEdit::PlayerGetOrigin
 ================
 */
 void idGameEdit::PlayerGetOrigin( idVec3 &org ) const {
 	org = gameLocal.GetLocalPlayer()->GetPhysics()->GetOrigin();
 }
 
 /*
 ================
 idGameEdit::PlayerGetAxis
 ================
 */
 void idGameEdit::PlayerGetAxis( idMat3 &axis ) const {
 	axis = gameLocal.GetLocalPlayer()->GetPhysics()->GetAxis();
 }
 
 /*
 ================
 idGameEdit::PlayerGetViewAngles
 ================
 */
 void idGameEdit::PlayerGetViewAngles( idAngles &angles ) const {
 	angles = gameLocal.GetLocalPlayer()->viewAngles;
 }
 
 /*
 ================
 idGameEdit::PlayerGetEyePosition
 ================
 */
 void idGameEdit::PlayerGetEyePosition( idVec3 &org ) const {
 	org = gameLocal.GetLocalPlayer()->GetEyePosition();
 }
 
 
 /*
 ================
 idGameEdit::MapGetEntityDict
 ================
 */
 const idDict *idGameEdit::MapGetEntityDict( const char *name ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile && name && *name ) {
 		idMapEntity *mapent = mapFile->FindEntity( name );
 		if ( mapent ) {
 			return &mapent->epairs;
 		}
 	}
 	return NULL;
 }
 
 /*
 ================
 idGameEdit::MapSave
 ================
 */
 void idGameEdit::MapSave( const char *path ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if (mapFile) {
 		mapFile->Write( (path) ? path : mapFile->GetName(), ".map");
 	}
 }
 
 /*
 ================
 idGameEdit::MapSetEntityKeyVal
 ================
 */
 void idGameEdit::MapSetEntityKeyVal( const char *name, const char *key, const char *val ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile && name && *name ) {
 		idMapEntity *mapent = mapFile->FindEntity( name );
 		if ( mapent ) {
 			mapent->epairs.Set( key, val );
 		}
 	}
 }
 
 /*
 ================
 idGameEdit::MapCopyDictToEntity
 ================
 */
 void idGameEdit::MapCopyDictToEntity( const char *name, const idDict *dict ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile && name && *name ) {
 		idMapEntity *mapent = mapFile->FindEntity( name );
 		if ( mapent ) {
 			for ( int i = 0; i < dict->GetNumKeyVals(); i++ ) {
 				const idKeyValue *kv = dict->GetKeyVal( i );
 				const char *key = kv->GetKey();
 				const char *val = kv->GetValue();
 				mapent->epairs.Set( key, val );
 			}
 		}
 	}
 }
 
 
 
 /*
 ================
 idGameEdit::MapGetUniqueMatchingKeyVals
 ================
 */
 int idGameEdit::MapGetUniqueMatchingKeyVals( const char *key, const char *list[], int max ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	int count = 0;
 	if ( mapFile ) {
 		for ( int i = 0; i < mapFile->GetNumEntities(); i++ ) {
 			idMapEntity *ent = mapFile->GetEntity( i );
 			if ( ent ) {
 				const char *k = ent->epairs.GetString( key );
 				if ( k != NULL && *k != NULL && count < max ) {
 					list[count++] = k;
 				}
 			}
 		}
 	}
 	return count;
 }
 
 /*
 ================
 idGameEdit::MapAddEntity
 ================
 */
 void idGameEdit::MapAddEntity( const idDict *dict ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile ) {
 		idMapEntity *ent = new (TAG_GAME) idMapEntity();
 		ent->epairs = *dict;
 		mapFile->AddEntity( ent );
 	}
 }
 
 /*
 ================
 idGameEdit::MapRemoveEntity
 ================
 */
 void idGameEdit::MapRemoveEntity( const char *name ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile ) {
 		idMapEntity *ent = mapFile->FindEntity( name );
 		if ( ent ) {
 			mapFile->RemoveEntity( ent );
 		}
 	}
 }
 
 
 /*
 ================
 idGameEdit::MapGetEntitiesMatchignClassWithString
 ================
 */
 int idGameEdit::MapGetEntitiesMatchingClassWithString( const char *classname, const char *match, const char *list[], const int max ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	int count = 0;
 	if ( mapFile ) {
 		int entCount = mapFile->GetNumEntities();
 		for ( int i = 0 ; i < entCount; i++ ) {
 			idMapEntity *ent = mapFile->GetEntity(i);
 			if (ent) {
 				idStr work = ent->epairs.GetString("classname");
 				if ( work.Icmp( classname ) == 0 ) {
 					if ( match && *match ) { 
 						work = ent->epairs.GetString( "soundgroup" );
 						if ( count < max && work.Icmp( match ) == 0 ) {
 							list[count++] = ent->epairs.GetString( "name" );
 						}
 					} else if ( count < max ) {
 						list[count++] = ent->epairs.GetString( "name" );
 					}
 				}
 			}
 		}
 	}
 	return count;
 }
 
 
 /*
 ================
 idGameEdit::MapEntityTranslate
 ================
 */
 void idGameEdit::MapEntityTranslate( const char *name, const idVec3 &v ) const {
 	idMapFile *mapFile = gameLocal.GetLevelMap();
 	if ( mapFile && name && *name ) {
 		idMapEntity *mapent = mapFile->FindEntity( name );
 		if ( mapent ) {
 			idVec3 origin;
 			mapent->epairs.GetVector( "origin", "", origin );
 			origin += v;
 			mapent->epairs.SetVector( "origin", origin );
 		}
 	}
 }