431a9c00a5
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
357 lines
12 KiB
C++
357 lines
12 KiB
C++
#include "StarEntityMap.hpp"
|
|
#include "StarTileEntity.hpp"
|
|
#include "StarInteractiveEntity.hpp"
|
|
#include "StarProjectile.hpp"
|
|
|
|
namespace Star {
|
|
|
|
float const EntityMapSpatialHashSectorSize = 16.0f;
|
|
int const EntityMap::MaximumEntityBoundBox = 10000;
|
|
|
|
EntityMap::EntityMap(Vec2U const& worldSize, EntityId beginIdSpace, EntityId endIdSpace)
|
|
: m_geometry(worldSize),
|
|
m_spatialMap(EntityMapSpatialHashSectorSize),
|
|
m_nextId(beginIdSpace),
|
|
m_beginIdSpace(beginIdSpace),
|
|
m_endIdSpace(endIdSpace) {}
|
|
|
|
EntityId EntityMap::reserveEntityId() {
|
|
if (m_spatialMap.size() >= (size_t)(m_endIdSpace - m_beginIdSpace))
|
|
throw EntityMapException("No more entity id space in EntityMap::reserveEntityId");
|
|
|
|
EntityId id = m_nextId;
|
|
while (m_spatialMap.contains(id))
|
|
id = cycleIncrement(id, m_beginIdSpace, m_endIdSpace);
|
|
m_nextId = cycleIncrement(id, m_beginIdSpace, m_endIdSpace);
|
|
|
|
return id;
|
|
}
|
|
|
|
Maybe<EntityId> EntityMap::maybeReserveEntityId(EntityId entityId) {
|
|
if (m_spatialMap.size() >= (size_t)(m_endIdSpace - m_beginIdSpace))
|
|
throw EntityMapException("No more entity id space in EntityMap::reserveEntityId");
|
|
|
|
if (entityId == NullEntityId || m_spatialMap.contains(entityId))
|
|
return {};
|
|
else
|
|
return entityId;
|
|
}
|
|
|
|
EntityId EntityMap::reserveEntityId(EntityId entityId) {
|
|
if (entityId == NullEntityId)
|
|
return reserveEntityId();
|
|
if (auto reserved = maybeReserveEntityId(entityId))
|
|
return *reserved;
|
|
|
|
m_nextId = entityId;
|
|
return reserveEntityId();
|
|
}
|
|
|
|
|
|
void EntityMap::addEntity(EntityPtr entity) {
|
|
auto position = entity->position();
|
|
auto boundBox = entity->metaBoundBox();
|
|
auto entityId = entity->entityId();
|
|
auto uniqueId = entity->uniqueId();
|
|
|
|
if (m_spatialMap.contains(entityId))
|
|
throw EntityMapException::format("Duplicate entity id '{}' in EntityMap::addEntity", entityId);
|
|
|
|
if (boundBox.isNegative() || boundBox.width() > MaximumEntityBoundBox || boundBox.height() > MaximumEntityBoundBox) {
|
|
throw EntityMapException::format("Entity id: {} type: {} bound box is negative or beyond the maximum entity bound box size in EntityMap::addEntity",
|
|
entity->entityId(), (int)entity->entityType());
|
|
}
|
|
|
|
if (entityId == NullEntityId)
|
|
throw EntityMapException::format("Null entity id in EntityMap::addEntity");
|
|
|
|
if (uniqueId && m_uniqueMap.hasLeftValue(*uniqueId))
|
|
throw EntityMapException::format("Duplicate entity unique id ({}) on entity id ({}) in EntityMap::addEntity", *uniqueId, entityId);
|
|
|
|
m_spatialMap.set(entityId, m_geometry.splitRect(boundBox, position), std::move(entity));
|
|
if (uniqueId)
|
|
m_uniqueMap.add(*uniqueId, entityId);
|
|
}
|
|
|
|
EntityPtr EntityMap::removeEntity(EntityId entityId) {
|
|
if (auto entity = m_spatialMap.remove(entityId)) {
|
|
m_uniqueMap.removeRight(entityId);
|
|
return entity.take();
|
|
}
|
|
return {};
|
|
}
|
|
|
|
size_t EntityMap::size() const {
|
|
return m_spatialMap.size();
|
|
}
|
|
|
|
List<EntityId> EntityMap::entityIds() const {
|
|
return m_spatialMap.keys();
|
|
}
|
|
|
|
void EntityMap::updateAllEntities(EntityCallback const& callback, function<bool(EntityPtr const&, EntityPtr const&)> sortOrder) {
|
|
auto updateEntityInfo = [&](SpatialMap::Entry const& entry) {
|
|
auto const& entity = entry.value;
|
|
|
|
auto position = entity->position();
|
|
auto boundBox = entity->metaBoundBox();
|
|
|
|
if (boundBox.isNegative() || boundBox.width() > MaximumEntityBoundBox || boundBox.height() > MaximumEntityBoundBox) {
|
|
throw EntityMapException::format("Entity id: {} type: {} bound box is negative or beyond the maximum entity bound box size in EntityMap::addEntity",
|
|
entity->entityId(), (int)entity->entityType());
|
|
}
|
|
|
|
auto entityId = entity->entityId();
|
|
if (entityId == NullEntityId)
|
|
throw EntityMapException::format("Null entity id in EntityMap::setEntityInfo");
|
|
|
|
auto rects = m_geometry.splitRect(boundBox, position);
|
|
if (!containersEqual(rects, entry.rects))
|
|
m_spatialMap.set(entityId, rects);
|
|
|
|
auto uniqueId = entity->uniqueId();
|
|
if (uniqueId) {
|
|
if (auto existingEntityId = m_uniqueMap.maybeRight(*uniqueId)) {
|
|
if (entityId != *existingEntityId)
|
|
throw EntityMapException::format("Duplicate entity unique id on entity ids ({}) and ({})", *existingEntityId, entityId);
|
|
} else {
|
|
m_uniqueMap.removeRight(entityId);
|
|
m_uniqueMap.add(*uniqueId, entityId);
|
|
}
|
|
} else {
|
|
m_uniqueMap.removeRight(entityId);
|
|
}
|
|
};
|
|
|
|
// Even if there is no sort order, we still copy pointers to a temporary
|
|
// list, so that it is safe to call addEntity from the callback.
|
|
m_entrySortBuffer.clear();
|
|
for (auto const& entry : m_spatialMap.entries())
|
|
m_entrySortBuffer.append(&entry.second);
|
|
|
|
if (sortOrder) {
|
|
m_entrySortBuffer.sort([&sortOrder](auto a, auto b) {
|
|
return sortOrder(a->value, b->value);
|
|
});
|
|
}
|
|
|
|
for (auto entry : m_entrySortBuffer) {
|
|
if (callback)
|
|
callback(entry->value);
|
|
updateEntityInfo(*entry);
|
|
}
|
|
}
|
|
|
|
EntityId EntityMap::uniqueEntityId(String const& uniqueId) const {
|
|
return m_uniqueMap.maybeRight(uniqueId).value(NullEntityId);
|
|
}
|
|
|
|
EntityPtr EntityMap::entity(EntityId entityId) const {
|
|
auto entity = m_spatialMap.value(entityId);
|
|
starAssert(!entity || entity->entityId() == entityId);
|
|
return entity;
|
|
}
|
|
|
|
EntityPtr EntityMap::uniqueEntity(String const& uniqueId) const {
|
|
return entity(uniqueEntityId(uniqueId));
|
|
}
|
|
|
|
List<EntityPtr> EntityMap::entityQuery(RectF const& boundBox, EntityFilter const& filter) const {
|
|
List<EntityPtr> values;
|
|
forEachEntity(boundBox, [&](EntityPtr const& entity) {
|
|
if (!filter || filter(entity))
|
|
values.append(entity);
|
|
});
|
|
return values;
|
|
}
|
|
|
|
List<EntityPtr> EntityMap::entitiesAt(Vec2F const& pos, EntityFilter const& filter) const {
|
|
auto entityList = entityQuery(RectF::withCenter(pos, {0, 0}), filter);
|
|
|
|
sortByComputedValue(entityList, [&](EntityPtr const& entity) -> float {
|
|
return vmagSquared(entity->position() - pos);
|
|
});
|
|
return entityList;
|
|
}
|
|
|
|
List<TileEntityPtr> EntityMap::entitiesAtTile(Vec2I const& pos, EntityFilterOf<TileEntity> const& filter) const {
|
|
List<TileEntityPtr> values;
|
|
forEachEntityAtTile(pos, [&](TileEntityPtr const& entity) {
|
|
if (!filter || filter(entity))
|
|
values.append(entity);
|
|
});
|
|
return values;
|
|
}
|
|
|
|
void EntityMap::forEachEntity(RectF const& boundBox, EntityCallback const& callback) const {
|
|
m_spatialMap.forEach(m_geometry.splitRect(boundBox), callback);
|
|
}
|
|
|
|
void EntityMap::forEachEntityLine(Vec2F const& begin, Vec2F const& end, EntityCallback const& callback) const {
|
|
return m_spatialMap.forEach(m_geometry.splitRect(RectF::boundBoxOf(begin, end)), [&](EntityPtr const& entity) {
|
|
if (m_geometry.lineIntersectsRect({begin, end}, entity->metaBoundBox().translated(entity->position())))
|
|
callback(entity);
|
|
});
|
|
}
|
|
|
|
void EntityMap::forEachEntityAtTile(Vec2I const& pos, EntityCallbackOf<TileEntity> const& callback) const {
|
|
RectF rect(Vec2F(pos[0], pos[1]), Vec2F(pos[0] + 1, pos[1] + 1));
|
|
forEachEntity(rect, [&](EntityPtr const& entity) {
|
|
if (auto tileEntity = as<TileEntity>(entity)) {
|
|
for (Vec2I space : tileEntity->spaces()) {
|
|
if (m_geometry.equal(pos, space + tileEntity->tilePosition()))
|
|
callback(tileEntity);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
void EntityMap::forAllEntities(EntityCallback const& callback, function<bool(EntityPtr const&, EntityPtr const&)> sortOrder) const {
|
|
// Even if there is no sort order, we still copy pointers to a temporary
|
|
// list, so that it is safe to call addEntity from the callback.
|
|
List<EntityPtr const*> allEntities;
|
|
allEntities.reserve(m_spatialMap.size());
|
|
for (auto const& entry : m_spatialMap.entries())
|
|
allEntities.append(&entry.second.value);
|
|
|
|
if (sortOrder) {
|
|
allEntities.sort([&sortOrder](EntityPtr const* a, EntityPtr const* b) {
|
|
return sortOrder(*a, *b);
|
|
});
|
|
}
|
|
|
|
for (auto ptr : allEntities)
|
|
callback(*ptr);
|
|
}
|
|
|
|
EntityPtr EntityMap::findEntity(RectF const& boundBox, EntityFilter const& filter) const {
|
|
EntityPtr res;
|
|
forEachEntity(boundBox, [&filter, &res](EntityPtr const& entity) {
|
|
if (res)
|
|
return;
|
|
if (filter(entity))
|
|
res = entity;
|
|
});
|
|
return res;
|
|
}
|
|
|
|
EntityPtr EntityMap::findEntityLine(Vec2F const& begin, Vec2F const& end, EntityFilter const& filter) const {
|
|
return findEntity(RectF::boundBoxOf(begin, end), [&](EntityPtr const& entity) {
|
|
if (m_geometry.lineIntersectsRect({begin, end}, entity->metaBoundBox().translated(entity->position()))) {
|
|
if (filter(entity))
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
EntityPtr EntityMap::findEntityAtTile(Vec2I const& pos, EntityFilterOf<TileEntity> const& filter) const {
|
|
RectF rect(Vec2F(pos[0], pos[1]), Vec2F(pos[0] + 1, pos[1] + 1));
|
|
return findEntity(rect, [&](EntityPtr const& entity) {
|
|
if (auto tileEntity = as<TileEntity>(entity)) {
|
|
for (Vec2I space : tileEntity->spaces()) {
|
|
if (m_geometry.equal(pos, space + tileEntity->tilePosition())) {
|
|
if (filter(tileEntity))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
List<EntityPtr> EntityMap::entityLineQuery(Vec2F const& begin, Vec2F const& end, EntityFilter const& filter) const {
|
|
List<EntityPtr> values;
|
|
forEachEntityLine(begin, end, [&](EntityPtr const& entity) {
|
|
if (!filter || filter(entity))
|
|
values.append(entity);
|
|
});
|
|
return values;
|
|
}
|
|
|
|
EntityPtr EntityMap::closestEntity(Vec2F const& center, float radius, EntityFilter const& filter) const {
|
|
EntityPtr closest;
|
|
float distSquared = square(radius);
|
|
RectF boundBox(center[0] - radius, center[1] - radius, center[0] + radius, center[1] + radius);
|
|
|
|
m_spatialMap.forEach(m_geometry.splitRect(boundBox), [&](EntityPtr const& entity) {
|
|
Vec2F pos = entity->position();
|
|
float thisDistSquared = m_geometry.diff(center, pos).magnitudeSquared();
|
|
if (distSquared > thisDistSquared) {
|
|
if (!filter || filter(entity)) {
|
|
distSquared = thisDistSquared;
|
|
closest = entity;
|
|
}
|
|
}
|
|
});
|
|
|
|
return closest;
|
|
}
|
|
|
|
InteractiveEntityPtr EntityMap::interactiveEntityNear(Vec2F const& pos, float maxRadius) const {
|
|
auto rect = RectF::withCenter(pos, Vec2F::filled(maxRadius));
|
|
InteractiveEntityPtr interactiveEntity;
|
|
double bestDistance = maxRadius + 100;
|
|
double bestCenterDistance = maxRadius + 100;
|
|
m_spatialMap.forEach(m_geometry.splitRect(rect), [&](EntityPtr const& entity) {
|
|
if (auto ie = as<InteractiveEntity>(entity)) {
|
|
if (ie->isInteractive()) {
|
|
if (auto tileEntity = as<TileEntity>(entity)) {
|
|
for (Vec2I space : tileEntity->interactiveSpaces()) {
|
|
auto dist = m_geometry.diff(pos, centerOfTile(space + tileEntity->tilePosition())).magnitude();
|
|
auto centerDist = m_geometry.diff(tileEntity->metaBoundBox().center() + tileEntity->position(), pos).magnitude();
|
|
if ((dist < bestDistance) || ((dist == bestDistance) && (centerDist < bestCenterDistance))) {
|
|
interactiveEntity = ie;
|
|
bestDistance = dist;
|
|
bestCenterDistance = centerDist;
|
|
}
|
|
}
|
|
} else {
|
|
auto box = ie->interactiveBoundBox().translated(entity->position());
|
|
auto dist = m_geometry.diffToNearestCoordInBox(box, pos).magnitude();
|
|
auto centerDist = m_geometry.diff(box.center(), pos).magnitude();
|
|
if ((dist < bestDistance) || ((dist == bestDistance) && (centerDist < bestCenterDistance))) {
|
|
interactiveEntity = ie;
|
|
bestDistance = dist;
|
|
bestCenterDistance = centerDist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (bestDistance <= maxRadius)
|
|
return interactiveEntity;
|
|
return {};
|
|
}
|
|
|
|
bool EntityMap::tileIsOccupied(Vec2I const& pos, bool includeEphemeral) const {
|
|
RectF rect(Vec2F(pos[0], pos[1]), Vec2F(pos[0] + 1, pos[1] + 1));
|
|
return (bool)findEntity(rect, [&](EntityPtr const& entity) {
|
|
if (auto tileEntity = as<TileEntity>(entity)) {
|
|
if (includeEphemeral || !tileEntity->ephemeral()) {
|
|
for (Vec2I space : tileEntity->spaces()) {
|
|
if (m_geometry.equal(pos, space + tileEntity->tilePosition())) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
bool EntityMap::spaceIsOccupied(RectF const& rect, bool includesEphemeral) const {
|
|
for (auto const& entity : entityQuery(rect)) {
|
|
if (!includesEphemeral && entity->ephemeral())
|
|
continue;
|
|
|
|
for (RectF const& c : m_geometry.splitRect(entity->collisionArea(), entity->position())) {
|
|
if (!c.isNull() && rect.intersects(c))
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|