/*************************************************************************** * 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 // 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 "cell.h" #include "cellcache.h" #include "instance.h" #include "layer.h" #include "location.h" #include "trigger.h" namespace FIFE { class TriggerChangeListener : public CellChangeListener, public InstanceChangeListener, public InstanceDeleteListener { public: TriggerChangeListener(Trigger* trigger) { m_trigger = trigger; } virtual ~TriggerChangeListener() {} // InstanceDeleteListener callback virtual void onInstanceDeleted(Instance* instance) { const std::vector& types = m_trigger->getTriggerConditions(); if (std::find(types.begin(), types.end(), INSTANCE_TRIGGER_DELETE) != types.end()) { m_trigger->setTriggered(); } m_trigger->detach(); } // CellChangeListener callback virtual void onInstanceEnteredCell(Cell* cell, Instance* instance) { const std::vector& types = m_trigger->getTriggerConditions(); if (std::find(types.begin(), types.end(), CELL_TRIGGER_ENTER) != types.end()) { const std::vector& restrict = m_trigger->getEnabledInstances(); if (m_trigger->isEnabledForAllInstances() || std::find(restrict.begin(), restrict.end(), instance) != restrict.end()) { m_trigger->setTriggered(); } } } // CellChangeListener callback virtual void onInstanceExitedCell(Cell* cell, Instance* instance) { const std::vector& types = m_trigger->getTriggerConditions(); if (std::find(types.begin(), types.end(), CELL_TRIGGER_EXIT) != types.end()) { const std::vector& restrict = m_trigger->getEnabledInstances(); if (m_trigger->isEnabledForAllInstances() || std::find(restrict.begin(), restrict.end(), instance) != restrict.end()) { m_trigger->setTriggered(); } } } // CellChangeListener callback virtual void onBlockingChangedCell(Cell* cell, CellTypeInfo type, bool blocks) { const std::vector& types = m_trigger->getTriggerConditions(); if (std::find(types.begin(), types.end(), CELL_TRIGGER_BLOCKING_CHANGE) != types.end()) { m_trigger->setTriggered(); } } // InstanceChangeListener callback virtual void onInstanceChanged(Instance* instance, InstanceChangeInfo info) { const std::vector& types = m_trigger->getTriggerConditions(); if (m_trigger->getAttached() == instance && (info & ICHANGE_CELL) == ICHANGE_CELL) { m_trigger->move(); } if (types.empty()) { return; } if ((info & ICHANGE_LOC) == ICHANGE_LOC && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_LOCATION) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_ROTATION) == ICHANGE_ROTATION && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_ROTATION) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_SPEED) == ICHANGE_SPEED && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_SPEED) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_ACTION) == ICHANGE_ACTION && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_ACTION) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_TIME_MULTIPLIER) == ICHANGE_TIME_MULTIPLIER && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_TIME_MULTIPLIER) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_SAYTEXT) == ICHANGE_SAYTEXT && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_SAYTEXT) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_BLOCK) == ICHANGE_BLOCK && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_BLOCK) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_CELL) == ICHANGE_CELL && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_CELL) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_TRANSPARENCY) == ICHANGE_TRANSPARENCY && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_TRANSPARENCY) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_VISIBLE) == ICHANGE_VISIBLE && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_VISIBLE) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_STACKPOS) == ICHANGE_STACKPOS && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_STACKPOS) != types.end()) { m_trigger->setTriggered(); } else if ((info & ICHANGE_VISUAL) == ICHANGE_VISUAL && std::find(types.begin(), types.end(), INSTANCE_TRIGGER_VISUAL) != types.end()) { m_trigger->setTriggered(); } } private: Trigger* m_trigger; }; Trigger::Trigger(): m_name(""), m_triggered(false), m_enabledAll(false), m_attached(NULL) { m_changeListener = new TriggerChangeListener(this); } Trigger::Trigger(const std::string& name): m_name(name), m_triggered(false), m_enabledAll(false), m_attached(NULL) { m_changeListener = new TriggerChangeListener(this); } Trigger::~Trigger() { detach(); std::vector::iterator it = m_assigned.begin(); for (; it != m_assigned.end(); ++it) { (*it)->removeChangeListener(m_changeListener); } delete m_changeListener; } void Trigger::addTriggerListener(ITriggerListener* listener) { std::vector::iterator it = std::find(m_triggerListeners.begin(), m_triggerListeners.end(), listener); if (it == m_triggerListeners.end()) { m_triggerListeners.push_back(listener); } } void Trigger::removeTriggerListener(ITriggerListener* listener) { std::vector::iterator i = m_triggerListeners.begin(); while (i != m_triggerListeners.end()) { if ((*i) == listener) { // set the pointer to null, so it can be removed later *i = NULL; return; } ++i; } } void Trigger::reset() { m_triggered = false; } void Trigger::setTriggered() { if (!m_triggered) { m_triggered = true; std::vector::iterator i = m_triggerListeners.begin(); while (i != m_triggerListeners.end()) { if (*i) { (*i)->onTriggered(); } ++i; } } // remove null pointer m_triggerListeners.erase(std::remove(m_triggerListeners.begin(), m_triggerListeners.end(), (ITriggerListener*)NULL), m_triggerListeners.end()); } void Trigger::addTriggerCondition(TriggerCondition type) { std::vector::iterator it = std::find(m_triggerConditions.begin(), m_triggerConditions.end(), type); if (it == m_triggerConditions.end()) { m_triggerConditions.push_back(type); } } const std::vector& Trigger::getTriggerConditions() { return m_triggerConditions; } void Trigger::removeTriggerCondition(TriggerCondition type) { std::vector::iterator it = std::find(m_triggerConditions.begin(), m_triggerConditions.end(), type); if (it != m_triggerConditions.end()) { m_triggerConditions.erase(it); } } void Trigger::enableForInstance(Instance* instance) { std::vector::iterator it = std::find(m_enabledInstances.begin(), m_enabledInstances.end(), instance); if (it == m_enabledInstances.end()) { m_enabledInstances.push_back(instance); } } const std::vector& Trigger::getEnabledInstances() { return m_enabledInstances; } void Trigger::disableForInstance(Instance* instance) { std::vector::iterator it = std::find(m_enabledInstances.begin(), m_enabledInstances.end(), instance); if (it != m_enabledInstances.end()) { m_enabledInstances.erase(it); } } void Trigger::enableForAllInstances() { m_enabledAll = true; } bool Trigger::isEnabledForAllInstances() { return m_enabledAll; } void Trigger::disableForAllInstances() { m_enabledAll = false; } void Trigger::assign(Layer* layer, const ModelCoordinate& pt) { Cell* cell = layer->getCellCache()->getCell(pt); if (!cell) { return; } std::vector::iterator it = std::find(m_assigned.begin(), m_assigned.end(), cell); if (it == m_assigned.end()) { m_assigned.push_back(cell); cell->addChangeListener(m_changeListener); } } void Trigger::remove(Layer* layer, const ModelCoordinate& pt) { Cell* cell = layer->getCellCache()->getCell(pt); if (!cell) { return; } std::vector::iterator it = std::find(m_assigned.begin(), m_assigned.end(), cell); if (it != m_assigned.end()) { m_assigned.erase(it); cell->removeChangeListener(m_changeListener); } } void Trigger::assign(Cell* cell) { std::vector::iterator it = std::find(m_assigned.begin(), m_assigned.end(), cell); if (it == m_assigned.end()) { m_assigned.push_back(cell); cell->addChangeListener(m_changeListener); } } void Trigger::remove(Cell* cell) { std::vector::iterator it = std::find(m_assigned.begin(), m_assigned.end(), cell); if (it != m_assigned.end()) { m_assigned.erase(it); cell->removeChangeListener(m_changeListener); } } const std::vector& Trigger::getAssignedCells() { return m_assigned; } void Trigger::attach(Instance* instance) { if (instance == m_attached) { return; } if (m_attached) { detach(); } m_attached = instance; m_attached->addDeleteListener(m_changeListener); m_attached->addChangeListener(m_changeListener); } void Trigger::detach() { if (m_attached) { m_attached->removeDeleteListener(m_changeListener); m_attached->removeChangeListener(m_changeListener); m_attached = 0; } } void Trigger::move() { if (m_assigned.empty()) { return; } ModelCoordinate newPos = m_attached->getLocationRef().getLayerCoordinates(); ModelCoordinate oldPos = m_attached->getOldLocationRef().getLayerCoordinates(); moveTo(newPos, oldPos); } void Trigger::moveTo(const ModelCoordinate& newPos, const ModelCoordinate& oldPos) { ModelCoordinate mc(newPos.x-oldPos.x, newPos.y-oldPos.y); CellCache* cache = m_attached->getLocationRef().getLayer()->getCellCache(); std::vector newCells; std::vector::iterator it = m_assigned.begin(); for (; it != m_assigned.end(); ++it) { ModelCoordinate coord = (*it)->getLayerCoordinates(); coord.x += mc.x; coord.y += mc.y; Cell* c = cache->getCell(coord); if (c) { newCells.push_back(c); } } for (it = newCells.begin(); it != newCells.end(); ++it) { std::vector::iterator found = std::find(m_assigned.begin(), m_assigned.end(), *it); if (found != m_assigned.end()) { m_assigned.erase(found); } else { // add new (*it)->addChangeListener(m_changeListener); } } // remove old for (it = m_assigned.begin(); it != m_assigned.end(); ++it) { (*it)->removeChangeListener(m_changeListener); } m_assigned = newCells; } }