mirror of
https://github.com/worldforge/cyphesis
synced 2026-08-13 12:26:04 -04:00
323 lines
11 KiB
C++
323 lines
11 KiB
C++
/*
|
|
Copyright (C) 2015 erik
|
|
|
|
This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <rulesets/mind/AwareMind.h>
|
|
#include <rulesets/mind/AwarenessStore.h>
|
|
#include <rulesets/mind/AwarenessStoreProvider.h>
|
|
#include <rulesets/mind/SharedTerrain.h>
|
|
#include <rulesets/TerrainProperty.h>
|
|
|
|
#include "navigation/Awareness.h"
|
|
#include "navigation/Steering.h"
|
|
|
|
#include "common/log.h"
|
|
#include "common/SystemTime.h"
|
|
#include "common/Tick.h"
|
|
#include "common/debug.h"
|
|
|
|
#include <Atlas/Objects/RootEntity.h>
|
|
#include <Atlas/Objects/Operation.h>
|
|
#include <Atlas/Objects/Entity.h>
|
|
|
|
#include <wfmath/atlasconv.h>
|
|
|
|
#include <Mercator/Terrain.h>
|
|
|
|
#include <iostream>
|
|
|
|
static const bool debug_flag = true;
|
|
|
|
AwareMind::AwareMind(const std::string &id, long intId, SharedTerrain& sharedTerrain, AwarenessStoreProvider& awarenessStoreProvider) :
|
|
BaseMind(id, intId), mSharedTerrain(sharedTerrain), mAwarenessStoreProvider(awarenessStoreProvider), mAwarenessStore(nullptr), mSteering(new Steering(*this)), mServerTimeDiff(
|
|
0)
|
|
{
|
|
m_map.setListener(this);
|
|
}
|
|
|
|
AwareMind::~AwareMind()
|
|
{
|
|
if (mAwareness) {
|
|
auto& entities = m_map.getEntities();
|
|
//Remove all our still known entities from the awareness
|
|
for (auto entry : entities) {
|
|
if (entry.second->m_location.m_loc == m_location.m_loc) {
|
|
mAwareness->removeEntity(*this, *entry.second);
|
|
}
|
|
}
|
|
mAwareness->removeAwarenessArea(getId());
|
|
mAwareness->removeObserver();
|
|
}
|
|
delete mSteering;
|
|
}
|
|
|
|
void AwareMind::operation(const Operation & op, OpVector & res)
|
|
{
|
|
|
|
//If it's a "move" tick we'll process it here and won't send it on to the mind.
|
|
if (op->getClassNo() == Atlas::Objects::Operation::TICK_NO) {
|
|
if (!op->getArgs().empty()) {
|
|
auto arg = op->getArgs().front();
|
|
if (arg->getName() == "move") {
|
|
processMoveTick(op, res);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mServerTimeDiff == 0 && op->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) {
|
|
if (op->hasAttrFlag(Atlas::Objects::Operation::SECONDS_FLAG)) {
|
|
double stamp = op->getSeconds();
|
|
mServerTimeDiff = getCurrentLocalTime() - stamp;
|
|
}
|
|
}
|
|
|
|
BaseMind::operation(op, res);
|
|
}
|
|
|
|
double AwareMind::getCurrentLocalTime() const
|
|
{
|
|
SystemTime time;
|
|
time.update();
|
|
return (time.seconds() + (time.microseconds() * 0.000001));
|
|
}
|
|
|
|
double AwareMind::getCurrentServerTime() const
|
|
{
|
|
return getCurrentLocalTime() - mServerTimeDiff;
|
|
}
|
|
|
|
void AwareMind::processMoveTick(const Operation & op, OpVector & res)
|
|
{
|
|
//Default to checking movement every 0.2 seconds, unless steering tells us otherwise
|
|
double futureTick = 0.2;
|
|
|
|
if (mAwareness) {
|
|
auto remainingDirtyTiles = mAwareness->rebuildDirtyTile();
|
|
if (remainingDirtyTiles > 0) {
|
|
futureTick = 0;
|
|
} else {
|
|
if (mAwareness->needsPruning()) {
|
|
mAwareness->pruneTiles();
|
|
}
|
|
if (mAwareness->needsPruning()) {
|
|
futureTick = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mSteering) {
|
|
SteeringResult result = mSteering->update(getCurrentServerTime());
|
|
if (result.direction.isValid()) {
|
|
Atlas::Objects::Operation::Move move;
|
|
Atlas::Objects::Entity::Anonymous what;
|
|
// what->setLoc(m_entity->getLocation()->getId());
|
|
what->setId(getId());
|
|
what->setAttr("velocity", result.direction.toAtlas());
|
|
if (result.destination.isValid()) {
|
|
what->setAttr("pos", result.destination.toAtlas());
|
|
}
|
|
|
|
move->setFrom(getId());
|
|
move->setArgs1(what);
|
|
|
|
// if (debug_flag) {
|
|
// std::cout << "Move arg {" << std::endl;
|
|
// debug_dump(what, std::cout);
|
|
// std::cout << "}" << std::endl << std::flush;
|
|
// }
|
|
|
|
res.push_back(move);
|
|
}
|
|
if (result.timeToNextWaypoint) {
|
|
futureTick = std::min(*result.timeToNextWaypoint, futureTick);
|
|
}
|
|
}
|
|
|
|
Atlas::Objects::Operation::Tick tick;
|
|
Atlas::Objects::Entity::Anonymous arg;
|
|
arg->setName("move");
|
|
tick->setArgs1(arg);
|
|
tick->setFutureSeconds(futureTick);
|
|
|
|
res.push_back(tick);
|
|
}
|
|
|
|
int AwareMind::updatePath()
|
|
{
|
|
return mSteering->updatePath(getCurrentServerTime());
|
|
}
|
|
|
|
Steering& AwareMind::getSteering()
|
|
{
|
|
return *mSteering;
|
|
}
|
|
|
|
void AwareMind::setType(const TypeNode * t)
|
|
{
|
|
BaseMind::setType(t);
|
|
//log(INFO, "Creating store.");
|
|
mAwarenessStore = &mAwarenessStoreProvider.getStore(getType());
|
|
}
|
|
|
|
void AwareMind::entityAdded(const MemEntity& entity)
|
|
{
|
|
if (mAwareness) {
|
|
// log(INFO, String::compose("Adding entity %1", entity.getId()));
|
|
//TODO: check if the entity is dynamic
|
|
if (entity.m_location.m_loc == m_location.m_loc) {
|
|
mAwareness->addEntity(*this, entity, false);
|
|
}
|
|
} else {
|
|
//Check if we've received the current domain entity.
|
|
if (this->m_location.m_loc && entity.getIntId() == this->m_location.m_loc->getIntId()) {
|
|
//log(INFO, "Creating awareness.");
|
|
requestAwareness(entity);
|
|
|
|
Atlas::Message::Element terrainElem;
|
|
if (entity.getAttr("terrain", terrainElem) == 0) {
|
|
parseTerrain(terrainElem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AwareMind::requestAwareness(const MemEntity& entity)
|
|
{
|
|
mAwareness = mAwarenessStore->requestAwareness(entity);
|
|
mAwareness->addObserver();
|
|
mAwareness->addEntity(*this, *this, true);
|
|
auto& entities = m_map.getEntities();
|
|
//Add all existing known entities that have the same parent entity as ourselves.
|
|
for (auto entry : entities) {
|
|
if (entry.first != getIntId()) {
|
|
if (entry.second->m_location.m_loc == m_location.m_loc) {
|
|
mAwareness->addEntity(*this, *entry.second, false);
|
|
}
|
|
}
|
|
}
|
|
mSteering->setAwareness(mAwareness.get());
|
|
}
|
|
|
|
void AwareMind::entityUpdated(const MemEntity& entity, const Atlas::Objects::Entity::RootEntity & ent, LocatedEntity* oldLocation)
|
|
{
|
|
if (mAwareness) {
|
|
//Update the awareness if location, position, velocity, orientation or bbox has changed
|
|
if (ent->hasAttrFlag(Atlas::Objects::Entity::LOC_FLAG) || ent->hasAttrFlag(Atlas::Objects::Entity::POS_FLAG) || ent->hasAttrFlag(Atlas::Objects::Entity::VELOCITY_FLAG)
|
|
|| ent->hasAttr("orientation") || ent->hasAttr("bbox")) {
|
|
if (oldLocation == entity.m_location.m_loc) {
|
|
//Location wasn't changed
|
|
if (entity.m_location.m_loc == this->m_location.m_loc) {
|
|
//log(INFO, "Updated entity.");
|
|
mAwareness->updateEntityMovement(*this, entity);
|
|
}
|
|
} else {
|
|
//Check if new location is the domain, and then add the entity
|
|
if (entity.m_location.m_loc == this->m_location.m_loc) {
|
|
//log(INFO, "Adding entity.");
|
|
mAwareness->addEntity(*this, entity, false);
|
|
} else if (oldLocation == this->m_location.m_loc) {
|
|
//log(INFO, "Removing entity.");
|
|
mAwareness->removeEntity(*this, entity);
|
|
}
|
|
}
|
|
|
|
//If it was ourselves that moved we should notify steering that it shouldn't wait any more for a movement op.
|
|
if (entity.getIntId() == getIntId()) {
|
|
mSteering->setIsExpectingServerMovement(false);
|
|
}
|
|
}
|
|
} else {
|
|
if (this->m_location.m_loc && entity.getIntId() == this->m_location.m_loc->getIntId()) {
|
|
if (ent->hasAttr("terrain")) {
|
|
|
|
Atlas::Message::Element terrainElement;
|
|
if (ent->copyAttr("terrain", terrainElement) == 0) {
|
|
parseTerrain(terrainElement);
|
|
}
|
|
}
|
|
if (!mAwareness) {
|
|
requestAwareness(entity);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AwareMind::parseTerrain(const Atlas::Message::Element& terrainElement)
|
|
{
|
|
if (terrainElement.isMap()) {
|
|
const Atlas::Message::MapType& terrainMap = terrainElement.Map();
|
|
auto pointsI = terrainMap.find("points");
|
|
if (pointsI != terrainMap.end() && pointsI->second.isMap()) {
|
|
|
|
std::vector<SharedTerrain::BasePointDefinition> pointDefs;
|
|
|
|
auto& pointsMap = pointsI->second.Map();
|
|
for (auto& pointEntry : pointsMap) {
|
|
if (pointEntry.second.isList()) {
|
|
auto& pointsList = pointEntry.second.List();
|
|
if (pointsList.size() == 3) {
|
|
if (!pointsList[0].isNum()) {
|
|
continue;
|
|
}
|
|
if (!pointsList[1].isNum()) {
|
|
continue;
|
|
}
|
|
if (!pointsList[2].isNum()) {
|
|
continue;
|
|
}
|
|
|
|
pointDefs.emplace_back(
|
|
SharedTerrain::BasePointDefinition { (int)pointsList[0].asNum(), (int)pointsList[1].asNum(), Mercator::BasePoint(pointsList[2].asNum()) });
|
|
}
|
|
}
|
|
}
|
|
std::vector<SharedTerrain::BasePointDefinition> changedPoints = mSharedTerrain.setBasePoints(pointDefs);
|
|
if (mAwareness) {
|
|
int res = mSharedTerrain.getTerrain().getResolution();
|
|
for (auto& entry : changedPoints) {
|
|
WFMath::AxisBox<2> area(WFMath::Point<2>(entry.x - res, entry.y - res), WFMath::Point<2>(entry.x + res, entry.y + res));
|
|
mAwareness->markTilesAsDirty(std::move(area));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void AwareMind::entityDeleted(const MemEntity& entity)
|
|
{
|
|
if (mAwareness) {
|
|
//log(INFO, "Removed entity.");
|
|
mAwareness->removeEntity(*this, entity);
|
|
}
|
|
}
|
|
|
|
void AwareMind::onContainered(const LocatedEntity * new_loc)
|
|
{
|
|
}
|
|
|
|
double AwareMind::getServerTimeDiff() const
|
|
{
|
|
return mServerTimeDiff;
|
|
}
|
|
|