void Tile::initFullPolygon(int mazeWidth, int mazeHeight) {
Meters halfWallWidth = Meters(P()->wallWidth()) / 2.0;
Meters tileLength = Meters(P()->wallLength() + P()->wallWidth());
Cartesian lowerLeftPoint(tileLength * getX() - halfWallWidth * (getX() == 0 ? 1 : 0),
tileLength * getY() - halfWallWidth * (getY() == 0 ? 1 : 0));
Cartesian upperRightPoint(tileLength * (getX() + 1) + halfWallWidth * (getX() == mazeWidth - 1 ? 1 : 0),
tileLength * (getY() + 1) + halfWallWidth * (getY() == mazeHeight - 1 ? 1 : 0));
Cartesian lowerRightPoint(upperRightPoint.getX(), lowerLeftPoint.getY());
Cartesian upperLeftPoint(lowerLeftPoint.getX(), upperRightPoint.getY());
m_fullPolygon = Polygon({lowerLeftPoint, upperLeftPoint, upperRightPoint, lowerRightPoint});
}
void testNavMesh()
{
Event::EventManager m;
Event::ListenerRegister & reg = m.getListenerRegister();
AI::NavMesh::NavMeshGenerationEngine navMeshGenerationEngine;
navMeshGenerationEngine.registerListeners(reg);
vector<Threading::ThreadableInterface*> threadables;
threadables.push_back(&m);
Threading::Thread eventThread(threadables, 2);
eventThread.start();
vector<Threading::ThreadableInterface*> threadables2;
threadables2.push_back(&navMeshGenerationEngine);
Threading::Thread generationThread(threadables2, 2);
generationThread.start();
Event::EventQueue & queue = m.getEventQueue();
Geometry::Vec2Df lowerLeftPoint(0.f, 0.f);
Geometry::Vec2Df upperRightPoint(128.f,128.f);
queue << new AI::NavMesh::AreaCreatedEvent(lowerLeftPoint, upperRightPoint);
// Create some obtacles
queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(110.f,110.f), Geometry::Vec2Df(119.f,119.f)));
queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(60.f,60.f), Geometry::Vec2Df(70.f,70.f)));
queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(10.f,10.f), Geometry::Vec2Df(15.f,15.f)));
queue << new AI::NavMesh::NavMeshOverEvent(lowerLeftPoint,upperRightPoint);
int k = 0;
while (k < 20)
{
k++;
Threading::sleep(Core::makeDurationMillis(200));
}
eventThread.stop();
generationThread.stop();
// Draw navMesh
Test::SvgDrawer drawer(256,256);
const AI::NavMesh::NavMeshContainer::NavMeshesList& navMeshes = navMeshGenerationEngine.getNavMeshes().getNavMeshesList();
if(navMeshes.size() > 0)
{
AI::NavMesh::NavMesh* navMesh = navMeshes.at(0);
// Path finding
const Graph::PlanarGraph& graph = navMesh->getGraph();
const Graph::PlanarNode& startNode = graph.getNodes().front();
const Graph::PlanarNode& goalNode = graph.getNodes().back();
Graph::PlanarGraph::NodeCollection path;
Graph::BasicAStar(graph, startNode, goalNode, path);
drawNavMesh(*navMesh, drawer);
//drawPath(path, drawer);
//std::cout << drawer.getContent().str();
}
// Test AI
// Create entity
Threading::ConcurrentRessource<Ecs::World> w(
new Ecs::World(m.getEventQueue())
);
Ecs::Entity e1, e2;
{
Threading::ConcurrentWriter<Ecs::World> world = w.getWriter();
e1 = createNewCharacter(
world,
Geometry::Vec3Df(0.0,0.0,0.0),
Geometry::Vec3Df(0.0,0.0,0.0),
true,
queue
);
e2 = createNewCharacter(
world,
Geometry::Vec3Df(80.0,80.0,0.0),
Geometry::Vec3Df(0.0,0.0,0.0),
false,
queue
);
}
// Create thrads for systems
AI::AiSystem aiSystem(w);
AI::Sensor::SensorSystem sensorSystem(w);
Physics::MovementSystem movementSystem(w, m.getEventQueue());
AI::Subsystem::TargetingSystem targetingSystem(w);
vector<Threading::ThreadableInterface*> aiSystemVector;
vector<Threading::ThreadableInterface*> movementSystemVector;
vector<Threading::ThreadableInterface*> targetingSystemVector;
vector<Threading::ThreadableInterface*> sensorSystemVector;
aiSystemVector.push_back(&sensorSystem);
aiSystemVector.push_back(&targetingSystem);
aiSystemVector.push_back(&aiSystem);
movementSystemVector.push_back(&movementSystem);
Threading::Thread aiThread(aiSystemVector, 20);
//Threading::Thread sensorThread(sensorSystemVector, 5);
//Threading::Thread targetingThread(targetingSystemVector, 5);
Threading::Thread movementThread(movementSystemVector, 20);
// Get the position component of e1
Ecs::ComponentGroup::ComponentTypeCollection types;
types.insert(Geometry::PositionComponent::Type);
Ecs::ComponentGroup prototype(types);
Ecs::ComponentGroup componentsE1 = w.getWriter()->getEntityComponents(
e1,
prototype
);
Ecs::ComponentGroup componentsE2 =
w.getWriter()->getEntityComponents(e2, prototype);
types.insert(AI::Subsystem::TargetingComponent::Type);
Ecs::ComponentGroup components =
w.getWriter()->getEntityComponents(e1, Ecs::ComponentGroup(types));
//sensorThread.start();
//targetingThread.start();
aiThread.start();
movementThread.start();
std::vector<Geometry::Vec2Df> positions;
positions.push_back(Geometry::Vec2Df(0,0));
/*
bool b = true;
while(b)
{
Geometry::Vec2Df lastPos = positions.back();
Geometry::Vec3Df pos = positionComponentE1.getPosition();
if((pos -positionComponentE2.getPosition()).getLength() < 2.f)
b = false;
Threading::sleep(0,20);
if(pos.getX() != lastPos.getX() && pos.getY() != lastPos.getY())
positions.push_back(Geometry::Vec2Df(pos.getX(), pos.getY()));
}
for (int j =0; j < 20; j++)
{
Threading::sleep(0,100);
}
*/
std::vector<Geometry::Vec2Df> positionsE2;
std::vector<Geometry::Vec2Df> targets;
// Taget is moving slowly to the upper-right corner of the navMesh
Geometry::Vec3Df offset(0.1, -0.2, 0.0);
for (int j =0; j < 20*20; j++)
{
Threading::sleep(Core::makeDurationMillis(50));
ConcurrentReader<Geometry::PositionComponent> positionComponentE1 =
getConcurrentReader<Ecs::Component, Geometry::PositionComponent>(
componentsE1.getComponent(Geometry::PositionComponent::Type)
);
ConcurrentWriter<Geometry::PositionComponent> positionComponentE2 =
getConcurrentWriter<Ecs::Component, Geometry::PositionComponent>(
componentsE2.getComponent(Geometry::PositionComponent::Type)
);
ConcurrentReader<AI::Subsystem::TargetingComponent> targetingComponent =
getConcurrentReader<Ecs::Component, AI::Subsystem::TargetingComponent>(
components.getComponent(AI::Subsystem::TargetingComponent::Type)
);
Geometry::Vec3Df pos1 = positionComponentE1->getPosition();
Geometry::Vec3Df pos2 = positionComponentE2->getPosition();
Geometry::Vec3Df target = targetingComponent->getTargetPosition();
Geometry::Vec3Df newPos = pos2 + offset;
positionComponentE2->setPosition(newPos);
positionsE2.push_back(Geometry::Vec2Df(newPos.getX(), newPos.getY()));
positions.push_back(Geometry::Vec2Df(pos1.getX(), pos1.getY()));
targets.push_back(Geometry::Vec2Df(target.getX(), target.getY()));
}
aiThread.stop();
//sensorThread.stop();
//targetingThread.stop();
movementThread.stop();
if(navMeshes.size() > 0)
{
ConcurrentWriter<Geometry::PositionComponent> positionComponentE2 =
getConcurrentWriter<Ecs::Component, Geometry::PositionComponent>(
componentsE2.getComponent(Geometry::PositionComponent::Type)
);
AI::NavMesh::NavMesh* navMesh = navMeshes.at(0);
// Path finding
const Graph::PlanarGraph& graph = navMesh->getGraph();
Geometry::Vec3Df pos2 = positionComponentE2->getPosition();
Graph::PlanarNode startNode; navMesh->getNode( Geometry::Vec2Df(0, 0), startNode);
Graph::PlanarNode goalNode; navMesh->getNode( Geometry::Vec2Df(pos2.getX(), pos2.getY()), goalNode);
Graph::PlanarGraph::NodeCollection path;
Graph::BasicAStar(graph, startNode, goalNode, path);
drawPath(path, drawer);
}
for(unsigned int i = 0; i < positions.size(); i++)
{
Geometry::Vec2Df pos = positions[i];
drawer.drawCircle(pos.getX(), pos.getY(), 1, "green");
}
for(unsigned int i = 0; i < positionsE2.size(); i++)
{
Geometry::Vec2Df pos = positionsE2[i];
drawer.drawCircle(pos.getX(), pos.getY(), 1, "orange");
Geometry::Vec2Df target = targets[i];
drawer.drawCircle(target.getX(), target.getY(), 1, "purple");
}
drawer.end();
std::cout << drawer.getContent().str();
}