/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ // Standard C++ library includes #include // 3rd party library includes //#include // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "audio/soundsource.h" #include "util/log/logger.h" #include "util/base/exception.h" #include "util/math/fife_math.h" #include "util/time/timemanager.h" #include "model/metamodel/grids/cellgrid.h" #include "model/metamodel/ipather.h" #include "model/metamodel/action.h" #include "model/metamodel/timeprovider.h" #include "model/structures/layer.h" #include "model/structures/map.h" #include "model/structures/instancetree.h" #include "view/visual.h" #include "pathfinder/route.h" #include "instance.h" namespace FIFE { static Logger _log(LM_INSTANCE); class ActionInfo { public: ActionInfo(IPather* pather, const Location& curloc): m_action(NULL), m_target(NULL), m_speed(0), m_repeating(false), m_action_start_time(0), m_action_offset_time(0), m_prev_call_time(0), m_pather(pather), m_leader(NULL), m_route(NULL), m_delete_route(true) {} ~ActionInfo() { if (m_route && m_delete_route) { int32_t sessionId = m_route->getSessionId(); if (sessionId != -1) { m_pather->cancelSession(sessionId); } delete m_route; } delete m_target; } // Current action, owned by object Action* m_action; // target location for ongoing movement Location* m_target; // current movement speed double m_speed; // should action be repeated? used only for non-moving actions, moving ones repeat until movement is finished bool m_repeating; // action start time (ticks) uint32_t m_action_start_time; // action offset time (ticks) for resuming an action uint32_t m_action_offset_time; // ticks since last call uint32_t m_prev_call_time; // pather IPather* m_pather; // leader for follow activity Instance* m_leader; // pointer to route that contain path and additional information Route* m_route; bool m_delete_route; }; class SayInfo { public: SayInfo(const std::string& txt, uint32_t duration): m_txt(txt), m_duration(duration), m_start_time(0) {} std::string m_txt; uint32_t m_duration; uint32_t m_start_time; }; Instance::InstanceActivity::InstanceActivity(Instance& source): m_location(source.m_location), m_oldLocation(source.m_location), m_rotation(source.m_rotation), m_oldRotation(source.m_rotation), m_action(NULL), m_soundSource(NULL), m_speed(0), m_timeMultiplier(1.0), m_sayText(""), m_changeListeners(), m_actionListeners(), m_actionInfo(NULL), m_sayInfo(NULL), m_timeProvider(NULL), m_blocking(source.m_blocking), m_additional(ICHANGE_NO_CHANGES) { } Instance::InstanceActivity::~InstanceActivity() { delete m_actionInfo; delete m_sayInfo; delete m_timeProvider; delete m_soundSource; } void Instance::InstanceActivity::update(Instance& source) { source.m_changeInfo = ICHANGE_NO_CHANGES; if (m_additional != ICHANGE_NO_CHANGES) { source.m_changeInfo = m_additional; m_additional = ICHANGE_NO_CHANGES; } if (m_location != source.m_location) { source.m_changeInfo |= ICHANGE_LOC; if (m_location.getLayerCoordinates() != source.m_location.getLayerCoordinates()) { m_oldLocation.setLayer(m_location.getLayer()); m_oldLocation.setLayerCoordinates(m_location.getLayerCoordinates()); source.m_changeInfo |= ICHANGE_CELL; } m_location = source.m_location; } if (m_rotation != source.m_rotation) { m_oldRotation = m_rotation; source.m_changeInfo |= ICHANGE_ROTATION; m_rotation = source.m_rotation; } if (m_actionInfo && (m_speed != m_actionInfo->m_speed)) { source.m_changeInfo |= ICHANGE_SPEED; m_speed = m_actionInfo->m_speed; } if (m_actionInfo && (m_action != m_actionInfo->m_action)) { source.m_changeInfo |= ICHANGE_ACTION; m_action = m_actionInfo->m_action; } if (m_timeProvider && (m_timeMultiplier != m_timeProvider->getMultiplier())) { source.m_changeInfo |= ICHANGE_TIME_MULTIPLIER; m_timeMultiplier = m_timeProvider->getMultiplier(); } if (m_sayInfo && (m_sayText != m_sayInfo->m_txt)) { source.m_changeInfo |= ICHANGE_SAYTEXT; m_sayText = m_sayInfo->m_txt; } if (m_blocking != source.m_blocking) { source.m_changeInfo |= ICHANGE_BLOCK; m_blocking = source.m_blocking; } if (source.m_changeInfo != ICHANGE_NO_CHANGES) { std::vector::iterator i = m_changeListeners.begin(); while (i != m_changeListeners.end()) { if (NULL != *i) { (*i)->onInstanceChanged(&source, source.m_changeInfo); } ++i; } // Really remove "removed" listeners. m_changeListeners.erase( std::remove(m_changeListeners.begin(),m_changeListeners.end(), (InstanceChangeListener*)NULL), m_changeListeners.end()); } } Instance::Instance(Object* object, const Location& location, const std::string& identifier): m_id(identifier), m_rotation(0), m_activity(NULL), m_changeInfo(ICHANGE_NO_CHANGES), m_object(object), m_ownObject(false), m_location(location), m_visual(NULL), m_blocking(object->isBlocking()), m_overrideBlocking(false), m_cellStackPos(object->getCellStackPosition()), m_specialCost(object->isSpecialCost()), m_cost(object->getCost()), m_costId(object->getCostId()), m_mainMultiInstance(NULL) { // create multi object instances if (object->isMultiObject()) { m_mainMultiInstance = this; uint32_t count = 0; Layer* layer = m_location.getLayer(); const ExactModelCoordinate& emc = m_location.getExactLayerCoordinatesRef(); const std::set& multis = object->getMultiParts(); std::set::const_iterator it = multis.begin(); for (; it != multis.end(); ++it, ++count) { if (*it == m_object) { continue; } std::vector partcoords = (*it)->getMultiPartCoordinates(m_rotation); std::vector::iterator coordit = partcoords.begin(); for (; coordit != partcoords.end(); ++coordit) { ExactModelCoordinate tmp_emc(emc.x+(*coordit).x, emc.y+(*coordit).y, emc.z+(*coordit).z); std::ostringstream counter; counter << count; Instance* instance = layer->createInstance(*it, tmp_emc, identifier+counter.str()); InstanceVisual::create(instance); m_multiInstances.push_back(instance); instance->addDeleteListener(this); instance->setMainMultiInstance(this); } } } } Instance::~Instance() { std::vector::iterator itor; for(itor = m_deleteListeners.begin(); itor != m_deleteListeners.end(); ++itor) { if (*itor != NULL) { (*itor)->onInstanceDeleted(this); } } if(m_activity && m_activity->m_actionInfo) { // Don't ditribute onActionFinished in case we're already // deleting. m_activity->m_actionListeners.clear(); finalizeAction(); } if (!m_multiInstances.empty()) { std::vector::iterator it = m_multiInstances.begin(); for (; it != m_multiInstances.end(); ++it) { (*it)->removeDeleteListener(this); (*it)->setMainMultiInstance(NULL); } } delete m_activity; delete m_visual; if (m_ownObject) { delete m_object; } } void Instance::initializeChanges() { if (!m_activity) { m_activity = new InstanceActivity(*this); } if (m_location.getLayer()) { m_location.getLayer()->setInstanceActivityStatus(this, true); } } void Instance::prepareForUpdate() { if (isActive()) { refresh(); } else { initializeChanges(); } } bool Instance::isActive() const { return (m_activity != 0); } Object* Instance::getObject() { return m_object; } void Instance::setLocation(const Location& loc) { // ToDo: Handle the case when the layers are different if(m_location != loc) { prepareForUpdate(); if (m_location.getLayerCoordinates() != loc.getLayerCoordinates()) { m_location.getLayer()->getInstanceTree()->removeInstance(this); m_location = loc; m_location.getLayer()->getInstanceTree()->addInstance(this); } else { m_location = loc; } } } Location Instance::getLocation() const { return m_location; } Location& Instance::getLocationRef() { return m_location; } void Instance::setRotation(int32_t rotation) { while (rotation < 0) { rotation += 360; } rotation %= 360; if(m_rotation != rotation) { prepareForUpdate(); m_rotation = rotation; } } int32_t Instance::getRotation() const { return m_rotation; } void Instance::setId(const std::string& identifier) { m_id = identifier; } const std::string& Instance::getId() { return m_id; } void Instance::setBlocking(bool blocking) { if (m_overrideBlocking) { prepareForUpdate(); m_blocking = blocking; } } bool Instance::isBlocking() const { return m_blocking; } void Instance::setOverrideBlocking(bool overblock) { m_overrideBlocking = overblock; } bool Instance::isOverrideBlocking() const { return m_overrideBlocking; } void Instance::addActionListener(InstanceActionListener* listener) { initializeChanges(); m_activity->m_actionListeners.push_back(listener); } void Instance::removeActionListener(InstanceActionListener* listener) { if (!m_activity) { return; } std::vector::iterator i = m_activity->m_actionListeners.begin(); while (i != m_activity->m_actionListeners.end()) { if ((*i) == listener) { *i = NULL; return; } ++i; } FL_WARN(_log, "Cannot remove unknown listener"); } void Instance::addChangeListener(InstanceChangeListener* listener) { initializeChanges(); m_activity->m_changeListeners.push_back(listener); } void Instance::callOnActionFrame(Action* action, int32_t frame) { if (!m_activity) { return; } std::vector::iterator i = m_activity->m_actionListeners.begin(); while (i != m_activity->m_actionListeners.end()) { if(*i) { (*i)->onInstanceActionFrame(this, action, frame); } ++i; } } void Instance::removeChangeListener(InstanceChangeListener* listener) { if (!m_activity) { return; } std::vector::iterator i = m_activity->m_changeListeners.begin(); while (i != m_activity->m_changeListeners.end()) { if ((*i) == listener) { *i = NULL; return; } ++i; } FL_WARN(_log, "Cannot remove unknown listener"); } void Instance::initializeAction(const std::string& actionName) { assert(m_object); initializeChanges(); const Action *old_action = m_activity->m_actionInfo ? m_activity->m_actionInfo->m_action : NULL; if (m_activity->m_actionInfo) { cancelAction(); } m_activity->m_actionInfo = new ActionInfo(m_object->getPather(), m_location); m_activity->m_actionInfo->m_action = m_object->getAction(actionName); if (!m_activity->m_actionInfo->m_action) { delete m_activity->m_actionInfo; m_activity->m_actionInfo = NULL; throw NotFound(std::string("action ") + actionName + " not found"); } m_activity->m_actionInfo->m_prev_call_time = getRuntime(); if (m_activity->m_actionInfo->m_action != old_action) { m_activity->m_actionInfo->m_action_start_time = m_activity->m_actionInfo->m_prev_call_time; } // start sound if (m_activity->m_actionInfo->m_action->getAudio()) { if (!m_activity->m_soundSource) { m_activity->m_soundSource = new SoundSource(this); } m_activity->m_soundSource->setActionAudio(m_activity->m_actionInfo->m_action->getAudio()); } else if (old_action && old_action->getAudio()) { m_activity->m_soundSource->setActionAudio(NULL); } if (isMultiObject()) { std::vector::iterator multi_it = m_multiInstances.begin(); for (; multi_it != m_multiInstances.end(); ++multi_it) { (*multi_it)->initializeAction(actionName); } } } void Instance::move(const std::string& actionName, const Location& target, const double speed, const std::string& costId) { // if new move is identical with the old then return if (m_activity) { if (m_activity->m_actionInfo) { if (m_activity->m_actionInfo->m_target) { if (m_activity->m_actionInfo->m_target->getLayerCoordinates() == target.getLayerCoordinates() && Mathd::Equal(speed, m_activity->m_actionInfo->m_speed) && m_activity->m_actionInfo->m_action == m_object->getAction(actionName) && costId == m_activity->m_actionInfo->m_route->getCostId()) { return; } } } } initializeAction(actionName); m_activity->m_actionInfo->m_target = new Location(target); m_activity->m_actionInfo->m_speed = speed; FL_DBG(_log, LMsg("starting action ") << actionName << " from" << m_location << " to " << target << " with speed " << speed); Route* route = m_activity->m_actionInfo->m_route; if (!route) { route = new Route(m_location, *m_activity->m_actionInfo->m_target); route->setRotation(getRotation()); if (costId != "") { route->setCostId(costId); } if (isMultiCell()) { route->setObject(m_object); route->setOccupiedArea(m_location.getLayer()->getCellGrid()-> toMultiCoordinates(m_location.getLayerCoordinates(), m_object->getMultiObjectCoordinates(m_rotation))); } else if (m_object->getZStepRange() != -1 || !m_object->getWalkableAreas().empty()) { route->setObject(m_object); } m_activity->m_actionInfo->m_route = route; if (!m_activity->m_actionInfo->m_pather->solveRoute(route)) { setFacingLocation(target); finalizeAction(); } } } void Instance::follow(const std::string& actionName, Instance* leader, const double speed) { initializeAction(actionName); m_activity->m_actionInfo->m_target = new Location(leader->getLocationRef()); m_activity->m_actionInfo->m_speed = speed; m_activity->m_actionInfo->m_leader = leader; leader->addDeleteListener(this); FL_DBG(_log, LMsg("starting action ") << actionName << " from" << m_location << " to " << *m_activity->m_actionInfo->m_target << " with speed " << speed); } void Instance::follow(const std::string& actionName, Route* route, const double speed) { initializeAction(actionName); m_activity->m_actionInfo->m_target = new Location(route->getEndNode()); m_activity->m_actionInfo->m_speed = speed; m_activity->m_actionInfo->m_route = route; m_activity->m_actionInfo->m_delete_route = false; if (isMultiCell()) { route->setObject(m_object); route->setOccupiedArea(m_location.getLayer()->getCellGrid()-> toMultiCoordinates(m_location.getLayerCoordinates(), m_object->getMultiObjectCoordinates(m_rotation))); } else if (m_object->getZStepRange() != -1 || !m_object->getWalkableAreas().empty()) { route->setObject(m_object); } FL_DBG(_log, LMsg("starting action ") << actionName << " from" << m_location << " to " << *m_activity->m_actionInfo->m_target << " with speed " << speed); } void Instance::cancelMovement(uint32_t length) { if (m_activity) { ActionInfo* info = m_activity->m_actionInfo; if (info) { Route* route = info->m_route; if (route) { route->cutPath(length); } } } } Route* Instance::getRoute() { if (m_activity) { ActionInfo* info = m_activity->m_actionInfo; if (info) { return info->m_route; } } return NULL; } void Instance::setCellStackPosition(uint8_t stack) { m_cellStackPos = stack; } uint8_t Instance::getCellStackPosition() { return m_cellStackPos; } bool Instance::isSpecialCost() { return m_specialCost; } const std::vector& Instance::getMultiInstances() { return m_multiInstances; } void Instance::setMainMultiInstance(Instance* main) { m_mainMultiInstance = main; } Instance* Instance::getMainMultiInstance() { return m_mainMultiInstance; } void Instance::actOnce(const std::string& actionName, const Location& direction) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = false; setFacingLocation(direction); } void Instance::actOnce(const std::string& actionName, int32_t rotation) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = false; setRotation(rotation); } void Instance::actOnce(const std::string& actionName) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = false; } void Instance::actRepeat(const std::string& actionName, const Location& direction) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = true; setFacingLocation(direction); } void Instance::actRepeat(const std::string& actionName, int32_t rotation) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = true; setRotation(rotation); } void Instance::actRepeat(const std::string& actionName) { initializeAction(actionName); m_activity->m_actionInfo->m_repeating = true; } void Instance::say(const std::string& text, uint32_t duration) { initializeChanges(); delete m_activity->m_sayInfo; m_activity->m_sayInfo = NULL; if (text != "") { m_activity->m_sayInfo = new SayInfo(text, duration); m_activity->m_sayInfo->m_start_time = getRuntime(); } } const std::string* Instance::getSayText() const { if (m_activity && m_activity->m_sayInfo) { return &m_activity->m_sayInfo->m_txt; } return NULL; } bool Instance::processMovement() { ActionInfo* info = m_activity->m_actionInfo; Route* route = info->m_route; Location target; if (info->m_leader) { target = info->m_leader->getLocationRef(); } else { target = *info->m_target; } if (!route) { route = new Route(m_location, *info->m_target); route->setRotation(getRotation()); info->m_route = route; if (isMultiCell()) { route->setObject(m_object); route->setOccupiedArea(m_location.getLayer()->getCellGrid()-> toMultiCoordinates(m_location.getLayerCoordinates(), m_object->getMultiObjectCoordinates(m_rotation))); } else if (m_object->getZStepRange() != -1 || !m_object->getWalkableAreas().empty()) { route->setObject(m_object); } if (!info->m_pather->solveRoute(route)) { setFacingLocation(target); return true; } // update target if needed } else if (route->getEndNode().getLayerCoordinates() != target.getLayerCoordinates()) { if (route->isReplanned() || isMultiCell()) { *info->m_target = route->getEndNode(); route->setReplanned(false); if (isMultiCell()) { route->setOccupiedArea(m_location.getLayer()->getCellGrid()-> toMultiCoordinates(m_location.getLayerCoordinates(), m_object->getMultiObjectCoordinates(m_rotation))); } } else { if (route->getPathLength() == 0) { route->setStartNode(m_location); } else { route->setStartNode(route->getCurrentNode()); } route->setEndNode(target); if (!info->m_pather->solveRoute(route)) { setFacingLocation(target); return true; } } } if (route->getRouteStatus() == ROUTE_SOLVED) { // timeslice for this movement uint32_t timedelta = m_activity->m_timeProvider->getGameTime() - info->m_prev_call_time; // how far we can travel double distance_to_travel = (static_cast(timedelta) / 1000.0) * info->m_speed; // location for this movement Location nextLocation = m_location; bool can_follow = info->m_pather->followRoute(m_location, route, distance_to_travel, nextLocation); if (can_follow) { setRotation(route->getRotation()); // move to another layer if (m_location.getLayer() != nextLocation.getLayer()) { m_location.getLayer()->getMap()->addInstanceForTransfer(this, nextLocation); if (!m_multiInstances.empty()) { std::vector::iterator it = m_multiInstances.begin(); for (; it != m_multiInstances.end(); ++it) { Location newloc = nextLocation; std::vector tmpcoords = m_location.getLayer()->getCellGrid()-> toMultiCoordinates(nextLocation.getLayerCoordinates(), (*it)->getObject()->getMultiPartCoordinates(m_rotation)); newloc.setLayerCoordinates(tmpcoords.front()); m_location.getLayer()->getMap()->addInstanceForTransfer(*it, newloc); } } return false; } setLocation(nextLocation); return false; } // move to another layer if (m_location.getLayer() != nextLocation.getLayer()) { m_location.getLayer()->getMap()->addInstanceForTransfer(this, nextLocation); if (!m_multiInstances.empty()) { std::vector::iterator it = m_multiInstances.begin(); for (; it != m_multiInstances.end(); ++it) { Location newloc = nextLocation; std::vector tmpcoords = m_location.getLayer()->getCellGrid()-> toMultiCoordinates(nextLocation.getLayerCoordinates(), (*it)->getObject()->getMultiPartCoordinates(m_rotation)); newloc.setLayerCoordinates(tmpcoords.front()); m_location.getLayer()->getMap()->addInstanceForTransfer(*it, newloc); } } return true; } setLocation(nextLocation); // need new route? if (route->getEndNode().getLayerCoordinates() != m_location.getLayerCoordinates()) { if (m_location.getLayerDistanceTo(target) > 1.5) { if (route->getPathLength() == 0) { route->setStartNode(m_location); } else { route->setStartNode(route->getPreviousNode()); } route->setEndNode(target); route->setOccupiedArea(m_location.getLayer()->getCellGrid()-> toMultiCoordinates(m_location.getLayerCoordinates(), m_object->getMultiObjectCoordinates(m_rotation))); return !info->m_pather->solveRoute(route); } setFacingLocation(target); } return true; } else if (route->getRouteStatus() == ROUTE_FAILED) { return true; } return false; } InstanceChangeInfo Instance::update() { if (!m_activity) { return ICHANGE_NO_CHANGES; } // remove DeleteListeners m_deleteListeners.erase(std::remove(m_deleteListeners.begin(),m_deleteListeners.end(), (InstanceDeleteListener*)NULL), m_deleteListeners.end()); if (!m_activity->m_timeProvider) { bindTimeProvider(); } ActionInfo* info = m_activity->m_actionInfo; if (info) { // FL_DBG(_log, "updating instance"); if (info->m_target) { // FL_DBG(_log, "action contains target for movement"); bool movement_finished = processMovement(); if (movement_finished) { // FL_DBG(_log, "movement finished"); finalizeAction(); } } else { // FL_DBG(_log, "action does not contain target for movement"); if (m_activity->m_timeProvider->getGameTime() - info->m_action_start_time + info->m_action_offset_time >= info->m_action->getDuration()) { if (info->m_repeating) { info->m_action_start_time = m_activity->m_timeProvider->getGameTime(); // prock: offset no longer needed info->m_action_offset_time = 0; } else if (!m_object->isMultiPart()) { finalizeAction(); } } } // previous code may invalidate actioninfo. if( m_activity->m_actionInfo ) { m_activity->m_actionInfo->m_prev_call_time = m_activity->m_timeProvider->getGameTime(); } } m_activity->update(*this); if (m_activity->m_sayInfo) { if (m_activity->m_sayInfo->m_duration > 0) { if (m_activity->m_timeProvider->getGameTime() >= m_activity->m_sayInfo->m_start_time + m_activity->m_sayInfo->m_duration) { say(""); } } } else if (!m_activity->m_actionInfo && m_changeInfo == ICHANGE_NO_CHANGES && m_activity->m_actionListeners.empty() && m_activity->m_changeListeners.empty()) { // delete superfluous activity delete m_activity; m_activity = 0; return ICHANGE_NO_CHANGES; } return m_changeInfo; } void Instance::finalizeAction() { FL_DBG(_log, "finalizing action"); assert(m_activity); assert(m_activity->m_actionInfo); if( m_activity->m_actionInfo->m_leader ) { m_activity->m_actionInfo->m_leader->removeDeleteListener(this); } Action* action = m_activity->m_actionInfo->m_action; delete m_activity->m_actionInfo; m_activity->m_actionInfo = NULL; // this is needed in case the new action is set on the same pump and // it is the same action as the finalized action m_activity->m_action = NULL; // stop audio if (action->getAudio() && m_activity->m_soundSource) { m_activity->m_soundSource->setActionAudio(NULL); } if (isMultiObject()) { std::vector::iterator multi_it = m_multiInstances.begin(); for (; multi_it != m_multiInstances.end(); ++multi_it) { (*multi_it)->finalizeAction(); } } std::vector::iterator i = m_activity->m_actionListeners.begin(); while (i != m_activity->m_actionListeners.end()) { if(*i) (*i)->onInstanceActionFinished(this, action); ++i; } m_activity->m_actionListeners.erase( std::remove(m_activity->m_actionListeners.begin(), m_activity->m_actionListeners.end(), (InstanceActionListener*)NULL), m_activity->m_actionListeners.end()); } void Instance::cancelAction() { FL_DBG(_log, "cancel action"); assert(m_activity); assert(m_activity->m_actionInfo); if( m_activity->m_actionInfo->m_leader ) { m_activity->m_actionInfo->m_leader->removeDeleteListener(this); } Action* action = m_activity->m_actionInfo->m_action; delete m_activity->m_actionInfo; m_activity->m_actionInfo = NULL; // this is needed in case the new action is set on the same pump and // it is the same action as the canceled action m_activity->m_action = NULL; if (isMultiObject()) { std::vector::iterator multi_it = m_multiInstances.begin(); for (; multi_it != m_multiInstances.end(); ++multi_it) { (*multi_it)->cancelAction(); } } std::vector::iterator i = m_activity->m_actionListeners.begin(); while (i != m_activity->m_actionListeners.end()) { if(*i) (*i)->onInstanceActionCancelled(this, action); ++i; } m_activity->m_actionListeners.erase( std::remove(m_activity->m_actionListeners.begin(), m_activity->m_actionListeners.end(), (InstanceActionListener*)NULL), m_activity->m_actionListeners.end()); } Action* Instance::getCurrentAction() const { if (m_activity && m_activity->m_actionInfo) { return m_activity->m_actionInfo->m_action; } return NULL; } Location Instance::getTargetLocation() const { if (m_activity && m_activity->m_actionInfo && m_activity->m_actionInfo->m_target) { return *m_activity->m_actionInfo->m_target; } return m_location; } double Instance::getMovementSpeed() const { if (m_activity && m_activity->m_actionInfo) { return m_activity->m_actionInfo->m_speed; } return 0; } void Instance::setFacingLocation(const Location& loc) { setRotation(getAngleBetween(m_location, loc)); } Location Instance::getFacingLocation() { return getFacing(m_location, m_rotation); } Location& Instance::getOldLocationRef() { if (m_activity) { return m_activity->m_oldLocation; } return m_location; } int32_t Instance::getOldRotation() const { if (m_activity) { return m_activity->m_oldRotation; } return m_rotation; } uint32_t Instance::getActionRuntime() { if (m_activity && m_activity->m_actionInfo) { if(!m_activity->m_timeProvider) bindTimeProvider(); return m_activity->m_timeProvider->getGameTime() - m_activity->m_actionInfo->m_action_start_time + m_activity->m_actionInfo->m_action_offset_time; } return getRuntime(); } void Instance::setActionRuntime(uint32_t time_offset) { m_activity->m_actionInfo->m_action_offset_time = time_offset; } void Instance::bindTimeProvider() { float multiplier = 1.0; if (m_activity->m_timeProvider) { multiplier = m_activity->m_timeProvider->getMultiplier(); } delete m_activity->m_timeProvider; m_activity->m_timeProvider = NULL; if (m_location.getLayer()) { Map* map = m_location.getLayer()->getMap(); if (map) { m_activity->m_timeProvider = new TimeProvider(map->getTimeProvider()); } } if (!m_activity->m_timeProvider) { m_activity->m_timeProvider = new TimeProvider(NULL); } m_activity->m_timeProvider->setMultiplier(multiplier); } void Instance::refresh() { initializeChanges(); bindTimeProvider(); } InstanceChangeInfo Instance::getChangeInfo() { if (m_activity) { return m_changeInfo; } return ICHANGE_NO_CHANGES; } void Instance::callOnTransparencyChange() { prepareForUpdate(); m_activity->m_additional |= ICHANGE_TRANSPARENCY; } void Instance::callOnVisibleChange() { prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISIBLE; } void Instance::callOnStackPositionChange() { prepareForUpdate(); m_activity->m_additional |= ICHANGE_STACKPOS; } void Instance::setTimeMultiplier(float multip) { initializeChanges(); if (!m_activity->m_timeProvider) { bindTimeProvider(); } m_activity->m_timeProvider->setMultiplier(multip); } float Instance::getTimeMultiplier() { if (m_activity && m_activity->m_timeProvider) { return m_activity->m_timeProvider->getMultiplier(); } return 1.0; } float Instance::getTotalTimeMultiplier() { if (m_activity && m_activity->m_timeProvider) { return m_activity->m_timeProvider->getTotalMultiplier(); } if (m_location.getLayer()) { Map* map = m_location.getLayer()->getMap(); if (map && map->getTimeProvider()) { return map->getTimeProvider()->getTotalMultiplier(); } } return 1.0; } uint32_t Instance::getRuntime() { if (m_activity) { if(!m_activity->m_timeProvider) bindTimeProvider(); return m_activity->m_timeProvider->getGameTime(); } if (m_location.getLayer()) { Map* map = m_location.getLayer()->getMap(); if (map && map->getTimeProvider()) { return map->getTimeProvider()->getGameTime(); } } return TimeManager::instance()->getTime(); } void Instance::setCost(const std::string& id, double cost) { m_specialCost = true; m_costId = id; m_cost = cost; } void Instance::resetCost() { m_specialCost = false; } double Instance::getCost() { if (m_specialCost) { return m_cost; } return m_object->getCost(); } std::string Instance::getCostId() { if (m_specialCost) { return m_costId; } return m_object->getCostId(); } double Instance::getSpeed() { return m_object->getSpeed(); } bool Instance::isSpecialSpeed() { return m_object->isSpecialSpeed(); } bool Instance::isMultiCell() { return m_object->isMultiObject(); } bool Instance::isMultiObject() { return !m_multiInstances.empty(); } void Instance::updateMultiInstances() { if (!m_multiInstances.empty()) { // use map coords for rotation and movement // instances are changed on InstanceTree but not on CellCache Location loc = m_location; const ExactModelCoordinate anchor = m_location.getMapCoordinates(); const ExactModelCoordinate& offset = m_object->getRotationAnchor(); loc.setExactLayerCoordinates(offset); const ExactModelCoordinate anchor_offset = loc.getMapCoordinates(); int32_t rot = m_rotation; if (m_object->isRestrictedRotation()) { rot = m_object->getRestrictedRotation(m_rotation); } double mcos = Mathd::Cos(double(rot) * (Mathd::pi()/180.0)); double msin = Mathd::Sin(double(rot) * (Mathd::pi()/180.0)); std::vector::iterator it = m_multiInstances.begin(); for (; it != m_multiInstances.end(); ++it) { // use rotation 0 to get the "default" coordinate std::vector mcv = (*it)->getObject()->getMultiPartCoordinates(0); loc.setLayerCoordinates(mcv.front()); ExactModelCoordinate emc = loc.getMapCoordinates(); ExactModelCoordinate nemc(emc.x-anchor_offset.x, emc.y-anchor_offset.y); emc.x = ((nemc.x * mcos + nemc.y * msin) + anchor_offset.x) + anchor.x; emc.y = ((-nemc.x * msin + nemc.y * mcos) + anchor_offset.y) + anchor.y; loc.setMapCoordinates(emc); (*it)->setLocation(loc); (*it)->setRotation(rot); } } } void Instance::addStaticColorOverlay(uint32_t angle, const OverlayColors& colors) { if (!m_ownObject) { createOwnObject(); } ObjectVisual* objVis = m_object->getVisual(); objVis->addStaticColorOverlay(angle, colors); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } OverlayColors* Instance::getStaticColorOverlay(int32_t angle) { if (!m_ownObject) { return 0; } ObjectVisual* objVis = m_object->getVisual(); return objVis->getStaticColorOverlay(angle); } void Instance::removeStaticColorOverlay(int32_t angle) { if (m_ownObject) { ObjectVisual* objVis = m_object->getVisual(); objVis->removeStaticColorOverlay(angle); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } bool Instance::isStaticColorOverlay() { if (!m_ownObject) { return false; } ObjectVisual* objVis = m_object->getVisual(); return objVis->isColorOverlay(); } void Instance::addColorOverlay(const std::string& actionName, uint32_t angle, const OverlayColors& colors) { ActionVisual* visual = getActionVisual(actionName, true); if (visual) { visual->addColorOverlay(angle, colors); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } OverlayColors* Instance::getColorOverlay(const std::string& actionName, uint32_t angle) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { return visual->getColorOverlay(angle); } return NULL; } void Instance::removeColorOverlay(const std::string& actionName, int32_t angle) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { visual->removeColorOverlay(angle); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } void Instance::addAnimationOverlay(const std::string& actionName, uint32_t angle, int32_t order, const AnimationPtr& animationptr) { ActionVisual* visual = getActionVisual(actionName, true); if (visual) { visual->addAnimationOverlay(angle, order, animationptr); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } std::map Instance::getAnimationOverlay(const std::string& actionName, int32_t angle) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { return visual->getAnimationOverlay(angle); } return std::map(); } void Instance::removeAnimationOverlay(const std::string& actionName, uint32_t angle, int32_t order) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { visual->removeAnimationOverlay(angle, order); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } void Instance::addColorOverlay(const std::string& actionName, uint32_t angle, int32_t order, const OverlayColors& colors) { ActionVisual* visual = getActionVisual(actionName, true); if (visual) { visual->addColorOverlay(angle, order, colors); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } OverlayColors* Instance::getColorOverlay(const std::string& actionName, uint32_t angle, int32_t order) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { return visual->getColorOverlay(angle, order); } return NULL; } void Instance::removeColorOverlay(const std::string& actionName, int32_t angle, int32_t order) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { visual->removeColorOverlay(angle, order); prepareForUpdate(); m_activity->m_additional |= ICHANGE_VISUAL; } } bool Instance::isAnimationOverlay(const std::string& actionName) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { return visual->isAnimationOverlay(); } return false; } bool Instance::isColorOverlay(const std::string& actionName) { ActionVisual* visual = getActionVisual(actionName, false); if (visual) { return visual->isColorOverlay(); } return false; } void Instance::convertToOverlays(const std::string& actionName, bool color) { ActionVisual* visual = getActionVisual(actionName, true); visual->convertToOverlays(color); } void Instance::createOwnObject() { if (!m_ownObject) { m_ownObject = true; ObjectVisual* ov = m_object->getVisual(); ObjectVisual* nov = 0; m_object = new Object(m_object->getId(), m_object->getNamespace(), m_object); if (!ov) { ObjectVisual::create(m_object); } else { nov = new ObjectVisual(*ov); m_object->adoptVisual(nov); } } } ActionVisual* Instance::getActionVisual(const std::string& actionName, bool create) { ActionVisual* nav = NULL; if (!m_ownObject) { createOwnObject(); } Action* action = m_object->getAction(actionName, false); if (!action) { action = m_object->getAction(actionName); if (!action) { throw NotFound(std::string("action ") + actionName + " not found"); } else if (create) { // if we change the current action then we have to replace the pointer bool replace = getCurrentAction() == action; // check if its the default action bool defaultAction = m_object->getDefaultAction() == action; ActionVisual* av = action->getVisual(); action = m_object->createAction(actionName, defaultAction); nav = new ActionVisual(*av); action->adoptVisual(nav); if (replace) { m_activity->m_actionInfo->m_action = action; } } } else { nav = action->getVisual(); } return nav; } void Instance::addDeleteListener(InstanceDeleteListener *listener) { m_deleteListeners.push_back(listener); } void Instance::removeDeleteListener(InstanceDeleteListener *listener) { if (!m_deleteListeners.empty()) { std::vector::iterator itor; itor = std::find(m_deleteListeners.begin(), m_deleteListeners.end(), listener); if(itor != m_deleteListeners.end()) { if ((*itor) == listener) { *itor = NULL; return; } } else { FL_WARN(_log, "Cannot remove unknown listener"); } } } void Instance::onInstanceDeleted(Instance* instance) { if(m_activity && m_activity->m_actionInfo && m_activity->m_actionInfo->m_leader == instance) { m_activity->m_actionInfo->m_leader = NULL; } if (isMultiObject()) { std::vector::iterator multi_it = m_multiInstances.begin(); for (; multi_it != m_multiInstances.end(); ++multi_it) { if (*multi_it == instance) { m_multiInstances.erase(multi_it); break; } } } } }