[golf_grpc] implement PeekAtDrawPile operation (#529)

* peek rpc

* joingame rpc and client call (needs tests)

* client unit tests

* add some tests

Author: aaylward

.clwb/.bazelproject

@@ -1,20 +1 @@
-directories:
-  cpp
-  protos
-  rust
-
-# Automatically includes all relevant targets under the 'directories' above
-derive_targets_from_directories: true
-
-targets:
-  # If source code isn't resolving, add additional targets that compile it here
-
-additional_languages:
-  # Uncomment any additional languages you want supported
-  # dart
-  # javascript
-  # python
-  # typescript
-
-build_flags:
-  --enable_workspace
+import intellij/clion.bazelproject

.gitignore

@@ -1,6 +1,7 @@
 target
 *.iml
 .ijwb
+.clwb
 bazel-*
 .DS_Store
 out

MODULE.bazel.lock

@@ -58,3 +58,24 @@ cc_test(
         "@googletest//:gtest_main",
     ],
 )
+
+cc_library(
+    name = "dealer",
+    srcs = ["dealer.cc"],
+    hdrs = ["dealer.h"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":cards",
+        "//protos/cards:cards_cc_proto",
+    ],
+)
+
+cc_test(
+    name = "dealer_test",
+    size = "small",
+    srcs = ["dealer_test.cc"],
+    deps = [
+        ":dealer",
+        "@googletest//:gtest_main",
+    ],
+)

cpp/cards/BUILD.bazel

@@ -14,10 +14,11 @@ class Card {
   Card(const Suit _suit, const Rank _rank) : suit(_suit), rank(_rank) {}
 
   explicit Card(const int shuffleIndex)
-      : suit(static_cast<Suit>(shuffleIndex % 4)), rank(static_cast<Rank>(shuffleIndex % 13)) {}
+      : suit(static_cast<Suit>(shuffleIndex % 4)), rank(static_cast<Rank>(shuffleIndex / 4)) {}
 
   [[nodiscard]] const Suit& getSuit() const { return suit; }
   [[nodiscard]] const Rank& getRank() const { return rank; }
+  [[nodiscard]] int intValue() const { return static_cast<int>(rank) * 4 + static_cast<int>(suit); }
   bool operator==(const Card& o) const { return suit == o.suit && rank == o.rank; }
 
  private:

cpp/cards/card.h

@@ -15,5 +15,5 @@ TEST(CardMapper, CardToString) {
 TEST(CardMapper, CardsToString) {
   CardMapper cm;
   std::vector<Card> cards{Card{0}, Card{1}};
-  EXPECT_EQ(cm.cardsToString(cards), R"(["2_C","3_D"])");
+  EXPECT_EQ(cm.cardsToString(cards), R"(["2_C","2_D"])");
 }

cpp/cards/card_mapper_test.cc

@@ -3,7 +3,11 @@
 #include <gtest/gtest.h>
 
 TEST(CARD_TEST, BasicAssertions) {
-  cards::Card c(0);
-  EXPECT_EQ(cards::Suit::Clubs, c.getSuit());
-  EXPECT_EQ(cards::Rank::Two, c.getRank());
+  cards::Card c_0(0);
+  EXPECT_EQ(cards::Suit::Clubs, c_0.getSuit());
+  EXPECT_EQ(cards::Rank::Two, c_0.getRank());
+
+  cards::Card c_1(1);
+  EXPECT_EQ(cards::Suit::Diamonds, c_1.getSuit());
+  EXPECT_EQ(cards::Rank::Two, c_1.getRank());
 }

cpp/cards/card_test.cc

@@ -0,0 +1,34 @@
+#include "dealer.h"
+
+#include <deque>
+#include <random>
+#include <vector>
+
+using std::deque;
+using std::vector;
+
+namespace cards {
+deque<Card> Dealer::DealNewUnshuffledDeck() {
+  deque<Card> deck{};
+  for (int i = 0; i < 52; i++) {
+    deck.emplace_back(i);
+  }
+  return deck;
+}
+
+void Dealer::ShuffleDeck(deque<Card>& deck) {
+  vector<int> cards{};
+  while (!deck.empty()) {
+    cards.emplace_back(deck.front().intValue());
+    deck.pop_front();
+  }
+  std::ranges::shuffle(cards, generator_);
+
+  for (auto& card : cards) {
+    deck.emplace_back(card);
+  }
+}
+
+void NoShuffleDealer::ShuffleDeck(deque<Card>& deck) {}
+
+}  // namespace cards

cpp/cards/dealer.cc

@@ -0,0 +1,30 @@
+#ifndef CPP_CARDS_DEALER_H
+#define CPP_CARDS_DEALER_H
+
+#include <deque>
+#include <random>
+
+#include "cpp/cards/card.h"
+#include "protos/cards/cards.pb.h"
+
+namespace cards {
+
+class Dealer {
+ public:
+  virtual ~Dealer() = default;
+  std::deque<Card> DealNewUnshuffledDeck();
+  virtual void ShuffleDeck(std::deque<Card>& deck);
+
+ private:
+  std::random_device rd_;
+  std::mt19937 generator_{rd_()};
+};
+
+class NoShuffleDealer : public Dealer {
+ public:
+  void ShuffleDeck(std::deque<Card>& deck) override;
+};
+
+}  // namespace cards
+
+#endif

cpp/cards/dealer.h

@@ -0,0 +1,26 @@
+#include "cpp/cards/dealer.h"
+
+#include <gtest/gtest.h>
+
+using namespace cards;
+
+TEST(Dealer, DealNewUnshuffledDeck) {
+  Dealer dealer;
+  auto unshuffled = dealer.DealNewUnshuffledDeck();
+
+  EXPECT_EQ(unshuffled.front().getSuit(), cards::Suit::Clubs);
+  EXPECT_EQ(unshuffled.front().getRank(), cards::Rank::Two);
+
+  EXPECT_EQ(unshuffled.back().getSuit(), cards::Suit::Spades);
+  EXPECT_EQ(unshuffled.back().getRank(), cards::Rank::Ace);
+}
+
+TEST(Dealer, ShuffledDeck) {
+  Dealer dealer;
+  auto deck = dealer.DealNewUnshuffledDeck();
+  dealer.ShuffleDeck(deck);
+
+  auto unshuffled = dealer.DealNewUnshuffledDeck();
+
+  EXPECT_NE(deck, unshuffled);
+}

cpp/cards/dealer_test.cc

@@ -15,6 +15,7 @@ cc_library(
         ":game_store",
         ":player",
         "//cpp/cards",
+        "//cpp/cards:dealer",
         "@com_google_absl//absl/status:statusor",
     ],
 )

cpp/cards/golf/BUILD.bazel

@@ -1,7 +1,5 @@
 #include "cpp/cards/golf/game_manager.h"
 
-#include <algorithm>
-#include <random>
 #include <unordered_set>
 #include <vector>
 
@@ -50,20 +48,8 @@ StatusOr<string> GameManager::registerUser(const string& user_id) {
 }
 
 deque<Card> GameManager::shuffleNewDeck() {
-  vector<int> cards{};
-  cards.reserve(52);
-  for (int i = 0; i < 52; i++) {
-    cards.push_back(i);
-  }
-
-  std::random_device rd;
-  std::mt19937 g(rd());
-  std::shuffle(cards.begin(), cards.end(), g);
-
-  deque<Card> deck{};
-  for (auto c : cards) {
-    deck.emplace_back(c);
-  }
+  auto deck = dealer_->DealNewUnshuffledDeck();
+  dealer_->ShuffleDeck(deck);
   return deck;
 }