From ffad8f84602544f8831ff4932903f11d4a0711ee Mon Sep 17 00:00:00 2001 From: Asuro Date: Tue, 11 Mar 2025 01:19:13 +0100 Subject: [PATCH] loading works!! --- .gitattributes | 1 + src/dependency/minidef/src/CppGen.cpp | 56 ++++++++++--- src/dependency/minidef/src/CppGen.h | 3 +- src/game/Level.cpp | 55 +++++++++++++ src/game/Puzzle.cpp | 15 +++- src/game/data/puzzles/hell yea.pzl | 3 + src/game/data/puzzles/test.pzl | 3 + src/gen/Def.cpp | 41 ++++++++++ src/gen/Def.h | 49 ++++++------ src/gen/Generated.cpp | 108 ++++++++++++++++++++++++++ src/gen/Generated.h | 10 +++ 11 files changed, 306 insertions(+), 38 deletions(-) create mode 100644 src/game/data/puzzles/hell yea.pzl create mode 100644 src/game/data/puzzles/test.pzl create mode 100644 src/gen/Def.cpp diff --git a/.gitattributes b/.gitattributes index bba2ffe..adcb0a8 100644 --- a/.gitattributes +++ b/.gitattributes @@ -4,3 +4,4 @@ *.png filter=lfs diff=lfs merge=lfs -text *.jpg filter=lfs diff=lfs merge=lfs -text *.blend filter=lfs diff=lfs merge=lfs -text +*.pzl filter=lfs diff=lfs merge=lfs -text diff --git a/src/dependency/minidef/src/CppGen.cpp b/src/dependency/minidef/src/CppGen.cpp index aabb65b..3b57a06 100644 --- a/src/dependency/minidef/src/CppGen.cpp +++ b/src/dependency/minidef/src/CppGen.cpp @@ -88,6 +88,25 @@ namespace Generated return isOk; } )END"; + + constexpr char LoadFuncHeader1[] = + R"END( bool Load(%s* obj, uint32_t count, Deserializer& serializer); +)END"; + constexpr char LoadFuncBodyStart1[] = R"END( bool Load(%s* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { +)END"; + constexpr char LoadFuncBodyType3[] = R"END( isOk = Load(%sobj[i].%s, %u, serializer) && isOk; +)END"; + constexpr char LoadFuncBodyEnum1[] = R"END( auto val = (%s)obj[i]; + isOk = Load(&val, 1, serializer) && isOk; +)END"; + constexpr char LoadFuncBodyEnd[] = R"END( } + return isOk; + } +)END"; } // namespace WriteTemplates void CppFileWriter::InitBuffer(WriteBuffer& buf) @@ -220,24 +239,32 @@ void CppFileWriter::WriteTypes(const Def::DefinitionFile& definitions) Write(WriteTemplates::StructEnd); } } -void CppFileWriter::WriteSaveMethods(const Def::DefinitionFile& definitions) +void CppFileWriter::WriteSaveLoadMethods(const Def::DefinitionFile& definitions) { - char buf[64]{0}; + char nameBuf[64]{0}; + char fieldBuf[64]{0}; for (int32_t enumIdx = 0; enumIdx < definitions.EnumCount; ++enumIdx) { const Def::Enum& e = definitions.Enums[enumIdx]; - bx::snprintf(buf, sizeof(buf), "%s::Enum", e.Name); - Write(WriteTemplates::SaveFuncHeader1, buf); + bx::snprintf(nameBuf, sizeof(nameBuf), "%s::Enum", e.Name); + PrintTypeName(fieldBuf, sizeof(fieldBuf), e.EnumType, definitions); - WriteCpp(WriteTemplates::SaveFuncBodyStart1, buf); - PrintTypeName(buf, sizeof(buf), e.EnumType, definitions); - WriteCpp(WriteTemplates::SaveFuncBodyEnum1, buf); + Write(WriteTemplates::SaveFuncHeader1, nameBuf); + Write(WriteTemplates::LoadFuncHeader1, nameBuf); + + WriteCpp(WriteTemplates::SaveFuncBodyStart1, nameBuf); + WriteCpp(WriteTemplates::SaveFuncBodyEnum1, fieldBuf); WriteCpp(WriteTemplates::SaveFuncBodyEnd); + + WriteCpp(WriteTemplates::LoadFuncBodyStart1, nameBuf); + WriteCpp(WriteTemplates::LoadFuncBodyEnum1, fieldBuf); + WriteCpp(WriteTemplates::LoadFuncBodyEnd); } for (int32_t typeIdx = 0; typeIdx < definitions.TypeCount; ++typeIdx) { const Def::Type& t = definitions.Types[typeIdx]; Write(WriteTemplates::SaveFuncHeader1, t.Name); + Write(WriteTemplates::LoadFuncHeader1, t.Name); WriteCpp(WriteTemplates::SaveFuncBodyStart1, t.Name); for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx) @@ -248,11 +275,18 @@ void CppFileWriter::WriteSaveMethods(const Def::DefinitionFile& definitions) bx::max(1, t.FieldArraySizes[fieldIdx])); } WriteCpp(WriteTemplates::SaveFuncBodyEnd); + + WriteCpp(WriteTemplates::LoadFuncBodyStart1, t.Name); + for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx) + { + WriteCpp(WriteTemplates::LoadFuncBodyType3, + t.FieldArraySizes[fieldIdx] > 0 ? "" : "&", + t.FieldNames[fieldIdx], + bx::max(1, t.FieldArraySizes[fieldIdx])); + } + WriteCpp(WriteTemplates::LoadFuncBodyEnd); } } -void CppFileWriter::WriteLoadMethods(const Def::DefinitionFile& definitions) -{ -} void CppFileWriter::GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions) { LOG(0, "Generating output files..."); @@ -264,7 +298,7 @@ void CppFileWriter::GenerateCpp(const bx::FilePath& outDir, const Def::Definitio WriteCpp(WriteTemplates::FileCppStart); WriteEnums(definitions); WriteTypes(definitions); - WriteSaveMethods(definitions); + WriteSaveLoadMethods(definitions); Write(WriteTemplates::FileEnd); WriteCpp(WriteTemplates::FileEnd); diff --git a/src/dependency/minidef/src/CppGen.h b/src/dependency/minidef/src/CppGen.h index e9572b6..6981df6 100644 --- a/src/dependency/minidef/src/CppGen.h +++ b/src/dependency/minidef/src/CppGen.h @@ -24,8 +24,7 @@ struct CppFileWriter void PrintTypeName(char* buf, int32_t bufSize, const Def::FieldType& type, const Def::DefinitionFile& definitions); void WriteEnums(const Def::DefinitionFile& definitions); void WriteTypes(const Def::DefinitionFile& definitions); - void WriteSaveMethods(const Def::DefinitionFile& definitions); - void WriteLoadMethods(const Def::DefinitionFile& definitions); + void WriteSaveLoadMethods(const Def::DefinitionFile& definitions); void GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions); void Write(const char* templateStr, ...); diff --git a/src/game/Level.cpp b/src/game/Level.cpp index 9d46fcf..27898f0 100644 --- a/src/game/Level.cpp +++ b/src/game/Level.cpp @@ -6,6 +6,10 @@ #include "Puzzle.h" #include "SDL3/SDL_mouse.h" #include "bgfx/bgfx.h" +#include "bx/error.h" +#include "bx/file.h" +#include "bx/filepath.h" +#include "bx/string.h" #include "imgui.h" #include "rendering/Rendering.h" #include @@ -72,6 +76,57 @@ namespace Game Generated::Setup(PuzzleData); + bx::Error err; + bx::DirectoryReader dirIter; + bx::FileInfo info; + bx::FilePath puzzleDirPath{"game/data/puzzles"}; + uint32_t puzIdx = 0; + if (dirIter.open(puzzleDirPath, &err)) + { + while (true) + { + int32_t readCount = dirIter.read(&info, sizeof(info), &err); + if (readCount == 0) break; + if (err.isOk()) + { + if (info.type != bx::FileType::File) continue; + bx::StringView pathEnd = info.filePath.getExt(); + if (bx::strCmpI(pathEnd, ".pzl") != 0) continue; + if (puzIdx >= BX_COUNTOF(Puzzles)) + { + LOG_WARN("Too many puzzles!"); + break; + } + + bx::FilePath fullPath = puzzleDirPath; + fullPath.join(info.filePath); + LOG("Loading %s", fullPath.getCPtr()); + + Generated::Deserializer ser; + ser.Init(fullPath); + if (Generated::Load(&Puzzles[puzIdx].Data, 1, ser)) + { + Puzzles[puzIdx].Setup(); + ++puzIdx; + } + else + { + LOG_WARN("Failed to load puzzle!"); + } + ser.Finish(); + } + else + { + LOG_ERROR("Failed parsing file name at %s:\n%s", puzzleDirPath.getCPtr(), err.getMessage()); + break; + } + } + } + else + { + LOG_ERROR("Failed to open puzzle dir at %s:\n%s", puzzleDirPath.getCPtr(), err.getMessage().getCPtr()); + } + if (Cubes.Count == 0) { for (uint32_t yy = 0; yy < 11; ++yy) diff --git a/src/game/Puzzle.cpp b/src/game/Puzzle.cpp index 6f65a33..8e7c838 100644 --- a/src/game/Puzzle.cpp +++ b/src/game/Puzzle.cpp @@ -38,7 +38,7 @@ namespace Generated } const StaticPuzzleCard& GetCard(const StaticPuzzleData& data, StaticPuzzleCardHandle H) { - // assert(IsValid(H)); + assert(IsValid(H)); return data.Cards[H.Idx]; } @@ -203,7 +203,7 @@ namespace Generated if (dataChanged) { char path[128]{0}; - bx::snprintf(path, sizeof(path), "game/data/%s.pzl", obj.PuzzleName); + bx::snprintf(path, sizeof(path), "game/data/puzzles/%s.pzl", obj.PuzzleName); Serializer ser; ser.Init(path); if (Save(&obj, 1, ser)) @@ -231,4 +231,15 @@ namespace Generated lhs += rhs; return lhs; } + PuzPos operator-=(PuzPos lhs, const PuzPos& rhs) + { + lhs.X -= rhs.X; + lhs.Y -= rhs.Y; + return lhs; + } + PuzPos operator-(PuzPos lhs, const PuzPos& rhs) + { + lhs -= rhs; + return lhs; + } } // namespace Generated diff --git a/src/game/data/puzzles/hell yea.pzl b/src/game/data/puzzles/hell yea.pzl new file mode 100644 index 0000000..09030ea --- /dev/null +++ b/src/game/data/puzzles/hell yea.pzl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fadb13f56deb93ae832808dc82bec034707f017f6cd70b18bb3c8f9d86d5fb00 +size 18110 diff --git a/src/game/data/puzzles/test.pzl b/src/game/data/puzzles/test.pzl new file mode 100644 index 0000000..4e1c001 --- /dev/null +++ b/src/game/data/puzzles/test.pzl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca5a0230894fad40db294317c016d4002833aa72573a20a80584ff661fc633d4 +size 18110 diff --git a/src/gen/Def.cpp b/src/gen/Def.cpp new file mode 100644 index 0000000..6b5411e --- /dev/null +++ b/src/gen/Def.cpp @@ -0,0 +1,41 @@ +#include "Def.h" + +#define INST(T) \ + template bool Save(const T* obj, uint32_t count, Serializer& serializer); \ + template bool Load(T * obj, uint32_t count, Deserializer & serializer); + +namespace Generated +{ + template bool Save(const T* obj, uint32_t count, Serializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk; + } + return isOk; + } + + template bool Load(T* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk; + } + return isOk; + } + + INST(uint8_t) + INST(uint16_t) + INST(uint32_t) + INST(uint64_t) + INST(int8_t) + INST(int16_t) + INST(int32_t) + INST(int64_t) + INST(float) + INST(double) + INST(bool) + INST(char) +} // namespace Generated diff --git a/src/gen/Def.h b/src/gen/Def.h index 986ef05..9503ea7 100644 --- a/src/gen/Def.h +++ b/src/gen/Def.h @@ -2,17 +2,6 @@ #include #include -#define SAVE_T(T) \ - inline bool Save(const T* obj, uint32_t count, Serializer& serializer) \ - { \ - bool isOk = true; \ - for (uint32_t i = 0; i < count; ++i) \ - { \ - isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk; \ - } \ - return isOk; \ - } - namespace Generated { struct Serializer @@ -40,17 +29,31 @@ namespace Generated } }; - SAVE_T(uint8_t) - SAVE_T(uint16_t) - SAVE_T(uint32_t) - SAVE_T(uint64_t) - SAVE_T(int8_t) - SAVE_T(int16_t) - SAVE_T(int32_t) - SAVE_T(int64_t) - SAVE_T(float) - SAVE_T(double) - SAVE_T(bool) - SAVE_T(char) + struct Deserializer + { + bx::Error Err; + bx::FilePath Path; + bx::FileReader Reader; + bool Init(const bx::FilePath& path) + { + Path = path; + Reader.open(path, &Err); + return Err.isOk(); + } + + bool Read(void* data, uint32_t size) + { + Reader.read(data, size, &Err); + return Err.isOk(); + } + + void Finish() + { + Reader.close(); + } + }; + + template bool Save(const T* obj, uint32_t count, Serializer& serializer); + template bool Load(T* obj, uint32_t count, Deserializer& serializer); } // namespace Generated diff --git a/src/gen/Generated.cpp b/src/gen/Generated.cpp index 1085cfd..4d2f880 100644 --- a/src/gen/Generated.cpp +++ b/src/gen/Generated.cpp @@ -12,6 +12,16 @@ namespace Generated } return isOk; } + bool Load(PuzzleElementType::Enum* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + auto val = (int32_t)obj[i]; + isOk = Load(&val, 1, serializer) && isOk; + } + return isOk; + } bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -22,6 +32,16 @@ namespace Generated } return isOk; } + bool Load(PuzPos* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].X, 1, serializer) && isOk; + isOk = Load(&obj[i].Y, 1, serializer) && isOk; + } + return isOk; + } bool Save(const ElemPos* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -32,6 +52,16 @@ namespace Generated } return isOk; } + bool Load(ElemPos* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].Position, 1, serializer) && isOk; + isOk = Load(&obj[i].ElemIdx, 1, serializer) && isOk; + } + return isOk; + } bool Save(const PuzzleNode* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -41,6 +71,15 @@ namespace Generated } return isOk; } + bool Load(PuzzleNode* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(obj[i].PlacedTypes, 4, serializer) && isOk; + } + return isOk; + } bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -51,6 +90,16 @@ namespace Generated } return isOk; } + bool Load(StaticPuzzleCard* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(obj[i].Nodes, 4, serializer) && isOk; + isOk = Load(&obj[i].ModelHandle, 1, serializer) && isOk; + } + return isOk; + } bool Save(const StaticPuzzleCardHandle* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -60,6 +109,15 @@ namespace Generated } return isOk; } + bool Load(StaticPuzzleCardHandle* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].Idx, 1, serializer) && isOk; + } + return isOk; + } bool Save(const StaticPuzzleData* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -69,6 +127,15 @@ namespace Generated } return isOk; } + bool Load(StaticPuzzleData* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(obj[i].Cards, 64, serializer) && isOk; + } + return isOk; + } bool Save(const PuzzleCardStack* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -80,6 +147,17 @@ namespace Generated } return isOk; } + bool Load(PuzzleCardStack* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].RefCard, 1, serializer) && isOk; + isOk = Load(&obj[i].MaxAvailableCount, 1, serializer) && isOk; + isOk = Load(&obj[i].UsedCount, 1, serializer) && isOk; + } + return isOk; + } bool Save(const PlacedPuzzleCard* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -92,6 +170,18 @@ namespace Generated } return isOk; } + bool Load(PlacedPuzzleCard* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].RefCard, 1, serializer) && isOk; + isOk = Load(&obj[i].Position, 1, serializer) && isOk; + isOk = Load(&obj[i].Rotation, 1, serializer) && isOk; + isOk = Load(&obj[i].IsLocked, 1, serializer) && isOk; + } + return isOk; + } bool Save(const PuzzleData* obj, uint32_t count, Serializer& serializer) { bool isOk = true; @@ -110,4 +200,22 @@ namespace Generated } return isOk; } + bool Load(PuzzleData* obj, uint32_t count, Deserializer& serializer) + { + bool isOk = true; + for (uint32_t i = 0; i < count; ++i) + { + isOk = Load(&obj[i].WidthTiles, 1, serializer) && isOk; + isOk = Load(&obj[i].HeightTiles, 1, serializer) && isOk; + isOk = Load(&obj[i].AvailableCardCount, 1, serializer) && isOk; + isOk = Load(obj[i].AvailableCards, 16, serializer) && isOk; + isOk = Load(&obj[i].PlacedCardCount, 1, serializer) && isOk; + isOk = Load(obj[i].PlacedCards, 256, serializer) && isOk; + isOk = Load(obj[i].PlacedNodes, 1024, serializer) && isOk; + isOk = Load(&obj[i].GoalPositionCount, 1, serializer) && isOk; + isOk = Load(obj[i].GoalPositions, 16, serializer) && isOk; + isOk = Load(obj[i].PuzzleName, 64, serializer) && isOk; + } + return isOk; + } } diff --git a/src/gen/Generated.h b/src/gen/Generated.h index 00c818b..b5009eb 100644 --- a/src/gen/Generated.h +++ b/src/gen/Generated.h @@ -94,13 +94,23 @@ namespace Generated char PuzzleName[64] = {}; }; bool Save(const PuzzleElementType::Enum* obj, uint32_t count, Serializer& serializer); + bool Load(PuzzleElementType::Enum* obj, uint32_t count, Deserializer& serializer); bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer); + bool Load(PuzPos* obj, uint32_t count, Deserializer& serializer); bool Save(const ElemPos* obj, uint32_t count, Serializer& serializer); + bool Load(ElemPos* obj, uint32_t count, Deserializer& serializer); bool Save(const PuzzleNode* obj, uint32_t count, Serializer& serializer); + bool Load(PuzzleNode* obj, uint32_t count, Deserializer& serializer); bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer); + bool Load(StaticPuzzleCard* obj, uint32_t count, Deserializer& serializer); bool Save(const StaticPuzzleCardHandle* obj, uint32_t count, Serializer& serializer); + bool Load(StaticPuzzleCardHandle* obj, uint32_t count, Deserializer& serializer); bool Save(const StaticPuzzleData* obj, uint32_t count, Serializer& serializer); + bool Load(StaticPuzzleData* obj, uint32_t count, Deserializer& serializer); bool Save(const PuzzleCardStack* obj, uint32_t count, Serializer& serializer); + bool Load(PuzzleCardStack* obj, uint32_t count, Deserializer& serializer); bool Save(const PlacedPuzzleCard* obj, uint32_t count, Serializer& serializer); + bool Load(PlacedPuzzleCard* obj, uint32_t count, Deserializer& serializer); bool Save(const PuzzleData* obj, uint32_t count, Serializer& serializer); + bool Load(PuzzleData* obj, uint32_t count, Deserializer& serializer); }