Game.hpp

Go to the documentation of this file.

/*
 * Tarot is an application for Android system to play to French Tarot.
 * Please visit https://github.com/richoux/Tarot for further information.
 * 
 * Copyright (C) 2013-2016 Florian Richoux
 *
 * This file is part of Tarot.
 * Tarot is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * Tarot is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with Tarot.  If not, see http://www.gnu.org/licenses/.
 */

#pragma once

#include <vector>
#include <stack>
#include <set>
#include <map>
#include <memory>

#include "Suits.hpp"
#include "Biddings.hpp"
#include "Team.hpp"
#include "Player.hpp"
#include "Human.hpp"
#include "AI.hpp"
#include "Card.hpp"
// #include "StratLang.hpp"
#include "Trick.hpp"
#include "Deck.hpp"

using namespace std; 

class Game
{
public:

  Game();
  

  Game( int& numberPlayers, const bool automatic = false );

  void chooseKing();


  void closeBiddings( const Biddings bestBid );


  double computeScore( const string& name ) const;

  void dealCards();

  Team endGame();

  inline Biddings getBidding() const { return bidding; }

  inline int getCardsPerPlayer() const { return cardsPerPlayer; }

  inline shared_ptr<Trick> getCurrentTrick() const { return currentTrick; }

  inline Team getDefenders() const { return defenders; }

  inline set< shared_ptr<Card> >getDog() const { return dog; }

  inline shared_ptr<Card> getKingCalled() const { return kingCalled; }

  inline int getIndexBidder() const { return indexBidder; }

  inline int getIndexNext() const { return indexNext; }

  inline int getIndexStarter() const { return indexStarter; }

  inline int getIndexToBid() const { return indexToBid; }

  inline int getNumberPlayers() const { return players.size(); }

  inline vector< shared_ptr<Player> > getPlayers() const { return players; }


  set<shared_ptr<Card> >getPlayerWonCards( const shared_ptr<Player> player ) const;

  inline Team getTakers() const { return takers; }

  shared_ptr<Trick> getTrick();
  
  inline Team getUnknownTeam() const { return unknown; }

  inline bool isBotsOnly() const { return botsOnly; }

  inline bool isKingFound() const { return kingFound; }

  void newGame();

  void printScores() const;


  shared_ptr< Card > playCard( bool &kingJustFound );


  bool sameTeam( const shared_ptr<Player> p1, const shared_ptr<Player> p2 ) const;

  void setGame( int& numberPlayers, const bool automatic = false );
  
  void showDeck() const;

  void showPlayersCards() const;

  void shuffleDeck();


  pair< shared_ptr<Player>, Biddings > takeBiddings( const Biddings &bestBid );

  void takeDog();

  inline void updateIndexBidder() { indexBidder = indexToBid; }

private:

  void addWonCards( const string& name, const set<shared_ptr<Card> >& cards );


  bool isCardCalled( const shared_ptr<Card> card, const shared_ptr<Player> player );

  void nextPlayer();


  void setNext( const shared_ptr<Player> player );

  void swapFool();
  
  void update();

  vector< shared_ptr<Player> >  players;                
  map< string, set<shared_ptr<Card> > > cardsPlayer;    
  // shared_ptr<StratLang>              language;
  shared_ptr<Trick>             currentTrick;           
  stack< shared_ptr<Trick> >    history;                
  shared_ptr<Player>            next;                   
  int                           indexNext;              
  int                           indexStarter;           
  int                           indexToBid;             
  int                           indexBidder;            
  Deck                          deck;                   
  set< shared_ptr<Card> >       dog;                    
  Team                          takers;                 
  Team                          defenders;              
  Team                          unknown;                
  Biddings                      bidding;                
  shared_ptr<Card>              kingCalled;             
  bool                          kingFound;              
  int                           dogSize;                
  int                           cardsPerPlayer;         
  int                           consecutiveDealing;     
  bool                          chelemAnnounced;        
  bool                          addDogAtTheEnd;         

  bool                          toSwap;                 
  bool                          botsOnly;               
  shared_ptr<Player>            foolGiver;              
  shared_ptr<Player>            foolReceiver;           
};