forked from 0ad/0ad
janwas
c0ed950657
this snowballed into a massive search+destroy of the hodgepodge of mostly equivalent types we had in use (int, uint, unsigned, unsigned int, i32, u32, ulong, uintN). it is more efficient to use 64-bit types in 64-bit mode, so the preferred default is size_t (for anything remotely resembling a size or index). tile coordinates are ssize_t to allow more efficient conversion to/from floating point. flags are int because we almost never need more than 15 distinct bits, bit test/set is not slower and int is fastest to type. finally, some data that is pretty much directly passed to OpenGL is now typed accordingly. after several hours, the code now requires fewer casts and less guesswork. other changes: - unit and player IDs now have an "invalid id" constant in the respective class to avoid casting and -1 - fix some endian/64-bit bugs in the map (un)packing. added a convenience function to write/read a size_t. - ia32: change CPUID interface to allow passing in ecx (required for cache topology detection, which I need at work). remove some unneeded functions from asm, replace with intrinsics where possible. This was SVN commit r5942.
490 lines
17 KiB
C++
490 lines
17 KiB
C++
#include "precompiled.h"
|
|
|
|
#include "EntityTemplate.h"
|
|
#include "EntityTemplateCollection.h"
|
|
#include "graphics/ObjectManager.h"
|
|
#include "ps/CStr.h"
|
|
#include "ps/Player.h"
|
|
#include "scripting/ScriptableComplex.inl"
|
|
#include "ps/XML/Xeromyces.h"
|
|
|
|
#include "ps/CLogger.h"
|
|
#define LOG_CATEGORY "entity"
|
|
|
|
STL_HASH_SET<CStr, CStr_hash_compare> CEntityTemplate::scriptsLoaded;
|
|
|
|
// Utility functions used in reading XML
|
|
namespace {
|
|
/**
|
|
* Converts the given string, consisting of underscores and letters,
|
|
* to camelCase: the first letter of each underscore-separated "word"
|
|
* is changed to lowercase. For example, the string MiniMap_Colour
|
|
* is converted to miniMap_colour.
|
|
*
|
|
* @param const std::string & str The string to convert.
|
|
* @return std::string The given string in camelCase.
|
|
**/
|
|
std::string toCamelCase( const std::string& str )
|
|
{
|
|
std::string ret = str;
|
|
for( size_t i=0; i<ret.size(); i++ )
|
|
{
|
|
if( i==0 || ret[i-1] == '_' )
|
|
{
|
|
ret[i] = tolower( ret[i] );
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
CEntityTemplate::CEntityTemplate( CPlayer* player )
|
|
{
|
|
m_player = player;
|
|
m_base = NULL;
|
|
|
|
AddProperty( L"tag", &m_Tag, false );
|
|
AddProperty( L"parent", &m_base, false );
|
|
AddProperty( L"unmodified", &m_unmodified, false );
|
|
|
|
for( int t = 0; t < EVENT_LAST; t++ )
|
|
{
|
|
AddProperty( EventNames[t], &m_EventHandlers[t], false );
|
|
AddHandler( t, &m_EventHandlers[t] );
|
|
}
|
|
|
|
// Initialize, make life a little easier on the scriptors
|
|
m_speed = m_turningRadius = 0.0f;
|
|
//m_extant = true;
|
|
m_foundation = CStrW();
|
|
m_socket = CStrW();
|
|
m_passThroughAllies = false;
|
|
m_sectorDivs = 4;
|
|
|
|
// Sentinel values for stamina and health (so scripts can check if an entity has no stamina or no HP).
|
|
m_speed = 0;
|
|
m_staminaMax = 0;
|
|
m_healthMax = 0;
|
|
|
|
m_bound_type = CBoundingObject::BOUND_NONE;
|
|
m_bound_circle = NULL;
|
|
m_bound_box = NULL;
|
|
|
|
// If these aren't set, we can get an infinite loop in CEntity::interpolate, which is nasty; they
|
|
// should be set in template_entity, but do this in case some entity forgets to inherit from that
|
|
m_anchorConformX = 0;
|
|
m_anchorConformZ = 0;
|
|
}
|
|
|
|
CEntityTemplate::~CEntityTemplate()
|
|
{
|
|
if( m_bound_box )
|
|
delete( m_bound_box );
|
|
if( m_bound_circle )
|
|
delete( m_bound_circle );
|
|
}
|
|
|
|
void CEntityTemplate::LoadBase()
|
|
{
|
|
// Copy the parent's bounds, unless we're providing a replacement.
|
|
if( m_bound_type == CBoundingObject::BOUND_NONE )
|
|
{
|
|
if( m_base->m_bound_type == CBoundingObject::BOUND_CIRCLE )
|
|
{
|
|
m_bound_circle = new CBoundingCircle();
|
|
m_bound_circle->SetRadius( m_base->m_bound_circle->m_radius );
|
|
m_bound_circle->SetHeight( m_base->m_bound_circle->m_height );
|
|
}
|
|
else if( m_base->m_bound_type == CBoundingObject::BOUND_OABB )
|
|
{
|
|
m_bound_box = new CBoundingBox();
|
|
m_bound_box->SetDimensions( m_base->m_bound_box->GetWidth(), m_base->m_bound_box->GetDepth() );
|
|
m_bound_box->SetHeight( m_base->m_bound_box->m_height );
|
|
}
|
|
m_bound_type = m_base->m_bound_type;
|
|
}
|
|
|
|
// Initialize sound group table from the parent's sound group table
|
|
for(SoundGroupTable::iterator it = m_base->m_SoundGroupTable.begin();
|
|
it != m_base->m_SoundGroupTable.end(); ++it)
|
|
{
|
|
m_SoundGroupTable[it->first] = it->second;
|
|
}
|
|
|
|
SetBase( m_base );
|
|
m_classes.SetParent( &( m_base->m_classes ) );
|
|
SetNextObject( m_base );
|
|
}
|
|
|
|
jsval CEntityTemplate::GetClassSet()
|
|
{
|
|
CStrW result = m_classes.GetMemberList();
|
|
return( ToJSVal( result ) );
|
|
}
|
|
|
|
void CEntityTemplate::SetClassSet( jsval value )
|
|
{
|
|
CStr memberCmdList = ToPrimitive<CStrW>( value );
|
|
m_classes.SetFromMemberList(memberCmdList);
|
|
|
|
RebuildClassSet();
|
|
}
|
|
|
|
void CEntityTemplate::RebuildClassSet()
|
|
{
|
|
m_classes.Rebuild();
|
|
InheritorsList::iterator it;
|
|
for( it = m_Inheritors.begin(); it != m_Inheritors.end(); it++ )
|
|
(*it)->RebuildClassSet();
|
|
}
|
|
|
|
bool CEntityTemplate::LoadXml( const CStr& filename )
|
|
{
|
|
CXeromyces XeroFile;
|
|
if (XeroFile.Load(filename) != PSRETURN_OK)
|
|
// Fail
|
|
return false;
|
|
|
|
// Define all the elements and attributes used in the XML file
|
|
#define EL(x) int el_##x = XeroFile.GetElementID(#x)
|
|
#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
|
|
// Only the ones we can't load using normal methods.
|
|
EL(Entity);
|
|
EL(Script);
|
|
EL(Event);
|
|
EL(Traits);
|
|
EL(Footprint);
|
|
EL(Depth);
|
|
EL(Height);
|
|
EL(Radius);
|
|
EL(Width);
|
|
EL(SoundGroups);
|
|
AT(Parent);
|
|
AT(On);
|
|
AT(File);
|
|
AT(Function);
|
|
#undef AT
|
|
#undef EL
|
|
|
|
XMBElement Root = XeroFile.GetRoot();
|
|
|
|
if( Root.GetNodeName() != el_Entity )
|
|
{
|
|
LOG(CLogger::Error, LOG_CATEGORY, "CEntityTemplate::LoadXml: XML root was not \"Entity\" in file %s. Load failed.", filename.c_str() );
|
|
return( false );
|
|
}
|
|
|
|
XMBElementList RootChildren = Root.GetChildNodes();
|
|
|
|
m_Tag = CStr(filename).AfterLast("/").BeforeLast(".xml");
|
|
|
|
m_Base_Name = Root.GetAttributes().GetNamedItem( at_Parent );
|
|
|
|
// Load our parent, if we have one
|
|
if( ! m_Base_Name.empty() )
|
|
{
|
|
CEntityTemplate* base = g_EntityTemplateCollection.GetTemplate( m_Base_Name, m_player );
|
|
if( base )
|
|
{
|
|
m_base = base;
|
|
LoadBase();
|
|
}
|
|
else
|
|
{
|
|
LOG(CLogger::Warning, LOG_CATEGORY, "Parent template \"%ls\" does not exist in template \"%ls\"", m_Base_Name.c_str(), m_Tag.c_str() );
|
|
// (The requested entity will still be returned, but with no parent.
|
|
// Is this a reasonable thing to do?)
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < RootChildren.Count; ++i)
|
|
{
|
|
XMBElement Child = RootChildren.Item(i);
|
|
|
|
int ChildName = Child.GetNodeName();
|
|
if( ChildName == el_Script )
|
|
{
|
|
CStr Include = Child.GetAttributes().GetNamedItem( at_File );
|
|
|
|
if( !Include.empty() && scriptsLoaded.find( Include ) == scriptsLoaded.end() )
|
|
{
|
|
scriptsLoaded.insert( Include );
|
|
g_ScriptingHost.RunScript( Include );
|
|
}
|
|
|
|
CStr Inline = Child.GetText();
|
|
if( !Inline.empty() )
|
|
{
|
|
g_ScriptingHost.RunMemScript( Inline.c_str(), Inline.length(), filename.c_str(), Child.GetLineNumber() );
|
|
}
|
|
}
|
|
else if (ChildName == el_Traits)
|
|
{
|
|
XMBElementList TraitChildren = Child.GetChildNodes();
|
|
for(int j = 0; j < TraitChildren.Count; ++j)
|
|
{
|
|
XMBElement TraitChild = TraitChildren.Item(j);
|
|
int TraitChildName = TraitChild.GetNodeName();
|
|
if( TraitChildName == el_Footprint )
|
|
{
|
|
XMBElementList FootprintChildren = TraitChild.GetChildNodes();
|
|
float radius=0, height=0, width=0, depth=0;
|
|
bool hadRadius = false, hadDepth = false;
|
|
for(int k = 0; k < FootprintChildren.Count; ++k)
|
|
{
|
|
XMBElement FootprintChild = FootprintChildren.Item(k);
|
|
int FootprintChildName = FootprintChild.GetNodeName();
|
|
if( FootprintChildName == el_Radius )
|
|
{
|
|
hadRadius = true;
|
|
radius = CStrW( FootprintChild.GetText() ).ToFloat();
|
|
}
|
|
else if( FootprintChildName == el_Width )
|
|
{
|
|
width = CStrW( FootprintChild.GetText() ).ToFloat();
|
|
}
|
|
else if( FootprintChildName == el_Height )
|
|
{
|
|
height = CStrW( FootprintChild.GetText() ).ToFloat();
|
|
}
|
|
else if( FootprintChildName == el_Depth )
|
|
{
|
|
hadDepth = true;
|
|
depth = CStrW( FootprintChild.GetText() ).ToFloat();
|
|
}
|
|
}
|
|
if( hadRadius )
|
|
{
|
|
// Specifying a circular footprint
|
|
if( !m_bound_circle )
|
|
m_bound_circle = new CBoundingCircle();
|
|
m_bound_circle->SetRadius( radius );
|
|
m_bound_circle->SetHeight( height );
|
|
m_bound_type = CBoundingObject::BOUND_CIRCLE;
|
|
}
|
|
else if( hadDepth )
|
|
{
|
|
// Specifying a rectangular footprint
|
|
if( !m_bound_box )
|
|
m_bound_box = new CBoundingBox();
|
|
m_bound_box->SetDimensions( width, depth );
|
|
m_bound_box->SetHeight( height );
|
|
m_bound_type = CBoundingObject::BOUND_OABB;
|
|
}
|
|
// Else, entity has no footprint.
|
|
}
|
|
}
|
|
// important so that scripts can see traits
|
|
XMLLoadProperty( XeroFile, Child, CStrW() );
|
|
}
|
|
else if( ChildName == el_Event )
|
|
{
|
|
// Action...On for consistency with the GUI.
|
|
CStrW EventName = L"on" + (CStrW)Child.GetAttributes().GetNamedItem( at_On );
|
|
|
|
CStrW Code (Child.GetText());
|
|
utf16string ExternalFunction = Child.GetAttributes().GetNamedItem( at_Function );
|
|
|
|
// Does a property with this name already exist?
|
|
|
|
for( size_t eventID = 0; eventID < EVENT_LAST; eventID++ )
|
|
{
|
|
if( CStrW( EventNames[eventID] ) == EventName )
|
|
{
|
|
if( ExternalFunction != utf16string() )
|
|
{
|
|
jsval fnval;
|
|
JSBool ret = JS_GetUCProperty( g_ScriptingHost.GetContext(), g_ScriptingHost.GetGlobalObject(), ExternalFunction.c_str(), ExternalFunction.size(), &fnval );
|
|
debug_assert( ret );
|
|
JSFunction* fn = JS_ValueToFunction( g_ScriptingHost.GetContext(), fnval );
|
|
if( !fn )
|
|
{
|
|
LOG(CLogger::Error, LOG_CATEGORY, "CEntityTemplate::LoadXml: Function does not exist for event %hs in file %s. Load failed.", EventName.c_str(), filename.c_str() );
|
|
break;
|
|
}
|
|
m_EventHandlers[eventID].SetFunction( fn );
|
|
}
|
|
else
|
|
m_EventHandlers[eventID].Compile( CStrW( filename ) + L"::" + EventName + L" (" + CStrW( Child.GetLineNumber() ) + L")", Code );
|
|
HasProperty( EventName )->m_Inherited = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if( ChildName == el_SoundGroups )
|
|
{
|
|
// Read every child element's value into m_SoundGroupTable with its tag as the key
|
|
XMBElementList children = Child.GetChildNodes();
|
|
for(int j = 0; j < children.Count; ++j)
|
|
{
|
|
XMBElement child = children.Item(j);
|
|
CStr8 name = toCamelCase( XeroFile.GetElementString( child.GetNodeName() ) );
|
|
CStr8 value = child.GetText();
|
|
m_SoundGroupTable[name] = value;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
XMLLoadProperty( XeroFile, Child, CStrW() );
|
|
}
|
|
}
|
|
|
|
|
|
if( m_player == 0 )
|
|
{
|
|
m_unmodified = this;
|
|
}
|
|
else
|
|
{
|
|
m_unmodified = g_EntityTemplateCollection.GetTemplate( m_Tag, 0 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CEntityTemplate::XMLLoadProperty( const CXeromyces& XeroFile, const XMBElement& Source, const CStrW& BasePropertyName )
|
|
{
|
|
// Add a property, put the node text into it.
|
|
CStrW PropertyName = BasePropertyName + CStrW( toCamelCase( XeroFile.GetElementString( Source.GetNodeName() ) ) );
|
|
|
|
IJSComplexProperty* Existing = HasProperty( PropertyName );
|
|
if( Existing )
|
|
{
|
|
if( !Existing->m_Intrinsic )
|
|
LOG(CLogger::Warning, LOG_CATEGORY, "CEntityTemplate::XMLAddProperty: %ls already defined for %ls. Property trees will be merged.", PropertyName.c_str(), m_Tag.c_str() );
|
|
Existing->Set( this, JSParseString( Source.GetText() ) );
|
|
//Existing->m_Inherited = false;
|
|
}
|
|
else
|
|
{
|
|
if( !Source.GetText().length() )
|
|
{
|
|
// Arbitrarily say that if a node has no other value, define it to be 'true'.
|
|
// Appears to be the most convenient thing to do in most circumstances.
|
|
AddProperty( PropertyName, JSVAL_TRUE );
|
|
}
|
|
else
|
|
{
|
|
AddProperty( PropertyName, Source.GetText() );
|
|
}
|
|
}
|
|
|
|
|
|
PropertyName += CStrW( L"." );
|
|
|
|
// Retrieve any attributes it has and add them as subproperties.
|
|
XMBAttributeList AttributeSet = Source.GetAttributes();
|
|
for( int AttributeID = 0; AttributeID < AttributeSet.Count; AttributeID++ )
|
|
{
|
|
XMBAttribute Attribute = AttributeSet.Item( AttributeID );
|
|
CStrW AttributeName = PropertyName + CStr8( toCamelCase( XeroFile.GetAttributeString( Attribute.Name ) ) );
|
|
Existing = HasProperty( AttributeName );
|
|
|
|
if( Existing )
|
|
{
|
|
Existing->Set( this, JSParseString( Attribute.Value ) );
|
|
Existing->m_Inherited = false;
|
|
}
|
|
else
|
|
AddProperty( AttributeName, Attribute.Value );
|
|
}
|
|
|
|
// Retrieve any child nodes the property has and, similarly, add them as subproperties.
|
|
XMBElementList NodeSet = Source.GetChildNodes();
|
|
for( int NodeID = 0; NodeID < NodeSet.Count; NodeID++ )
|
|
{
|
|
XMBElement Node = NodeSet.Item( NodeID );
|
|
XMLLoadProperty( XeroFile, Node, PropertyName );
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
Scripting Interface
|
|
*/
|
|
|
|
// Scripting initialization
|
|
|
|
void CEntityTemplate::ScriptingInit()
|
|
{
|
|
AddMethod<CStr, &CEntityTemplate::ToString>( "toString", 0 );
|
|
|
|
AddClassProperty( L"traits.id.classes", static_cast<GetFn>(&CEntityTemplate::GetClassSet), static_cast<SetFn>(&CEntityTemplate::SetClassSet) );
|
|
|
|
AddClassProperty( L"actions.move.speed", &CEntityTemplate::m_speed );
|
|
AddClassProperty( L"actions.move.turningRadius", &CEntityTemplate::m_turningRadius );
|
|
AddClassProperty( L"actions.move.run.speed", &CEntityTemplate::m_runSpeed );
|
|
AddClassProperty( L"actions.move.run.rangeMin", &CEntityTemplate::m_runMinRange );
|
|
AddClassProperty( L"actions.move.run.range", &CEntityTemplate::m_runMaxRange );
|
|
AddClassProperty( L"actions.move.run.regenRate", &CEntityTemplate::m_runRegenRate );
|
|
AddClassProperty( L"actions.move.run.decayRate", &CEntityTemplate::m_runDecayRate );
|
|
AddClassProperty( L"actions.move.passThroughAllies", &CEntityTemplate::m_passThroughAllies );
|
|
AddClassProperty( L"actor", &CEntityTemplate::m_actorName );
|
|
AddClassProperty( L"traits.health.max", &CEntityTemplate::m_healthMax );
|
|
AddClassProperty( L"traits.health.barHeight", &CEntityTemplate::m_healthBarHeight );
|
|
AddClassProperty( L"traits.health.barSize", &CEntityTemplate::m_healthBarSize );
|
|
AddClassProperty( L"traits.health.barWidth", &CEntityTemplate::m_healthBarWidth );
|
|
AddClassProperty( L"traits.health.borderHeight", &CEntityTemplate::m_healthBorderHeight);
|
|
AddClassProperty( L"traits.health.borderWidth", &CEntityTemplate::m_healthBorderWidth );
|
|
AddClassProperty( L"traits.health.borderName", &CEntityTemplate::m_healthBorderName );
|
|
AddClassProperty( L"traits.health.regenRate", &CEntityTemplate::m_healthRegenRate );
|
|
AddClassProperty( L"traits.health.regenStart", &CEntityTemplate::m_healthRegenStart );
|
|
AddClassProperty( L"traits.health.decayRate", &CEntityTemplate::m_healthDecayRate );
|
|
AddClassProperty( L"traits.stamina.max", &CEntityTemplate::m_staminaMax );
|
|
AddClassProperty( L"traits.stamina.barHeight", &CEntityTemplate::m_staminaBarHeight );
|
|
AddClassProperty( L"traits.stamina.barSize", &CEntityTemplate::m_staminaBarSize );
|
|
AddClassProperty( L"traits.stamina.barWidth", &CEntityTemplate::m_staminaBarWidth );
|
|
AddClassProperty( L"traits.stamina.borderHeight", &CEntityTemplate::m_staminaBorderHeight);
|
|
AddClassProperty( L"traits.stamina.borderWidth", &CEntityTemplate::m_staminaBorderWidth );
|
|
AddClassProperty( L"traits.stamina.borderName", &CEntityTemplate::m_staminaBorderName );
|
|
AddClassProperty( L"traits.rally.name", &CEntityTemplate::m_rallyName );
|
|
AddClassProperty( L"traits.rally.width", &CEntityTemplate::m_rallyWidth );
|
|
AddClassProperty( L"traits.rally.height", &CEntityTemplate::m_rallyHeight );
|
|
AddClassProperty( L"traits.flankPenalty.sectors", &CEntityTemplate::m_sectorDivs );
|
|
AddClassProperty( L"traits.pitch.sectors", &CEntityTemplate::m_pitchDivs );
|
|
AddClassProperty( L"traits.pitch.value", &CEntityTemplate::m_pitchValue );
|
|
AddClassProperty( L"traits.rank.width", &CEntityTemplate::m_rankWidth );
|
|
AddClassProperty( L"traits.rank.height", &CEntityTemplate::m_rankHeight );
|
|
AddClassProperty( L"traits.rank.name", &CEntityTemplate::m_rankName );
|
|
AddClassProperty( L"traits.ai.stance.curr", &CEntityTemplate::m_stanceName );
|
|
AddClassProperty( L"traits.miniMap.type", &CEntityTemplate::m_minimapType );
|
|
AddClassProperty( L"traits.miniMap.red", &CEntityTemplate::m_minimapR );
|
|
AddClassProperty( L"traits.miniMap.green", &CEntityTemplate::m_minimapG );
|
|
AddClassProperty( L"traits.miniMap.blue", &CEntityTemplate::m_minimapB );
|
|
AddClassProperty( L"traits.anchor.type", &CEntityTemplate::m_anchorType );
|
|
AddClassProperty( L"traits.anchor.conformX", &CEntityTemplate::m_anchorConformX );
|
|
AddClassProperty( L"traits.anchor.conformZ", &CEntityTemplate::m_anchorConformZ );
|
|
AddClassProperty( L"traits.vision.los", &CEntityTemplate::m_los );
|
|
AddClassProperty( L"traits.vision.permanent", &CEntityTemplate::m_visionPermanent );
|
|
AddClassProperty( L"traits.display.bars.enabled", &CEntityTemplate::m_barsEnabled );
|
|
AddClassProperty( L"traits.display.bars.offset", &CEntityTemplate::m_barOffset );
|
|
AddClassProperty( L"traits.display.bars.height", &CEntityTemplate::m_barHeight );
|
|
AddClassProperty( L"traits.display.bars.width", &CEntityTemplate::m_barWidth );
|
|
AddClassProperty( L"traits.display.bars.border", &CEntityTemplate::m_barBorder );
|
|
AddClassProperty( L"traits.display.bars.borderSize", &CEntityTemplate::m_barBorderSize );
|
|
AddClassProperty( L"traits.isTerritoryCentre", &CEntityTemplate::m_isTerritoryCentre );
|
|
AddClassProperty( L"traits.creation.foundation", &CEntityTemplate::m_foundation );
|
|
AddClassProperty( L"traits.creation.socket", &CEntityTemplate::m_socket );
|
|
AddClassProperty( L"traits.creation.territoryRestriction", &CEntityTemplate::m_territoryRestriction );
|
|
AddClassProperty( L"traits.creation.buildingLimitCategory", &CEntityTemplate::m_buildingLimitCategory );
|
|
|
|
|
|
|
|
CJSComplex<CEntityTemplate>::ScriptingInit( "EntityTemplate" );
|
|
}
|
|
|
|
// Script-bound functions
|
|
|
|
JSObject* CEntityTemplate::GetScriptExecContext( IEventTarget* target )
|
|
{
|
|
return( target->GetScriptExecContext( target ) );
|
|
}
|
|
|
|
CStr CEntityTemplate::ToString( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
|
|
{
|
|
if( m_player == 0 )
|
|
return "[object EntityTemplate: " + CStr(m_Tag) + " base]";
|
|
else
|
|
return "[object EntityTemplate: " + CStr(m_Tag) + " for player " + CStr((unsigned)m_player->GetPlayerID()) + "]";
|
|
}
|