void Map::generateRooms(int attempts) {
auto time = clock();
std::uniform_int_distribution<int> xDistribution(0, (this->width - 1) / 2);
std::uniform_int_distribution<int> yDistribution(0, (this->height - 1) / 2);
std::uniform_int_distribution<int> widthDistribution(3, 15);
std::uniform_int_distribution<int> heightDistribution(3, 15);
for (int i = 0; i < attempts; i++) {
bool intersects = false;
std::shared_ptr<Room> room = std::make_shared<Room>(xDistribution(generator) * 2 + 1, yDistribution(generator) * 2 + 1, widthDistribution(generator) * 2 + 1, heightDistribution(generator) * 2 + 1);
if (!isInside(room->x, room->y) || !isInside(room->x + room->width, room->y + room->height)
|| !isInside(room->x + room->width, room->y) ||!isInside(room->x, room->y + room->height)) {
continue;
}
room->applyTiles();
for (auto region : regions) {
if (room->intersects(region)) {
intersects = true;
break;
}
}
if (!intersects) {
//room->shrink(1, 1);
regions.push_back(room);
set(room->tiles, room);
}
}
time = clock() - time;
std::cout << "Generated rooms in " << (((float)time)/CLOCKS_PER_SEC) << " seconds" << std::endl;
}
void Simulation::populate(int number, int xMin, int yMin, int xMax, int yMax) //populates the planetList with randomly generated planets
{
std::default_random_engine generator;
std::uniform_int_distribution<int> massDistribution(10, 1000);
std::uniform_int_distribution<int> xDistribution(xMin, xMax);
std::uniform_int_distribution<int> yDistribution(yMin, yMax);
for (int i = 0; i < number; i++)
{
planetList.emplace_back(massDistribution(generator), xDistribution(generator), yDistribution(generator));
}
}
Ped::Tvector ShoppingPlanner::getRandomAttractionPosition() const
{
Ped::Tvector randomPosition = attraction->getPosition();
// → add random part
QSizeF size = attraction->getSize();
std::uniform_real_distribution<double> xDistribution ( -size.width() /2, size.width() /2 );
std::uniform_real_distribution<double> yDistribution ( -size.height() /2, size.height() /2 );
double xdiff = xDistribution ( RNG() );
double ydiff = yDistribution ( RNG() );
randomPosition += Ped::Tvector ( xdiff, ydiff );
return randomPosition;
}
void Mouse::respawn()
{
//get a random position
auto xPosition = xDistribution(randomEngine);
auto yPosition = yDistribution(randomEngine);
mouseBody.setPosition(xPosition, yPosition);
}
void MouseSpawner::spawn()
{
if (spawnTimer.getElapsedTime().asSeconds() >= spawnInterval())
{
spawnTimer.restart();
if (active && spawnedMice.size() < maximumSpawnedMice())
{
std::unique_ptr<Mouse> mouse = std::make_unique<Mouse>(nextId, m_mouseTexture);
sf::FloatRect windowRect(0, 0, static_cast<float>(window->getSize().x-m_mouseTexture.getSize().x), static_cast<float>(window->getSize().y - m_mouseTexture.getSize().y));
bool success;
do
{
success = true;
//get random spawn position
auto xPosition = xDistribution(randomEngine);
auto yPosition = yDistribution(randomEngine);
mouse->setBodyPosition(static_cast<float>(xPosition), static_cast<float>(yPosition));
// if (m_snake->checkForCollision(mouse->getBodyRect())) //check it doesn't collide with the snake
// {
// success = false;
// }
// else if (!windowRect.contains({ mouse->getBodyRect().left,mouse->getBodyRect().top })) // check it's in the window
// {
// success = false;
// }
// else
// {
// //check the rest of the mice for collisions
// for (auto& otherMouse : spawnedMice)
// {
// if (mouse->getBodyRect().intersects(otherMouse.second->getBodyRect()))
// {
// success = false;
// break;
// }
// }
// }
} while (!success);
spawnedMice.emplace(nextId, std::move(mouse));
++nextId;
}
}
}
void DungeonGenerator::generateLevel(int floorIndex, Dungeon* dungeon, int width, int height, std::default_random_engine engine, int startRoomX, int startRoomY)
{
RoomDescriptionGenerator roomDescriptionGenerator;
for (auto x = 0; x < width; x++)
{
for (auto y = 0; y < height; y++)
{
dungeon->setRoom(new Room(floorIndex, x, y, roomDescriptionGenerator.getRandomDescription()), x, y, floorIndex);
}
}
for (auto x = 0; x < width; x++)
{
for (auto y = 0; y < height; y++)
{
resetPossibleRandomDirections();
if (x == 0)
{
removeFromPossibleRandomDirections(Direction::WEST);
}
else if (x == (width - 1))
{
removeFromPossibleRandomDirections(Direction::EAST);
}
if (y == 0)
{
removeFromPossibleRandomDirections(Direction::NORTH);
}
else if (y == (height - 1))
{
removeFromPossibleRandomDirections(Direction::SOUTH);
}
std::uniform_int_distribution<int> amountOfRoomsDistibution {1, static_cast<int>(possibleRandomDirections_ ->size())};
Direction roomDirection;
auto amountOfConnectedRooms = amountOfRoomsDistibution(engine);
if (dungeon->getRoom(x, y, floorIndex)->getRoom(Direction::NORTH) != nullptr)
{
amountOfConnectedRooms--;
}
if (dungeon->getRoom(x, y, floorIndex)->getRoom(Direction::EAST) != nullptr)
{
amountOfConnectedRooms--;
}
if (dungeon->getRoom(x, y, floorIndex)->getRoom(Direction::SOUTH) != nullptr)
{
amountOfConnectedRooms--;
}
if (dungeon->getRoom(x, y, floorIndex)->getRoom(Direction::WEST) != nullptr)
{
amountOfConnectedRooms--;
}
for (auto i = 0; i < amountOfConnectedRooms; i++)
{
do
{
roomDirection = possibleRandomDirections_->at(amountOfRoomsDistibution(engine) - 1);
}
while (dungeon->getRoom(x, y, floorIndex)->getRoom(roomDirection) != nullptr);
dungeon->createDirection(x, y, floorIndex, roomDirection);
}
}
}
std::uniform_int_distribution<int> xDistribution { 0, (width - 1) };
std::uniform_int_distribution<int> yDistribution { 0, (height - 1) };
auto finishRoomX = xDistribution(engine);
auto finishRoomY = yDistribution(engine);
if (floorIndex <= 0)
{
dungeon->setStartRoom(dungeon->getRoom(finishRoomX, finishRoomY, floorIndex));
}
if (floorIndex > 0)
{
while (startRoomX == finishRoomX && startRoomY == finishRoomY)
{
finishRoomX = xDistribution(engine);
finishRoomY = yDistribution(engine);
}
dungeon->getRoom(finishRoomX, finishRoomY, floorIndex - 1)->setRoom(Direction::DOWN, dungeon->getRoom(finishRoomX, finishRoomY, floorIndex));
dungeon->getRoom(finishRoomX, finishRoomY, floorIndex)->setRoom(Direction::UP, dungeon->getRoom(finishRoomX, finishRoomY, floorIndex - 1));
}
if (floorIndex < (MAX_DUNGEON_LEVEL - 1))
{
int nPokemon = static_cast<int>((dungeon->getWidth() * dungeon->getHeight()) * POKEMON_PER_ROOM);
Pokemon* pokemon = nullptr;
for (auto counter = 0; counter < nPokemon; ++counter)
{
pokemon = pokemonGenerator_->getRandomPokemon();
if (pokemon != nullptr)
{
pokemon->levelUpTo(floorIndex + 1);
pokemon->setCurrentRoom(dungeon->getRoom(xDistribution(engine), yDistribution(engine), floorIndex));
}
}
auto nItems =static_cast<int>((dungeon->getWidth() * dungeon->getHeight()) * ITEMS_PER_ROOM);
for (auto counter = 0; counter < nItems; ++counter)
{
dungeon->getRoom(xDistribution(engine), yDistribution(engine), floorIndex)->addItem(itemGenerator_->getRandomItem());
}
auto nTraps = static_cast<int>((dungeon->getWidth() * dungeon->getHeight()) * TRAPS_PER_ROOM);
Room* trapRoom;
std::map<Direction, Trap*>* traps = nullptr;
std::map<Direction, Room*> rooms;
std::vector<Direction> directions;
Direction randomDirection;
bool setTrap;
for (auto counter = 0; counter < nTraps; ++counter)
{
setTrap = false;
do
{
trapRoom = dungeon->getRoom(xDistribution(engine), yDistribution(engine), floorIndex);
traps = trapRoom->getTraps();
rooms = trapRoom->getAccessableRooms();
if (traps->size() < rooms.size())
{
directions.clear();
for (auto i : rooms)
{
directions.push_back(i.first);
}
do
{
std::random_shuffle(directions.begin(), directions.end());
randomDirection = directions.at(0);
} while (traps->count(randomDirection) > 0);
trapRoom->setTrap(randomDirection, trapGenerator_->getRandomTrap());
setTrap = true;
}
} while (!setTrap);
}
generateLevel(++floorIndex, dungeon, width, height, engine, finishRoomX, finishRoomY);
}
else
{
auto mewXLoc = xDistribution(engine);
auto mewYLoc = yDistribution(engine);
int mewtwoXLoc;
int mewtwoYLoc;
do
{
mewtwoXLoc = xDistribution(engine);
mewtwoYLoc = yDistribution(engine);
}
while (mewXLoc == mewtwoXLoc && mewYLoc == mewtwoYLoc);
auto boss1 = pokemonGenerator_->getBoss(0);
auto boss2 = pokemonGenerator_->getBoss(1);
boss1->levelUpTo(BOSS_LEVEL);
boss2->levelUpTo(BOSS_LEVEL);
dungeon->getRoom(mewtwoXLoc, mewtwoYLoc, floorIndex)->setBoss(boss1);
boss1->setCurrentRoom(dungeon->getRoom(mewtwoXLoc, mewtwoYLoc, floorIndex));
dungeon->getRoom(mewXLoc, mewYLoc, floorIndex)->setBoss(boss2);
boss2->setCurrentRoom(dungeon->getRoom(mewXLoc, mewYLoc, floorIndex));
}
}
