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

#include "Ball.hh"
#include "Dice.hh"

#define CHECK_TEAM                              \
{                                               \
  if (selected_team_ == NULL)                   \
    return BAD_TEAM;                            \
}

#define CHECK_PLAYER                            \
{                                               \
  if (selected_player_ == NULL)                 \
    return BAD_PLAYER;                          \
}

#define CHECK_COORD(X, Y)                         \
{                                               \
  if (X < 0 || X >= COLS || Y < 0 || Y >= ROWS) \
    return BAD_ARGUMENT;                        \
}



inline Api::Api(CRules* rules)
  : BaseApi<CRules>(rules),
    selected_team_(NULL),
    selected_player_(NULL),
    skilled_player_(NULL),
    player_path_(NULL)
{
  for (int i = 0; i < ACT_LAST; i++)
    possible_actions_[i] = false;
  for (int i = 0; i < EFF_LAST; i++)
    possible_efforts_[i] = false;
}

inline Api::~Api()
{
}

/*
** Requests
*/

inline int Api::doEndTurn()
{
  assert(rules_->getState() != GS_WAIT);
  rules_->countRequestSending();
  rules_->sendPacket(MsgEndTurn());
  return SUCCESS;
}

inline int Api::doCalmDown()
{
  assert(rules_->getState() != GS_WAIT);
  if (rules_->getState() != GS_TOUCHDOOOWN)
    {
      LOG2("You do not have to stop fidgeting. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  rules_->countQueryProcessed();
  rules_->sendPacket(MsgTouchdooown());
  return SUCCESS;
}

inline int Api::doCelebrate()
{
  assert(rules_->getState() != GS_WAIT);
  if (rules_->getState() != GS_CELEBRATE)
    {
      LOG2("There is nothing to celebrate. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  rules_->countQueryProcessed();
  rules_->sendPacket(MsgEndGame());
  return SUCCESS;
}

inline int Api::doMoveTurnMarker()
{
  assert(rules_->getState() != GS_WAIT);
  rules_->sendPacket(MsgMoveTurnMarker());
  return SUCCESS;
}

inline int Api::doAskIllegalProcedure()
{
  assert(rules_->getState() != GS_WAIT);
  rules_->sendPacket(MsgIllegalProc());
  return SUCCESS;
}

inline int Api::doChooseKickoff(bool kickoff)
{
  assert(rules_->getState() != GS_WAIT);
  if (rules_->getState() != GS_DRAWKICKER)
    {
      LOG2("You do not have the choice of who will kick off. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  MsgDrawKicker pkt;
  pkt.kickoff = (kickoff ? 1 : 0);
  rules_->countQueryProcessed();
  rules_->sendPacket(pkt);
  return SUCCESS;
}

inline int Api::doPlacePlayer(const Coordinates& coord)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  if (rules_->getState() != GS_INITKICKOFF)
    {
      LOG2("It's not the right moment to place player #%1 on the field. (%2)",
          selected_player_->getId(), gameStateString());
      return INVALID_REQUEST;
   }
 
  MsgPlayerCoord pkt;
  pkt.player_id = selected_player_->getId();
  pkt.col = coord.col;
  pkt.row = coord.row;
  rules_->sendPacket(pkt);

  return SUCCESS;
}

inline int Api::doPlaceTeam(int formation_id)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);

  if (rules_->getState() != GS_INITKICKOFF)
    {
      LOG2("It's not the right moment to place our team on the field. (%1)", gameStateString());
      return INVALID_REQUEST;
    }
  if (formation_id < 1 || 4 < formation_id)
    {
      LOG2("`%1' is not a valid formation identifier.", formation_id);
      return INVALID_REQUEST;
    }

  MsgPlayerCoord pkt;
  for (int player_id = 1; player_id <= MAX_PLAYER; player_id++)
    if (rules_->our_team_->getPlayer(player_id) != NULL
        && rules_->our_team_->getPlayer(player_id)->getStatus() == STA_STANDING)
      {
        pkt.player_id = player_id;
        pkt.col = -1;
        pkt.row = -1;
        rules_->sendPacket(pkt);
      }
  rules_->our_team_->placeTeam(formation_id);
  return SUCCESS;
}

inline int Api::doEndPlacement()
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);

  if (rules_->getState() != GS_INITKICKOFF)
    {
      LOG2("It's not the right moment to end team placement. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  MsgInitKickoff pkt;
  pkt.place_team = 1;
  rules_->countQueryProcessed();
  rules_->sendPacket(pkt);

  return SUCCESS;
}

inline int Api::doPlaceBall(const Coordinates& coord)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);

  if (rules_->getState() != GS_KICKOFF)
    {
      LOG2("This is not the right moment to kick the ball. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  if (!rules_->match_->getField()->intoField(coord))
    {
      LOG2("Kick-off rejected. Ball is not into the field: %1.", coord);
      return INVALID_REQUEST;
    }
  if ((rules_->getCoachId() == 0 && coord.row < 13)
      || (rules_->getCoachId() == 1 && coord.row > 12))
    {
      LOG2("Kick-off rejected. Ball is in your part of the field: %1.", coord);
      return INVALID_REQUEST;
    }
  MsgBallCoord pkt;
  pkt.row = coord.row;
  pkt.col = coord.col;
  rules_->countQueryProcessed();
  rules_->sendPacket(pkt);

  return SUCCESS;
}

inline int Api::doGiveBall(int player_id)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);

  if (rules_->getState() != GS_TOUCHBACK)
    {
      LOG2("There is no touchback. (%1)", gameStateString());
      return INVALID_REQUEST;
    }

  const CPlayer* player = getPlayer(player_id);
  if (player == NULL)
    {
      LOG2("Player `%1' does not exist.", player_id);
      return BAD_PLAYER;
    }

  if (player->getStatus() != STA_STANDING)
    {
      LOG2("Player `%1' can't carry the ball. (%2)", player_id, player->getStatus());
      return INVALID_REQUEST;
    }
  MsgBallOwner pkt;
  pkt.player_id = player_id;
  rules_->countQueryProcessed();
  rules_->sendPacket(pkt);
  return SUCCESS;
}

inline int Api::doReroll(bool reroll)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  if (rules_->getState() != GS_REROLL && rules_->getState() != GS_BLOCK)
    {
      LOG2("Cannot do reroll nor accept (no dice to reroll). (%1)", gameStateString());
      return INVALID_REQUEST;
    }
  if (reroll && !rules_->our_team_->canUseReroll())
    {
      LOG2("Cannot use reroll (no one left or already use one this turn).");
      return INVALID_REQUEST;
    }

  MsgReroll msg(rules_->getCoachId());
  msg.reroll = reroll;
  rules_->countQueryProcessed();
  rules_->sendPacket(msg);
  return SUCCESS;
}

