lib/logic/solitaire/solitaire_game.part.dart - release.projects.croupier - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 part of solitaire;

 enum SolitairePileType { ACES, DISCARD, DRAW, DOWN, UP }

 class SolitaireGame extends Game {
   // Constants for the index-based offsets of the Solitaire Game's card collection.
   // There are 20 piles to track (4 aces, 1 discard, 1 draw, 7 down, 7 up).
   static const NUM_PILES = 20;
   static const OFFSET_ACES = 0;
   static const OFFSET_DISCARD = 4;
   static const OFFSET_DRAW = 5;
   static const OFFSET_DOWN = 6;
   static const OFFSET_UP = 13;

   SolitairePhase _phase = SolitairePhase.Deal;
   SolitairePhase get phase => _phase;
   void set phase(SolitairePhase other) {
     print('setting phase from ${_phase} to ${other}');
     _phase = other;
   }

   @override
   void set playerNumber(int other) {
     // TODO(alexfandrianto): Do we still need this?
     // The switch button requires us to change the current player.
     // Since the log writer has a notion of the associated user, we have to
     // change that too.
     super.playerNumber = other;
     SolitaireLog hl = this.gamelog;
     hl.logWriter.associatedUser = other;
   }

   SolitaireGame(int playerNumber)
       : super.create(GameType.Solitaire, new SolitaireLog(), playerNumber, NUM_PILES) {
     resetGame();
   }

   void resetGame() {
     this.resetCards();
   }

   int getCardValue(Card c) {
     String remainder = c.identifier.substring(1);
     switch (remainder) {
       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 isAce(Card c) {
     return getCardValue(c) == 1;
   }

   bool isKing(Card c) {
     return getCardValue(c) == 13;
   }

   bool isRed(Card c) {
     return getCardSuit(c) == 'h' || getCardSuit(c) == 'd';
   }

   bool isBlack(Card c) {
     return getCardSuit(c) == 's' || getCardSuit(c) == 'c';
   }

   bool get canDrawCard => cardCollections[OFFSET_DISCARD].length + cardCollections[OFFSET_DRAW].length > 0;

   bool get isGameWon {
     for (int i = 0; i < 4; i++) {
       if (this.cardCollections[i].length != 13) {
         return false;
       }
     }
     return true;
   }

   // UI Callback: Deal
   void dealCardsUI() {
     deck.shuffle();

     gamelog.add(new SolitaireCommand.deal(this.deckPeek(52, 0)));
   }

   // UI Callback: Move
   @override
   void move(Card card, List<Card> dest) {
     int targetPile = cardCollections.indexOf(dest);
     gamelog.add(new SolitaireCommand.move(card, targetPile));
   }

   // UI Callback: Draw
   void drawCardUI() {
     gamelog.add(new SolitaireCommand.draw());
   }

   // UI Callback: Flip
   void flipCardUI(int index) {
     gamelog.add(new SolitaireCommand.flip(index));
   }

   // Overridden from Game for Solitaire-specific logic:
   // Allows you to immediately show the Score phase after noticing that the
   // player has won.
   @override
   void triggerEvents() {
     switch (this.phase) {
       case SolitairePhase.Deal:
         if (this.deck.length == 0) {
           phase = SolitairePhase.Play;
         }
         return;
       case SolitairePhase.Play:
         if (this.isGameWon) {
           phase = SolitairePhase.Score;
         }
         return;
       case SolitairePhase.Score:
         return;
       default:
         assert(false);
     }
   }

   SolitairePileType pileType(int index) {
     if (index >= OFFSET_ACES && index < OFFSET_DISCARD) {
       return SolitairePileType.ACES;
     } else if (index == OFFSET_DISCARD) {
       return SolitairePileType.DISCARD;
     } else if (index == OFFSET_DRAW) {
       return SolitairePileType.DRAW;
     } else if (index >= OFFSET_DOWN && index < OFFSET_UP) {
       return SolitairePileType.DOWN;
     } else if (index >= OFFSET_UP && index < 20) {
       return SolitairePileType.UP;
     } else {
       assert(false);
       return null;
     }
   }

   bool _cardCompatibleUp(Card top, Card bot) {
     if (isBlack(top) && isBlack(bot)) {
       return false;
     } else if (isRed(top) && isRed(bot)) {
       return false;
     } else if (getCardValue(top) - 1 != getCardValue(bot)) {
       return false;
     }
     return true;
   }

   bool _cardCompatibleAces(Card top, Card bot) {
     return getCardSuit(top) == getCardSuit(bot) && getCardValue(top) + 1 == getCardValue(bot);
   }

   bool _isTopCard(Card c, int source) {
     List<Card> sourcePile = cardCollections[source];
     return sourcePile[sourcePile.length - 1] == c;
   }


   // The card in question must be the top card of the source (if it is from the aces or discard pile).
   // If the destination has no cards, you can play any king.
   // Otherwise, you have to be an opposite color AND 1 lower in value.
   String _checkUpDestination(Card c, int source, int destination, bool isAcesOrDiscard) {
     if (isAcesOrDiscard && !_isTopCard(c, source)) {
       return "Tried to move ${c.toString()}, but it is not the top card.";
     }

     List<Card> destPile = cardCollections[destination];
     if (destPile.length == 0) {
       if (!isKing(c)) {
         return "Destination is empty, but card is not a King.";
       }
       return null;
     }
     Card topCard = destPile[destPile.length - 1];
     if (!_cardCompatibleUp(topCard, c)) {
       return "${c.toString()} cannot be played on top of ${topCard.toString()}";
     }
     return null;
   }

   // The card in question must be the top card of the source.
   // If the destination has no cards, you can play any ace.
   // Otherwise, it has to be the same suit AND be 1 higher in value.
   String _checkAcesDestination(Card c, int source, int destination) {
     if (!_isTopCard(c, source)) {
       return "Tried to move ${c.toString()}, but it is not the top card.";
     }

     List<Card> destPile = cardCollections[destination];
     if (destPile.length == 0) {
       if (!isAce(c)) {
         return "Destination is empty, but card is not an Ace.";
       }
       return null;
     }
     Card topCard = destPile[destPile.length - 1];
     if (!_cardCompatibleAces(topCard, c)) {
       return "${c.toString()} cannot be played on top of ${topCard.toString()}";
     }
     return null;
   }

   // Returns null or the reason that the player cannot play the card.
   String canPlay(Card c, List<Card> dest) {
     int destination = cardCollections.indexOf(dest);
     int source = findCard(c);
     print("Can play? ${c}, ${source} ${destination}");

     if (phase != SolitairePhase.Play) {
       return "It is not the Play phase of Solitaire.";
     }
     if (source == -1) {
       return "Unknown card: (${c.toString()})";
     }
     if (dest == -1) {
       return "Unknown destination: ${dest}";
     }
     if (source == destination) {
       return "Source Pile is same as Destination Pile";
     }
     SolitairePileType sType = pileType(source);
     SolitairePileType dType = pileType(destination);
     switch(sType) {
       case SolitairePileType.ACES:
         if (dType != SolitairePileType.UP) {
           return "Destination Pile for ACES pile should be an UP pile.";
         }
         return _checkUpDestination(c, source, destination, true);
       case SolitairePileType.DISCARD:
         if (dType == SolitairePileType.UP) {
           return _checkUpDestination(c, source, destination, true);
         } else if (dType == SolitairePileType.ACES) {
           return _checkAcesDestination(c, source, destination);
         }
         return "Destination Pile for DISCARD should be an UP or ACES pile.";
       case SolitairePileType.DRAW:
         return "Source Pile should not be a DRAW pile.";
       case SolitairePileType.DOWN:
         return "Source Pile should not be a DOWN pile.";
       case SolitairePileType.UP:
         if (dType == SolitairePileType.UP) {
           return _checkUpDestination(c, source, destination, false);
         } else if (dType == SolitairePileType.ACES) {
           return _checkAcesDestination(c, source, destination);
         }
         return "Destination Pile for UP should be an UP or ACES pile.";
       default:
         assert(false);
     }

     return null;
   }

   // TODO(alexfandrianto): Maybe wanted for debug; if not, remove.
   void jumpToScorePhaseDebug() {
   }
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	part of solitaire;

	enum SolitairePileType { ACES, DISCARD, DRAW, DOWN, UP }

	class SolitaireGame extends Game {
	// Constants for the index-based offsets of the Solitaire Game's card collection.
	// There are 20 piles to track (4 aces, 1 discard, 1 draw, 7 down, 7 up).
	static const NUM_PILES = 20;
	static const OFFSET_ACES = 0;
	static const OFFSET_DISCARD = 4;
	static const OFFSET_DRAW = 5;
	static const OFFSET_DOWN = 6;
	static const OFFSET_UP = 13;

	SolitairePhase _phase = SolitairePhase.Deal;
	SolitairePhase get phase => _phase;
	void set phase(SolitairePhase other) {
	print('setting phase from ${_phase} to ${other}');
	_phase = other;
	}

	@override
	void set playerNumber(int other) {
	// TODO(alexfandrianto): Do we still need this?
	// The switch button requires us to change the current player.
	// Since the log writer has a notion of the associated user, we have to
	// change that too.
	super.playerNumber = other;
	SolitaireLog hl = this.gamelog;
	hl.logWriter.associatedUser = other;
	}

	SolitaireGame(int playerNumber)
	: super.create(GameType.Solitaire, new SolitaireLog(), playerNumber, NUM_PILES) {
	resetGame();
	}

	void resetGame() {
	this.resetCards();
	}

	int getCardValue(Card c) {
	String remainder = c.identifier.substring(1);
	switch (remainder) {
	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 isAce(Card c) {
	return getCardValue(c) == 1;
	}

	bool isKing(Card c) {
	return getCardValue(c) == 13;
	}

	bool isRed(Card c) {
	return getCardSuit(c) == 'h' \|\| getCardSuit(c) == 'd';
	}

	bool isBlack(Card c) {
	return getCardSuit(c) == 's' \|\| getCardSuit(c) == 'c';
	}

	bool get canDrawCard => cardCollections[OFFSET_DISCARD].length + cardCollections[OFFSET_DRAW].length > 0;

	bool get isGameWon {
	for (int i = 0; i < 4; i++) {
	if (this.cardCollections[i].length != 13) {
	return false;
	}
	}
	return true;
	}

	// UI Callback: Deal
	void dealCardsUI() {
	deck.shuffle();

	gamelog.add(new SolitaireCommand.deal(this.deckPeek(52, 0)));
	}

	// UI Callback: Move
	@override
	void move(Card card, List<Card> dest) {
	int targetPile = cardCollections.indexOf(dest);
	gamelog.add(new SolitaireCommand.move(card, targetPile));
	}

	// UI Callback: Draw
	void drawCardUI() {
	gamelog.add(new SolitaireCommand.draw());
	}

	// UI Callback: Flip
	void flipCardUI(int index) {
	gamelog.add(new SolitaireCommand.flip(index));
	}

	// Overridden from Game for Solitaire-specific logic:
	// Allows you to immediately show the Score phase after noticing that the
	// player has won.
	@override
	void triggerEvents() {
	switch (this.phase) {
	case SolitairePhase.Deal:
	if (this.deck.length == 0) {
	phase = SolitairePhase.Play;
	}
	return;
	case SolitairePhase.Play:
	if (this.isGameWon) {
	phase = SolitairePhase.Score;
	}
	return;
	case SolitairePhase.Score:
	return;
	default:
	assert(false);
	}
	}

	SolitairePileType pileType(int index) {
	if (index >= OFFSET_ACES && index < OFFSET_DISCARD) {
	return SolitairePileType.ACES;
	} else if (index == OFFSET_DISCARD) {
	return SolitairePileType.DISCARD;
	} else if (index == OFFSET_DRAW) {
	return SolitairePileType.DRAW;
	} else if (index >= OFFSET_DOWN && index < OFFSET_UP) {
	return SolitairePileType.DOWN;
	} else if (index >= OFFSET_UP && index < 20) {
	return SolitairePileType.UP;
	} else {
	assert(false);
	return null;
	}
	}

	bool _cardCompatibleUp(Card top, Card bot) {
	if (isBlack(top) && isBlack(bot)) {
	return false;
	} else if (isRed(top) && isRed(bot)) {
	return false;
	} else if (getCardValue(top) - 1 != getCardValue(bot)) {
	return false;
	}
	return true;
	}

	bool _cardCompatibleAces(Card top, Card bot) {
	return getCardSuit(top) == getCardSuit(bot) && getCardValue(top) + 1 == getCardValue(bot);
	}

	bool _isTopCard(Card c, int source) {
	List<Card> sourcePile = cardCollections[source];
	return sourcePile[sourcePile.length - 1] == c;
	}


	// The card in question must be the top card of the source (if it is from the aces or discard pile).
	// If the destination has no cards, you can play any king.
	// Otherwise, you have to be an opposite color AND 1 lower in value.
	String _checkUpDestination(Card c, int source, int destination, bool isAcesOrDiscard) {
	if (isAcesOrDiscard && !_isTopCard(c, source)) {
	return "Tried to move ${c.toString()}, but it is not the top card.";
	}

	List<Card> destPile = cardCollections[destination];
	if (destPile.length == 0) {
	if (!isKing(c)) {
	return "Destination is empty, but card is not a King.";
	}
	return null;
	}
	Card topCard = destPile[destPile.length - 1];
	if (!_cardCompatibleUp(topCard, c)) {
	return "${c.toString()} cannot be played on top of ${topCard.toString()}";
	}
	return null;
	}

	// The card in question must be the top card of the source.
	// If the destination has no cards, you can play any ace.
	// Otherwise, it has to be the same suit AND be 1 higher in value.
	String _checkAcesDestination(Card c, int source, int destination) {
	if (!_isTopCard(c, source)) {
	return "Tried to move ${c.toString()}, but it is not the top card.";
	}

	List<Card> destPile = cardCollections[destination];
	if (destPile.length == 0) {
	if (!isAce(c)) {
	return "Destination is empty, but card is not an Ace.";
	}
	return null;
	}
	Card topCard = destPile[destPile.length - 1];
	if (!_cardCompatibleAces(topCard, c)) {
	return "${c.toString()} cannot be played on top of ${topCard.toString()}";
	}
	return null;
	}

	// Returns null or the reason that the player cannot play the card.
	String canPlay(Card c, List<Card> dest) {
	int destination = cardCollections.indexOf(dest);
	int source = findCard(c);
	print("Can play? ${c}, ${source} ${destination}");

	if (phase != SolitairePhase.Play) {
	return "It is not the Play phase of Solitaire.";
	}
	if (source == -1) {
	return "Unknown card: (${c.toString()})";
	}
	if (dest == -1) {
	return "Unknown destination: ${dest}";
	}
	if (source == destination) {
	return "Source Pile is same as Destination Pile";
	}
	SolitairePileType sType = pileType(source);
	SolitairePileType dType = pileType(destination);
	switch(sType) {
	case SolitairePileType.ACES:
	if (dType != SolitairePileType.UP) {
	return "Destination Pile for ACES pile should be an UP pile.";
	}
	return _checkUpDestination(c, source, destination, true);
	case SolitairePileType.DISCARD:
	if (dType == SolitairePileType.UP) {
	return _checkUpDestination(c, source, destination, true);
	} else if (dType == SolitairePileType.ACES) {
	return _checkAcesDestination(c, source, destination);
	}
	return "Destination Pile for DISCARD should be an UP or ACES pile.";
	case SolitairePileType.DRAW:
	return "Source Pile should not be a DRAW pile.";
	case SolitairePileType.DOWN:
	return "Source Pile should not be a DOWN pile.";
	case SolitairePileType.UP:
	if (dType == SolitairePileType.UP) {
	return _checkUpDestination(c, source, destination, false);
	} else if (dType == SolitairePileType.ACES) {
	return _checkAcesDestination(c, source, destination);
	}
	return "Destination Pile for UP should be an UP or ACES pile.";
	default:
	assert(false);
	}

	return null;
	}

	// TODO(alexfandrianto): Maybe wanted for debug; if not, remove.
	void jumpToScorePhaseDebug() {
	}
	}