Fix #6659: Correct logging for bottom-of-library card moves (#6764)

* Fix #6659:  Correct logging for bottom-of-library card moves

Cause:
- This issue happens due to logic of moving the card from the top of the
  deck being reused when moving from the bottom of the deck, in a way
  that makes it impossible to check if the card came from the bottom.

Resolution:
- Updated the logging logic in the client for card moves.
- Added a gRPC parameter ('is_from_bottom') for card moves.
- Updates the server logic to reverse the order of the card move if the
'is_from_bottom' parameter is true.
- Added a test to show the expected behaviour of the fix.

NOTE: While the changes in this patch seem big, this is due to changing
the loop in the moveCard function to a helper function, in order to make
the bug fix change. The only change to the loop was to pass a
variable attribution to the moveCard function because it was redundant
to be in the loop.

* chore: run format on test

* refactor: new way to check if a move is from the bottom of the deck

* refactor: change isFromBottom check to static function

* update comments

Co-authored-by: ebbit1q <ebbit1q@gmail.com>

---------

Co-authored-by: ebbit1q <ebbit1q@gmail.com>

tests/CMakeLists.txt

@@ -65,4 +65,5 @@ target_link_libraries(
 add_subdirectory(card_zone_algorithms)
 add_subdirectory(carddatabase)
 add_subdirectory(loading_from_clipboard)
+add_subdirectory(movecard_tests)
 add_subdirectory(oracle)

tests/movecard_tests/CMakeLists.txt

@@ -0,0 +1,16 @@
+add_executable(reverse_card_move_test reverse_card_move_test.cpp)
+
+if(NOT GTEST_FOUND)
+  add_dependencies(reverse_card_move_test gtest)
+endif()
+
+target_link_libraries(
+  reverse_card_move_test
+  PRIVATE libcockatrice_network_server_remote
+  PRIVATE libcockatrice_rng
+  PRIVATE Threads::Threads
+  PRIVATE ${GTEST_BOTH_LIBRARIES}
+  PRIVATE ${TEST_QT_MODULES}
+)
+
+add_test(NAME reverse_card_move_test COMMAND reverse_card_move_test)

tests/movecard_tests/reverse_card_move_test.cpp

@@ -0,0 +1,91 @@
+#include "game/server_abstract_player.h"
+#include "game/server_card.h"
+#include "game/server_cardzone.h"
+#include "game/server_game.h"
+#include "server_response_containers.h"
+#include "server_room.h"
+#include "server_test_helpers.h"
+
+#include <gtest/gtest.h>
+#include <libcockatrice/protocol/pb/command_move_card.pb.h>
+#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
+#include <libcockatrice/rng/rng_abstract.h>
+#include <libcockatrice/utility/zone_names.h>
+
+RNG_Abstract *rng = nullptr; // this needs to be defined due to other functions in server
+
+TEST(ReverseCardMoveTest, MoveCardFromBottomTest)
+{
+    ServerInfo_User user;
+    user.set_name("test-user");
+
+    // instantiate a fake server instance
+    FakeServer server;
+    Server_Room room(0, 0, "", "", "", "", false, "", {}, &server);
+    Server_Game game(user, 1, "", "", 2, QList<int>(), false, false, false, false, false, false, 20, false, &room);
+    Server_AbstractPlayer player(&game, 1, user, false, nullptr);
+    Server_CardZone deckZone(&player, ZoneNames::DECK, true, ServerInfo_Zone::PublicZone);
+    Server_CardZone exileZone(&player, ZoneNames::EXILE, true, ServerInfo_Zone::PublicZone);
+
+    // setup the deck with 20 useless cards
+    for (int i = 0; i < 20; i++) {
+        auto *cardUseless = new Server_Card({"Card Useless", "card-Useless"}, player.newCardId(), i, 0);
+        deckZone.insertCard(cardUseless, i, 0);
+    }
+
+    // add 4 cards to the end of it
+    auto *cardA = new Server_Card({"Card A", "card-a"}, player.newCardId(), 20, 0);
+    auto *cardB = new Server_Card({"Card B", "card-b"}, player.newCardId(), 21, 0);
+    auto *cardC = new Server_Card({"Card C", "card-c"}, player.newCardId(), 22, 0);
+    auto *cardD = new Server_Card({"Card D", "card-d"}, player.newCardId(), 23, 0);
+
+    deckZone.insertCard(cardA, 20, 0);
+    deckZone.insertCard(cardB, 21, 0);
+    deckZone.insertCard(cardC, 22, 0);
+    deckZone.insertCard(cardD, 23, 0);
+
+    // try to move them, with the expected client given order (n-3, n-2, n-1, n)
+    CardToMove moveA;
+    moveA.set_card_id(cardA->getId());
+    CardToMove moveB;
+    moveB.set_card_id(cardB->getId());
+    CardToMove moveC;
+    moveC.set_card_id(cardC->getId());
+    CardToMove moveD;
+    moveD.set_card_id(cardD->getId());
+
+    QList<const CardToMove *> cardsToMove = {&moveA, &moveB, &moveC, &moveD};
+    GameEventStorage ges;
+
+    const auto response = player.moveCard(ges, &deckZone, cardsToMove, &exileZone, 0, 0, false, false, false);
+
+    EXPECT_EQ(response, Response::RespOk);
+
+    int positionA;
+    int positionB;
+    int positionC;
+    int positionD;
+    // find the cards in the destination zone and check they are the right card
+    EXPECT_EQ(exileZone.getCard(cardA->getId(), &positionA), cardA);
+    EXPECT_EQ(exileZone.getCard(cardB->getId(), &positionB), cardB);
+    EXPECT_EQ(exileZone.getCard(cardC->getId(), &positionC), cardC);
+    EXPECT_EQ(exileZone.getCard(cardD->getId(), &positionD), cardD);
+
+    // check that they are at the expected index
+    EXPECT_EQ(cardA->getX(), 3);
+    EXPECT_EQ(cardB->getX(), 2);
+    EXPECT_EQ(cardC->getX(), 1);
+    EXPECT_EQ(cardD->getX(), 0);
+
+    // also check if the given positions are correct
+    EXPECT_EQ(positionA, 3);
+    EXPECT_EQ(positionB, 2);
+    EXPECT_EQ(positionC, 1);
+    EXPECT_EQ(positionD, 0);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

tests/movecard_tests/server_test_helpers.h

@@ -0,0 +1,42 @@
+#include "server.h"
+#include "server_database_interface.h"
+
+class MockDatabaseInterface : public Server_DatabaseInterface
+{
+public:
+    AuthenticationResult checkUserPassword(Server_ProtocolHandler *,
+                                           const QString &,
+                                           const QString &,
+                                           const QString &,
+                                           QString &,
+                                           int &,
+                                           bool) override
+    {
+        return NotLoggedIn;
+    }
+    ServerInfo_User getUserData(const QString &, bool) override
+    {
+        return ServerInfo_User();
+    }
+    int getNextGameId() override
+    {
+        return 1;
+    }
+    int getNextReplayId() override
+    {
+        return 1;
+    }
+    int getActiveUserCount(QString) override
+    {
+        return 1;
+    }
+};
+
+class FakeServer : public Server
+{
+public:
+    FakeServer()
+    {
+        setDatabaseInterface(new MockDatabaseInterface());
+    }
+};