Api.hxx

/*
** TowBowlTactics, an adaptation of the tabletop game Blood Bowl.
**
** Copyright (C) 2006, 2007 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 "Dice.hh"

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

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

#define CHECK_POS(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)
{
  for (int i = 0; i < DCL_LAST; i++)
    possible_declarations_[i] = false;
  for (int i = 0; i < ACT_LAST; i++)
    possible_actions_[i] = false;
}

inline Api::~Api()
{
}

/*
** Actions
*/

inline void Api::doEndTurn()
{
  rules_->sendPacket(MsgEndTurn());
}

inline void Api::doMoveTurnMarker()
{
  rules_->sendPacket(MsgMoveTurnMarker());
}

inline void Api::doAskIllegalProcedure()
{
  rules_->sendPacket(MsgIllegalProc());
}

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_ACTION;
    }

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

inline int Api::doPlacePlayer(const Point& pos)
{
  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_ACTION;
    }

  Position player_pos(pos);
  MsgPlayerPos pkt;
  pkt.player_id = selected_player_->getId();
  pkt.col = player_pos.col;
  pkt.row = player_pos.row;
  rules_->sendPacket(pkt);

  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_ACTION;
    }

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

  return SUCCESS;
}

inline int Api::doPlaceBall(const Point& pos)
{
  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_ACTION;
    }

  Position bpos(pos);
  if (!rules_->field_->intoField(bpos))
    {
      LOG2("Kick-off rejected. Ball is not into the field: %1.", pos);
      return INVALID_ACTION;
    }
  if ((rules_->getCoachId() == 0 && bpos.row < 13)
      || (rules_->getCoachId() == 1 && bpos.row > 12))
    {
      LOG2("Kick-off rejected. Ball is in your part of the field: %1.", pos);
      return INVALID_ACTION;
    }
  MsgBallPos pkt;
  pkt.row = bpos.row;
  pkt.col = bpos.col;
  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_ACTION;
    }

  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_ACTION;
    }
  MsgGiveBall pkt;
  pkt.player_id = player_id;
  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_ACTION;
    }
  if (reroll && !selected_team_->canUseReroll())
    {
      LOG2("Cannot use reroll (no one left or already use one this turn).");
      return INVALID_ACTION;
    }

  MsgReroll msg(rules_->our_team_->getTeamId());
  msg.reroll = reroll;
  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_ACTION;
    }
  if (rules_->getState() != GS_REROLL && rules_->getState() != GS_SKILL)
    {
      LOG2("Cannot use the skill %1 or not now.", Player::stringify(skill));
      return INVALID_ACTION;
    }
  if (rules_->getState() == GS_REROLL && !useIt)
    {
      LOG2("Use Api::doReroll(false) in order to accept a roll result.");
      return INVALID_ACTION;
    }

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

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

  if (action == DCL_UNASSIGNED)
    {
      LOG2("You can't declare an empty action for player #%1.", selected_player_->getId());
      return INVALID_ACTION;
    }
  return rules_->our_team_->declareAction(selected_player_, action);
}

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_ACTION;
    }
  if (rules_->getState() == GS_REROLL)
    {
      MsgReroll msgr;
      msgr.reroll = false;
      rules_->sendPacket(msgr);
    }
  MsgBlockDice msg(rules_->our_team_->getTeamId());
  msg.dice = n;
  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_ACTION;
    }
  MsgBlockPush msg(rules_->our_team_->getTeamId());
  msg.square_chosen = n;
  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_ACTION;
    }
  MsgFollow msg(rules_->our_team_->getTeamId());
  msg.follow = follow;
  rules_->sendPacket(msg);
  return SUCCESS;
}

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 Point& 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 Point& to)
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  CHECK_TEAM;
  CHECK_PLAYER;

  return selected_player_->pass(to);
}

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

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

inline void Api::doCheatDice(int roll)
{
  MsgCheatDice pkt;
  pkt.next_result = roll;
  rules_->sendPacket(pkt);
}


/*
** Accessors, for the game
*/

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

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

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

inline Point Api::ball() const
{
  assert(rules_->getState() != GS_WAIT && rules_->getState() != GS_INITGAME);
  return rules_->ball_->getPosition();
}

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

inline int Api::teamId(const Point& pos)
{
  CHECK_POS(pos.x, pos.y);
  CPlayer* p = rules_->field_->getPlayer(pos);
  if (p != NULL)
    return p->getTeamId();
  return -1;
}

inline int Api::playerId(const Point& pos)
{
  CHECK_POS(pos.x, pos.y);
  CPlayer* p = rules_->field_->getPlayer(pos);
  if (p != NULL)
    return p->getId();
  return -1;
}

