/** * @brief Testet das Ausführen einer Bauoperation, die nicht komplett ausgeführt werden kann, weil das * Baumaterial nicht reicht. * * Baue 5 Rumbrennereien, wobei die Resourcen nur für 3 reichen */ TEST_F(BuildOperationTest, partialBuildOutOfResources) { const MapObjectType* distillery = configMgr->getMapObjectType("distillery"); // Testaufbau player->coins = 2000; colony->getGoods(configMgr->getGood("tools")).inventory = 11; colony->getGoods(configMgr->getGood("wood")).inventory = 20; colony->getGoods(configMgr->getGood("bricks")).inventory = 30; BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay({39, 34}, distillery, Direction::SOUTH); buildOperation.requestBuildWhenNothingInTheWay({39, 37}, distillery, Direction::SOUTH); buildOperation.requestBuildWhenNothingInTheWay({39, 39}, distillery, Direction::SOUTH); buildOperation.requestBuildWhenNothingInTheWay({37, 37}, distillery, Direction::SOUTH); buildOperation.requestBuildWhenNothingInTheWay({37, 39}, distillery, Direction::SOUTH); buildOperation.doBuild(); // Testauswertung: Resourcen korrekt abgezogen ASSERT_EQ(1400, player->coins); ASSERT_EQ(2, colony->getGoods(configMgr->getGood("tools")).inventory); ASSERT_EQ(14, colony->getGoods(configMgr->getGood("wood")).inventory); ASSERT_EQ(15, colony->getGoods(configMgr->getGood("bricks")).inventory); // Testauswertung: Gebäude in die Map übernommen assertCorrectBuild({39, 34}, distillery, Direction::SOUTH, 2, 2); assertCorrectBuild({39, 37}, distillery, Direction::SOUTH, 2, 2); assertCorrectBuild({39, 39}, distillery, Direction::SOUTH, 2, 2); ASSERT_TRUE(game->getMap()->getMapObjectFixedAt({37, 37}) == nullptr); ASSERT_TRUE(game->getMap()->getMapObjectFixedAt({37, 39}) == nullptr); }
/** * @brief Spezialtest "halbe Kreuzung" * * Wir bauen einen Feldweg von (46, 31) nach (46, 33). * Allerdings reicht das Geld nur für eine Kachel. * * Wir erwarten, dass beim Bau nur ein T-Stück entsteht, obwohl eine Kreuzung gezogen wurde. */ TEST_F(BuildOperationTest, partialCrossroads) { const Map* map = game->getMap(); const MapObjectType* farmRoad = configMgr->getMapObjectType("farm-road"); // Testaufbau player->coins = 5; BuildOperation buildOperation(context, *player); for (int y = 31; y <= 33; y++) { buildOperation.requestBuildWhenNothingInTheWay(MapCoords(46, y), farmRoad, Direction::SOUTH); } buildOperation.doBuild(); // Testauswertung ASSERT_EQ(0, player->coins); assertCorrectBuild({46, 31}, farmRoad, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_SOUTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({46, 31}))->streetConnections); assertCorrectBuild({46, 32}, farmRoad, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH | StreetConnections::BIT_MASK_EAST | StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({46, 32}))->streetConnections); ASSERT_TRUE(map->getMapObjectFixedAt({46, 33}) == nullptr); }
/** * @brief Testet das Ausführen einer einfachen Bauoperation. */ TEST_F(BuildOperationTest, regularBuild) { const MapObjectType* marketplace = configMgr->getMapObjectType("marketplace"); // Testaufbau player->coins = 5000; colony->getGoods(configMgr->getGood("tools")).inventory = 20; colony->getGoods(configMgr->getGood("wood")).inventory = 40; colony->getGoods(configMgr->getGood("bricks")).inventory = 30; BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay(MapCoords(45, 33), marketplace, Direction::SOUTH); buildOperation.requestBuildWhenNothingInTheWay(MapCoords(37, 33), marketplace, Direction::NORTH); buildOperation.requestBuildWhenNothingInTheWay(MapCoords(38, 37), marketplace, Direction::WEST); buildOperation.doBuild(); // Testauswertung: Resourcen korrekt abgezogen ASSERT_EQ(4400, player->coins); ASSERT_EQ(8, colony->getGoods(configMgr->getGood("tools")).inventory); ASSERT_EQ(10, colony->getGoods(configMgr->getGood("wood")).inventory); ASSERT_EQ(30, colony->getGoods(configMgr->getGood("bricks")).inventory); // Testauswertung: Gebäude in die Map übernommen assertCorrectBuild({45, 33}, marketplace, Direction::SOUTH, 4, 3); assertCorrectBuild({37, 33}, marketplace, Direction::NORTH, 4, 3); assertCorrectBuild({38, 37}, marketplace, Direction::WEST, 3, 4); }
/** * @brief Testet das Ausführen einer Bauoperation, die Straßen überbaut bzw. anpasst * * Ziehe Straßenzug von (46, 31) nach (46, 36). * 4 Kacheln kommen neu dazu, 2 werden überbaut (wovon nur eine was kostet). */ TEST_F(BuildOperationTest, overbuildAndAdeptStreet) { const Map* map = game->getMap(); const MapObjectType* farmRoad = configMgr->getMapObjectType("farm-road"); const MapObjectType* cobbledStreet = configMgr->getMapObjectType("cobbled-street"); // Testaufbau player->coins = 1000; colony->getGoods(configMgr->getGood("tools")).inventory = 10; colony->getGoods(configMgr->getGood("wood")).inventory = 20; colony->getGoods(configMgr->getGood("bricks")).inventory = 25; BuildOperation buildOperation(context, *player); for (int y = 31; y <= 36; y++) { buildOperation.requestBuildWhenNothingInTheWay(MapCoords(46, y), cobbledStreet, Direction::SOUTH); } unsigned long mapObjectsCountBefore = game->getMap()->getMapObjects().size(); buildOperation.doBuild(); unsigned long mapObjectsCountAfter = game->getMap()->getMapObjects().size(); // Testauswertung: Sicherstellen, dass die Anzahl der Map-Objekte stimmt. // Nicht, dass es zwei Map-Objekte auf derselben Koordinate gibt ASSERT_EQ(mapObjectsCountBefore + 4, mapObjectsCountAfter); // Testauswertung: Resourcen korrekt abgezogen (nur 5 der 6 Kacheln kosten was) ASSERT_EQ(975, player->coins); ASSERT_EQ(10, colony->getGoods(configMgr->getGood("tools")).inventory); ASSERT_EQ(20, colony->getGoods(configMgr->getGood("wood")).inventory); ASSERT_EQ(20, colony->getGoods(configMgr->getGood("bricks")).inventory); // Testauswertung: Straßen in die Map übernommen bzw. angepasst assertCorrectBuild({46, 31}, cobbledStreet, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_SOUTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({46, 31}))->streetConnections); assertCorrectBuild({46, 32}, cobbledStreet, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH | StreetConnections::BIT_MASK_EAST | StreetConnections::BIT_MASK_SOUTH | StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({46, 32}))->streetConnections); for (int y = 33; y <= 35; y++) { assertCorrectBuild({ 46, y }, cobbledStreet, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH | StreetConnections::BIT_MASK_SOUTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({ 46, y }))->streetConnections); } assertCorrectBuild({46, 36}, cobbledStreet, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH | StreetConnections::BIT_MASK_EAST | StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({46, 36}))->streetConnections); assertCorrectBuild({45, 32}, farmRoad, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_EAST | StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({45, 32}))->streetConnections); assertCorrectBuild({47, 32}, farmRoad, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({47, 32}))->streetConnections); }
/** * @brief Überprüft, ob korrekt erkannt wird, wenn was im Weg is */ TEST_F(BuildOperationTest, somethingInTheWay) { const MapObjectType* tavern = configMgr->getMapObjectType("tavern"); { // Wirtshaus normal einsetzen: genug Platz BuildOperation buildOperation(context, *player); buildOperation.requestBuild(MapCoords(45, 33), tavern, Direction::SOUTH); const BuildOperationResult& result = buildOperation.getResult(); ASSERT_EQ(BuildOperationResult::OK, result.result); ASSERT_EQ(6, result.size()); ASSERT_EQ(true, result.at(MapCoords(46, 35))->buildAllowed); } { // Wirtshaus gedreht einsetzen: genug Platz BuildOperation buildOperation(context, *player); buildOperation.requestBuild(MapCoords(45, 33), tavern, Direction::WEST); const BuildOperationResult& result = buildOperation.getResult(); ASSERT_EQ(BuildOperationResult::OK, result.result); ASSERT_EQ(6, result.size()); ASSERT_EQ(true, result.at(MapCoords(47, 34))->buildAllowed); } { // Wirtshaus normal einsetzen: ein Feldweg im Weg BuildOperation buildOperation(context, *player); buildOperation.requestBuild(MapCoords(39, 34), tavern, Direction::NORTH); const BuildOperationResult& result = buildOperation.getResult(); ASSERT_EQ(BuildOperationResult::NOT_OK, result.result); ASSERT_EQ(6, result.size()); ASSERT_EQ(false, result.at(MapCoords(40, 35))->buildAllowed); } { // Wirtshaus gedreht einsetzen: ein Feldweg im Weg BuildOperation buildOperation(context, *player); buildOperation.requestBuild(MapCoords(38, 36), tavern, Direction::EAST); const BuildOperationResult& result = buildOperation.getResult(); ASSERT_EQ(BuildOperationResult::NOT_OK, result.result); ASSERT_EQ(6, result.size()); ASSERT_EQ(false, result.at(MapCoords(40, 37))->buildAllowed); } }
/** * @brief Überprüft, ob die Baukosten korrekt berücksichtigt werden */ TEST_F(BuildOperationTest, buildingCosts) { const MapObjectType* toolsmiths = configMgr->getMapObjectType("toolsmiths"); Colony* colony = game->getColony({ 43, 34 }); { player->coins = 500; colony->getGoods(configMgr->getGood("tools")).inventory = 6; colony->getGoods(configMgr->getGood("wood")).inventory = 30; colony->getGoods(configMgr->getGood("bricks")).inventory = 20; BuildOperation buildOperation(context, *player); const MapCoords mc1 = { 45, 34 }; const MapCoords mc2 = { 47, 34 }; const MapCoords mc3 = { 39, 37 }; // Erste Werkzeugschmiede setzen: Alle Rohstoffe reichen buildOperation.requestBuildWhenNothingInTheWay(mc1, toolsmiths, Direction::SOUTH); ASSERT_EQ(true, buildOperation.getResult().at(mc1)->resourcesEnoughToBuildThis); // Zweite Werkzeugschmiede hinzufügen: Rohstoffe reichen immer noch. Werkzeuge reichen exakt buildOperation.requestBuildWhenNothingInTheWay(mc2, toolsmiths, Direction::SOUTH); ASSERT_EQ(true, buildOperation.getResult().at(mc1)->resourcesEnoughToBuildThis); ASSERT_EQ(true, buildOperation.getResult().at(mc2)->resourcesEnoughToBuildThis); // Dritte Werkzeugschmiede hinzufügen: Werkzeuge reichen nicht mehr buildOperation.requestBuildWhenNothingInTheWay(mc3, toolsmiths, Direction::SOUTH); ASSERT_EQ(true, buildOperation.getResult().at(mc1)->resourcesEnoughToBuildThis); ASSERT_EQ(true, buildOperation.getResult().at(mc2)->resourcesEnoughToBuildThis); ASSERT_EQ(false, buildOperation.getResult().at(mc3)->resourcesEnoughToBuildThis); } { // Geld reicht nicht player->coins = 100; colony->getGoods(configMgr->getGood("tools")).inventory = 3; colony->getGoods(configMgr->getGood("wood")).inventory = 2; colony->getGoods(configMgr->getGood("bricks")).inventory = 5; BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay({38, 40}, toolsmiths, Direction::SOUTH); ASSERT_EQ(false, buildOperation.getResult().at({38, 40})->resourcesEnoughToBuildThis); } }
/** * @brief Fügt einen Abreißauftrag der Queue hinzu und prüft, ob alle betroffenen Kacheln als "zu entfernen" * markiert werden */ TEST_F(BuildOperationTest, demolishMapObject) { BuildOperation buildOperation(context, *player); buildOperation.requestDemolish(*context.game->getMap()->getMapObjectFixedAt({48, 40})); BuildOperationResult result = buildOperation.getResult(); ASSERT_EQ(BuildOperationResult::OK, result.result); ASSERT_EQ(4, result.size()); ASSERT_EQ(true, result.at(MapCoords(48, 40))->deleteMapObjectThere); ASSERT_EQ(true, result.at(MapCoords(49, 40))->deleteMapObjectThere); ASSERT_EQ(true, result.at(MapCoords(48, 41))->deleteMapObjectThere); ASSERT_EQ(true, result.at(MapCoords(49, 41))->deleteMapObjectThere); }
/** * @brief Überprüft, dass wir auch mit einer leeren Buildqueue zurechtkommen. */ TEST_F(BuildOperationTest, emptyBuildQueue) { const MapObjectType* pioneersHouse1 = configMgr->getMapObjectType("pioneers-house1"); BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay({47, 39}, pioneersHouse1, Direction::NORTH); // da is belegt buildOperation.updateBuildMaterials(); // rebuildResult() triggern ASSERT_TRUE(buildOperation.getMapObjectsToBuild().empty()); ASSERT_TRUE(buildOperation.getResult().empty()); ASSERT_EQ(BuildOperationResult::OK, buildOperation.getResult().result); }
listItem* buildOperationList(){ unsigned int i_lineNumber = 1; void *currentOperation; listItem *currListOperation = (listItem*) malloc(sizeof(listItem)); listItem *startOfList = currListOperation; char s[1024]; memset(currListOperation, 0, sizeof(listItem)); memset(s, 0, 1024); while(fgets(s, 1024, g_fdDataFile) != NULL) { char *s_operation, *s_argument; int i = 0; char *last, *tok[6]; unsigned int i_fileDescriptor = 0; s[ strlen(s) - 1 ] = '\0'; tok[0] = strtok(s, ","); while (tok[++i] = strtok(NULL, ",")); s_operation = tok[0]; i_fileDescriptor = atoi( tok[1] ); s_argument = tok[2]; currentOperation = buildOperation(s_operation, i_fileDescriptor, s_argument, i_lineNumber); if (currentOperation != NULL) { listItem *t = (listItem*) malloc(sizeof(listItem)); (*t).item = NULL; (*t).next = NULL; (*currListOperation).item = currentOperation; (*currListOperation).next = t; (*t).prev = currListOperation; currListOperation = t; } else { printf("[WARNING] Unrecognized operation line %d [%s]\n", i_lineNumber, (s == NULL ? "null" : s) ); } i_lineNumber ++; memset(s, 0, 1024); } fclose(g_fdDataFile); return startOfList; }
/** * @brief Überprüft, ob Überlappungen beim Hinzufügen von Bauaufträgen korrekt erkannt werden. */ TEST_F(BuildOperationTest, overlappingRequestBuild) { const MapObjectType* marketplace = configMgr->getMapObjectType("marketplace"); { // Ersten Marktplatz setzen BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay(MapCoords(45, 33), marketplace, Direction::SOUTH); ASSERT_EQ(12, buildOperation.getResult().size()); // Weiteren Marktplatz überlappen -> es darf sich nix tun buildOperation.requestBuildWhenNothingInTheWay(MapCoords(48, 32), marketplace, Direction::WEST); ASSERT_EQ(12, buildOperation.getResult().size()); // Weiteren Marktplatz überlappen über Bauqueue und bestehendes Objekt -> es darf sich auch nix tun buildOperation.requestBuildWhenNothingInTheWay(MapCoords(43, 31), marketplace, Direction::WEST); ASSERT_EQ(12, buildOperation.getResult().size()); // Weiteren Marktplatz korrekt hinzufügen buildOperation.requestBuildWhenNothingInTheWay(MapCoords(49, 33), marketplace, Direction::EAST); ASSERT_EQ(24, buildOperation.getResult().size()); } { const MapCoords mapCoords(47, 39); // Mit requestBuildWhenNothingInTheWay darf ich auf der Karte nicht überlappen BuildOperation buildOperation(context, *player); buildOperation.requestBuildWhenNothingInTheWay(mapCoords, marketplace, Direction::SOUTH); ASSERT_EQ(0, buildOperation.getResult().size()); // Mit requestBuild schon buildOperation.requestBuild(mapCoords, marketplace, Direction::SOUTH); ASSERT_EQ(12, buildOperation.getResult().size()); } }
/** * @brief Test, der Straßenanpassung testet, wenn die Resourcen nicht mehr reichen. * Beim Bau dürfen nur Ersetzungen vorgenommen werden, die angrenzen an Straßen, wofür die Resourcen reichen. * * Wir bauen einen Feldweg von (43, 44) nach (47, 44). * Allerdings reicht das Geld nur für zwei Kacheln. */ TEST_F(BuildOperationTest, adeptStreetsOutOfResources) { const Map* map = game->getMap(); const MapObjectType* farmRoad = configMgr->getMapObjectType("farm-road"); const MapObjectType* cobbledStreet = configMgr->getMapObjectType("cobbled-street"); // Testaufbau player->coins = 10; BuildOperation buildOperation(context, *player); for (int x = 43; x <= 47; x++) { buildOperation.requestBuildWhenNothingInTheWay(MapCoords(x, 44), farmRoad, Direction::SOUTH); } buildOperation.doBuild(); // Testauswertung // Resourcen korrekt nur für 2 Kacheln abgezogen ASSERT_EQ(0, player->coins); // Bau korrekt assertCorrectBuild({43, 44}, farmRoad, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_EAST | StreetConnections::BIT_MASK_SOUTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({43, 44}))->streetConnections); assertCorrectBuild({44, 44}, farmRoad, Direction::SOUTH, 1, 1); for (int x = 45; x <= 47; x++) { ASSERT_TRUE(game->getMap()->getMapObjectFixedAt({x, 44}) == nullptr); } // partielle Anpassung an (44, 44): nur West! Für die Ost-Verbindung reichen die Resourcen nicht ASSERT_EQ(StreetConnections::BIT_MASK_WEST, dynamic_cast<const Street*>(map->getMapObjectFixedAt({44, 44}))->streetConnections); // Anpassung an (43, 45) assertCorrectBuild({43, 45}, cobbledStreet, Direction::SOUTH, 1, 1); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({43, 45}))->streetConnections); // Keine Anpassungen an (45, 45), (47, 45), (47, 43), da die Resourcen nicht reichen ASSERT_EQ(0, dynamic_cast<const Street*>(map->getMapObjectFixedAt({45, 45}))->streetConnections); ASSERT_EQ(0, dynamic_cast<const Street*>(map->getMapObjectFixedAt({47, 45}))->streetConnections); ASSERT_EQ(StreetConnections::BIT_MASK_NORTH, dynamic_cast<const Street*>(map->getMapObjectFixedAt({47, 43}))->streetConnections); }
/** * @brief Überprüft, dass beim Bau von Häusern sich bereits bestehende Häuser nicht ändern, wenn wir * ein weiteres hinzufügen. */ TEST_F(BuildOperationTest, addingOneMoreHouse) { // Testaufbau const MapObjectType* pioneersHouse1 = configMgr->getMapObjectType("pioneers-house1"); const std::forward_list<MapCoords> mapCoordsToBuildThere = { {38, 32}, {38, 34}, {38, 36}, {38, 38}, {38, 40}, {38, 42}, {36, 33}, {36, 35}, {36, 37}, {36, 39}, {45, 33}, {47, 34}, {49, 33}, {51, 35}, {51, 37}, {52, 39}, {54, 39} }; Colony* colony = game->getColony({ 43, 34 }); colony->getGoods(configMgr->getGood("wood")).inventory = 65; // Testdurchführung: Baue viele Häuser, baue danach ein weiteres. Es dürfen sich bestehende nicht ändern. BuildOperation buildOperation(context, *player); for (const MapCoords& mapCoords : mapCoordsToBuildThere) { buildOperation.requestBuildWhenNothingInTheWay(mapCoords, pioneersHouse1, Direction::SOUTH); }; BuildOperationResult resultBefore = buildOperation.getResult(); const MapCoords mapCoordsToBuildAfter = {43, 29}; buildOperation.requestBuildWhenNothingInTheWay(mapCoordsToBuildAfter, pioneersHouse1, Direction::SOUTH); BuildOperationResult resultAfter = buildOperation.getResult(); // Testauswertung ASSERT_EQ(68, resultBefore.size()); ASSERT_EQ(72, resultAfter.size()); for (const MapCoords& mapCoords : mapCoordsToBuildThere) { const MapObjectType* mapObjectTypeBefore = resultBefore.at(mapCoords)->mapObjectToReplaceWith->getMapObjectType(); const MapObjectType* mapObjectTypeAfter = resultAfter.at(mapCoords)->mapObjectToReplaceWith->getMapObjectType(); ASSERT_EQ(mapObjectTypeBefore, mapObjectTypeAfter) << "mapCoords = " << ::testing::PrintToString(mapCoords); } ASSERT_TRUE(resultAfter.at(mapCoordsToBuildAfter)->mapObjectToReplaceWith != nullptr); }
/** * @brief Überprüft, ob man die Objekte in der richtigen Reihenfolge wieder aus der Liste kriegt */ TEST_F(BuildOperationTest, orderOfInsertion) { const MapObjectType* pioneersHouse1 = configMgr->getMapObjectType("pioneers-house1"); BuildOperation buildOperation(context, *player); buildOperation.requestBuild({36, 37}, pioneersHouse1, Direction::EAST); buildOperation.requestBuild({39, 40}, pioneersHouse1, Direction::EAST); buildOperation.requestBuild({36, 39}, pioneersHouse1, Direction::EAST); buildOperation.requestBuild({39, 34}, pioneersHouse1, Direction::EAST); const std::list<MapObjectToBuild>& mapObjectsToBuild = buildOperation.getMapObjectsToBuild(); auto iter = mapObjectsToBuild.cbegin(); ASSERT_EQ(MapCoords(36, 37), iter->mapCoords); iter++; ASSERT_EQ(MapCoords(39, 40), iter->mapCoords); iter++; ASSERT_EQ(MapCoords(36, 39), iter->mapCoords); iter++; ASSERT_EQ(MapCoords(39, 34), iter->mapCoords); iter++; ASSERT_TRUE(iter == mapObjectsToBuild.cend()); }
/** * @brief Überprüft, dass Häuser beim Enqueue in die BuildOperation zufällig gewählt werden. * Wir bauen 2x dasselbe und wollen ein anderes Ergebnis haben. */ TEST_F(BuildOperationTest, randomizeWhenBuildingHouses) { // Testaufbau const unsigned char HOUSE_TYPES_COUNT = 5; const MapObjectType* pioneersHouses[HOUSE_TYPES_COUNT] = { configMgr->getMapObjectType("pioneers-house1"), configMgr->getMapObjectType("pioneers-house2"), configMgr->getMapObjectType("pioneers-house3"), configMgr->getMapObjectType("pioneers-house4"), configMgr->getMapObjectType("pioneers-house5") }; const std::forward_list<MapCoords> mapCoordsToBuildThere = { {38, 32}, {38, 34}, {38, 36}, {38, 38}, {38, 40}, {38, 42}, {36, 33}, {36, 35}, {36, 37}, {36, 39}, {45, 33}, {47, 34}, {49, 33}, {51, 35}, {51, 37}, {52, 39}, {54, 39} }; Colony* colony = game->getColony({ 43, 34 }); colony->getGoods(configMgr->getGood("wood")).inventory = 60; // Testdurchführung: Baue zweimal dasselbe und vergleiche das Ergebnis auto doOneBuild = [&]() { BuildOperation buildOperation(context, *player); for (const MapCoords& mapCoords : mapCoordsToBuildThere) { buildOperation.requestBuildWhenNothingInTheWay(mapCoords, pioneersHouses[0], Direction::SOUTH); } return buildOperation.getResult(); }; BuildOperationResult result1 = doOneBuild(); BuildOperationResult result2 = doOneBuild(); // Testauswertung ASSERT_EQ(68, result1.size()); // Beide Ergebnis müssen 17 Häuser haben ASSERT_EQ(68, result2.size()); unsigned int differences = 0; unsigned int pioneersHouse1CountInResult1 = 0; unsigned int pioneersHouse1CountInResult2 = 0; for (const MapCoords& mapCoords : mapCoordsToBuildThere) { const MapObjectType* mapObjectType1 = result1.at(mapCoords)->mapObjectToReplaceWith->getMapObjectType(); const MapObjectType* mapObjectType2 = result2.at(mapCoords)->mapObjectToReplaceWith->getMapObjectType(); if (mapObjectType1 != mapObjectType2) { differences++; } if (mapObjectType1 == pioneersHouses[0]) { pioneersHouse1CountInResult1++; } if (mapObjectType2 == pioneersHouses[0]) { pioneersHouse1CountInResult2++; } } ASSERT_NE(pioneersHouse1CountInResult1, 17); // Die Häuser dürfen nicht alle pioneersHouse1 sein ASSERT_NE(pioneersHouse1CountInResult2, 17); ASSERT_GT(differences, 0); // Die Häuser dürfen nicht alle identisch sein }