Game.hh

/*
** TowBowlTactics, a turn-based strategy football game.
**
** Copyright (C) 2006-2010 The TBT Team.
**
** This program 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 2
** of the License, or (at your option) any later version.
**
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
**
** The TBT Team consists of people listed in the `AUTHORS' file.
*/

#ifndef GAME_HH_
# define GAME_HH_

# include "Event.hh"
# include "Sprite.hh"
# include "tools.hh"

# include <SDL.h>

// All forward decl. Avoid recompilation of all sdlvisu when a header
// is modified.
class Api;
class App;
class SDLWindow;
class Input;
class TextSurface;
class InputTextSurface;
class VirtualSurface;

BEGIN_NS(sdlvisu);

class Map;
class Panel;
class InfoBar;
class VisuPlayer;
class ActionPopup;
class DialogHandler;
class RulesCrutch;
class CmdButton;

enum eVisuGameState {
  VGS_PAUSE = 0,            
  VGS_SHOWDLGBOX = 10,      
  VGS_WAITINPUT,            
  VGS_WAITINIT = 20,        
  VGS_SHOWACTIONPOPUP = 40, 
  VGS_MAKEEFFORT = 50,      
  VGS_INPLAY = 60,          
  VGS_NOTHING = 70          
};

enum eGameScreenChildsZ {
  GSCZ_ACTIONPOPUP = 1,
  GSCZ_INFOBAR,
  GSCZ_TEXTBOX,
  GSCZ_DIALOGBOX,
  GSCZ_PAUSE
};

enum eVisuGameCommand {
  VGC_CHAT = 0,
  VGC_DEBUG,
  VGC_END,
  VGC_FORMATION,
  VGC_PAUSE,
  VGC_QUIT,

  VGC_LAST = VGC_QUIT,
};

class Game : public Event
{
public:
  Game(SDLWindow& win, Api* api, App* app);
  ~Game();

  Api*                  getApi() const;
  const RulesCrutch&    getRulesCrutch() const; // only Game can modify it.

  Input&                getInput() const; // do not modify input.
  VirtualSurface&       getScreen() const;

  const InfoBar&        getInfoBar() const; // only Game can modify it.
  Map&                  getMap() const;
  Panel&                getPanel() const;

  bool isStateSet(enum eVisuGameState s) const;

  void setState(enum eVisuGameState s);

  void unsetState(enum eVisuGameState s);

  static const char* stringify(enum eVisuGameState s);
  static const char* stringify(enum eVisuGameCommand c);

  bool hasMoreSteps();

  int gameStep();

private:

  /*
  ** All Events.
  */

  virtual void evIllegal(int team_id, int was_token, enum eError error);
  virtual void evChat(int coach_id, const std::string& msg);

  virtual void evInitGame();
  virtual void evCelebration();
  virtual void evEndGame();
  virtual void evCancelGame(int team_id);

  virtual void evHalf(int half);
  virtual void evDrawKicker(int team_id, bool is_a_question);
  virtual void evPlaceTeam(int team_id);
  virtual void evKickOff(int team_id);
  virtual void evTouchBack(int team_id);
  virtual void evNewTurn(int team_id, int cur_half, int cur_turn);
  virtual void evEndTurn(int team_id);
  virtual void evMoveTurnMarker();
  virtual void evTurnOver(enum eTurnOverMotive motive);
  virtual void evTouchdooown(int team_id, int player_id);

  virtual void evBallCoord(const Coordinates& old_coord, const Coordinates& new_coord);
  virtual void evBallOwner(int old_team_id, int old_player_id,
                           int team_id, int player_id);

  virtual void evPlayerCreate(int team_id, int player_id);
  virtual void evPlayerStatus(int team_id, int player_id, enum eStatus, enum eStatus);
  virtual void evPlayerCoord(int team_id, int player_id,
                             const Coordinates& old_coord,
                             const Coordinates& new_coord);
  virtual void evPlayerKnocked(int team_id, int player_id);

  virtual void evAction(int team_id, int player_id, enum eAction action);
  virtual void evEffort(int team_id, int player_id, enum eEffort effort,
                            const Coordinates& to);
  virtual void evRequestProcessed(int team_id);
  virtual void evResult(int team_id, int player_id, enum eRoll roll_type, int result, 
                        int modifier, int required, bool reroll, enum eSkill skill);
  virtual void evBlockResult(int team_id, int player_id, int opponent_player_id, 
                             int nb_dice, enum eBlockDiceFace result[3],
                             int dice_chooser_id, bool reroll);
  virtual void evBlockDice(int team_id, int dice);
  virtual void evBlockPush(int team_id, const Coordinates& coord, int nb_squares, const Coordinates squares[], int chosen_square);
  virtual void evFollow(int team_id, int follow);

  virtual void evReroll(int team_id, bool reroll);
  virtual void evSkill(int team_id, int player_id, enum eSkill skill, int choice);

  SDLWindow&            win_;    
  Api*                  api_;    
  App*                  app_;    
  RulesCrutch*          rules_crutch_; 

  ActionPopup*          action_popup_;  
  Surface*              ib_shadow_;     
  InfoBar*              info_bar_;      
  Map*                  map_;           
  Panel*                panel_;         
  CmdButton*            commands_[VGC_LAST + 1];

  VisuPlayer*           vplayers_[2][MAX_PLAYER]; 
  Sprite                block_push_[3];   
  InputTextSurface*     chat_;

  std::set<enum eVisuGameState> state_list_;  
  DialogHandler*        dlg_handler_; 
  Surface*              pause_bg_; 
  TextSurface*          pause_text_; 
};

END_NS(sdlvisu);

#endif /* !GAME_HH_ */