This is the firstpass (untested) implementation of Hearts in Croupier.
The UI has not been updated to correspond to this new information either.
diff --git a/Makefile b/Makefile
index b56dd51..c905372 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,25 @@
-lint:
- dartanalyzer lib/main.dart
+# Get the packages used by the dart project, according to pubspec.yaml
+# I don't know why but pub get reverts me... Or perhaps Sublime does?
+get-packages:
+ pub upgrade
-start:
+TEST_FILES := $(shell find test -name *.dart ! -name *.part.dart)
+
+check-fmt:
+ dartfmt -n lib/main.dart $(TEST_FILES)
+
+lint: get-packages
+ dartanalyzer lib/main.dart
+ dartanalyzer $(TEST_FILES)
+
+start: get-packages
./packages/sky/sky_tool start
-install:
+install: get-packages
./packages/sky/sky_tool start --install
+
+test: get-packages
+ pub run test
+
+clean:
+ rm -rf packages
diff --git a/lib/components/card_collection.dart b/lib/components/card_collection.dart
index a7d4ba8..27d0bcc 100644
--- a/lib/components/card_collection.dart
+++ b/lib/components/card_collection.dart
@@ -19,7 +19,7 @@
CardCollectionComponent(this.cards, this.faceUp, this.orientation, this.parentCallback);
- void syncFields(CardCollectionComponent other) {
+ void syncConstructorArguments(CardCollectionComponent other) {
//assert(false); // Why do we need to do this?
//status = other.status;
cards = other.cards;
diff --git a/lib/components/croupier.dart b/lib/components/croupier.dart
index 38909a8..e33e015 100644
--- a/lib/components/croupier.dart
+++ b/lib/components/croupier.dart
@@ -10,7 +10,7 @@
CroupierComponent(this.croupier) : super();
- void syncFields(CroupierComponent other) {
+ void syncConstructorArguments(CroupierComponent other) {
croupier = other.croupier;
}
diff --git a/lib/components/draggable.dart b/lib/components/draggable.dart
index 21be29b..4415645 100644
--- a/lib/components/draggable.dart
+++ b/lib/components/draggable.dart
@@ -9,7 +9,7 @@
Draggable(this.child);
- void syncFields(Draggable other) {
+ void syncConstructorArguments(Draggable other) {
child = other.child;
}
diff --git a/lib/components/game.dart b/lib/components/game.dart
index ab5eea5..1f384b2 100644
--- a/lib/components/game.dart
+++ b/lib/components/game.dart
@@ -17,7 +17,7 @@
setState(() {});
}
- void syncFields(GameComponent other) {
+ void syncConstructorArguments(GameComponent other) {
this.game = other.game;
}
diff --git a/lib/logic/game.dart b/lib/logic/game.dart
index df02af9..1a450f2 100644
--- a/lib/logic/game.dart
+++ b/lib/logic/game.dart
@@ -58,9 +58,19 @@
return -1;
}
+ void resetCards() {
+ for (int i = 0; i < cardCollections.length; i++) {
+ cardCollections[i].clear();
+ }
+ deck.addAll(Card.All);
+ }
+
// UNIMPLEMENTED: Let subclasses override this?
// Or is it improper to do so?
void move(Card card, List<Card> dest) {}
+
+ // UNIMPLEMENTED: Override this to implement game-specific logic after each event.
+ void triggerEvents() {}
}
class ProtoGame extends Game {
@@ -80,7 +90,7 @@
}
void deal(int playerId, int numCards) {
- gamelog.add(new HeartsCommand.deal(playerId, this.deckPeek(numCards)));
+ gamelog.add(new ProtoCommand.deal(playerId, this.deckPeek(numCards)));
}
// Overrides Game's move method with the "move" logic for the card dragging prototype.
@@ -95,50 +105,407 @@
}
int destId = cardCollections.indexOf(dest);
- gamelog.add(new HeartsCommand.pass(i, destId, <Card>[card]));
+ gamelog.add(new ProtoCommand.pass(i, destId, <Card>[card]));
debugString = 'Move ${i} ${card.toString()}';
print(debugString);
}
}
+enum HeartsPhase {
+ Deal, Pass, Take, Play, Score
+}
+
class HeartsGame extends Game {
- HeartsGame(int playerNumber) : super._create(GameType.Hearts, playerNumber, 6) {
- // playerNumber would be used in a real game, but I have to ignore it for debugging.
- // It would determine faceUp/faceDown status.faceDown
+ static const PLAYER_A = 0;
+ static const PLAYER_B = 1;
+ static const PLAYER_C = 2;
+ static const PLAYER_D = 3;
+ static const PLAYER_A_PLAY = 4;
+ static const PLAYER_B_PLAY = 5;
+ static const PLAYER_C_PLAY = 6;
+ static const PLAYER_D_PLAY = 7;
+ static const PLAYER_A_TRICK = 8;
+ static const PLAYER_B_TRICK = 9;
+ static const PLAYER_C_TRICK = 10;
+ static const PLAYER_D_TRICK = 11;
+ static const PLAYER_A_PASS = 12;
+ static const PLAYER_B_PASS = 13;
+ static const PLAYER_C_PASS = 14;
+ static const PLAYER_D_PASS = 15;
- // TODO: Set the number of piles created to either 9 (1x per player, 1 discard, 4 play piles) or 12 (2x per player, 4 play piles)
- // But for now, we will deal with 6. 1x per player, 1 discard, and 1 undrawn pile.
+ static const OFFSET_HAND = 0;
+ static const OFFSET_PLAY = 4;
+ static const OFFSET_TRICK = 8;
+ static const OFFSET_PASS = 12;
- // We do some arbitrary things here... Just for setup.
+ // Note: These cards are final because the "classic" deck has 52 cards.
+ // It is up to the renderer to reskin those cards as needed.
+ final Card TWO_OF_CLUBS = new Card("classic", "c2");
+ final Card QUEEN_OF_SPADES = new Card("classic", "sq");
+
+ HeartsPhase phase;
+ int roundNumber;
+ int lastTrickTaker;
+ bool heartsBroken;
+
+ // Used by the score screen to track scores and see which players are ready to continue to the next round.
+ List<int> scores = [0, 0, 0, 0];
+ List<bool> ready;
+
+ HeartsGame(int playerNumber) : super._create(GameType.Hearts, playerNumber, 16) {
+ prepareRound();
+ }
+
+ void prepareRound() {
+ if (roundNumber == null) {
+ roundNumber = 0;
+ } else {
+ roundNumber++;
+ }
+
+ phase = HeartsPhase.Deal;
+
+ this.resetCards();
+ heartsBroken = false;
+ lastTrickTaker = null;
deck.shuffle();
- deal(0, 8);
- deal(1, 5);
- deal(2, 4);
- deal(3, 1);
+ deal(PLAYER_A, 13);
+ deal(PLAYER_B, 13);
+ deal(PLAYER_C, 13);
+ deal(PLAYER_D, 13);
+
+ if (this.passTarget != null) {
+ phase = HeartsPhase.Pass;
+ } else {
+ phase = HeartsPhase.Play;
+ }
+ }
+
+ int get trickNumber {
+ return 13 - cardCollections[0].length;
+ }
+
+ int get passTarget {
+ switch (roundNumber % 4) { // is a 4-cycle
+ case 0:
+ return (playerNumber - 1) % 4; // passLeft
+ case 1:
+ return (playerNumber + 1) % 4; // passRight
+ case 2:
+ return (playerNumber + 2) % 4; // passAcross
+ case 3:
+ return null; // no player to pass to
+ default:
+ assert(false);
+ return null;
+ }
+ }
+ int get takeTarget {
+ switch (roundNumber % 4) { // is a 4-cycle
+ case 0:
+ return (playerNumber + 1) % 4; // takeRight
+ case 1:
+ return (playerNumber - 1) % 4; // takeLeft
+ case 2:
+ return (playerNumber + 2) % 4; // taleAcross
+ case 3:
+ return null; // no player to pass to
+ default:
+ assert(false);
+ return null;
+ }
+ }
+
+ // Please only call this in the Play phase. Otherwise, it's pretty useless.
+ int get whoseTurn {
+ if (phase != HeartsPhase.Play) {
+ return null;
+ }
+ if (trickNumber == 0) {
+ return (this.findCard(TWO_OF_CLUBS) + this.numPlayed) % 4;
+ } else {
+ return (lastTrickTaker + this.numPlayed) % 4;
+ }
+ }
+
+ int getCardValue(Card c) {
+ String remainder = c.identifier.substring(1);
+ switch (remainder) {
+ case "0": // ace
+ return 14;
+ case "k":
+ return 13;
+ case "q":
+ return 12;
+ case "j":
+ return 11;
+ default:
+ return int.parse(remainder);
+ }
+ }
+
+ String getCardSuit(Card c) {
+ return c.identifier[0];
+ }
+ bool isHeartsCard(Card c) {
+ return getCardSuit(c) == 'h' && c.deck == 'classic';
+ }
+ bool isQSCard(Card c) {
+ return c == QUEEN_OF_SPADES;
+ }
+ bool isFirstCard(Card c) {
+ return c == TWO_OF_CLUBS;
+ }
+
+ bool isPenaltyCard(Card c) {
+ return isQSCard(c) || isHeartsCard(c);
+ }
+
+ bool hasSuit(int player, String suit) {
+ Card matchesSuit = this.cardCollections[player + OFFSET_HAND].firstWhere(
+ (Card element) => (getCardSuit(element) == suit),
+ orElse: () => null
+ );
+ return matchesSuit != null;
+ }
+
+ Card get leadingCard {
+ assert(this.numPlayed == 1);
+ for (int i = 0; i < 4; i++) {
+ if (cardCollections[i + OFFSET_HAND].length == 1) {
+ return cardCollections[i + OFFSET_HAND][0];
+ }
+ }
+ assert(false);
+ return null;
+ }
+ int get numPlayed {
+ int count = 0;
+ for (int i = 0; i < 4; i++) {
+ if (cardCollections[i + OFFSET_HAND].length == 1) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ bool get allPassed => cardCollections[PLAYER_A_PASS].length == 3 &&
+ cardCollections[PLAYER_B_PASS].length == 3 &&
+ cardCollections[PLAYER_C_PASS].length == 3 &&
+ cardCollections[PLAYER_D_PASS].length == 3;
+ bool get allTaken => cardCollections[PLAYER_A_PASS].length == 0 &&
+ cardCollections[PLAYER_B_PASS].length == 0 &&
+ cardCollections[PLAYER_C_PASS].length == 0 &&
+ cardCollections[PLAYER_D_PASS].length == 0;
+ bool get allPlayed => this.numPlayed == 4;
+
+ bool get allReady => ready[0] && ready[1] && ready[2] && ready[3];
+ void setReady(int playerId) {
+ ready[playerId] = true;
+ }
+ void unsetReady() {
+ ready = <bool>[false, false, false, false];
}
void deal(int playerId, int numCards) {
gamelog.add(new HeartsCommand.deal(playerId, this.deckPeek(numCards)));
}
- // Overrides Game's move method with the "move" logic for Hearts.
+ // Note that this will be called by the UI.
+ // It won't be possible to pass for other players, except via the GameLog.
+ void passCards(List<Card> cards) {
+ assert(phase == HeartsPhase.Pass && this.passTarget != null);
+ if (cards.length != 3) {
+ throw new ArgumentError('3 cards expected, but got: ${cards.toString()}');
+ }
+ gamelog.add(new HeartsCommand.pass(playerNumber, cards));
+ }
+
+ // Note that this will be called by the UI.
+ // It won't be possible to take cards for other players, except via the GameLog.
+ void takeCards() {
+ assert(phase == HeartsPhase.Take && this.takeTarget != null);
+ List<Card> cards = this.cardCollections[takeTarget + OFFSET_PASS];
+ assert(cards.length == 3);
+
+ gamelog.add(new HeartsCommand.take(playerNumber));
+ }
+
+ // Note that this will be called by the UI.
+ // It won't be possible to set the readiness for other players, except via the GameLog.
+ void setReadyUI() {
+ assert(phase == HeartsPhase.Score);
+ gamelog.add(new HeartsCommand.ready(playerNumber));
+ }
+
+ // Note that this will be called by the UI.
+ // TODO: Does this really need to be overridden? That seems like bad structure in GameComponent.
+ // Overrides Game's move method with the "move" logic for Hearts. Used for drag-drop.
+ // Note that this can only be called in the Play Phase of your turn.
+ // The UI will handle the drag-drop of the Pass Phase with its own state.
+ // The UI will initiate pass separately.
void move(Card card, List<Card> dest) {
- // The first step is to find the card. Where is it?
- // then we can remove it and add to the dest.
- debugString = 'Moving... ${card.toString()}';
+ assert(phase == HeartsPhase.Play && whoseTurn == playerNumber);
+
int i = findCard(card);
if (i == -1) {
- debugString = 'NO... ${card.toString()}';
- return;
+ throw new StateError('card does not exist or was not dealt: ${card.toString()}');
}
int destId = cardCollections.indexOf(dest);
+ if (destId == -1) {
+ throw new StateError('destination list does not exist: ${dest.toString()}');
+ }
+ if (destId != playerNumber + OFFSET_PLAY) {
+ throw new StateError('player ${playerNumber} is not playing to the correct list: ${destId}');
+ }
- gamelog.add(new HeartsCommand.pass(i, destId, <Card>[card]));
+ gamelog.add(new HeartsCommand.play(playerNumber, card));
- debugString = 'Move ${i} ${card.toString()}';
+ debugString = 'Play ${i} ${card.toString()}';
print(debugString);
}
+
+ // Overridden from Game for Hearts-specific logic:
+ // Switch from Pass to Take phase when all 4 players are passing.
+ // Switch from Take to Play phase when all 4 players have taken.
+ // During Play, if all 4 players play a card, move the tricks around.
+ // During Play, once all cards are gone and last trick is taken, go to Score phase (compute score and possibly end game).
+ // Switch from Score to Deal phase when all 4 players indicate they are ready.
+ void triggerEvents() {
+ switch (this.phase) {
+ case HeartsPhase.Deal:
+ return;
+ case HeartsPhase.Pass:
+ if (this.allPassed) {
+ phase = HeartsPhase.Take;
+ }
+ return;
+ case HeartsPhase.Take:
+ if (this.allTaken) {
+ phase = HeartsPhase.Play;
+ }
+ return;
+ case HeartsPhase.Play:
+ if (this.allPlayed) {
+ // Determine who won this trick.
+ int winner = this.determineTrickWinner();
+
+ // Move the cards to their trick list. Also check if hearts was broken.
+ // Note: Some variants of Hearts allows the QUEEN_OF_SPADES to break hearts too.
+ for (int i = 0; i < 4; i++) {
+ List<Card> play = this.cardCollections[i + OFFSET_PLAY];
+ if (!heartsBroken && isHeartsCard(play[0])) {
+ heartsBroken = true;
+ }
+ this.cardCollections[winner + OFFSET_TRICK].addAll(play); // or add(play[0])
+ play.clear();
+ }
+
+ // Set them as the next person to go.
+ this.lastTrickTaker = winner;
+
+ // Additionally, if that was the last trick, move onto the score phase.
+ if (this.trickNumber == 13) {
+ this.prepareScore();
+ }
+ }
+ return;
+ case HeartsPhase.Score:
+ if (this.allReady) {
+ this.prepareRound();
+ }
+ return;
+ default:
+ assert(false);
+ }
+ }
+
+ // Returns null or the reason that the player cannot play the card.
+ String canPlay(int player, Card c) {
+ if (phase != HeartsPhase.Play) {
+ return "It is not the Play phase of Hearts.";
+ }
+ if (!cardCollections[player].contains(c)) {
+ return "Player ${player} does not have the card (${c.toString()})";
+ }
+ if (this.whoseTurn != player) {
+ return "It is not Player ${player}'s turn.";
+ }
+ if (trickNumber == 0 && this.numPlayed == 0 && c != TWO_OF_CLUBS) {
+ return "Player ${player} must play the two of clubs.";
+ }
+ if (trickNumber == 0 && isPenaltyCard(c)) {
+ return "Cannot play a penalty card on the first round of Hearts.";
+ }
+ if (isHeartsCard(c) && !heartsBroken) {
+ return "Cannot lead with a heart when the suit has not been broken yet.";
+ }
+ String leadingSuit = getCardSuit(this.leadingCard);
+ String otherSuit = getCardSuit(c);
+ if (this.numPlayed >= 1 && leadingSuit != otherSuit && hasSuit(player, leadingSuit)) {
+ return "Must follow with a ${leadingSuit}.";
+ }
+ return null;
+ }
+
+ int determineTrickWinner() {
+ String leadingSuit = this.getCardSuit(this.leadingCard);
+ int highestIndex;
+ int highestValue; // oh no, aces are highest.
+ for (int i = 0; i < 4; i++) {
+ Card c = cardCollections[i + OFFSET_PLAY][0];
+ int value = this.getCardValue(c);
+ String suit = this.getCardSuit(c);
+ if (suit == leadingSuit && (highestIndex == null || highestValue < value)) {
+ highestIndex = i;
+ highestValue = value;
+ }
+ }
+
+ return highestIndex;
+ }
+ void prepareScore() {
+ this.unsetReady();
+
+ phase = HeartsPhase.Score;
+
+ // Count up points and check if someone shot the moon.
+ int shotMoon = null;
+ for (int i = 0; i < 4; i++) {
+ int delta = computeScore(i);
+ this.scores[i] += delta;
+ if (delta == 26) { // Shot the moon!
+ shotMoon = i;
+ }
+ }
+
+ // If someone shot the moon, apply the proper score adjustments here.
+ if (shotMoon != null) {
+ for (int i = 0; i < 4; i++) {
+ if (shotMoon == i) {
+ this.scores[i] -= 26;
+ } else {
+ this.scores[i] += 26;
+ }
+ }
+ }
+ }
+
+ int computeScore(int player) {
+ int total = 0;
+ List<Card> trickCards = this.cardCollections[player + OFFSET_TRICK];
+ for (int i = 0; i < trickCards.length; i++) {
+ Card c = trickCards[i];
+ if (isHeartsCard(c)) {
+ total++;
+ }
+ if (isQSCard(c)) {
+ total += 13;
+ }
+ }
+ return total;
+ }
}
@@ -157,6 +524,7 @@
while (position < log.length) {
log[position].execute(game);
+ game.triggerEvents();
if (game.updateCallback != null) {
game.updateCallback();
}
@@ -169,7 +537,6 @@
void execute(Game game);
}
-
class HeartsCommand extends GameCommand {
final String data; // This will be parsed.
@@ -180,13 +547,146 @@
HeartsCommand.deal(int playerId, List<Card> cards) :
this.data = computeDeal(playerId, cards);
- // TODO: receiverId is actually implied by the game round. So it may end up being removable.
- HeartsCommand.pass(int senderId, int receiverId, List<Card> cards) :
- this.data = computePass(senderId, receiverId, cards);
+ HeartsCommand.pass(int senderId, List<Card> cards) :
+ this.data = computePass(senderId, cards);
+
+ HeartsCommand.take(int takerId) :
+ this.data = computeTake(takerId);
HeartsCommand.play(int playerId, Card c) :
this.data = computePlay(playerId, c);
+ HeartsCommand.ready(int playerId) :
+ this.data = computeReady(playerId);
+
+ static computeDeal(int playerId, List<Card> cards) {
+ StringBuffer buff = new StringBuffer();
+ buff.write("Deal:${playerId}:");
+ cards.forEach((card) => buff.write("${card.toString()}:"));
+ buff.write("END");
+ return buff.toString();
+ }
+ static computePass(int senderId, List<Card> cards) {
+ StringBuffer buff = new StringBuffer();
+ buff.write("Pass:${senderId}:");
+ cards.forEach((card) => buff.write("${card.toString()}:"));
+ buff.write("END");
+ return buff.toString();
+ }
+ static computeTake(int takerId) {
+ return "Take:${takerId}:END";
+ }
+ static computePlay(int playerId, Card c) {
+ return "Play:${playerId}:${c.toString()}:END";
+ }
+ static computeReady(int playerId) {
+ return "Ready:${playerId}:END";
+ }
+
+ void execute(Game g) {
+ HeartsGame game = g as HeartsGame;
+
+ print("HeartsCommand is executing: ${data}");
+ List<String> parts = data.split(":");
+ switch (parts[0]) {
+ case "Deal":
+ if (game.phase != HeartsPhase.Deal) {
+ throw new StateError("Cannot process deal commands when not in Deal phase");
+ }
+ // Deal appends cards to playerId's hand.
+ int playerId = int.parse(parts[1]);
+ List<Card> hand = game.cardCollections[playerId];
+
+ // The last part is 'END', but the rest are cards.
+ for (int i = 2; i < parts.length - 1; i++) {
+ Card c = new Card.fromString(parts[i]);
+ this.transfer(game.deck, hand, c);
+ }
+ return;
+ case "Pass":
+ if (game.phase != HeartsPhase.Pass) {
+ throw new StateError("Cannot process pass commands when not in Pass phase");
+ }
+ // Pass moves a set of cards from senderId to receiverId.
+ int senderId = int.parse(parts[1]);
+ int receiverId = senderId + HeartsGame.OFFSET_PASS;
+ List<Card> handS = game.cardCollections[senderId];
+ List<Card> handR = game.cardCollections[receiverId];
+
+ // The last part is 'END', but the rest are cards.
+ for (int i = 2; i < parts.length - 1; i++) {
+ Card c = new Card.fromString(parts[i]);
+ this.transfer(handS, handR, c);
+ }
+ return;
+ case "Take":
+ if (game.phase != HeartsPhase.Take) {
+ throw new StateError("Cannot process take commands when not in Take phase");
+ }
+ int takerId = int.parse(parts[1]);
+ int senderPile = game.takeTarget + HeartsGame.OFFSET_PASS;
+ List<Card> handS = game.cardCollections[senderPile];
+ List<Card> handT = game.cardCollections[takerId];
+ handS.addAll(handT);
+ handT.clear();
+ return;
+ case "Play":
+ if (game.phase != HeartsPhase.Play) {
+ throw new StateError("Cannot process play commands when not in Play phase");
+ }
+
+ // Play the card from the player's hand to their play pile.
+ int playerId = int.parse(parts[1]);
+ int targetId = playerId + HeartsGame.OFFSET_PLAY;
+ List<Card> hand = game.cardCollections[playerId];
+ List<Card> discard = game.cardCollections[targetId];
+
+ Card c = new Card.fromString(parts[2]);
+
+ // If the card isn't valid, then we have an error.
+ String reason = game.canPlay(playerId, c);
+ if (reason != null) {
+ throw new StateError("Player ${playerId} cannot play ${c.toString()} because ${reason}");
+ }
+ this.transfer(hand, discard, c);
+ return;
+ case "Ready":
+ if (game.phase != HeartsPhase.Score) {
+ throw new StateError("Cannot process ready commands when not in Score phase");
+ }
+ int playerId = int.parse(parts[1]);
+ game.setReady(playerId);
+ return;
+ default:
+ print(data);
+ assert(false); // How could this have happened?
+ }
+ }
+
+ void transfer(List<Card> sender, List<Card> receiver, Card c) {
+ assert(sender.contains(c));
+ sender.remove(c);
+ receiver.add(c);
+ }
+}
+
+class ProtoCommand extends GameCommand {
+ final String data; // This will be parsed.
+
+ // Usually this constructor is used when reading from a log/syncbase.
+ ProtoCommand(this.data);
+
+ // The following constructors are used for the player generating the ProtoCommand.
+ ProtoCommand.deal(int playerId, List<Card> cards) :
+ this.data = computeDeal(playerId, cards);
+
+ // TODO: receiverId is actually implied by the game round. So it may end up being removable.
+ ProtoCommand.pass(int senderId, int receiverId, List<Card> cards) :
+ this.data = computePass(senderId, receiverId, cards);
+
+ ProtoCommand.play(int playerId, Card c) :
+ this.data = computePlay(playerId, c);
+
static computeDeal(int playerId, List<Card> cards) {
StringBuffer buff = new StringBuffer();
buff.write("Deal:${playerId}:");
@@ -206,7 +706,7 @@
}
void execute(Game game) {
- print("HeartsCommand is executing: ${data}");
+ print("ProtoCommand is executing: ${data}");
List<String> parts = data.split(":");
switch (parts[0]) {
case "Deal":
diff --git a/lib/main.dart b/lib/main.dart
index ef523a3..64cef29 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -29,6 +29,7 @@
}
void main() {
+ print('started');
CroupierApp app = new CroupierApp();
// Had difficulty reading from a file, so I can use this to simulate it.
@@ -55,4 +56,5 @@
runApp(app);
+ print('running');
}
\ No newline at end of file
diff --git a/pubspec.yaml b/pubspec.yaml
index a8ad234..298989f 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,4 +1,5 @@
name: your_app_name
dependencies:
sky: any
- sky_tools: any
\ No newline at end of file
+ sky_tools: any
+ test: any
\ No newline at end of file
diff --git a/test/hearts_test.dart b/test/hearts_test.dart
new file mode 100644
index 0000000..ffdb360
--- /dev/null
+++ b/test/hearts_test.dart
@@ -0,0 +1,77 @@
+import "package:test/test.dart";
+import "../lib/logic/game.dart";
+
+void main() {
+ HeartsGame game = new HeartsGame(0);
+
+ group("Card Manipulation", () {
+ test("Dealing", () {
+ // By virtue of creating the game, HeartsGame should have 4 collections with 13 cards and 8 collections with 0 cards each.
+
+ });
+ test("Passing", () {
+
+ });
+ test("Playing", () {
+
+ });
+ });
+ group("Card Manipulation - Error Cases", () {
+ test("Dealing - missing card", () {
+
+ });
+ test("Dealing - wrong number of cards", () {
+
+ });
+ test("Dealing - wrong phase", () {
+
+ });
+ test("Passing - missing card", () {
+
+ });
+ test("Passing - wrong number of cards", () {
+
+ });
+ test("Passing - wrong phase", () {
+
+ });
+ test("Playing - missing card", () {
+
+ });
+ test("Playing - invalid card (not 2 of clubs as first card)", () {
+
+ });
+ test("Playing - invalid card (no penalty on first round)", () {
+ // NOTE: It is actually possible to be forced to play a penalty card on round 1.
+ // But the odds are miniscule, so this rule will be enforced.
+ });
+ test("Playing - invalid card (suit mismatch)", () {
+
+ });
+ test("Playing - invalid card (hearts not broken yet)", () {
+
+ });
+ test("Playing - wrong turn", () {
+
+ });
+ test("Playing - wrong phase", () {
+
+ });
+ });
+ group("Scoring", () {
+ test("Count Points", () {
+ // In this situation, what's the score?
+ });
+ test("Count Points 2", () {
+ // In this alternative situation, what's the score?
+ });
+ });
+ group("Game Over", () {
+ test("Has the game ended? Yes", () {
+ // Check if the game has ended. Should be yes.
+ });
+ test("Has the game ended? No", () {
+ // Check if the game has ended. Should be no.
+ });
+ });
+}
\ No newline at end of file
