Event.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 EVENT_HH_
# define EVENT_HH_

# include "Constants.hh"
# include "Dice.hh"
# include "rules/EventProcess.hh"

enum eCustomEvent {
  eInitGame,
};

class Event
{
public:
  Event() {}
  virtual ~Event() {}

  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) {}
  
  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 evMoveTurnMarker() {}
  virtual void evTurnOver(enum eTurnOverMotive motive);
  virtual void evTouchdooown(int team_id, int player_id);
  virtual void evEndTurn(int team_id);
  virtual void evTimer(bool pause);

  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 evPlayerMaRemain(int team_id, int player_id,
                                int old_ma_remain, int new_ma_remain);
  virtual void evPlayerStatus(int team_id, int player_id,
                              enum eStatus old_status, enum eStatus status);
  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_dices, 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);
};

inline void Event::evIllegal(int, int, enum eError) {}
inline void Event::evChat(int, const std::string&) {}

inline void Event::evHalf(int) {}
inline void Event::evDrawKicker(int, bool) {}
inline void Event::evPlaceTeam(int) {}
inline void Event::evKickOff(int) {}
inline void Event::evTouchBack(int) {}
inline void Event::evNewTurn(int, int, int) {}
inline void Event::evTurnOver(enum eTurnOverMotive) {}
inline void Event::evTouchdooown(int, int) {}
inline void Event::evEndTurn(int) {}
inline void Event::evTimer(bool) {}

inline void Event::evBallCoord(const Coordinates&, const Coordinates&) {}
inline void Event::evBallOwner(int, int, int, int) {}

inline void Event::evPlayerCreate(int, int) {}
inline void Event::evPlayerStatus(int, int, enum eStatus, enum eStatus) {}
inline void Event::evPlayerCoord(int, int, const Coordinates&, const Coordinates&) {}
inline void Event::evPlayerMaRemain(int, int, int, int) {}
inline void Event::evPlayerKnocked(int, int) {}

inline void Event::evAction(int, int, enum eAction) {}
inline void Event::evEffort(int, int, enum eEffort, const Coordinates&) {}
inline void Event::evRequestProcessed(int) {}
inline void Event::evResult(int, int, enum eRoll, int, int, int, bool, enum eSkill) {}
inline void Event::evBlockResult(int, int, int, int, enum eBlockDiceFace[3], int, bool) {}
inline void Event::evBlockDice(int, int) {}
inline void Event::evBlockPush(int, const Coordinates&, int, const Coordinates[], int) {}
inline void Event::evFollow(int, int) {}

inline void Event::evReroll(int, bool) {}
inline void Event::evSkill(int, int, enum eSkill, int) {}

#endif /* !EVENT_HH_ */