inline int Api::doUseSkill(enum eSkill skill, bool useIt)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);

  if (skilled_player_ == NULL)
    return BAD_PLAYER;
  if (!skilled_player_->hasSkill(skill))
    {
      LOG2("Player %1 of team %2 doesn't have the skill %3.", skilled_player_->getId(),
          skilled_player_->getTeamId(), Player::stringify(skill));
      return INVALID_REQUEST;
    }
  if (rules_->getState() != GS_REROLL && rules_->getState() != GS_SKILL)
    {
      LOG2("Cannot use the skill %1 or not now.", Player::stringify(skill));
      return INVALID_REQUEST;
    }
  if (rules_->getState() == GS_REROLL && !useIt)
    {
      LOG2("Use Api::doReroll(false) in order to accept a roll result.");
      return INVALID_REQUEST;
    }

  MsgSkill msg(rules_->getCoachId());
  msg.player_id = skilled_player_->getId();
  msg.skill = skill;
  msg.choice = (useIt ? 1 : 0 );
  rules_->countQueryProcessed();
  rules_->sendPacket(msg);
  return SUCCESS;
}

inline int Api::doBeginAction(enum eAction action)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  if (action == ACT_UNASSIGNED)
    {
      LOG2("Cannot begin an unassigned action for player #%1.",
          selected_player_->getId());
      return INVALID_REQUEST;
    }
  return rules_->our_team_->beginAction(selected_player_, action);
}

