wip

src/game/Level.cpp

@@ -180,6 +180,13 @@ namespace Game
             Cubes.Get(PlayerOutsideViewCube).Setup();
         }
 
+        {
+            Deserializer d;
+            d.Init("game/data/static/uiconfig.dat", "UICO");
+            d.ReadT(GetInstance().Player.Config);
+            d.Finish();
+        }
+
         UIQuads.Count = 0;
         PuzzleTiles.Count = 0;
         PuzzleTileCovers.Count = 0;
@@ -190,16 +197,10 @@ namespace Game
                 Puzzles[i].Setup();
             }
         }
+
         PuzzleUI.Setup();
         TabletHandle = UIQuads.New();
         UpdatePlayerInputMode();
-
-        {
-            Deserializer d;
-            d.Init("game/data/static/uiconfig.dat", "UICO");
-            d.ReadT(GetInstance().Player.Config);
-            d.Finish();
-        }
     }
 
     void Level::Update()

src/game/Puzzle.cpp

@@ -377,6 +377,45 @@ namespace Puzzle
         return true;
     }
 
+    void RecalculateInitialAvailable(PuzzleData& obj)
+    {
+        for (int32_t i = 0; i < obj.AvailableCardCount; ++i)
+        {
+            obj.AvailableCards[i].UsedCount = obj.AvailableCards[i].MaxAvailableCount;
+        }
+
+        for (int32_t y = 0; y < obj.HeightTiles; ++y)
+        {
+            for (int32_t x = 0; x < obj.WidthTiles; ++x)
+            {
+                auto& placedCard = obj.PlacedCards[y * Puzzle::Config::MaxPuzzleSizeCards + x];
+                if (Puzzle::IsValid(placedCard.RefCard))
+                {
+                    bool found = false;
+                    for (int32_t i = 0; i < obj.AvailableCardCount; ++i)
+                    {
+                        if (obj.AvailableCards[i].RefCard.Idx == placedCard.RefCard.Idx)
+                        {
+                            found = true;
+                            obj.AvailableCards[i].MaxAvailableCount++;
+                        }
+                    }
+                    if (!found)
+                    {
+                        if (obj.AvailableCardCount == Puzzle::Config::MaxAvailableStacks)
+                        {
+                            LOG_ERROR("Read limit of available card stacks!");
+                            break;
+                        }
+                        obj.AvailableCards[obj.AvailableCardCount] = {};
+                        obj.AvailableCards[obj.AvailableCardCount].RefCard = placedCard.RefCard;
+                        obj.AvailableCards[obj.AvailableCardCount].MaxAvailableCount = 1;
+                    }
+                }
+            }
+        }
+    }
+
     bool RenderDebugUI(PuzzleData& obj)
     {
         bool isVisible = true;
@@ -485,6 +524,7 @@ namespace Puzzle
                             {
                                 placedCard.Flags =
                                     (PlacedPuzzleCardFlags::Enum)(placedCard.Flags ^ PlacedPuzzleCardFlags::Locked);
+                                RecalculateInitialAvailable(obj);
                             }
                         }
                         if (!isLocked && IsValid(placedCard.RefCard))
@@ -506,6 +546,7 @@ namespace Puzzle
                                 placedCard.Position = cardPos;
                                 placedCard.Flags = (PlacedPuzzleCardFlags::Enum)SetFlags(placedCard.Flags,
                                                                                          PlacedPuzzleCardFlags::Locked);
+                                RecalculateInitialAvailable(obj);
                             }
                             ImGui::EndDragDropTarget();
                         }

src/game/UI.cpp

@@ -112,36 +112,39 @@ namespace Game
         Vec3 quadPlaneIntersectPos;
         Vec3 mousePosWorld = GetMousePosWorld();
 
