/*************************************************************************** * 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 // 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 "util/log/logger.h" #include "view/visual.h" #include "cell.h" #include "cellcache.h" #include "instance.h" #include "layer.h" namespace FIFE { static Logger _log(LM_STRUCTURES); Cell::Cell(int32_t coordint, ModelCoordinate coordinate, Layer* layer): m_coordId(coordint), m_coordinate(coordinate), m_layer(layer), m_zone(NULL), m_transition(NULL), m_inserted(false), m_protect(false) { } Cell::~Cell() { // calls CellDeleteListener, e.g. for transition if (!m_deleteListeners.empty()) { std::vector::iterator it = m_deleteListeners.begin(); for (; it != m_deleteListeners.end(); ++it) { if (*it) { (*it)->onCellDeleted(this); } } } // remove cell from zone if (m_zone) { m_zone->removeCell(this); } // delete m_transition; if (m_transition) { deleteTransition(); } // remove cell from cache (costs, narrow, area) m_layer->getCellCache()->removeCell(this); } void Cell::addInstances(const std::list& instances) { CellCache* cache = m_layer->getCellCache(); for (std::list::const_iterator it = instances.begin(); it != instances.end(); ++it) { std::pair::iterator, bool> ret = m_instances.insert(*it); if (ret.second) { if ((*it)->isSpecialCost()) { cache->registerCost((*it)->getCostId(), (*it)->getCost()); cache->addCellToCost((*it)->getCostId(), this); } if ((*it)->isSpecialSpeed()) { cache->setSpeedMultiplier(this, (*it)->getSpeed()); } if ((*it)->getObject()->getArea() != "") { cache->addCellToArea((*it)->getObject()->getArea(), this); } callOnInstanceEntered(*it); } } updateCellBlockingInfo(); } void Cell::addInstance(Instance* instance) { std::pair::iterator, bool> ret = m_instances.insert(instance); if (ret.second) { CellCache* cache = m_layer->getCellCache(); if (instance->isSpecialCost()) { cache->registerCost(instance->getCostId(), instance->getCost()); cache->addCellToCost(instance->getCostId(), this); } if (instance->isSpecialSpeed()) { cache->setSpeedMultiplier(this, instance->getSpeed()); } if (instance->getObject()->getArea() != "") { cache->addCellToArea(instance->getObject()->getArea(), this); } callOnInstanceEntered(instance); updateCellBlockingInfo(); } } void Cell::changeInstance(Instance* instance) { updateCellBlockingInfo(); } void Cell::removeInstance(Instance* instance) { if (m_instances.erase(instance) == 0) { FL_ERR(_log, "Tried to remove an instance from cell, but given instance could not be found."); return; } CellCache* cache = m_layer->getCellCache(); if (instance->isSpecialCost()) { cache->removeCellFromCost(instance->getCostId(), this); } if (instance->isSpecialSpeed()) { cache->resetSpeedMultiplier(this); // try to find other speed value if (!m_instances.empty()) { std::set::iterator it = m_instances.begin(); for (; it != m_instances.end(); ++it) { if ((*it)->isSpecialSpeed()) { cache->setSpeedMultiplier(this, (*it)->getSpeed()); break; } } } } if (instance->getObject()->getArea() != "") { cache->removeCellFromArea(instance->getObject()->getArea(), this); } callOnInstanceExited(instance); updateCellBlockingInfo(); } bool Cell::isNeighbor(Cell* cell) { std::vector::iterator it = m_neighbors.begin(); for (; it != m_neighbors.end(); ++it) { if (*it == cell) { return true; } } return false; } void Cell::updateCellBlockingInfo() { CellTypeInfo old_type = m_type; m_coordinate.z = MIN_CELL_Z; if (!m_instances.empty()) { int32_t pos = -1; bool cellblock = (m_type == CTYPE_CELL_NO_BLOCKER || m_type == CTYPE_CELL_BLOCKER); for (std::set::iterator it = m_instances.begin(); it != m_instances.end(); ++it) { if (cellblock) { continue; } uint8_t stackpos = (*it)->getCellStackPosition(); if (stackpos < pos) { continue; } // update cell z if (m_coordinate.z < (*it)->getLocationRef().getLayerCoordinates().z && (*it)->getObject()->isStatic()) { m_coordinate.z = (*it)->getLocationRef().getLayerCoordinates().z; } if ((*it)->getCellStackPosition() > pos) { pos = (*it)->getCellStackPosition(); if ((*it)->isBlocking()) { if (!(*it)->getObject()->isStatic()) { m_type = CTYPE_DYNAMIC_BLOCKER; } else { m_type = CTYPE_STATIC_BLOCKER; } } else { m_type = CTYPE_NO_BLOCKER; } } else { // if positions are equal then static_blockers win if ((*it)->isBlocking() && m_type != CTYPE_STATIC_BLOCKER) { if (!(*it)->getObject()->isStatic()) { m_type = CTYPE_DYNAMIC_BLOCKER; } else { m_type = CTYPE_STATIC_BLOCKER; } } } } } else { if (m_type == CTYPE_STATIC_BLOCKER || m_type == CTYPE_DYNAMIC_BLOCKER) { m_type = CTYPE_NO_BLOCKER; } } if (Mathd::Equal(m_coordinate.z, MIN_CELL_Z)) { m_coordinate.z = 0; } if (old_type != m_type) { bool block = (m_type == CTYPE_STATIC_BLOCKER || m_type == CTYPE_DYNAMIC_BLOCKER || m_type == CTYPE_CELL_BLOCKER); m_layer->getCellCache()->setBlockingUpdate(true); callOnBlockingChanged(block); } } void Cell::updateCellInfo() { updateCellBlockingInfo(); if (!m_deleteListeners.empty()) { m_deleteListeners.erase( std::remove(m_deleteListeners.begin(), m_deleteListeners.end(), (CellDeleteListener*)NULL), m_deleteListeners.end()); } if (!m_changeListeners.empty()) { m_changeListeners.erase( std::remove(m_changeListeners.begin(), m_changeListeners.end(), (CellChangeListener*)NULL), m_changeListeners.end()); } } bool Cell::defaultCost() { return m_layer->getCellCache()->isDefaultCost(this); } void Cell::setCostMultiplier(double multi) { m_layer->getCellCache()->setCostMultiplier(this, multi); } double Cell::getCostMultiplier() { return m_layer->getCellCache()->getCostMultiplier(this); } void Cell::resetCostMultiplier() { m_layer->getCellCache()->resetCostMultiplier(this); } bool Cell::defaultSpeed() { return m_layer->getCellCache()->isDefaultSpeed(this); } void Cell::setSpeedMultiplier(double multi) { m_layer->getCellCache()->setSpeedMultiplier(this, multi); } double Cell::getSpeedMultiplier() { return m_layer->getCellCache()->getSpeedMultiplier(this); } void Cell::resetSpeedMultiplier() { m_layer->getCellCache()->resetSpeedMultiplier(this); } Zone* Cell::getZone() { return m_zone; } void Cell::setZone(Zone* zone) { m_zone = zone; } void Cell::resetZone() { m_inserted = false; m_zone = NULL; } bool Cell::isInserted() { return m_inserted; } void Cell::setInserted(bool inserted) { m_inserted = inserted; } bool Cell::isZoneProtected() { return m_protect; } void Cell::setZoneProtected(bool protect) { m_protect = protect; } CellTypeInfo Cell::getCellType() { return m_type; } void Cell::setCellType(CellTypeInfo type) { m_type = type; } const std::set& Cell::getInstances() { return m_instances; } void Cell::setCellId(int32_t id) { m_coordId = id; } int32_t Cell::getCellId() { return m_coordId; } const ModelCoordinate Cell::getLayerCoordinates() const { return m_coordinate; } void Cell::addNeighbor(Cell* cell) { m_neighbors.push_back(cell); } const std::vector& Cell::getNeighbors() { return m_neighbors; } void Cell::resetNeighbors() { m_neighbors.clear(); if (m_transition) { CellCache* cache = m_transition->m_layer->getCellCache(); if (cache) { Cell* cell = cache->getCell(m_transition->m_mc); if (cell) { m_neighbors.push_back(cell); } } } } Layer* Cell::getLayer() { return m_layer; } void Cell::createTransition(Layer* layer, const ModelCoordinate& mc, bool immediate) { TransitionInfo* trans = new TransitionInfo(layer); // if layers are the same then it's a portal if (layer != m_layer) { trans->m_difflayer = true; } trans->m_immediate = immediate; trans->m_mc = mc; deleteTransition(); m_transition = trans; Cell* c = layer->getCellCache()->getCell(mc); if (c) { m_neighbors.push_back(c); c->addDeleteListener(this); m_layer->getCellCache()->addTransition(this); } else { delete m_transition; m_transition = NULL; } } void Cell::deleteTransition() { if (m_transition) { Cell* oldc = m_transition->m_layer->getCellCache()->getCell(m_transition->m_mc); std::vector::iterator it = m_neighbors.begin(); for (; it != m_neighbors.end(); ++it) { if (*it == oldc) { m_neighbors.erase(it); break; } } oldc->removeDeleteListener(this); m_layer->getCellCache()->removeTransition(this); delete m_transition; m_transition = NULL; } } TransitionInfo* Cell::getTransition() { return m_transition; } void Cell::addDeleteListener(CellDeleteListener* listener) { m_deleteListeners.push_back(listener); } void Cell::removeDeleteListener(CellDeleteListener* listener) { std::vector::iterator it = m_deleteListeners.begin(); for (; it != m_deleteListeners.end(); ++it) { if (*it == listener) { *it = NULL; break; } } } void Cell::onCellDeleted(Cell* cell) { std::vector::iterator it = m_neighbors.begin(); for (; it != m_neighbors.end(); ++it) { if (*it == cell) { deleteTransition(); break; } } } void Cell::addChangeListener(CellChangeListener* listener) { m_changeListeners.push_back(listener); } void Cell::removeChangeListener(CellChangeListener* listener) { std::vector::iterator it = m_changeListeners.begin(); for (; it != m_changeListeners.end(); ++it) { if (*it == listener) { *it = NULL; break; } } } void Cell::callOnInstanceEntered(Instance* instance) { if (m_changeListeners.empty()) { return; } std::vector::iterator i = m_changeListeners.begin(); while (i != m_changeListeners.end()) { if (*i) { (*i)->onInstanceEnteredCell(this, instance); } ++i; } } void Cell::callOnInstanceExited(Instance* instance) { if (m_changeListeners.empty()) { return; } std::vector::iterator i = m_changeListeners.begin(); while (i != m_changeListeners.end()) { if (*i) { (*i)->onInstanceExitedCell(this, instance); } ++i; } } void Cell::callOnBlockingChanged(bool blocks) { if (m_changeListeners.empty()) { return; } std::vector::iterator i = m_changeListeners.begin(); while (i != m_changeListeners.end()) { if (*i) { (*i)->onBlockingChangedCell(this, m_type, blocks); } ++i; } } } // FIFE