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