/* Copyright (C) 2007, 2010 - Bit-Blot This file is part of Aquaria. Aquaria 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 2 of the License, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "StateManager.h" #include "Core.h" StateManager *stateManager = 0; //========[ StateObject ]========// StateObject::StateObject() : ActionMapper() { } void StateObject::registerState(StateObject *sb, const std::string &name) { core->registerStateObject(sb, name); } StateObject::~StateObject() { } void StateObject::removeState() { clearActions(); clearCreatedEvents(); //stateManager->getState(name)->eraseRenderObjects(); } void StateObject::addRenderObject(RenderObject *renderObject, int layer) { stateManager->getState(name)->addRenderObject(renderObject, layer); } void StateObject::removeRenderObject(RenderObject *renderObject) { stateManager->getState(name)->removeRenderObject(renderObject); } void StateObject::action(int id, int state) { } void StateObject::update(float dt) { ActionMapper::onUpdate(dt); } //========[ STATEDATA ]========// StateData::StateData() { stateObject = 0; } StateData::~StateData() { /* std::ostringstream os; os << "removing " << renderObjects.size() << " render Objects"; MessageBox(0,os.str().c_str(),"",MB_OK); */ for (int i = 0; i < renderObjects.size(); i++) { removeRenderObject (renderObjects[i]); delete renderObjects[i]; } } void StateData::addRenderObject(RenderObject *renderObject, int layer) { core->addRenderObject(renderObject, layer); renderObjects.push_back (renderObject); renderObject->setStateDataObject(this); renderObject->layer = layer; } void StateData::removeRenderObject(RenderObject *renderObject) { core->enqueueRenderObjectDeletion(renderObject); removeRenderObjectFromList(renderObject); } void StateData::removeRenderObjectFromList(RenderObject *renderObject) { for (std::vector::iterator i = renderObjects.begin(); i != renderObjects.end(); ) { if ((*i) == renderObject) { i = renderObjects.erase(i); } else { i ++; } } } // assume this only happens on render state end void StateData::eraseRenderObjects() { // why clear garbage here? //core->clearGarbage(); for (int i = 0; i < renderObjects.size(); i++) { RenderObject *r = renderObjects[i]; if (r && !r->isDead()) { core->enqueueRenderObjectDeletion(renderObjects[i]); } } renderObjects.clear(); } //========[ STATEMANAGER ]========// StateManager::StateManager() { stateManager = this; stateChangeFlag = false; enqueuedStateStage = -1; statesTopIndex = -1; } StateManager::~StateManager() { clearStateObjects(); } StateData *StateManager::getState (const std::string &state) { for (int i = 0; i <= statesTopIndex; i++) { StateData *s = states[i]; if (s->name == state) return s; } return 0; } void StateManager::removeState(std::string state) { getState(state)->eraseRenderObjects(); } void StateManager::jumpState (const std::string &state) { if (canChangeState()) { popAllStates(); pushState(state); } } /* enqueueJumpState force will force the state change regardless of the result of canChangeState() staged = if true, the manager will pop all the states and allow the system to clear garbage before pushing the new state */ void StateManager::enqueueJumpState (const std::string &state, bool force, bool staged) { if (force || canChangeState()) { enqueuedJumpState = state; if (staged) { enqueuedStateStage = 0; } else { enqueuedStateStage = -1; } } } bool StateManager::isStateJumpPending() { return !enqueuedJumpState.empty(); } void StateManager::pushState(const std::string &s) { std::string state = s; stringToLower(state); if (canChangeState()) { if (states_full()) { debugLog("state stack overflow!!"); return; } StateData *s = new StateData; s->name = state; states[++statesTopIndex] = s; applyState(state); if (stateObjects[state]) { s->stateObject = stateObjects[state]; stateObjects[state]->applyState(); } stateChangeFlag = true; } } void StateManager::popAllStates() { if (!states_empty()) { popState(); popAllStates(); } } void StateManager::popState() { if (canChangeState() && !states_empty()) { if (stateObjects[(*(states_top())).name]) stateObjects[(*(states_top())).name]->removeState(); //states_top()->eraseRenderObjects(); std::string n = (*(states_top())).name; removeState(n); delete states_top(); if (core->getNestedMains()==1) core->clearGarbage(); statesTopIndex--; stateChangeFlag = true; } } std::string StateManager::getNameFromDerivedClassTypeName(const std::string &typeidName) { /* int loc = typeidName.find_last_of("class "); if (loc != std::string::npos) { std::string tmp = typeidName.substr(6, typeidName.length()); int loc2 = tmp.find_last_of("::"); if (loc2 != std::string::npos) return tmp.substr(loc2+1, tmp.size()); else return tmp; } else return typeidName; */ return ""; } void StateManager::registerStateObject(StateObject *stateObject, const std::string &name) { //const char *c = typeid(*stateObject).name(); stateObject->name = name; stringToLower(stateObject->name); //getNameFromDerivedClassTypeName(c); if (stateObject->name.empty()) { exit_error("StateManager::registerStateObject - Empty name."); } if (!stateObjects[stateObject->name]) stateObjects[stateObject->name] = stateObject; /* if (c) free((void*)c); */ } StateObject *StateManager::addStateInstance(StateObject *s) { stateInstances.push_back(s); return s; } void StateManager::clearStateInstances() { for (int i = 0; i < stateInstances.size(); i++) { StateObject *obj = stateInstances[i]; delete obj; } stateInstances.clear(); } void StateManager::clearStateObjects() { stateObjects.clear(); } void StateManager::onUpdate(float dt) { for (int i = 0; i <= statesTopIndex; i++) { StateObject *obj = stateObjects[states[i]->name]; if (obj) obj->update(dt); } if (canChangeState() && !enqueuedJumpState.empty()) { if (enqueuedStateStage == 0) { enqueuedStateStage = -1; popAllStates(); } else if (enqueuedStateStage == -1) { std::string copy = enqueuedJumpState; enqueuedJumpState = ""; jumpState(copy); } } } StateData *StateManager::getTopStateData() { if (!states_empty()) return states_top(); else return 0; } StateObject *StateManager::getTopStateObject() { StateData *s = getTopStateData(); if (s) { return s->stateObject; } else return 0; }