Player.hxx

/*
** 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.
*/

inline Player::Player(const MsgPlayerCreate* m)
  : id_(m->player_id),
    team_id_(m->client_id),
    status_(STA_RESERVE),
    ma_(m->ma),
    st_(m->st),
    ag_(m->ag),
    av_(m->av),
    ma_remain_(-1),
    has_blocked_(false),
    has_played_(false),
    action_(ACT_UNASSIGNED),
    will_prone_(false),
    has_tackle_zone_(true)
{
  name_ = packetToString(m->name);

  int nb = m->skill_nb > MAX_SKILL ? MAX_SKILL : m->skill_nb;
  for (int i = 0; i < nb; i++)
    skill_list_.push_back(static_cast<eSkill>(m->skill[i]));
}

inline Player::~Player()
{
}

inline int Player::getId() const
{
  return id_;
}

inline int Player::getTeamId() const
{
  return team_id_;
}

inline const Coordinates& Player::getCoordinates() const
{
  return coord_;
}

inline const std::string& Player::getName() const
{
  return name_;
}

inline const std::string& Player::getPositionName() const
{
  return position_name_;
}

inline int Player::getMa() const
{
  return ma_;
}

inline int Player::getMaRemain() const
{
  return ma_remain_;
}

inline int Player::getSt() const
{
  return st_;
}

inline int Player::getAg() const
{
  return ag_;
}

inline int Player::getAv() const
{
  return av_;
}

inline enum eStatus Player::getStatus() const
{
  return status_;
}

inline bool Player::hasPlayed() const
{
  return has_played_;
}
    
inline void Player::setHasPlayed()
{
  has_played_ = true;
}
    
inline bool Player::hasBlocked() const
{
  return has_blocked_;
}
    
inline void Player::setHasBlocked()
{
  has_blocked_ = true;
}
    
inline enum eAction Player::getAction() const
{
  return action_;
}

inline void Player::setAction(enum eAction action)
{
  action_ = action;
}

inline bool Player::hasSkill(enum eSkill skill) const
{
  return std::find(skill_list_.begin(), skill_list_.end(), skill) != skill_list_.end();
}

inline const Player::SkillList& Player::getSkillList() const
{
  return skill_list_;
}

inline bool Player::hasUsedSkill(enum eSkill skill) const
{
  return std::find(used_skill_list_.begin(), used_skill_list_.end(), skill) != used_skill_list_.end();
}

inline void Player::useSkill(enum eSkill skill)
{
  used_skill_list_.push_back(skill);
}

inline void Player::resetTurn()
{
  action_ = ACT_UNASSIGNED;
  has_blocked_ = false;
  has_played_ = false;
  ma_remain_ = ma_;
  used_skill_list_.clear();
  will_prone_ = (status_ == STA_STUNNED);
  resetTackleZone();
}

inline const char* Player::stringify(enum eStatus status)
{
  if (STA_UNASSIGNED <= status && status <= STA_LAST)
    {
      return bb5_playerstatus_str[status];
    }
  return "Undefined player status";
}

inline const char* Player::stringify(enum eAction action)
{
  if (ACT_UNASSIGNED <= action && action <= ACT_LAST)
    {
      return bb5_action_str[action];
    }
  return "Undefined action";
}

inline const char* Player::stringify(enum eEffort effort)
{
  if (EFF_UNASSIGNED <= effort && effort <= EFF_LAST)
    {
      return bb5_effort_str[effort];
    }
  return "Undefined effort";
}

inline const char* Player::stringify(enum eSkill skill)
{
  if (SK_UNASSIGNED <= skill && skill <= SK_LAST)
    {
      return bb5_skill_str[skill];
    }
  return "Undefined skill";
}

inline std::ostream& operator<< (std::ostream& os, const Player& p)
{
  p.printDebug(os);
  return os;
}

inline void Player::printDebug(std::ostream& os) const
{
  os << "Player `" << id_ << "' (team `" << team_id_ << "') - " << name_ << std::endl;

  if (status_ != STA_STANDING && status_ != STA_PRONE && status_ != STA_STUNNED)
    os << "  coordinates   : out of the field" << std::endl;
  else
    os << "  coordinates   : " << coord_ << std::endl;

  os << "  carateristics : ma: " << ma_ << " | "
     << "st: " << st_ << " | "
     << "ag: " << ag_ << " | "
     << "av: " << av_ << std::endl;
    
  if (!skill_list_.empty())
    {
      os << "  skills        : ";
      Player::SkillList::const_iterator it, itused;
      for (it = skill_list_.begin(); it != skill_list_.end(); it++)
        {
          if (it != skill_list_.begin())
        os << " | ";
          os << stringify(*it);
          for (itused = used_skill_list_.begin();
              itused != used_skill_list_.end(); itused++)
            {
              if ((*itused) == (*it))
                {
                  os << " (used)";
                  break;
                }
            }
        }
      os << std::endl;
    }

  os
    << "  action        : " << stringify(action_) << std::endl
    << "  has blocked   : " << (has_blocked_ ? "yes" : "no") << std::endl
    << "  has played    : " << (has_played_ ? "yes" : "no") << std::endl
    << "  has tackle z. : " << (has_tackle_zone_ ? "yes" : "no") << std::endl
    << "  ma remain     : " << ma_remain_ << std::endl
    << "  status        : " << stringify(status_) << std::endl
    << "  will prone    : " << (has_played_ ? "yes" : "no") << std::endl;
}

inline bool Player::hasTackleZone() const
{
  return has_tackle_zone_;
}

inline void Player::lostTackleZone()
{
  has_tackle_zone_=false;
}

inline void Player::resetTackleZone()
{
  has_tackle_zone_=true;
}