SPlayer.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 SPLAYER_HH_
# define SPLAYER_HH_

# include "Dice.hh"
# include "Player.hh"
# include "SField.hh"

class OpStack;
class SMatch;
class SPlayerMsg;
class SRules;
class STeam;

class SPlayer : public Player
{
public:
  SPlayer(SRules* r, const MsgPlayerCreate* msg, SMatch* m, STeam* t, SPlayerMsg* pm);

  bool acceptPlayerCreation();

  bool checkAndDeclareTouchdooown();

  void setCoordinates(const Coordinates& coord, bool advertise_client = true);
  void setMaRemain(int new_ma_remain);
  void setStatus(enum eStatus new_status);
  void setProne();
  void prepareKickoff();

  void setUsableSkill(enum eSkill skill);

  void checkArmour(int av_mod, int inj_mod);
  void bePushedInTheCrowd();
 
  void considerBlockDices(bool reroll);
  void resolveBlockDice(int chosen_dice);
  void resolveBlockBothDownDefender(bool block);
  void resolveBlockBothDownAttacker(bool block);
  void resolveBlockDefenderStumble(bool dodge);
  void setPusher(SPlayer* p);
  void tryBlockPush(SPlayer* target);
  void resolveBlockPush(int chosen_square);
  void considerBlockFollow();
  void finishBlockFollow(bool follow);
  void finishBlockPush();
  void finishBlockAction();

  void tryCatchBall(bool accurate_pass);
  void finishCatchBall(bool reroll, bool success);
  void tryDodge();
  void finishDodge(bool reroll, bool success);
  void tryMove(Coordinates& aim);
  void tryPickUp();
  void finishPickUp(bool reroll, bool success);
  void tryStandUp();
  void finishStandUp(bool reroll, bool success);
  void tryTame();
  void finishTame(bool reroll, bool success);
  void tryThrow();
  void finishThrow(bool reroll, int success);

  // Message handlers called by SPlayerMsg.
  void msgPlayerCoord(const MsgPlayerCoord* m);
  void msgAction(const MsgAction* m);
  void msgMove(const MsgMove* m);
  void msgStandUp(const MsgStandUp* m);
  void msgBlock(const MsgBlock* m);
  void msgFoul(const MsgFoul* m);
  void msgHandOff(const MsgHandOff* m);
  void msgPass(const MsgPass* m);
  void msgSkill(const MsgSkill* m);

private:
  void setRerollAvailability();
  void setUsableSkills();
  void setSkillAvailability(enum eSkill skill);
  bool canUseSkill(enum eSkill skill) const;
  //FIXME: This will have to be deleted for extra rules,
  // because up to three skills could be usable for the same roll.
  enum eSkill getUsableSkill() const;

  bool rollAgility(enum eRoll roll_type, int modifier);
  bool rollAgility();

  void rollInjury(int modifier);
  enum eStatus rollCasualty();

  void tryBlock();
  void rollBlock();

  void tryFoul();

  void tryHandOff();

  void rollCatchBall();
  void rollDodge();
  void rollPickUp();
  void rollStandUp();
  void rollTame();
  void rollThrow();

  int nb_block_dices_;
  Coordinates push_choices_[3];
  int nb_push_choices_;
  int dice_chooser_id_;
  enum eBlockDiceFace block_results_[3];
  bool target_knocked_;
  bool follow_;

  Coordinates move_aim_; 
  Coordinates move_from_; 
  enum eRoll roll_attempted_;
  SkillList usable_skills_; 
  bool reroll_enabled_;
  int modifier_; 
  Coordinates throw_aim_;
  float distance_;
  bool fumble_;

  SRules* r_; 
  SMatch* m_; 
  STeam* t_; 
  SField* f_; 
  Dice* d_; 
  SPlayerMsg* pm_;
  OpStack* ops_;

  SPlayer* pusher_; 
  SPlayer* target_; 
};

#endif /* !SPLAYER_HH_ */