inline int Api::doEndAction()
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  return rules_->our_team_->endAction();
}

inline int Api::doChooseBlockDice(int n)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  if (rules_->getState() != GS_BLOCK && rules_->getState() != GS_REROLL)
    {
      LOG2("You do not have the choice of which block dice to apply.");
      return INVALID_REQUEST;
    }
  if (rules_->getState() == GS_REROLL)
    {
      rules_->sq_->storeBlockDiceChoice(n);
      MsgReroll msgr;
      msgr.reroll = false;
      rules_->countQueryProcessed();
      rules_->sendPacket(msgr);
    }
  else // GS_BLOCK
    {
      MsgBlockDice msg(rules_->getCoachId());
      msg.dice = n;
      rules_->countQueryProcessed();
      rules_->sendPacket(msg);
    }
  return SUCCESS;
}

inline int Api::doBlockPush(int n)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  if (rules_->getState() != GS_PUSH)
    {
      LOG2("You do not have the choice of which square to push in.");
      return INVALID_REQUEST;
    }
  MsgBlockPush msg(rules_->getCoachId());
  msg.chosen_square = n;
  rules_->countQueryProcessed();
  rules_->sendPacket(msg);
  return SUCCESS;
}

inline int Api::doFollow(bool follow)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  if (rules_->getState() != GS_FOLLOW)
    {
      LOG2("You do not have the choice to follow or not.");
      return INVALID_REQUEST;
    }
  MsgFollow msg(rules_->getCoachId());
  msg.follow = follow;
  rules_->countQueryProcessed();
  rules_->sendPacket(msg);
  return SUCCESS;
}

inline int Api::doEffort(enum eEffort effort, const Coordinates& to)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  switch(effort)
    {
    case EFF_STANDUP:
      return selected_player_->standUp();
      break;
    case EFF_MOVE:
      return selected_player_->move(to);
      break;
    case EFF_BLOCK:
        {
          CPlayer* opponent = rules_->getMatch()->getField()->getPlayer(to);
          return selected_player_->block(opponent);
        }
      break;
    case EFF_FOUL:
        {
          CPlayer* opponent = rules_->getMatch()->getField()->getPlayer(to);
          return selected_player_->foul(opponent);
        }
      break;
    case EFF_HANDOFF:
        {
          CPlayer* target = rules_->getMatch()->getField()->getPlayer(to);
          return selected_player_->handoff(target);
        }
      break;
    case EFF_THROW:
      return selected_player_->pass(to);
      break;
    default:
      LOG2("Cannot perform unknown effort %1 for player #%2.",
          effort, selected_player_->getId());
      return INVALID_REQUEST;
      break;
    }
}

inline int Api::doStandUpPlayer()
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  return selected_player_->standUp();
}

inline int Api::doMovePlayer(const Coordinates& to)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  return selected_player_->move(to);
}

inline int Api::doBlockPlayer(int def_p)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  CPlayer* opponent = rules_->other_team_->getPlayer(def_p);
  return selected_player_->block(opponent);
}

inline int Api::doPassPlayer(const Coordinates& to)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  return selected_player_->pass(to);
}

inline int Api::sendChatMessage(const std::string& msg)
{
  if (rules_->getState() == GS_WAIT)
    return BAD_ARGUMENT;

  MsgChat pkt;
  stringToPacket(pkt.msg, msg, sizeof(pkt.msg));
  rules_->sendPacket(pkt);
  return SUCCESS;
}

inline int Api::sendDebugRequest()
{
  if (rules_->getState() == GS_WAIT)
    return BAD_ARGUMENT;

  Log::getDefaultInst()->getStream() << *rules_ << std::flush;

  rules_->sendPacket(MsgDebug());
  return SUCCESS;
}

inline int Api::doCheatDice(int roll)
{
  if (rules_->getState() == GS_WAIT)
    return BAD_ARGUMENT;

  MsgCheatDice pkt;
  pkt.next_result = roll;
  rules_->sendPacket(pkt);
  return SUCCESS;
}


/*
** Accessors, for the game
*/

inline int Api::turn() const
{
  return rules_->match_->getTurn();
}

