/*virtual*/ void WBActionEldGoToLevel::InitializeFromDefinition( const SimpleString& DefinitionName )
{
WBAction::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( GoToNextLevel );
m_GoToNextLevel = ConfigManager::GetBool( sGoToNextLevel, false, sDefinitionName );
STATICHASH( GoToPrevLevel );
m_GoToPrevLevel = ConfigManager::GetBool( sGoToPrevLevel, false, sDefinitionName );
STATICHASH( ReturnToHub );
m_ReturnToHub = ConfigManager::GetBool( sReturnToHub, false, sDefinitionName );
STATICHASH( Restart );
m_Restart = ConfigManager::GetBool( sRestart, false, sDefinitionName );
STATICHASH( FullRestart );
m_FullRestart = ConfigManager::GetBool( sFullRestart, false, sDefinitionName );
STATICHASH( Immediate );
m_Immediate = ConfigManager::GetBool( sImmediate, false, sDefinitionName );
STATICHASH( Level );
m_Level = ConfigManager::GetString( sLevel, "", sDefinitionName );
MAKEHASH( m_Level );
STATICHASH( WorldDef );
m_WorldDef = ConfigManager::GetHash( sWorldDef, HashedString::NullString, sm_Level );
}
void UIWidgetText::UpdatePosition()
{
MAKEHASH( m_Archetype );
MAKEHASH( m_Name );
STATICHASH( DisplayWidth );
const float DisplayWidth = ConfigManager::GetFloat( sDisplayWidth );
const float ParentWidth = m_OriginParent ? m_OriginParent->GetWidth() : DisplayWidth;
const float ParentX = m_OriginParent ? Ceiling( m_OriginParent->GetX() ) : 0.0f;
STATICHASH( DisplayHeight );
const float DisplayHeight = ConfigManager::GetFloat( sDisplayHeight );
const float ParentHeight = m_OriginParent ? m_OriginParent->GetHeight() : DisplayHeight;
const float ParentY = m_OriginParent ? Ceiling( m_OriginParent->GetY() ) : 0.0f;
STATICHASH( PixelX );
STATICHASH( PixelOffsetX );
STATICHASH( ScreenX );
float X =
ConfigManager::GetArchetypeFloat( sPixelOffsetX, sm_Archetype, 0.0f, sm_Name ) +
Pick(
ConfigManager::GetArchetypeFloat( sPixelX, sm_Archetype, 0.0f, sm_Name ),
ParentWidth * ConfigManager::GetArchetypeFloat( sScreenX, sm_Archetype, 0.0f, sm_Name ) );
STATICHASH( PixelY );
STATICHASH( PixelOffsetY );
STATICHASH( ScreenY );
float Y =
ConfigManager::GetArchetypeFloat( sPixelOffsetY, sm_Archetype, 0.0f, sm_Name ) +
Pick(
ConfigManager::GetArchetypeFloat( sPixelY, sm_Archetype, 0.0f, sm_Name ),
ParentHeight * ConfigManager::GetArchetypeFloat( sScreenY, sm_Archetype, 0.0f, sm_Name ) );
// Get dimensions so we can do different origins
Array<STypesetGlyph> UnusedTypesetting;
Vector2 Dimensions;
Array<unicode_t> CodePoints;
GetString().UTF8ToUnicode( CodePoints );
m_Font->Arrange( CodePoints, SRect( 0.0f, 0.0f, m_WrapWidth, 0.0f ), UnusedTypesetting, Dimensions );
AdjustDimensionsToParent( X, Y, Dimensions.x, Dimensions.y, ParentX, ParentY, ParentWidth, ParentHeight );
GetPositionFromOrigin( X, Y, Dimensions.x, Dimensions.y );
STATICHASH( ClampToPixelGrid );
m_ClampToPixelGrid = ConfigManager::GetArchetypeBool( sClampToPixelGrid, sm_Archetype, true, sm_Name );
if( m_ClampToPixelGrid )
{
// Add 0.5 to compensate for font UVs being on half pixel intervals.
m_TopLeft.x = Round( m_TopLeft.x ) + 0.5f;
m_TopLeft.y = Round( m_TopLeft.y ) + 0.5f;
}
// Offset to properly align on pixel grid.
const float PixelGridOffset = GetPixelGridOffset();
m_TopLeft.x -= PixelGridOffset;
m_TopLeft.y -= PixelGridOffset;
}
const SimpleString EldritchGame::GetRIPLevel()
{
STATICHASH( EldritchWorld );
STATICHASH( DefaultRIPName );
const SimpleString DefaultRIPName = ConfigManager::GetString( sDefaultRIPName, "", sEldritchWorld );
MAKEHASH( m_CurrentLevelName );
STATICHASH( RIPName );
const SimpleString RIPLevelName = ConfigManager::GetString( sRIPName, DefaultRIPName.CStr(), sm_CurrentLevelName );
MAKEHASH( RIPLevelName );
const SimpleString RIPLevel = ConfigManager::GetLocalizedString( sRIPLevelName, "" );
return RIPLevel;
}
void WBPEConstantBool::InitializeFromDefinition( const SimpleString& DefinitionName )
{
STATICHASH( Value );
MAKEHASH( DefinitionName );
m_Value = ConfigManager::GetBool( sValue, false, sDefinitionName );
}
void UIScreenEldBindInputs::CreateLabelWidgetDefinition()
{
m_LabelWidgetDefinitionName = SimpleString::PrintF( "_BindLabel%d", m_ExposedInputIndex );
const SimpleString LabelString = SimpleString::PrintF( "Bind%s", m_ExposedInput.CStr() );
MAKEHASH( m_LabelWidgetDefinitionName );
STATICHASH( UIWidgetType );
ConfigManager::SetString( sUIWidgetType, "Text", sm_LabelWidgetDefinitionName );
STATICHASH( Archetype );
ConfigManager::SetString( sArchetype, m_ArchetypeName.CStr(), sm_LabelWidgetDefinitionName );
STATICHASH( Parent );
ConfigManager::SetString( sParent, m_Parent.CStr(), sm_LabelWidgetDefinitionName );
STATICHASH( String );
ConfigManager::SetString( sString, LabelString.CStr(), sm_LabelWidgetDefinitionName );
STATICHASH( PixelX );
ConfigManager::SetFloat( sPixelX, m_Column0X, sm_LabelWidgetDefinitionName );
STATICHASH( PixelY );
ConfigManager::SetFloat( sPixelY, m_Y, sm_LabelWidgetDefinitionName );
}
void UIScreenEldBindInputs::CreateCompositeWidgetDefinition()
{
m_CompositeWidgetDefinitionName = SimpleString::PrintF( "_BindComposite%d", m_ExposedInputIndex );
MAKEHASH( m_CompositeWidgetDefinitionName );
STATICHASH( UIWidgetType );
ConfigManager::SetString( sUIWidgetType, "Composite", sm_CompositeWidgetDefinitionName );
STATICHASH( Focus );
ConfigManager::SetBool( sFocus, true, sm_CompositeWidgetDefinitionName );
STATICHASH( NumChildren );
ConfigManager::SetInt( sNumChildren, 4, sm_CompositeWidgetDefinitionName );
STATICHASH( Child0 );
ConfigManager::SetString( sChild0, m_LabelWidgetDefinitionName.CStr(), sm_CompositeWidgetDefinitionName );
STATICHASH( Child1 );
ConfigManager::SetString( sChild1, m_KeyboardWidgetDefinitionName.CStr(), sm_CompositeWidgetDefinitionName );
STATICHASH( Child2 );
ConfigManager::SetString( sChild2, m_MouseWidgetDefinitionName.CStr(), sm_CompositeWidgetDefinitionName );
STATICHASH( Child3 );
ConfigManager::SetString( sChild3, m_ControllerWidgetDefinitionName.CStr(), sm_CompositeWidgetDefinitionName );
STATICHASH( NumActions );
ConfigManager::SetInt( sNumActions, 1, sm_CompositeWidgetDefinitionName );
STATICHASH( Action0 );
ConfigManager::SetString( sAction0, m_BindActionDefinitionName.CStr(), sm_CompositeWidgetDefinitionName );
}
void UIScreenEldBindInputs::CreateControllerWidgetDefinition()
{
m_ControllerWidgetDefinitionName = SimpleString::PrintF( "_BindController%d", m_ExposedInputIndex );
const SimpleString InputString = SimpleString::PrintF( "#{l:EldritchController:%s}", m_ExposedInput.CStr() ); // Using localization to map name to glyph
MAKEHASH( m_ControllerWidgetDefinitionName );
STATICHASH( UIWidgetType );
ConfigManager::SetString( sUIWidgetType, "Text", sm_ControllerWidgetDefinitionName );
STATICHASH( Archetype );
ConfigManager::SetString( sArchetype, m_ControllerArchetypeName.CStr(), sm_ControllerWidgetDefinitionName );
STATICHASH( Parent );
ConfigManager::SetString( sParent, m_Parent.CStr(), sm_ControllerWidgetDefinitionName );
STATICHASH( IsLiteral );
ConfigManager::SetBool( sIsLiteral, true, sm_ControllerWidgetDefinitionName );
STATICHASH( DynamicString );
ConfigManager::SetString( sDynamicString, InputString.CStr(), sm_ControllerWidgetDefinitionName );
STATICHASH( PixelX );
ConfigManager::SetFloat( sPixelX, m_Column3X, sm_ControllerWidgetDefinitionName );
STATICHASH( PixelY );
ConfigManager::SetFloat( sPixelY, m_Y, sm_ControllerWidgetDefinitionName );
}
void UIScreenEldBindInputs::CreateMouseWidgetDefinition()
{
m_MouseWidgetDefinitionName = SimpleString::PrintF( "_BindMouse%d", m_ExposedInputIndex );
const SimpleString InputString = SimpleString::PrintF( "#{l:EldritchMouse:%s}", m_ExposedInput.CStr() );
MAKEHASH( m_MouseWidgetDefinitionName );
STATICHASH( UIWidgetType );
ConfigManager::SetString( sUIWidgetType, "Text", sm_MouseWidgetDefinitionName );
STATICHASH( Archetype );
ConfigManager::SetString( sArchetype, m_ArchetypeName.CStr(), sm_MouseWidgetDefinitionName );
STATICHASH( Parent );
ConfigManager::SetString( sParent, m_Parent.CStr(), sm_MouseWidgetDefinitionName );
STATICHASH( IsLiteral );
ConfigManager::SetBool( sIsLiteral, true, sm_MouseWidgetDefinitionName );
STATICHASH( DynamicString );
ConfigManager::SetString( sDynamicString, InputString.CStr(), sm_MouseWidgetDefinitionName );
STATICHASH( PixelX );
ConfigManager::SetFloat( sPixelX, m_Column2X, sm_MouseWidgetDefinitionName );
STATICHASH( PixelY );
ConfigManager::SetFloat( sPixelY, m_Y, sm_MouseWidgetDefinitionName );
}
void EldritchGame::RequestGoToPrevLevel()
{
XTRACE_FUNCTION;
MAKEHASH( m_CurrentLevelName );
STATICHASH( PrevLevel );
const SimpleString PrevLevelName = ConfigManager::GetString( sPrevLevel, "", sm_CurrentLevelName );
MAKEHASH( PrevLevelName );
STATICHASH( WorldDef );
const HashedString PrevWorldDef = ConfigManager::GetHash( sWorldDef, HashedString::NullString, sPrevLevelName );
RequestGoToLevel( PrevLevelName, PrevWorldDef, false );
}
void EldritchGame::Initialize()
{
if( GetSaveLoad()->TryLoadMaster() )
{
// We're good! Don't flush the master file; if the game crashes, we still want it around!
}
else
{
// There was no master file, or the master file didn't have a world state (was saved
// when the player was dead, etc.). Create a new world, but don't mess with persistence.
STATICHASH( EldritchWorld );
STATICHASH( InitialLevel );
SetCurrentLevelName( ConfigManager::GetString( sInitialLevel, "", sEldritchWorld ) );
MAKEHASH( m_CurrentLevelName );
STATICHASH( WorldDef );
const HashedString InitialWorldDef = ConfigManager::GetHash( sWorldDef, HashedString::NullString, sm_CurrentLevelName );
EldritchFramework* const pFramework = EldritchFramework::GetInstance();
EldritchWorld* const pWorld = pFramework->GetWorld();
pWorld->SetCurrentWorld( InitialWorldDef );
pWorld->Create();
pFramework->InitializeTools();
RefreshUIReturnToHubEnabled();
}
}
void InputContext::Initialize( const SimpleString& DefinitionName, InputSystem* const pInputSystem )
{
ASSERT( pInputSystem );
// Use "InputContext_DummyInput" instead of NullString as the default, so that we can validly redirect to a null input.
STATIC_HASHED_STRING( InputContext_DummyInput );
MAKEHASH( DefinitionName );
STATICHASH( Suppress );
m_SuppressUnredirectedInputs = ConfigManager::GetInheritedBool( sSuppress, false, sDefinitionName );
const uint NumInputs = pInputSystem->m_Inputs.Size();
for( uint InputIndex = 0; InputIndex < NumInputs; ++InputIndex )
{
const InputSystem::SInput& Input = pInputSystem->m_Inputs[ InputIndex ];
const HashedString RedirectedInput = ConfigManager::GetInheritedHash( Input.m_String, sInputContext_DummyInput, sDefinitionName );
if( RedirectedInput != sInputContext_DummyInput )
{
m_InputRedirects[ Input.m_Hash ] = RedirectedInput;
}
}
const uint NumAnalogInputs = pInputSystem->m_AnalogInputs.Size();
for( uint AnalogInputIndex = 0; AnalogInputIndex < NumAnalogInputs; ++AnalogInputIndex )
{
const InputSystem::SAnalogInput& AnalogInput = pInputSystem->m_AnalogInputs[ AnalogInputIndex ];
const HashedString RedirectedInput = ConfigManager::GetInheritedHash( AnalogInput.m_String, sInputContext_DummyInput, sDefinitionName );
if( RedirectedInput != sInputContext_DummyInput )
{
m_InputRedirects[ AnalogInput.m_Hash ] = RedirectedInput;
}
}
}
/*virtual*/ void WBPEGetState::InitializeFromDefinition( const SimpleString& DefinitionName )
{
MAKEHASH( DefinitionName );
STATICHASH( EntityPE );
m_EntityPE = WBParamEvaluatorFactory::Create( ConfigManager::GetString( sEntityPE, "", sDefinitionName ) );
}
void EldritchFramework::InitializeDLC() {
STATICHASH(NumDLC);
const uint NumDLC = ConfigManager::GetInt(sNumDLC);
for (uint DLCIndex = 0; DLCIndex < NumDLC; ++DLCIndex) {
const SimpleString DLCName =
ConfigManager::GetSequenceString("DLC%d", DLCIndex, "");
MAKEHASH(DLCName);
STATICHASH(PackageFilename);
const SimpleString PackageFilename =
ConfigManager::GetString(sPackageFilename, "", sDLCName);
// DLC will always preempt base content (so it can be used for patching as
// well as DLC per se).
PackStream::StaticAddPackageFile(PackageFilename.CStr(), true);
// Load config files for DLC, if DLC was successfully loaded.
// (We can't check a return value from StaticAddPackageFile, because I won't
// have package
// files during development but it still needs to load loose DLC files.)
STATICHASH(NumConfigFiles);
const uint NumConfigFiles =
ConfigManager::GetInt(sNumConfigFiles, 0, sDLCName);
for (uint ConfigFileIndex = 0; ConfigFileIndex < NumConfigFiles;
++ConfigFileIndex) {
const SimpleString ConfigFile = ConfigManager::GetSequenceString(
"ConfigFile%d", ConfigFileIndex, "", sDLCName);
if (PackStream::StaticFileExists(ConfigFile.CStr())) {
ConfigManager::Load(PackStream(ConfigFile.CStr()));
}
}
}
}
void WBPEConstantFloat::InitializeFromDefinition( const SimpleString& DefinitionName )
{
STATICHASH( Value );
MAKEHASH( DefinitionName );
m_Value = ConfigManager::GetFloat( sValue, 0.0f, sDefinitionName );
}
void RodinBTNodeLog::InitializeFromDefinition(
const SimpleString& DefinitionName) {
MAKEHASH(DefinitionName);
STATICHASH(Message);
m_Message = ConfigManager::GetString(sMessage, "", sDefinitionName);
}
/*virtual*/ void WBCompEldSensorVision::InitializeFromDefinition( const SimpleString& DefinitionName )
{
Super::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( EyeOffsetZ );
m_EyeOffsetZ = ConfigManager::GetInheritedFloat( sEyeOffsetZ, 0.0f, sDefinitionName );
STATICHASH( Radius );
m_RadiusSq = Square( ConfigManager::GetInheritedFloat( sRadius, 0.0f, sDefinitionName ) );
STATICHASH( ConeAngle );
m_ConeCos = Cos( DEGREES_TO_RADIANS( ConfigManager::GetInheritedFloat( sConeAngle, 0.0f, sDefinitionName ) ) );
STATICHASH( ConeScaleZ );
const float ConeScaleZ = ConfigManager::GetInheritedFloat( sConeScaleZ, 0.0f, sDefinitionName );
m_ConeInvZScale = ( ConeScaleZ > 0.0f ) ? ( 1.0f / ConeScaleZ ) : ConeScaleZ;
STATICHASH( CertaintyFalloffRadius );
m_CertaintyFalloffRadius = ConfigManager::GetInheritedFloat( sCertaintyFalloffRadius, 0.0f, sDefinitionName );
STATICHASH( DistanceCertaintyFactor );
m_DistanceCertaintyFactor = ConfigManager::GetInheritedFloat( sDistanceCertaintyFactor, 0.0f, sDefinitionName );
STATICHASH( CertaintyVelocity );
m_CertaintyVelocity = ConfigManager::GetInheritedFloat( sCertaintyVelocity, 0.0f, sDefinitionName );
STATICHASH( CertaintyDecay );
m_CertaintyDecay = ConfigManager::GetInheritedFloat( sCertaintyDecay, 0.0f, sDefinitionName );
}
// Make deep copies so the caller can delete its arrays
// (I chose to do this because it's synonymous with copying
// verts into D3D buffers.)
void BoneArray::Init( HashedString* BoneNames, SBone* Bones, const char* MeshFilename, Animation* Animations, int NumFrames, int NumBones, int NumAnims )
{
m_NumFrames = NumFrames;
m_NumBones = NumBones;
m_NumAnimations = NumAnims;
int TotalBones = m_NumFrames * m_NumBones;
m_BoneNames = new HashedString[ NumBones ];
memcpy_s( m_BoneNames, sizeof( HashedString ) * NumBones, BoneNames, sizeof( HashedString ) * NumBones );
m_Bones = new SBone[ TotalBones ];
memcpy_s( m_Bones, sizeof( SBone ) * TotalBones, Bones, sizeof( SBone ) * TotalBones );
m_Animations = new Animation[ NumAnims ];
memcpy_s( m_Animations, sizeof( Animation ) * NumAnims, Animations, sizeof( Animation ) * NumAnims );
// Set runtime anim properties from config
STATICHASH( AnimationMap );
MAKEHASH( MeshFilename );
SimpleString AnimationMapName = ConfigManager::GetString( sMeshFilename, "", sAnimationMap );
for( int AnimIndex = 0; AnimIndex < NumAnims; ++AnimIndex )
{
Animation& Animation = m_Animations[ AnimIndex ];
Animation.InitializeFromDefinition( SimpleString::PrintF( "%s:%s", AnimationMapName.CStr(), Animation.m_Name ) );
}
}
RodinBTNode* RodinBTNodeFactory::Create(
const SimpleString& DefinitionName,
WBCompRodinBehaviorTree* const pBehaviorTree) {
STATICHASH(NodeType);
MAKEHASH(DefinitionName);
HashedString NodeType =
ConfigManager::GetHash(sNodeType, "", sDefinitionName);
Map<HashedString, RodinBTNodeFactoryFunc>::Iterator FactoryIter =
sFactoryFuncMap.Search(NodeType);
if (FactoryIter.IsNull()) {
PRINTF("Invalid type requested for RodinBTNode %s.\n",
DefinitionName.CStr());
WARNDESC("Invalid RodinBTNode type requested.");
return nullptr;
}
RodinBTNodeFactoryFunc pFactory = (*FactoryIter);
ASSERT(pFactory);
RodinBTNode* pNewNode = pFactory();
ASSERT(pNewNode);
pNewNode->m_DefinitionName = DefinitionName;
pNewNode->m_BehaviorTree = pBehaviorTree;
pNewNode->InitializeFromDefinition(DefinitionName);
return pNewNode;
}
void EldritchGame::RequestGoToNextLevel()
{
XTRACE_FUNCTION;
MAKEHASH( m_CurrentLevelName );
STATICHASH( NextLevel );
const SimpleString NextLevelName = ConfigManager::GetString( sNextLevel, "", sm_CurrentLevelName );
MAKEHASH( NextLevelName );
STATICHASH( WorldDef );
const HashedString NextWorldDef = ConfigManager::GetHash( sWorldDef, HashedString::NullString, sNextLevelName );
RequestGoToLevel( NextLevelName, NextWorldDef, true );
}
void WBPERodinBlackboardGet::InitializeFromDefinition( const SimpleString& DefinitionName )
{
MAKEHASH( DefinitionName );
STATICHASH( BlackboardKey );
m_BlackboardKey = ConfigManager::GetHash( sBlackboardKey, HashedString::NullString, sDefinitionName );
}
void MusicManager::PlaySequence( const SimpleString& DefinitionName )
{
// Interrupt the current sequences
Flush();
// Unify some of this with what happens in tick
STATICHASH( File );
MAKEHASH( DefinitionName );
SimpleString Filename = ConfigManager::GetString( sFile, "", sDefinitionName );
if( Filename != "" )
{
SSoundInit SoundInit;
SoundInit.m_Filename = Filename.CStr();
SoundInit.m_IsStream = true;
SoundInit.m_IsLooping = false;
SoundInit.m_Is3D = false;
SoundInit.m_Category = "Music";
SoundInit.m_Priority = ESP_High;
m_CurrentSequence.m_Sound = m_AudioSystem->GetSoundManager()->GetSound( SoundInit, DefinitionName );
m_CurrentSequence.m_Instance = m_CurrentSequence.m_Sound->CreateSoundInstance();
m_AudioSystem->AddSoundInstance( m_CurrentSequence.m_Instance );
m_CurrentSequence.m_Instance->Tick(); // Tick to apply all properties
m_CurrentSequence.m_Instance->SetPaused( false );
m_CurrentSequence.m_DefinitionName = DefinitionName;
QueueNextSequence();
}
}
void RodinBTNodeConditionPE::InitializeFromDefinition( const SimpleString& DefinitionName )
{
MAKEHASH( DefinitionName );
STATICHASH( ValuePE );
m_ValuePE.InitializeFromDefinition( ConfigManager::GetString( sValuePE, "", sDefinitionName ) );
}
void RodinBTNodeSendEvent::InitializeFromDefinition( const SimpleString& DefinitionName )
{
MAKEHASH( DefinitionName );
STATICHASH( EventName );
m_EventName = ConfigManager::GetHash( sEventName, "", sDefinitionName );
STATICHASH( QueueEvent );
m_QueueEvent = ConfigManager::GetBool( sQueueEvent, false, sDefinitionName );
STATICHASH( DispatchDelay );
m_DispatchDelay = ConfigManager::GetFloat( sDispatchDelay, 0.0f, sDefinitionName );
STATICHASH( Recipient );
const SimpleString RecipientDef = ConfigManager::GetString( sRecipient, "", sDefinitionName );
m_RecipientPE.InitializeFromDefinition( RecipientDef );
STATICHASH( NumParameters );
const uint NumParameters = ConfigManager::GetInt( sNumParameters, 0, sDefinitionName );
for( uint ParameterIndex = 0; ParameterIndex < NumParameters; ++ParameterIndex )
{
const HashedString Name = ConfigManager::GetSequenceHash( "Parameter%dName", ParameterIndex, HashedString::NullString, sDefinitionName );
const SimpleString ValuePEDef = ConfigManager::GetSequenceString( "Parameter%dValue", ParameterIndex, "", sDefinitionName );
SNamedParameter& Parameter = m_Parameters.PushBack();
Parameter.m_Name = Name;
Parameter.m_ValuePE.InitializeFromDefinition( ValuePEDef );
}
}
void RodinBTNodeEldTurnToward::InitializeFromDefinition( const SimpleString& DefinitionName )
{
MAKEHASH( DefinitionName );
STATICHASH( TurnTargetBlackboardKey );
m_TurnTargetBlackboardKey = ConfigManager::GetHash( sTurnTargetBlackboardKey, HashedString::NullString, sDefinitionName );
}
void Sprite::InitializeAnimations( const SimpleString& SpriteName )
{
STATICHASH( Width );
STATICHASH( Height );
STATICHASH( NumAnimations );
MAKEHASH( SpriteName );
m_Width = ConfigManager::GetInt( sWidth, m_pSurface->GetWidth(), sSpriteName );
m_Height = ConfigManager::GetInt( sHeight, m_pSurface->GetHeight(), sSpriteName );
m_Animations.Clear();
ASSERT( m_pSurface );
ASSERT( m_Width <= m_pSurface->GetWidth() );
ASSERT( m_Height <= m_pSurface->GetHeight() );
int FrameColumns = m_pSurface->GetWidth() / m_Width;
int NumAnimations = ConfigManager::GetInt( sNumAnimations, 0, sSpriteName );
for( int AnimIndex = 0; AnimIndex < NumAnimations; ++AnimIndex )
{
Sprite::Animation* Animation = new Sprite::Animation;
SimpleString AnimationName = ConfigManager::GetSequenceString( "Animation%d", AnimIndex, "", sSpriteName );
STATICHASH( NumFrames );
MAKEHASH( AnimationName );
int NumFrames = ConfigManager::GetInt( sNumFrames, 0, sAnimationName );
for( int FrameIndex = 0; FrameIndex < NumFrames; ++FrameIndex )
{
Sprite::Frame Frame;
int FrameNum = ConfigManager::GetSequenceInt( "Frame%d", FrameIndex, 0, sAnimationName );
Frame.Duration = ConfigManager::GetSequenceFloat( "Duration%d", FrameIndex, 0.0f, sAnimationName );
Frame.x = ( FrameNum % FrameColumns ) * m_Width;
Frame.y = ( FrameNum / FrameColumns ) * m_Height;
ASSERT( Frame.Duration > 0.0f || NumFrames == 1 );
Animation->m_Frames.PushBack( Frame );
}
m_Animations.Insert( HashedString( AnimationName ), Animation );
}
}
void RodinBTNodeTimeout::InitializeFromDefinition( const SimpleString& DefinitionName )
{
RodinBTNodeDecorator::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( TimeoutPE );
m_TimeoutPE.InitializeFromDefinition( ConfigManager::GetString( sTimeoutPE, "", sDefinitionName ) );
}
/*virtual*/ void WBActionEldSetLight::InitializeFromDefinition( const SimpleString& DefinitionName )
{
WBAction::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( AddLight );
m_AddLight = ConfigManager::GetBool( sAddLight, false, sDefinitionName );
}
void RodinBTNodeUseStatMod::InitializeFromDefinition( const SimpleString& DefinitionName )
{
RodinBTNodeDecorator::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( StatModEvent );
m_StatModEvent = ConfigManager::GetHash( sStatModEvent, HashedString::NullString, sDefinitionName );
}
/*virtual*/ void WBCompEldIcicles::InitializeFromDefinition( const SimpleString& DefinitionName )
{
Super::InitializeFromDefinition( DefinitionName );
MAKEHASH( DefinitionName );
STATICHASH( CheckDistance );
m_CheckDistance = ConfigManager::GetInheritedFloat( sCheckDistance, 0.0f, sDefinitionName );
}
Clock::MultiplierRequest* Clock::AddMultiplierRequest( const SimpleString& DefinitionName )
{
STATICHASH( Duration );
STATICHASH( Multiplier );
MAKEHASH( DefinitionName );
return AddMultiplierRequest(
ConfigManager::GetFloat( sDuration, 0.0f, sDefinitionName ),
ConfigManager::GetFloat( sMultiplier, 0.0f, sDefinitionName ) );
}
