mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up drlg tests

pull/4671/head
Anders Jenbo 4 years ago
parent
d770407b3b
commit
54cd839cf6
13 changed files with 277 additions and 278 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 13
      Source/diablo.cpp
  2. 1
      Source/diablo.h
  3. 50
      Source/gendung.cpp
  4. 3
      Source/gendung.h
  5. 12
      Source/interfac.cpp
  6. 8
      Source/loadsave.cpp
  7. 21
      Source/multi.cpp
  8. 1
      Source/trigs.cpp
  9. 138
      test/drlg_l1_test.cpp
  10. 65
      test/drlg_l2_test.cpp
  11. 96
      test/drlg_l3_test.cpp
  12. 71
      test/drlg_l4_test.cpp
  13. 76
      test/drlg_test.hpp

13
Source/diablo.cpp
Unescape View File

@ -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;

1
Source/diablo.h
Unescape View File

@ -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;

50
Source/gendung.cpp
Unescape View File

@ -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;

3
Source/gendung.h
Unescape View File

@ -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;

12
Source/interfac.cpp
Unescape View File

@ -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();

8
Source/loadsave.cpp
Unescape View File

@ -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<uint32_t>();
leveltype = static_cast<dungeon_type>(file.NextBE<uint32_t>());
if (!setlevel)
leveltype = gnLevelTypeTbl[currlevel];
leveltype = GetLevelType(currlevel);
int viewX = file.NextBE<int32_t>();
int viewY = file.NextBE<int32_t>();
invflag = file.NextBool8();
@ -2264,9 +2264,11 @@ void SaveGameData()
file.WriteBE<uint32_t>(static_cast<uint32_t>(std::min(Missiles.size(), MaxMissilesForSaveGame)));
file.WriteBE<int32_t>(ActiveObjectCount);
leveltype = GetLevelType(currlevel);
for (uint8_t i = 0; i < giNumberOfLevels; i++) {
file.WriteBE<uint32_t>(glSeedTbl[i]);
file.WriteBE<int32_t>(getHellfireLevelType(gnLevelTypeTbl[i]));
file.WriteBE<int32_t>(getHellfireLevelType(GetLevelType(i)));
}
Player &myPlayer = *MyPlayer;

21
Source/multi.cpp
Unescape View File

@ -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");

1
Source/trigs.cpp
Unescape View File

@ -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;

138
test/drlg_l1_test.cpp
Unescape View File

@ -1,14 +1,10 @@
#include <fmt/format.h>
#include <gtest/gtest.h>
#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<MegaTile[]>(206);
leveltype = DTYPE_CATHEDRAL;
} else if (level >= 21 && level <= 24) {
pMegaTiles = std::make_unique<MegaTile[]>(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<uint16_t>(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<uint8_t>(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<uint8_t>(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));
}

65
test/drlg_l2_test.cpp
Unescape View File

@ -1,81 +1,50 @@
#include <fmt/format.h>
#include <gtest/gtest.h>
#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<MegaTile[]>(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<uint16_t>(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<uint8_t>(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<uint8_t>(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));
}

96
test/drlg_l3_test.cpp
Unescape View File

@ -1,123 +1,93 @@
#include <fmt/format.h>
#include <gtest/gtest.h>
#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<MegaTile[]>(206);
leveltype = DTYPE_CAVES;
} else if (level >= 17 && level <= 20) {
dunPath = fmt::format("test/fixtures/hellfire/{}-{}.dun", level, seed);
pMegaTiles = std::make_unique<MegaTile[]>(166);
leveltype = DTYPE_NEST;
}
currlevel = level;
CreateL3Dungeon(seed, entry);
auto dunData = LoadFileInMem<uint16_t>(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<uint8_t>(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<uint8_t>(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));
}

71
test/drlg_l4_test.cpp
Unescape View File

@ -1,85 +1,52 @@
#include <fmt/format.h>
#include <gtest/gtest.h>
#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<MegaTile[]>(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<uint16_t>(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<uint8_t>(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<uint8_t>(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));
}

76
test/drlg_test.hpp
Unescape View File

@ -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<uint16_t[]> DunData;
void LoadExpectedLevelData(const char *fixture)
{
paths::SetPrefPath(paths::BasePath());
std::string dunPath = "test/fixtures/";
dunPath.append(fixture);
DunData = LoadFileInMem<uint16_t>(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<MegaTile[]>(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<uint8_t>(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<uint8_t>(SDL_SwapLE16(*transparentLayer));
transparentLayer++;
ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y;
}
}
}
Write Preview
Loading…
Cancel
Save