inline int Api::half() const
{
  return rules_->match_->getHalf();
}

inline int Api::getActiveTeamId() const
{
  return rules_->match_->getActiveTeamId();
}

inline int Api::myTeamId() const
{
  return rules_->getCoachId();
}

inline Coordinates Api::ball() const
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  return rules_->match_->getBall()->getCoordinates();
}

inline const CPlayer* Api::getBallOwner() const
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  return rules_->match_->getBall()->getOwner();
}

inline int Api::teamId(const Coordinates& coord)
{
  CHECK_COORD(coord.col, coord.row);
  CPlayer* p = rules_->match_->getField()->getPlayer(coord);
  if (p != NULL)
    return p->getTeamId();
  return -1;
}

inline int Api::playerId(const Coordinates& coord)
{
  CHECK_COORD(coord.col, coord.row);
  CPlayer* p = rules_->match_->getField()->getPlayer(coord);
  if (p != NULL)
    return p->getId();
  return -1;
}

inline int Api::selectTeam(int team_id)
{
  if (rules_->getState() == GS_WAIT ||
      (team_id != 0 && team_id != 1))
    return BAD_ARGUMENT;

  selected_team_ = NULL;
  selected_player_ = NULL;
  
  if (team_id != 0 && team_id != 1)
    return BAD_ARGUMENT;

  selected_team_ = rules_->match_->getTeam(team_id);
  return SUCCESS;
}

inline int Api::selectPlayer(int player_id)
{
  CHECK_TEAM;
  selected_player_ = selected_team_->getPlayer(player_id);
  return selected_player_ == NULL ? BAD_PLAYER : SUCCESS;
}

inline int Api::selectSkilledPlayer(int player_id)
{
  skilled_player_ = rules_->our_team_->getPlayer(player_id);
  return skilled_player_ == NULL ? BAD_PLAYER : SUCCESS;
}

inline int Api::actionPossibleNumber()
{
  CHECK_TEAM;
  CHECK_PLAYER;

  if (selected_player_->hasPlayed())
    return 0;
  if (selected_player_->getAction() != ACT_UNASSIGNED)
    return 0;
  if (selected_player_->getStatus() != STA_STANDING
      && selected_player_->getStatus() != STA_PRONE)
    return 0;

  int number = ACT_LAST;
  for (int i = 0; i < ACT_LAST; i++)
    possible_actions_[i] = true;

  if (selected_player_->getStatus() == STA_PRONE ||
      !(rules_->match_->getField()->hasAdjacentPlayer(
          selected_player_->getCoordinates(),
          STA_STANDING,
          rules_->other_team_->getTeamId())))
    {
      number --;
      possible_actions_[ACT_BLOCK - 1] = false;
    }
  for (int i = 0; i < ACT_LAST; i++)
    {
      if (selected_team_->hasDoneAction(static_cast<enum eAction>(i + 1)) &&
          ((i + 1) == ACT_BLITZ ||
           (i + 1) == ACT_FOUL ||
           (i + 1) == ACT_PASS ||
           (i + 1) == ACT_TRANSMIT))
        {
          number --;
          possible_actions_[i] = false;
        }
    }
  return number;
}

inline int Api::actionPossible(int index) const
{
  if (index < 0 || ACT_LAST <= index)
    return BAD_ARGUMENT;

  int action = ACT_UNASSIGNED;
  while (index >= 0)
    {
      action ++;
      if (action > ACT_LAST)
        return BAD_ARGUMENT;
      else if (possible_actions_[action - 1])
        index --;
    }
  return action;
}