-        for (int32_t i = 0; i < Puzzle::Config::MaxAvailableStacks; ++i)
+        for (int32_t stackIdx = 0; stackIdx < Puzzle::Config::MaxAvailableStacks; ++stackIdx)
         {
-            auto& card = Data.AvailableCards[i];
-            for (int32_t j = 0; j < UIAvailableCardMaxStackPreview; j++)
+            auto& card = Data.AvailableCards[stackIdx];
+            for (int32_t cardIdx = 0; cardIdx < UIAvailableCardMaxStackPreview; cardIdx++)
             {
-                auto h = UIAvailableCards[i * UIAvailableCardMaxStackPreview + j];
+                auto h = UIAvailableCards[stackIdx * UIAvailableCardMaxStackPreview + cardIdx];
                 auto& quad = level.UIQuads.Get(h);
                 int32_t remaining = (int32_t)card.MaxAvailableCount - (int32_t)card.UsedCount;
-                if (i < Data.AvailableCardCount && j < remaining)
+                if (stackIdx < Data.AvailableCardCount && cardIdx < remaining)
                 {
-                    quad.UIPos = Vec3{j * 0.05f + i * 1.2f, 4.2f + (j % 2 == 0 ? 0.02f : 0.0f), j * 0.001f} *
+                    quad.UIPos = Vec3{cardIdx * 0.05f + stackIdx * 1.2f,
+                                      4.2f + (cardIdx % 2 == 0 ? 0.02f : 0.0f),
+                                      cardIdx * 0.001f} *
                                  UICardOffset * UICardScale;
                     UpdateQuad(level.UIQuads, h);
                     quad.EData.Visible = true;
-                    quad.EData.TextureHandle = Puzzle::IsValid(Data.AvailableCards[i].RefCard)
-                                                   ? staticCards[Data.AvailableCards[i].RefCard.Idx].BoardTextureHandle
-                                                   : Gen::TextureHandle{};
+                    quad.EData.TextureHandle = Puzzle::IsValid(card.RefCard)
+                                                   ? staticCards[card.RefCard.Idx].BoardTextureHandle
+                                                   : Gen::TextureHandle{0};
+                    quad.EData.TextureHandle = {4};
                     quad.EData.Transform.Scale = {UICardScale, UICardScale, UICardScale};
                     quad.EData.DotColor = {1.0f, 1.0f, 1.0f, 1.0f};
                     quad.EData.BaseColor = {1.0f, 1.0f, 1.0f, 1.0f};
 
-                    if (j == 0)
+                    if (cardIdx == 0)
                     {
                         if (IsQuadHovered(quad.EData.Transform, mousePosWorld, quadPlaneIntersectPos) &&
                             DraggedAvailableCardIdx == UINT16_MAX && DraggedCard.X == -1 &&
                             GetMouseButtonPressedNow(MouseButton::Left))
                         {
-                            DraggedAvailableCardIdx = i;
+                            DraggedAvailableCardIdx = stackIdx;
                         }
-                        if (DraggedAvailableCardIdx == i)
+                        if (DraggedAvailableCardIdx == stackIdx)
                         {
                             Vec3 dragPos = quadPlaneIntersectPos;
                             dragPos += StaticData.ZAxis * -0.01f;
@@ -180,6 +183,7 @@ namespace Game
 
     Vec3 CalcBoardOffset(const Gen::PuzzleData& puzData)
     {
+        return {};
         return Vec3{
                    (float)(puzData.WidthTiles) / (2.0f * Puzzle::Config::CardSize),
                    (float)(puzData.HeightTiles) / (2.0f * Puzzle::Config::CardSize),
@@ -244,6 +248,15 @@ namespace Game
                     Vec3 boardTilePos = boardPos / UICardOffset;
                     int32_t xPos = (int32_t)bx::round(boardTilePos.x);
                     int32_t yPos = (int32_t)bx::round(boardTilePos.y);
+                    LOG("boardPos: %f %f %f, offset: %f %f %f, xy: %i %i",
+                        boardPos.x,
+                        boardPos.y,
+                        boardPos.z,
+                        boardOffset.x,
+                        boardOffset.y,
+                        boardOffset.z,
+                        xPos,
+                        yPos);
                     Gen::PuzPos srcCardPos = {(int8_t)DraggedCard.X, (int8_t)DraggedCard.Y};
                     Gen::PlacedPuzzleCard& srcCard =
                         Data.PlacedCards[srcCardPos.Y * Puzzle::Config::MaxPuzzleSizeCards + srcCardPos.X];