void StateManager::resetActiveState(void) { // Is there no currently active state to reset? if(!mStack.empty()) { // Retrieve the currently active state IState* anState = mStack.back(); // Log the resetting of an active state ILOG() << "StateManager::resetActiveState(" << anState->getID() << ")" << std::endl; // Pause the currently active state anState->pause(); // Call the ReInit method to Reset the currently active state anState->reInit(); // Resume the currently active state anState->resume(); // Don't keep pointers around we don't need anymore anState = NULL; } else { // Quit the application with an error status response if(NULL != mApp) { mApp->quit(StatusAppStackEmpty); } return; } }
void StateManager::removeActiveState(void) { // Is there no currently active state to drop? if(!mStack.empty()) { // Retrieve the currently active state IState* anState = mStack.back(); // Log the removing of an active state ILOG() << "StateManager::removeActiveState(" << anState->getID() << ")" << std::endl; // Pause the currently active state anState->pause(); // Deinitialize the currently active state before we pop it off the stack anState->deInit(); // Pop the currently active state off the stack mStack.pop_back(); // Move this state to our dropped stack mDead.push_back(anState); // Don't keep pointers around we don't need anymore anState = NULL; } else { // Quit the application with an error status response if(NULL != mApp) { mApp->quit(StatusAppStackEmpty); } return; } // Is there another state to activate? then call Resume to activate it if(!mStack.empty()) { // Has this state ever been initialized? if(mStack.back()->isInitComplete()) { // Resume the new active state mStack.back()->resume(); } else { // Initialize the new active state mStack.back()->doInit(); } } else { // There are no states on the stack, exit the program if(NULL != mApp) { mApp->quit(StatusAppOK); } } }
bool StateManager::update(size_t dt) { if (m_bNeedDestroy) { IState* st = m_States.top(); st->destroy(); delete st; m_States.pop(); m_bNeedDestroy = false; return true; } if (m_newState != 0) { m_States.push(m_newState); m_newState = 0; return true; } if (m_States.empty()) return false; if (m_bNeedInit) { m_States.top()->init(); m_bNeedInit = false; return true; } m_States.top()->update(dt); m_States.top()->render(); return true; }
IState* IState::clone() { IState *res = IState::create(); res->copy(this); return res; }
void StateManager::destroy() { for (size_t i = 0; i != eState_Size; ++i) { IState* s = states_[i]; if (s) { s->destroy(); delete s; states_[i] = 0; } } }
void StateManager::setActiveState(Id theStateID) { std::vector<IState*>::iterator it; // Find the state that matches theStateID for(it=mStack.begin(); it < mStack.end(); it++) { // Does this state match theStateID? then activate it as the new // currently active state if((*it)->getID() == theStateID) { // Get a pointer to soon to be currently active state IState* anState = *it; // Log the setting of a previously active state as the current active state ILOG() << "StateManager::setActiveState(" << anState->getID() << ")" << std::endl; // Erase it from the list of previously active states mStack.erase(it); // Is there a state currently running? then Pause it if(!mStack.empty()) { // Pause the currently running state since we are changing the // currently active state to the one specified by theStateID mStack.back()->pause(); } // Add the new active state mStack.push_back(anState); // Don't keep pointers we don't need around anState = NULL; // Has this state ever been initialized? if(mStack.back()->isInitComplete()) { // Resume the new active state mStack.back()->resume(); } else { // Initialize the new active state mStack.back()->doInit(); } // Exit our find loop break; } // if((*it)->getID() == theStateID) } // for(it=mStack.begin(); it < mStack.end(); it++) }
IState* IState::clone() { IState *res = IState::create(); res->copy(this); //std::map< int, int>::iterator iterInt; //iterInt = m_IntProps.begin(); //for ( ; iterInt != m_IntProps.end(); ++iterInt) { // // res->m_IntProps[iterInt->first] = iterInt->second; //} //std::map< int, bool>::iterator iterBool; //iterBool = m_EnableProps.begin(); //for ( ; iterBool != m_EnableProps.end(); ++iterBool) { // // res->m_EnableProps[iterBool->first] = iterBool->second; //} //std::map< int, float>::iterator iterFloat; //iterFloat = m_FloatProps.begin(); //for ( ; iterFloat != m_FloatProps.end(); ++iterFloat) { // // res->m_FloatProps[iterFloat->first] = iterFloat->second; //} //std::map< int, vec4>::iterator iterVec4; //iterVec4 = m_Float4Props.begin(); //for ( ; iterVec4 != m_Float4Props.end(); ++iterVec4) { // // res->m_Float4Props[iterVec4->first] = iterVec4->second; //} //std::map< int, bvec4>::iterator iterBool4; //iterBool4 = m_Bool4Props.begin(); //for ( ; iterBool4 != m_Bool4Props.end(); ++iterBool4) { // // res->m_Bool4Props[iterBool4->first] = iterBool4->second; //} //iterInt = m_EnumProps.begin(); //for ( ; iterInt != m_EnumProps.end(); ++iterInt) { // // res->m_EnumProps[iterInt->first] = iterInt->second; //} return res; }
StateManager::~StateManager() { ILOGM("StateManager::dtor()"); // Drop all active states while(!mStack.empty()) { // Retrieve the currently active state IState* anState = mStack.back(); // Pop the currently active state off the stack mStack.pop_back(); // Pause the currently active state anState->pause(); // De-initialize the state anState->deInit(); // Handle the cleanup before we pop it off the stack anState->cleanup(); // Just delete the state now delete anState; // Don't keep pointers around we don't need anState = NULL; } // Delete all our dropped states while(!mDead.empty()) { // Retrieve the currently active state IState* anState = mDead.back(); // Pop the currently active state off the stack mDead.pop_back(); // Pause the currently active state anState->pause(); // De-initialize the state anState->deInit(); // Handle the cleanup before we pop it off the stack anState->cleanup(); // Just delete the state now delete anState; // Don't keep pointers around we don't need anState = NULL; } // Clear pointers we don't need anymore mApp = NULL; }
bool Manager::_popState( IProgressState* newpstate ) { if( !m_states->current() ) return( false ); if( !newpstate ) newpstate = m_progressStateDefault; m_engine->resetTimer(); m_states->current()->onExit(); m_engine->resetTimer(); ActorManager* am = m_actors->current(); DELETE_OBJECT( am ); m_actors->pop(); ControlManager* ctm = m_controls->current(); DELETE_OBJECT( ctm ); m_controls->pop(); CollisionManager* clm = m_collisions->current(); DELETE_OBJECT( clm ); m_collisions->pop(); IState* s = m_states->current(); DELETE_OBJECT( s ); m_states->pop(); m_assets->releaseLevel( m_states->count() + 1 ); IState* c = m_states->current(); if( !m_changeState && c ) { if( newpstate ) { m_loading = true; newpstate->onEnter(); m_loading = false; } m_engine->resetTimer(); c->onEnter( newpstate ); m_engine->resetTimer(); if( newpstate ) { m_loading = true; newpstate->onExit(); m_loading = false; m_assetsLoading->releaseLevel( m_states->count() + 1 ); } } return( true ); }
void StateManager::cleanup(void) { // Always call our cleanup events with our pointer when this method is called mCleanupEvents.doEvents(); // Remove one of our dead states if(!mDead.empty()) { // Retrieve the dead state IState* anState = mDead.back(); assert(NULL != anState && "StateManager::handleCleanup() invalid dropped state pointer"); // Pop the dead state off the stack mDead.pop_back(); // Call the DeInit if it hasn't been called yet if(anState->isInitComplete()) { anState->deInit(); } // Handle the cleanup before we delete anState anState->cleanup(); // Just delete the state now delete anState; // Don't keep pointers around we don't need anState = NULL; } // Make sure we still have an active state if(NULL == mStack.back()) { // There are no states on the stack, exit the program if(NULL != mApp) { mApp->quit(StatusAppOK); } } }
bool Manager::_pushState( IState* newstate, IProgressState* newpstate ) { if( !newstate ) return( false ); if( !newpstate ) newpstate = m_progressStateDefault; IState* c = m_states->current(); if( m_states->push( newstate ) ) { if( !m_changeState && c ) { m_engine->resetTimer(); c->onExit(); m_engine->resetTimer(); } m_actors->push( xnew ActorManager() ); Global::use().actors = m_actors->current(); m_controls->push( xnew ControlManager() ); Global::use().controls = m_controls->current(); m_collisions->push( xnew CollisionManager() ); Global::use().collisions = m_collisions->current(); if( newpstate ) { m_loading = true; newpstate->onEnter(); m_loading = false; } m_engine->resetTimer(); newstate->onEnter( newpstate ); m_engine->resetTimer(); if( newpstate ) { m_loading = true; newpstate->onExit(); m_loading = false; m_assetsLoading->releaseLevel( m_states->count() ); } return( true ); } return( false ); }
void Game::Loop(void) { Logger::Log() << "Loop()"; // Clock used in restricting Update loop to a fixed rate sf::Clock update_clock; update_clock.Reset(); // Update immediately Uint32 next_update = update_clock.GetElapsedTime(); // Loop while IsRunning returns true while(IsRunning() && window.IsOpened()) { IState* currentState = stateManager.GetActiveState(); // Check for corrupt state returned by our StateManager assert(NULL != currentState && "Game::Loop() received a bad pointer"); while (update_clock.GetElapsedTime() > next_update) { sf::Event event; while(window.PollEvent(event)) { switch (event.Type) { case sf::Event::Closed: // Window closed Quit(EXIT_SUCCESS); break; case sf::Event::GainedFocus: // Window gained focus // resume state currentState->Resume(); break; case sf::Event::LostFocus: // Window lost focus // Pause state currentState->Pause(); break; case sf::Event::Resized: // Window resized break; default: // Allow state to handle events currentState->HandleEvents(event); break; } } // Update current state currentState->UpdateFixed(); next_update += update_rate; } // Draw current state currentState->Draw(); window.Display(); // Cleanup state } }
//------------------------------------------------------------------------------ void Engine::start() { Logger::setLogLevel(Logger::L_INFO); log.info("Starting engine."); setup(); // Start the game loop while (renderWindow_->isOpen()) { IState *state = state_manager_.getActiveState(); // Process events sf::Event event; while (renderWindow_->pollEvent(event)) { // Close window : exit if (event.type == sf::Event::Closed) renderWindow_->close(); state->handleEvent(event); } // Clear screen renderWindow_->clear(); state->update(); state->draw(); //drawFps(); // Update the window renderWindow_->display(); } }
void IApp::ProcessInput(IState& theState) { // Variable for storing the current input event to be processed sf::Event anEvent; #if (SFML_VERSION_MAJOR < 2) while(mWindow.GetEvent(anEvent)) #else while(mWindow.pollEvent(anEvent)) #endif { // Handle some input events and let the current state handle the rest #if (SFML_VERSION_MAJOR < 2) // Switch on Event Type switch(anEvent.Type) #else // Switch on Event Type switch(anEvent.type) #endif { case sf::Event::Closed: // Window closed Quit(StatusAppOK); break; case sf::Event::GainedFocus: // Window gained focus theState.Resume(); break; case sf::Event::LostFocus: // Window lost focus theState.Pause(); break; case sf::Event::Resized: // Window resized break; default: // Current active state will handle theState.HandleEvents(anEvent); } // switch(anEvent.Type) } // while(mWindow.GetEvent(anEvent)) }
/* ISoundEngine * StateMachine::getSoundEngine() { return m_pSndEngine; } */ irr::u32 StateMachine::run() { bool bQuit, bSettings = false; s32 lastFPS = -1; m_bGraphicsChanged = false; //load device from setting files //#ifdef WIN32 // SettingHandler *setup = new SettingHandler("asset/conf/Device.xml"); // m_pDevice = setup->createDeviceFromSettings(); // delete setup; //#else m_pDevice = createDevice(video::EDT_OPENGL, dimension2d<u32>(SCREEN_WIDTH, SCREEN_HEIGHT), 16, false, false, false, 0); //setup->createDeviceFromSettings(); //#endif m_pDevice->setWindowCaption(L"PinBob"); //main loop do { m_pDevice->setWindowCaption(L"PinBob"); initStates(m_pDevice); m_bGraphicsChanged = false; bQuit = false; //This loop will run until the game is quit or the graphics mode is to be re-inited while (m_pDevice->run() && !bQuit && !m_bGraphicsChanged) { //m_bDrawScene is "false" if the active state wants to do all the drawing stuff on it's own //if the active state wants to do all the drawing stuff,just set call" setDrawScene(false)" if (m_bDrawScene && m_pDevice->isWindowActive()) { m_pDriver->beginScene(true, true, SColor(0, 200, 200, 200)); m_pSmgr->drawAll(); m_pGuienv->drawAll(); m_pDriver->endScene(); } s32 fps = m_pDriver->getFPS(); if (lastFPS != fps) { m_iFps = fps; core::stringw str = L"Dancy ["; str += m_pDriver->getName(); str += "] FPS:"; str += fps; m_pDevice->setWindowCaption(str.c_str()); lastFPS = fps; } u32 iRet = m_pActive ? m_pActive->update() : 0; //a return value of "0" from the active state shows that no state change is made if (iRet) { //the index of the state to be changed to is the return value -1 (remember: "0" means "no change") iRet--; //an out of bounds index is interpreted as "quit program" signal if (iRet < m_aStates.size()) { printf("Return state number is %d.\n", iRet); //get the next state IState *pNext = m_aStates[iRet]; //deactivate the current state m_pActive->deactivate(pNext); //activate the next state pNext->activate(m_pActive); //save config file on each state change //ConfigFileManager::getSharedInstance()->writeConfig(m_pDevice,"asset/conf/SettingManager.xml"); m_pActive = pNext; } else bQuit = true; } } if (m_pActive) { m_pActive->deactivate(NULL); } clearStates(); //CShadowManager::getSharedInstance()->clear(); m_pSmgr->getMeshCache()->clear(); m_pDevice->closeDevice(); m_pDevice->drop(); } while (m_bGraphicsChanged); return 0; }
void attack() { state->attack(); }
void run() { state->run(); }
void StateManager::dropActiveState(void) { // Is there no currently active state to drop? if(!mStack.empty()) { // Retrieve the currently active state IState* anState = mStack.back(); // Log the dropping of an active state ILOG() << "StateManager::dropActiveState(" << anState->getID() << ")" << std::endl; // Pause the currently active state anState->pause(); // Deinit currently active state before we pop it off the stack // (handleCleanup() will be called by IState::doInit() method if this // state is ever set active again) anState->deInit(); // Pop the currently active state off the stack mStack.pop_back(); // Move this now inactive state to the absolute back of our stack mStack.insert(mStack.begin(), anState); // Don't keep pointers around we don't need anymore anState = NULL; } else { // Quit the application with an error status response if(NULL != mApp) { mApp->quit(StatusAppStackEmpty); } return; } // Is there another state to activate? then call Resume to activate it if(!mStack.empty()) { // Has this state ever been initialized? if(mStack.back()->isInitComplete()) { // Resume the new active state mStack.back()->resume(); } else { // Initialize the new active state mStack.back()->doInit(); } } else { // There are no states on the stack, exit the program if(NULL != mApp) { mApp->quit(StatusAppOK); } } }