inline int Api::effortPossibleNumber()
{
  CHECK_TEAM;
  CHECK_PLAYER;

  if (selected_player_->hasPlayed())
    return 0;
  if (selected_player_->getAction() == ACT_UNASSIGNED)
    return 0;
  if (selected_player_->getStatus() != STA_STANDING
      && selected_player_->getStatus() != STA_PRONE)
    return 0;

  int number = 0;
  for (int i = 0; i < EFF_LAST; i++)
    possible_efforts_[i] = false;

  if (selected_player_->getStatus() == STA_PRONE)
    {
      if (selected_player_->getAction() != ACT_BLOCK
          && selected_player_->getMaRemain() > 0)
        {
          number ++;
          possible_efforts_[EFF_STANDUP - 1] = true;
        }
      return number;
    }
  
  if (selected_player_->getAction() != ACT_BLOCK
      && selected_player_->getMaRemain() > 0
      && rules_->match_->getField()->hasAdjacentEmptySquare(selected_player_->getCoordinates()))
    {
      number ++;
      possible_efforts_[EFF_MOVE - 1] = true;
    }
  if ((selected_player_->getAction() == ACT_BLOCK
        || selected_player_->getAction() == ACT_BLITZ)
      && !(selected_player_->hasBlocked())
      && selected_player_->getMaRemain() > 0
      && rules_->match_->getField()->hasAdjacentPlayer(
        selected_player_->getCoordinates(),
        STA_STANDING,
        rules_->other_team_->getTeamId()))
    {
      number ++;
      possible_efforts_[EFF_BLOCK - 1] = true;
    }
  if (selected_player_->getAction() == ACT_FOUL
      && (!selected_player_->hasPlayed())
      && (rules_->match_->getField()->hasAdjacentPlayer(
          selected_player_->getCoordinates(), STA_PRONE,
          rules_->other_team_->getTeamId()) ||
        rules_->match_->getField()->hasAdjacentPlayer(
          selected_player_->getCoordinates(), STA_STUNNED,
          rules_->other_team_->getTeamId())))
    {
      number ++;
      possible_efforts_[EFF_FOUL - 1] = true;
    }
  if (selected_player_->getAction() == ACT_TRANSMIT
       && selected_player_ == rules_->match_->getBall()->getOwner()
       && (rules_->match_->getField()->hasAdjacentPlayer(
           selected_player_->getCoordinates(), STA_STANDING,
           rules_->our_team_->getTeamId()) ||
         rules_->match_->getField()->hasAdjacentPlayer(
           selected_player_->getCoordinates(), STA_STANDING,
           rules_->other_team_->getTeamId())))
    {
      number ++;
      possible_efforts_[EFF_HANDOFF - 1] = true;
    }
  if (selected_player_->getAction() == ACT_PASS
       && selected_player_ == rules_->match_->getBall()->getOwner())
    {
      number ++;
      possible_efforts_[EFF_THROW - 1] = true;
    }
  return number;
}

inline int Api::effortPossible(int index) const
{
  if (index < 0 || EFF_LAST <= index)
    return BAD_ARGUMENT;

  int effort = EFF_UNASSIGNED;
  while (index >= 0)
    {
      effort ++;
      if (effort > EFF_LAST)
        return BAD_ARGUMENT;
      else if (possible_efforts_[effort - 1])
        index --;
    }
  return effort;
}

inline int Api::isEffortPossible(int effort) const
{
  if (effort <= EFF_UNASSIGNED || EFF_LAST < effort)
    return BAD_ARGUMENT;

  return (possible_efforts_[effort - 1]) ? 1 : 0;
}

inline int Api::moveLength(const Coordinates& to)
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_COORD(to.col, to.row);

  player_path_ = &rules_->match_->getField()->getPath(selected_player_->getCoordinates(),
                                          to,
                                          selected_player_);
  return player_path_->size();
}

inline int Api::moveDifficulty(int step)
{
  if (player_path_ == NULL || step < 0 || step >= (int)player_path_->size())
    return BAD_ARGUMENT;

  Coordinates from_coord = (step == 0)
    ? selected_player_->getCoordinates()
    : ((*player_path_)[step - 1]);
  int nbTZFrom = rules_->match_->getField()->getNbTackleZones(
      1 - selected_team_->getTeamId(), from_coord);
  if (nbTZFrom == 0)
    return 0;

  Coordinates dest_coord = (*player_path_)[step];
  int tzDestMalus;
  if (selected_player_->hasSkill(SK_STUNTY))
    tzDestMalus = 0;
  else
    tzDestMalus = rules_->match_->getField()->getTackleZonesMalus(
        1 - selected_team_->getTeamId(), dest_coord);
  return (7 - std::min(selected_player_->getAg(), 6)) + tzDestMalus - 1;
}

