From 54cd839cf6c7b4647f3b1906275f9dcae225b7a8 Mon Sep 17 00:00:00 2001 From: Anders Jenbo Date: Sun, 5 Jun 2022 14:55:29 +0200 Subject: [PATCH] Clean up drlg tests --- Source/diablo.cpp | 13 ++-- Source/diablo.h | 1 - Source/gendung.cpp | 50 +++++++++++++++ Source/gendung.h | 3 + Source/interfac.cpp | 12 ++-- Source/loadsave.cpp | 8 ++- Source/multi.cpp | 21 ------- Source/trigs.cpp | 1 - test/drlg_l1_test.cpp | 138 +++++++++++++++++++----------------------- test/drlg_l2_test.cpp | 65 ++++++-------------- test/drlg_l3_test.cpp | 96 ++++++++++------------------- test/drlg_l4_test.cpp | 71 ++++++---------------- test/drlg_test.hpp | 76 +++++++++++++++++++++++ 13 files changed, 277 insertions(+), 278 deletions(-) create mode 100644 test/drlg_test.hpp diff --git a/Source/diablo.cpp b/Source/diablo.cpp index fc368c335..8d4831f83 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -37,6 +37,7 @@ #include "engine/random.hpp" #include "error.h" #include "gamemenu.h" +#include "gendung.h" #include "gmenu.h" #include "help.h" #include "hwcursor.hpp" @@ -90,7 +91,6 @@ namespace devilution { uint32_t glSeedTbl[NUMLEVELS]; -dungeon_type gnLevelTypeTbl[NUMLEVELS]; Point MousePosition; bool gbRunGame; bool gbRunGameResult; @@ -1172,34 +1172,31 @@ void LoadAllGFX() } /** - * @param lvldir method of entry + * @param entry Where is the player entering from */ -void CreateLevel(lvl_entry lvldir) +void CreateLevel(lvl_entry entry) { + CreateDungeon(glSeedTbl[currlevel], entry); + switch (leveltype) { case DTYPE_TOWN: - CreateTown(lvldir); InitTownTriggers(); break; case DTYPE_CATHEDRAL: case DTYPE_CRYPT: - CreateL5Dungeon(glSeedTbl[currlevel], lvldir); InitL1Triggers(); Freeupstairs(); break; case DTYPE_CATACOMBS: - CreateL2Dungeon(glSeedTbl[currlevel], lvldir); InitL2Triggers(); Freeupstairs(); break; case DTYPE_CAVES: case DTYPE_NEST: - CreateL3Dungeon(glSeedTbl[currlevel], lvldir); InitL3Triggers(); Freeupstairs(); break; case DTYPE_HELL: - CreateL4Dungeon(glSeedTbl[currlevel], lvldir); InitL4Triggers(); Freeupstairs(); break; diff --git a/Source/diablo.h b/Source/diablo.h index 3c4ff28ab..49b6d3491 100644 --- a/Source/diablo.h +++ b/Source/diablo.h @@ -59,7 +59,6 @@ enum class MouseActionType : int { }; extern uint32_t glSeedTbl[NUMLEVELS]; -extern dungeon_type gnLevelTypeTbl[NUMLEVELS]; extern Point MousePosition; extern bool gbRunGame; extern bool gbRunGameResult; diff --git a/Source/gendung.cpp b/Source/gendung.cpp index 34ea2ed9b..590b36e46 100644 --- a/Source/gendung.cpp +++ b/Source/gendung.cpp @@ -7,11 +7,16 @@ #include "gendung.h" +#include "drlg_l1.h" +#include "drlg_l2.h" +#include "drlg_l3.h" +#include "drlg_l4.h" #include "engine/load_file.hpp" #include "engine/random.hpp" #include "init.h" #include "lighting.h" #include "options.h" +#include "town.h" namespace devilution { @@ -373,6 +378,51 @@ void FindTransparencyValues(Point floor, uint8_t floorID) } // namespace +dungeon_type GetLevelType(int level) +{ + if (level == 0) + return DTYPE_TOWN; + if (level <= 4) + return DTYPE_CATHEDRAL; + if (level <= 8) + return DTYPE_CATACOMBS; + if (level <= 12) + return DTYPE_CAVES; + if (level <= 16) + return DTYPE_HELL; + if (level <= 20) + return DTYPE_NEST; + if (level <= 24) + return DTYPE_CRYPT; + + return DTYPE_NONE; +} + +void CreateDungeon(uint32_t rseed, lvl_entry entry) +{ + switch (leveltype) { + case DTYPE_TOWN: + CreateTown(entry); + break; + case DTYPE_CATHEDRAL: + case DTYPE_CRYPT: + CreateL5Dungeon(rseed, entry); + break; + case DTYPE_CATACOMBS: + CreateL2Dungeon(rseed, entry); + break; + case DTYPE_CAVES: + case DTYPE_NEST: + CreateL3Dungeon(rseed, entry); + break; + case DTYPE_HELL: + CreateL4Dungeon(rseed, entry); + break; + default: + app_fatal("Invalid level type"); + } +} + void FillSolidBlockTbls() { size_t tileCount; diff --git a/Source/gendung.h b/Source/gendung.h index 2152e795f..1aa76f660 100644 --- a/Source/gendung.h +++ b/Source/gendung.h @@ -233,6 +233,9 @@ extern char dSpecial[MAXDUNX][MAXDUNY]; extern int themeCount; extern THEME_LOC themeLoc[MAXTHEMES]; +dungeon_type GetLevelType(int level); +void CreateDungeon(uint32_t rseed, lvl_entry entry); + constexpr bool InDungeonBounds(Point position) { return position.x >= 0 && position.x < MAXDUNX && position.y >= 0 && position.y < MAXDUNY; diff --git a/Source/interfac.cpp b/Source/interfac.cpp index 8b2316197..809a8bec1 100644 --- a/Source/interfac.cpp +++ b/Source/interfac.cpp @@ -62,7 +62,7 @@ Cutscenes PickCutscene(interface_mode uMsg) if (lvl == 16 && uMsg == WM_DIABNEXTLVL) return CutGate; - switch (gnLevelTypeTbl[lvl]) { + switch (GetLevelType(lvl)) { case DTYPE_TOWN: return CutTown; case DTYPE_CATHEDRAL: @@ -268,7 +268,7 @@ void ShowProgress(interface_mode uMsg) FreeGameMem(); setlevel = false; currlevel = myPlayer.plrlevel; - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); IncProgress(); LoadGameLevel(false, ENTRY_MAIN); IncProgress(); @@ -283,7 +283,7 @@ void ShowProgress(interface_mode uMsg) IncProgress(); FreeGameMem(); currlevel--; - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); assert(myPlayer.plrlevel == currlevel); IncProgress(); LoadGameLevel(false, ENTRY_PREV); @@ -345,7 +345,7 @@ void ShowProgress(interface_mode uMsg) FreeGameMem(); setlevel = false; currlevel = myPlayer.plrlevel; - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); IncProgress(); LoadGameLevel(false, ENTRY_TWARPDN); IncProgress(); @@ -360,7 +360,7 @@ void ShowProgress(interface_mode uMsg) IncProgress(); FreeGameMem(); currlevel = myPlayer.plrlevel; - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); IncProgress(); LoadGameLevel(false, ENTRY_TWARPUP); IncProgress(); @@ -375,7 +375,7 @@ void ShowProgress(interface_mode uMsg) IncProgress(); FreeGameMem(); currlevel = myPlayer.plrlevel; - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); IncProgress(); LoadGameLevel(false, ENTRY_MAIN); IncProgress(); diff --git a/Source/loadsave.cpp b/Source/loadsave.cpp index e7a975d11..993083665 100644 --- a/Source/loadsave.cpp +++ b/Source/loadsave.cpp @@ -893,7 +893,7 @@ void ConvertLevels() if (!LevelFileExists()) continue; - leveltype = gnLevelTypeTbl[i]; + leveltype = GetLevelType(currlevel); LoadLevel(); SaveLevel(); @@ -1979,7 +1979,7 @@ void LoadGame(bool firstflag) currlevel = file.NextBE(); leveltype = static_cast(file.NextBE()); if (!setlevel) - leveltype = gnLevelTypeTbl[currlevel]; + leveltype = GetLevelType(currlevel); int viewX = file.NextBE(); int viewY = file.NextBE(); invflag = file.NextBool8(); @@ -2264,9 +2264,11 @@ void SaveGameData() file.WriteBE(static_cast(std::min(Missiles.size(), MaxMissilesForSaveGame))); file.WriteBE(ActiveObjectCount); + leveltype = GetLevelType(currlevel); + for (uint8_t i = 0; i < giNumberOfLevels; i++) { file.WriteBE(glSeedTbl[i]); - file.WriteBE(getHellfireLevelType(gnLevelTypeTbl[i])); + file.WriteBE(getHellfireLevelType(GetLevelType(i))); } Player &myPlayer = *MyPlayer; diff --git a/Source/multi.cpp b/Source/multi.cpp index d29171436..5d569ed49 100644 --- a/Source/multi.cpp +++ b/Source/multi.cpp @@ -342,26 +342,6 @@ void SendPlayerInfo(int pnum, _cmd_id cmd) dthread_send_delta(pnum, cmd, std::move(pkplr), sizeof(PlayerPack)); } -dungeon_type InitLevelType(int l) -{ - if (l == 0) - return DTYPE_TOWN; - if (l >= 1 && l <= 4) - return DTYPE_CATHEDRAL; - if (l >= 5 && l <= 8) - return DTYPE_CATACOMBS; - if (l >= 9 && l <= 12) - return DTYPE_CAVES; - if (l >= 13 && l <= 16) - return DTYPE_HELL; - if (l >= 17 && l <= 20) - return DTYPE_NEST; - if (l >= 21 && l <= 24) - return DTYPE_CRYPT; - - return DTYPE_CATHEDRAL; -} - void SetupLocalPositions() { currlevel = 0; @@ -785,7 +765,6 @@ bool NetInit(bool bSinglePlayer) for (int i = 0; i < NUMLEVELS; i++) { glSeedTbl[i] = AdvanceRndSeed(); - gnLevelTypeTbl[i] = InitLevelType(i); } if (!SNetGetGameInfo(GAMEINFO_NAME, szPlayerName, 128)) nthread_terminate_game("SNetGetGameInfo1"); diff --git a/Source/trigs.cpp b/Source/trigs.cpp index cc2121c2b..d3cc6da5d 100644 --- a/Source/trigs.cpp +++ b/Source/trigs.cpp @@ -692,7 +692,6 @@ bool ForceL4Trig() void Freeupstairs() { - for (int i = 0; i < numtrigs; i++) { int tx = trigs[i].position.x; int ty = trigs[i].position.y; diff --git a/test/drlg_l1_test.cpp b/test/drlg_l1_test.cpp index 01cfec6f0..69be04f57 100644 --- a/test/drlg_l1_test.cpp +++ b/test/drlg_l1_test.cpp @@ -1,14 +1,10 @@ -#include #include -#include "diablo.h" -#include "drlg_l1.h" -#include "engine/load_file.hpp" +#include "drlg_test.hpp" #include "gendung.h" #include "lighting.h" #include "player.h" #include "quests.h" -#include "utils/paths.h" using namespace devilution; @@ -28,151 +24,143 @@ TEST(Drlg_l1, DRLG_Init_Globals) EXPECT_EQ(dLight[0][0], 0); } -void TestCreateL5Dungeon(bool hellfire, int level, uint32_t seed, lvl_entry entry) -{ - if (level >= 1 && level <= 4) { - MyPlayer->pOriginalCathedral = !hellfire; - pMegaTiles = std::make_unique(206); - leveltype = DTYPE_CATHEDRAL; - } else if (level >= 21 && level <= 24) { - pMegaTiles = std::make_unique(217); - leveltype = DTYPE_CRYPT; - } - - currlevel = level; - CreateL5Dungeon(seed, entry); - - std::string path = paths::BasePath(); - - paths::SetPrefPath(path); - std::string dunPath; - if (hellfire) - dunPath = fmt::format("test/fixtures/hellfire/{}-{}.dun", level, seed); - else - dunPath = fmt::format("test/fixtures/diablo/{}-{}.dun", level, seed); - auto dunData = LoadFileInMem(dunPath.c_str()); - ASSERT_NE(dunData, nullptr) << "Unable to load test fixture " << dunPath; - ASSERT_EQ(Size(DMAXX, DMAXY), Size(dunData[0], dunData[1])); - - const uint16_t *tileLayer = &dunData[2]; - - for (int y = 0; y < DMAXY; y++) { - for (int x = 0; x < DMAXX; x++) { - auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); - tileLayer++; - ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; - } - } - - const uint16_t *transparentLayer = &dunData[2 + DMAXX * DMAXY * 13]; - - for (int y = 16; y < 16 + DMAXY * 2; y++) { - for (int x = 16; x < 16 + DMAXX * 2; x++) { - auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); - transparentLayer++; - ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; - } - } -} - TEST(Drlg_l1, CreateL5Dungeon_diablo_1_743271966) { - TestCreateL5Dungeon(false, 1, 743271966, ENTRY_MAIN); + LoadExpectedLevelData("diablo/1-743271966.dun"); + + MyPlayer->pOriginalCathedral = true; + + TestCreateDungeon(1, 743271966, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(51, 82)); - TestCreateL5Dungeon(false, 1, 743271966, ENTRY_PREV); + TestCreateDungeon(1, 743271966, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(81, 47)); } TEST(Drlg_l1, CreateL5Dungeon_diablo_2_1383137027) { + LoadExpectedLevelData("diablo/2-1383137027.dun"); + + MyPlayer->pOriginalCathedral = true; + Quests[Q_PWATER]._qlevel = 2; Quests[Q_PWATER]._qactive = QUEST_INIT; - TestCreateL5Dungeon(false, 2, 1383137027, ENTRY_MAIN); + TestCreateDungeon(2, 1383137027, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(57, 74)); - TestCreateL5Dungeon(false, 2, 1383137027, ENTRY_PREV); + TestCreateDungeon(2, 1383137027, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(57, 79)); } TEST(Drlg_l1, CreateL5Dungeon_diablo_3_844660068) { - TestCreateL5Dungeon(false, 3, 844660068, ENTRY_MAIN); + LoadExpectedLevelData("diablo/3-844660068.dun"); + + MyPlayer->pOriginalCathedral = true; + + TestCreateDungeon(3, 844660068, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(67, 52)); - TestCreateL5Dungeon(false, 3, 844660068, ENTRY_PREV); + TestCreateDungeon(3, 844660068, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(85, 45)); } TEST(Drlg_l1, CreateL5Dungeon_diablo_4_609325643) { - TestCreateL5Dungeon(false, 4, 609325643, ENTRY_MAIN); + LoadExpectedLevelData("diablo/4-609325643.dun"); + + MyPlayer->pOriginalCathedral = true; + + TestCreateDungeon(4, 609325643, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(85, 78)); - TestCreateL5Dungeon(false, 4, 609325643, ENTRY_PREV); + TestCreateDungeon(4, 609325643, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(55, 47)); } TEST(Drlg_l1, CreateL5Dungeon_hellfire_1_401921334) { - TestCreateL5Dungeon(true, 1, 401921334, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/1-401921334.dun"); + + MyPlayer->pOriginalCathedral = false; + + TestCreateDungeon(1, 401921334, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(79, 80)); - TestCreateL5Dungeon(true, 1, 401921334, ENTRY_PREV); + TestCreateDungeon(1, 401921334, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(49, 63)); } TEST(Drlg_l1, CreateL5Dungeon_hellfire_2_128964898) { + LoadExpectedLevelData("hellfire/2-128964898.dun"); + + MyPlayer->pOriginalCathedral = false; Quests[Q_PWATER]._qactive = QUEST_NOTAVAIL; - TestCreateL5Dungeon(true, 2, 128964898, ENTRY_MAIN); + TestCreateDungeon(2, 128964898, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(55, 68)); - TestCreateL5Dungeon(true, 2, 128964898, ENTRY_PREV); + TestCreateDungeon(2, 128964898, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(49, 63)); } TEST(Drlg_l1, CreateL5Dungeon_hellfire_3_1799396623) { - TestCreateL5Dungeon(true, 3, 1799396623, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/3-1799396623.dun"); + + MyPlayer->pOriginalCathedral = false; + + TestCreateDungeon(3, 1799396623, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(59, 68)); - TestCreateL5Dungeon(true, 3, 1799396623, ENTRY_PREV); + TestCreateDungeon(3, 1799396623, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(47, 55)); } TEST(Drlg_l1, CreateL5Dungeon_hellfire_4_1190318991) { - TestCreateL5Dungeon(true, 4, 1190318991, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/4-1190318991.dun"); + + MyPlayer->pOriginalCathedral = false; + + TestCreateDungeon(4, 1190318991, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(67, 80)); - TestCreateL5Dungeon(true, 4, 1190318991, ENTRY_PREV); + TestCreateDungeon(4, 1190318991, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(77, 45)); } TEST(Drlg_l1, CreateL5Dungeon_crypt_1_2122696790) { - TestCreateL5Dungeon(true, 21, 2122696790, ENTRY_TWARPUP); + LoadExpectedLevelData("hellfire/21-2122696790.dun"); + + TestCreateDungeon(21, 2122696790, ENTRY_TWARPUP); EXPECT_EQ(ViewPosition, Point(61, 80)); - TestCreateL5Dungeon(true, 21, 2122696790, ENTRY_PREV); + TestCreateDungeon(21, 2122696790, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(53, 67)); } TEST(Drlg_l1, CreateL5Dungeon_crypt_2_1191662129) { + LoadExpectedLevelData("hellfire/22-1191662129.dun"); + Quests[Q_PWATER]._qactive = QUEST_NOTAVAIL; - TestCreateL5Dungeon(true, 22, 1191662129, ENTRY_MAIN); + TestCreateDungeon(22, 1191662129, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(71, 47)); - TestCreateL5Dungeon(true, 22, 1191662129, ENTRY_PREV); + TestCreateDungeon(22, 1191662129, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(85, 71)); } TEST(Drlg_l1, CreateL5Dungeon_crypt_3_97055268) { - TestCreateL5Dungeon(true, 23, 97055268, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/23-97055268.dun"); + + TestCreateDungeon(23, 97055268, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(71, 57)); - TestCreateL5Dungeon(true, 23, 97055268, ENTRY_PREV); + TestCreateDungeon(23, 97055268, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(81, 59)); } TEST(Drlg_l1, CreateL5Dungeon_crypt_4_1324803725) { - TestCreateL5Dungeon(true, 24, 1324803725, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/24-1324803725.dun"); + + TestCreateDungeon(24, 1324803725, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(79, 47)); } diff --git a/test/drlg_l2_test.cpp b/test/drlg_l2_test.cpp index dc6b36121..55d8aba87 100644 --- a/test/drlg_l2_test.cpp +++ b/test/drlg_l2_test.cpp @@ -1,81 +1,50 @@ #include #include -#include "drlg_l2.h" -#include "engine/load_file.hpp" +#include "drlg_test.hpp" #include "gendung.h" -#include "utils/paths.h" using namespace devilution; namespace { -void TestCreateL2Dungeon(int level, uint32_t seed, lvl_entry entry) -{ - pMegaTiles = std::make_unique(160); - leveltype = DTYPE_CATACOMBS; - - currlevel = level; - CreateL2Dungeon(seed, entry); - - std::string path = paths::BasePath(); - - paths::SetPrefPath(path); - std::string dunPath = fmt::format("test/fixtures/diablo/{}-{}.dun", level, seed); - auto dunData = LoadFileInMem(dunPath.c_str()); - ASSERT_NE(dunData, nullptr) << "Unable to load test fixture " << dunPath; - ASSERT_EQ(Size(DMAXX, DMAXY), Size(dunData[0], dunData[1])); - - const uint16_t *tileLayer = &dunData[2]; - - for (int y = 0; y < DMAXY; y++) { - for (int x = 0; x < DMAXX; x++) { - auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); - tileLayer++; - ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; - } - } - - const uint16_t *transparentLayer = &dunData[2 + DMAXX * DMAXY * 13]; - - for (int y = 16; y < 16 + DMAXY * 2; y++) { - for (int x = 16; x < 16 + DMAXX * 2; x++) { - auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); - transparentLayer++; - ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; - } - } -} - TEST(Drlg_l2, CreateL2Dungeon_diablo_5_1677631846) { - TestCreateL2Dungeon(5, 1677631846, ENTRY_MAIN); + LoadExpectedLevelData("diablo/5-1677631846.dun"); + + TestCreateDungeon(5, 1677631846, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(27, 28)); - TestCreateL2Dungeon(5, 1677631846, ENTRY_PREV); + TestCreateDungeon(5, 1677631846, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(26, 62)); } TEST(Drlg_l2, CreateL2Dungeon_diablo_6_2034738122) { - TestCreateL2Dungeon(6, 2034738122, ENTRY_MAIN); + LoadExpectedLevelData("diablo/6-2034738122.dun"); + + TestCreateDungeon(6, 2034738122, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(33, 26)); - TestCreateL2Dungeon(6, 2034738122, ENTRY_PREV); + TestCreateDungeon(6, 2034738122, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(34, 52)); } TEST(Drlg_l2, CreateL2Dungeon_diablo_7_680552750) { - TestCreateL2Dungeon(7, 680552750, ENTRY_MAIN); + LoadExpectedLevelData("diablo/7-680552750.dun"); + + TestCreateDungeon(7, 680552750, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(27, 26)); - TestCreateL2Dungeon(7, 680552750, ENTRY_PREV); + TestCreateDungeon(7, 680552750, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(78, 52)); } TEST(Drlg_l2, CreateL2Dungeon_diablo_8_1999936419) { - TestCreateL2Dungeon(8, 1999936419, ENTRY_MAIN); + LoadExpectedLevelData("diablo/8-1999936419.dun"); + + TestCreateDungeon(8, 1999936419, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(39, 74)); - TestCreateL2Dungeon(8, 1999936419, ENTRY_PREV); + TestCreateDungeon(8, 1999936419, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(48, 46)); } diff --git a/test/drlg_l3_test.cpp b/test/drlg_l3_test.cpp index 16ff59ac3..f924e8754 100644 --- a/test/drlg_l3_test.cpp +++ b/test/drlg_l3_test.cpp @@ -1,123 +1,93 @@ #include #include -#include "drlg_l3.h" -#include "engine/load_file.hpp" +#include "drlg_test.hpp" #include "gendung.h" #include "quests.h" -#include "utils/paths.h" using namespace devilution; namespace { -void TestCreateL3Dungeon(int level, uint32_t seed, lvl_entry entry) -{ - paths::SetPrefPath(paths::BasePath()); - - std::string dunPath; - - if (level >= 9 && level <= 12) { - dunPath = fmt::format("test/fixtures/diablo/{}-{}.dun", level, seed); - pMegaTiles = std::make_unique(206); - leveltype = DTYPE_CAVES; - } else if (level >= 17 && level <= 20) { - dunPath = fmt::format("test/fixtures/hellfire/{}-{}.dun", level, seed); - pMegaTiles = std::make_unique(166); - leveltype = DTYPE_NEST; - } - - currlevel = level; - CreateL3Dungeon(seed, entry); - - auto dunData = LoadFileInMem(dunPath.c_str()); - ASSERT_NE(dunData, nullptr) << "Unable to load test fixture " << dunPath; - ASSERT_EQ(Size(DMAXX, DMAXY), Size(dunData[0], dunData[1])); - - const uint16_t *tileLayer = &dunData[2]; - - for (int y = 0; y < DMAXY; y++) { - for (int x = 0; x < DMAXX; x++) { - auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); - tileLayer++; - ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; - } - } - - const uint16_t *transparentLayer = &dunData[2 + DMAXX * DMAXY * 13]; - - for (int y = 16; y < 16 + DMAXY * 2; y++) { - for (int x = 16; x < 16 + DMAXX * 2; x++) { - auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); - transparentLayer++; - ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; - } - } -} - TEST(Drlg_l3, CreateL3Dungeon_diablo_9_262005438) { - TestCreateL3Dungeon(9, 262005438, ENTRY_MAIN); + LoadExpectedLevelData("diablo/9-262005438.dun"); + + TestCreateDungeon(9, 262005438, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(41, 73)); - TestCreateL3Dungeon(9, 262005438, ENTRY_PREV); + TestCreateDungeon(9, 262005438, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(73, 59)); } TEST(Drlg_l3, CreateL3Dungeon_diablo_10_1630062353) { + LoadExpectedLevelData("diablo/10-1630062353.dun"); + Quests[Q_ANVIL]._qactive = QUEST_NOTAVAIL; - TestCreateL3Dungeon(10, 1630062353, ENTRY_MAIN); + TestCreateDungeon(10, 1630062353, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(55, 37)); - TestCreateL3Dungeon(10, 1630062353, ENTRY_PREV); + TestCreateDungeon(10, 1630062353, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(19, 47)); } TEST(Drlg_l3, CreateL3Dungeon_diablo_11_384626536) { - TestCreateL3Dungeon(11, 384626536, ENTRY_MAIN); + LoadExpectedLevelData("diablo/11-384626536.dun"); + + TestCreateDungeon(11, 384626536, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(29, 19)); - TestCreateL3Dungeon(11, 384626536, ENTRY_PREV); + TestCreateDungeon(11, 384626536, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(65, 65)); } TEST(Drlg_l3, CreateL3Dungeon_diablo_12_2104541047) { - TestCreateL3Dungeon(12, 2104541047, ENTRY_MAIN); + LoadExpectedLevelData("diablo/12-2104541047.dun"); + + TestCreateDungeon(12, 2104541047, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(35, 23)); - TestCreateL3Dungeon(12, 2104541047, ENTRY_PREV); + TestCreateDungeon(12, 2104541047, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(21, 83)); } TEST(Drlg_l3, CreateL3Dungeon_hive_1_19770182) { - TestCreateL3Dungeon(17, 19770182, ENTRY_TWARPUP); + LoadExpectedLevelData("hellfire/17-19770182.dun"); + + TestCreateDungeon(17, 19770182, ENTRY_TWARPUP); EXPECT_EQ(ViewPosition, Point(75, 81)); - TestCreateL3Dungeon(17, 19770182, ENTRY_PREV); + TestCreateDungeon(17, 19770182, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(59, 41)); } TEST(Drlg_l3, CreateL3Dungeon_hive_2_1522546307) { - TestCreateL3Dungeon(18, 1522546307, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/18-1522546307.dun"); + + TestCreateDungeon(18, 1522546307, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(47, 19)); - TestCreateL3Dungeon(18, 1522546307, ENTRY_PREV); + TestCreateDungeon(18, 1522546307, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(33, 35)); } TEST(Drlg_l3, CreateL3Dungeon_hive_3_125121312) { - TestCreateL3Dungeon(19, 125121312, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/19-125121312.dun"); + + TestCreateDungeon(19, 125121312, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(61, 25)); - TestCreateL3Dungeon(19, 125121312, ENTRY_PREV); + TestCreateDungeon(19, 125121312, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(21, 85)); } TEST(Drlg_l3, CreateL3Dungeon_hive_4_1511478689) { - TestCreateL3Dungeon(20, 1511478689, ENTRY_MAIN); + LoadExpectedLevelData("hellfire/20-1511478689.dun"); + + TestCreateDungeon(20, 1511478689, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(65, 41)); - TestCreateL3Dungeon(20, 1511478689, ENTRY_PREV); + TestCreateDungeon(20, 1511478689, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(65, 41)); } diff --git a/test/drlg_l4_test.cpp b/test/drlg_l4_test.cpp index 5abee77cc..2c4a26b0b 100644 --- a/test/drlg_l4_test.cpp +++ b/test/drlg_l4_test.cpp @@ -1,85 +1,52 @@ #include #include -#include "drlg_l4.h" -#include "engine/load_file.hpp" +#include "drlg_test.hpp" #include "gendung.h" #include "quests.h" -#include "utils/paths.h" using namespace devilution; namespace { -void TestCreateL4Dungeon(bool changed, int level, uint32_t seed, lvl_entry entry) -{ - pMegaTiles = std::make_unique(137); - leveltype = DTYPE_HELL; - - currlevel = level; - CreateL4Dungeon(seed, entry); - - std::string path = paths::BasePath(); - - paths::SetPrefPath(path); - std::string dunPath; - if (changed) - dunPath = fmt::format("test/fixtures/diablo/{}-{}-changed.dun", level, seed); - else - dunPath = fmt::format("test/fixtures/diablo/{}-{}.dun", level, seed); - auto dunData = LoadFileInMem(dunPath.c_str()); - ASSERT_NE(dunData, nullptr) << "Unable to load test fixture " << dunPath; - ASSERT_EQ(Size(DMAXX, DMAXY), Size(dunData[0], dunData[1])); - - const uint16_t *tileLayer = &dunData[2]; - - for (int y = 0; y < DMAXY; y++) { - for (int x = 0; x < DMAXX; x++) { - auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); - tileLayer++; - ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; - } - } - - const uint16_t *transparentLayer = &dunData[2 + DMAXX * DMAXY * 13]; - - for (int y = 16; y < 16 + DMAXY * 2; y++) { - for (int x = 16; x < 16 + DMAXX * 2; x++) { - auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); - transparentLayer++; - ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; - } - } -} - TEST(Drlg_l4, CreateL4Dungeon_diablo_13_428074402) { - TestCreateL4Dungeon(false, 13, 428074402, ENTRY_MAIN); + LoadExpectedLevelData("diablo/13-428074402.dun"); + + TestCreateDungeon(13, 428074402, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(26, 64)); - TestCreateL4Dungeon(false, 13, 428074402, ENTRY_PREV); + TestCreateDungeon(13, 428074402, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(47, 79)); } TEST(Drlg_l4, CreateL4Dungeon_diablo_14_717625719) { - TestCreateL4Dungeon(false, 14, 717625719, ENTRY_MAIN); + LoadExpectedLevelData("diablo/14-717625719.dun"); + + TestCreateDungeon(14, 717625719, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(90, 64)); - TestCreateL4Dungeon(false, 14, 717625719, ENTRY_PREV); + TestCreateDungeon(14, 717625719, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(49, 31)); } TEST(Drlg_l4, CreateL4Dungeon_diablo_15_1583642716) { + LoadExpectedLevelData("diablo/15-1583642716.dun"); + Quests[Q_DIABLO]._qactive = QUEST_INIT; - TestCreateL4Dungeon(false, 15, 1583642716, ENTRY_MAIN); + + TestCreateDungeon(15, 1583642716, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(44, 26)); - TestCreateL4Dungeon(false, 15, 1583642716, ENTRY_PREV); + TestCreateDungeon(15, 1583642716, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(87, 69)); + LoadExpectedLevelData("diablo/15-1583642716-changed.dun"); + Quests[Q_DIABLO]._qactive = QUEST_ACTIVE; - TestCreateL4Dungeon(true, 15, 1583642716, ENTRY_MAIN); + + TestCreateDungeon(15, 1583642716, ENTRY_MAIN); EXPECT_EQ(ViewPosition, Point(44, 26)); - TestCreateL4Dungeon(true, 15, 1583642716, ENTRY_PREV); + TestCreateDungeon(15, 1583642716, ENTRY_PREV); EXPECT_EQ(ViewPosition, Point(87, 69)); } diff --git a/test/drlg_test.hpp b/test/drlg_test.hpp new file mode 100644 index 000000000..85199b7d8 --- /dev/null +++ b/test/drlg_test.hpp @@ -0,0 +1,76 @@ +/** + * @file drlg_test.hpp + * + * Helpers for dungeon related tests. + */ +#pragma once + +#include "engine/load_file.hpp" +#include "utils/paths.h" + +using namespace devilution; + +int GetTileCount(dungeon_type levelType) +{ + switch (levelType) { + case DTYPE_TOWN: + return 376; + case DTYPE_CATHEDRAL: + return 206; + case DTYPE_CATACOMBS: + return 160; + case DTYPE_CAVES: + return 206; + case DTYPE_HELL: + return 137; + case DTYPE_NEST: + return 166; + case DTYPE_CRYPT: + return 217; + default: + app_fatal("Invalid level type"); + } +} + +std::unique_ptr DunData; + +void LoadExpectedLevelData(const char *fixture) +{ + paths::SetPrefPath(paths::BasePath()); + + std::string dunPath = "test/fixtures/"; + dunPath.append(fixture); + DunData = LoadFileInMem(dunPath.c_str()); + ASSERT_NE(DunData, nullptr) << "Unable to load test fixture " << dunPath; + ASSERT_EQ(Size(DMAXX, DMAXY), Size(DunData[0], DunData[1])); +} + +void TestCreateDungeon(int level, uint32_t seed, lvl_entry entry) +{ + currlevel = level; + leveltype = GetLevelType(level); + + pMegaTiles = std::make_unique(GetTileCount(leveltype)); + + CreateDungeon(seed, entry); + + const uint16_t *tileLayer = &DunData[2]; + + for (int y = 0; y < DMAXY; y++) { + for (int x = 0; x < DMAXX; x++) { + auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); + tileLayer++; + ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; + } + } + + const uint16_t *transparentLayer = &DunData[2 + DMAXX * DMAXY * 13]; + + for (int y = 16; y < 16 + DMAXY * 2; y++) { + for (int x = 16; x < 16 + DMAXX * 2; x++) { + auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); + transparentLayer++; + ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; + } + } +}