inline void Api::selectTeam(int team_id)
{
  selected_team_ = NULL;
  selected_player_ = NULL;

  if (rules_->getState() == GS_WAIT)
    return;
  if (team_id == US || (team_id <= 1 && team_id == rules_->getCoachId()))
    selected_team_ = rules_->our_team_;
  if (team_id == THEM || ((team_id == 0 || team_id == 1) && team_id != rules_->getCoachId()))
    selected_team_ = rules_->other_team_;
}

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::declarationPossibleNumber()
{
  CHECK_TEAM;
  CHECK_PLAYER;

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

  int number = DCL_LAST;
  for (int i = 0; i < DCL_LAST; i++)
    possible_declarations_[i] = true;

  if (selected_player_->getStatus() == STA_PRONE ||
      !(rules_->getField()->hasAdjacentPlayer(
          selected_player_->getPosition(),
          STA_STANDING,
          rules_->other_team_->getTeamId())))
    {
      number --;
      possible_declarations_[DCL_BLOCK] = false;
    }
  if (selected_team_->hasDoneBlitz())
    {
      number --;
      possible_declarations_[DCL_BLITZ] = false;
    }
  if (selected_team_->hasDonePass())
    {
      number --;
      possible_declarations_[DCL_PASS] = false;
    }
  return number;
}

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

  int declared_action = DCL_UNASSIGNED;
  while (index >= 0)
    {
      declared_action ++;
      if (declared_action >= DCL_LAST)
        return BAD_ARGUMENT;
      else if (possible_declarations_[declared_action])
        index --;
    }
  return declared_action;
}

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

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

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

  if (selected_player_->getStatus() == STA_PRONE)
    {
      if (selected_player_->getAction() != DCL_BLOCK)
        {
          number ++;
          possible_actions_[ACT_STANDUP] = true;
        }
      return number;
    }
  
  if (selected_player_->getAction() != DCL_BLOCK
      && rules_->getField()->hasAdjacentEmptySquare(selected_player_->getPosition()))
    {
      number ++;
      possible_actions_[ACT_MOVE] = true;
    }
  if ((selected_player_->getAction() == DCL_BLOCK
        || selected_player_->getAction() == DCL_BLITZ)
      && rules_->getField()->hasAdjacentPlayer(
        selected_player_->getPosition(),
        STA_STANDING,
        rules_->other_team_->getTeamId())
      && !(selected_player_->hasBlocked()))
    {
      number ++;
      possible_actions_[ACT_BLOCK] = true;
    }
  if (selected_player_->getAction() == DCL_PASS
       && selected_player_ == rules_->ball_->getOwner()
       )
    {
      number ++;
      possible_actions_[ACT_THROW] = true;
    }
  return number;
}

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

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

inline int Api::moveLength(const Point& to)
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_POS(to.x, to.y);

  player_path_ = &rules_->field_->getPath(selected_player_->getPosition(),
                                          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;

  Position step_pos((*player_path_)[step]);
  int nbt = rules_->field_->getNbTackleZones(selected_team_->getTeamId(), step_pos);
  if (nbt == 0)
    return 0;
  return (7 - std::min(selected_player_->getAg(), 6)) + nbt - 1;
}

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

  return (*player_path_)[step];
}

inline int Api::movePossible(const Point& to)
{
  CHECK_TEAM;
  CHECK_PLAYER;
  CHECK_POS(to.x, to.y);

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

inline int Api::remainingTime() const
{
  int state = rules_->getState();
  int tr;

  if (state != GS_COACH1 && state != GS_COACH2)
    return -1;
  tr = rules_->timer_.getTimeRemaining();
  return tr < 0 ? 0 : tr;
}


inline const char* Api::gameStateString() const
{
  switch (rules_->getState())
    {
    case GS_INITGAME:
      return "GS_INITGAME";
    case GS_INITHALF:
      return "GS_INITHALF";
    case GS_DRAWKICKER:
      return "GS_DRAWKICKER";
    case GS_INITKICKOFF:
      return "GS_INITKICKOFF";
    case GS_KICKOFF:
      return "GS_KICKOFF";
    case GS_COACH1:
      return "GS_COACH1";
    case GS_COACH2:
      return "GS_COACH2";
    case GS_TOUCHBACK:
      return "GS_TOUCHBACK";
    case GS_REROLL:
      return "GS_REROLL";
    case GS_BLOCK:
      return "GS_BLOCK";
    case GS_PUSH:
      return "GS_PUSH";
    case GS_FOLLOW:
      return "GS_FOLLOW";
    case GS_SKILL:
      return "GS_SKILL";
    }
  return BaseApi<CRules>::getStateString();
}

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 Point& pos)
{
  return rules_->field_->getPlayer(pos);
}

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

---