inline Coordinates Api::movePath(int step)
{
  if (player_path_ == NULL || step < 0 || step >= (int)player_path_->size())
    return Coordinates(-1, -1);

  return (*player_path_)[step];
}

inline int Api::movePossible(const Coordinates& to)
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_COORD(to.col, to.row);

  // FIXME: do a better implementation.
  return rules_->match_->getField()->getPath(selected_player_->getCoordinates(),
                                 to,
                                 selected_player_).empty() ? 0 : 1;
}

inline int Api::blockDicesNumber(const Coordinates& to) const
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_COORD(to.col, to.row);

  if (!to.isNear(selected_player_->getCoordinates()))
    return INVALID_REQUEST;

  CPlayer* p = rules_->match_->getField()->getPlayer(to);
  if (p == NULL || p->getStatus() != STA_STANDING
      || p->getTeamId() == selected_player_->getTeamId())
    return INVALID_REQUEST;

  int dices = rules_->match_->getField()->getNbBlockDices(selected_player_->getCoordinates(), to);
  if (dices == 0) { ERR("target undefined or synchronisation error between field and players"); }

  return blockDicesNumberPadding() + dices;
}

inline int Api::blockDicesNumberPadding() const
{
  return 4;
}

inline int Api::throwDifficulty(const Coordinates& to) const
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_COORD(to.col, to.row);

  // FIXME: Factorize the code to common/ since SPlayer uses the same.
  float distance = to.distance(rules_->match_->getBall()->getCoordinates());
  if (selected_player_ != rules_->match_->getBall()->getOwner()
    || distance == 0.f || distance >= 16.f) 
    {
      return INVALID_REQUEST;
    }
  return 7 - std::min(5, std::max(1,
        selected_player_->getAg()
        + (distance < 4.f ? 1 :   // quick pass
          distance < 8.f ? 0 :    // short pass
          distance < 12.f ? -1 :  // long pass
          -2)                     // bomb
        - rules_->match_->getField()->getNbTackleZones(
          1 - selected_team_->getTeamId(),
          selected_player_->getCoordinates())
        + (selected_player_->hasSkill(SK_STRONGARM) && distance >= 4.f ? 1 : 0)
        - (selected_player_->hasSkill(SK_STUNTY) ? 1 : 0)));
}

inline int Api::remainingTime() const
{
  assert(rules_->getState() != GS_WAIT);
  int ta = rules_->match_->getTimer().getAllowedTime();
  int tr = rules_->match_->getTimer().getTimeRemaining();
  return (tr < 0 || tr > ta) ? 0 : tr;
}

inline int Api::isTimerPaused() const
{
  return rules_->match_->getTimer().isPaused() ? 1 : 0;
}

inline const char* Api::gameStateString() const
{
  return Match<CPlayer>::stringifyGameState(rules_->getState());
}

inline int Api::canMakeRequest() const
{
  return ((rules_->nb_requests_sent_ == 0) ? 1 : 0);
}

inline int Api::mustMakeChoice() const
{
  return ((rules_->nb_server_queries_ > 0) ? 1 : 0);
}

inline const CTeam* Api::getTeam() const
{
  return selected_team_;
}

inline const CPlayer* Api::getPlayer() const
{
  return selected_player_;
}

inline const CPlayer* Api::getPlayer(int player_id)
{
  if (selected_team_ == NULL)
    return NULL;
  return selected_team_->getPlayer(player_id);
}

inline const CPlayer* Api::getPlayer(const Coordinates& coord)
{
  return rules_->match_->getField()->getPlayer(coord);
}

inline const CPlayer* Api::getActivePlayer() const
{
  CTeam* t;
  if (rules_->match_->getActiveTeamId() == rules_->getCoachId())
    t = rules_->our_team_;
  else if (rules_->match_->getActiveTeamId() == ((rules_->getCoachId() + 1) % 2))
    t = rules_->other_team_;
  else
    return NULL;
  return t->getPlayer(t->getActivePlayerId());
}

inline const Weather* Api::getWeather() const
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  return rules_->match_->getWeather();
}