SPlayerMsg.hxx

/*
** TowBowlTactics, a turn-based strategy football game.
** 
** Copyright (C) 2007-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 "SMatch.hh"
#include "SPlayer.hh"

inline SPlayer* SPlayerMsg::getPlayer(int token, int team_id, int player_id)
{
  if (team_id < 0 || team_id > 1 ||
      player_id < 1 || player_id > MAX_PLAYER ||
      p_[team_id][player_id - 1] == NULL)
    {
      LOG3("Token `%1' is addressed to non-existent player `%2' of team `%3'.",
          r_->stringifyToken(token), player_id, team_id);
      r_->sendIllegal(token, team_id, ERR_NONEXISTENTPLAYER);
      return NULL;
    }
  return p_[team_id][player_id - 1];
}

/*
** Messages senders.
*/

inline void SPlayerMsg::sendAction(enum eAction action, const SPlayer* p) const
{
  MsgAction m(p->getTeamId());
  m.player_id = p->getId();
  m.action = action;
  r_->sendPacket(m);
}

inline void SPlayerMsg::sendMsgBlockPush(int nb_squares,
    const Coordinates squares[], const SPlayer* target, int chosen_square) const
{
  MsgBlockPush pkt(r_->getMatch()->getCurrentTeamId());
  pkt.target_row = target->getCoordinates().row;
  pkt.target_col = target->getCoordinates().col;
  pkt.nb_squares = nb_squares;
  for (int i = 0; i < nb_squares; i++)
    {
      pkt.squares[i].row = squares[i].row;
      pkt.squares[i].col = squares[i].col;
    }
  pkt.chosen_square = chosen_square;
  if (chosen_square == -1 && nb_squares > 1)
    r_->getMatch()->waitForCurrentOpponentChoice(pkt.client_id);
  r_->sendPacket(pkt);
}

inline void SPlayerMsg::sendMsgKnocked(const SPlayer* p) const
{
  MsgPlayerKnocked pkt(p->getTeamId());
  pkt.player_id = p->getId();
  r_->sendPacket(pkt);
}

inline void SPlayerMsg::sendCoordinates(const Coordinates& old_coord, const SPlayer* p) const
{
  MsgPlayerCoord pkt(p->getTeamId());
  pkt.player_id = p->getId();
  pkt.old_row = old_coord.row;
  pkt.old_col = old_coord.col;
  pkt.row = p->getCoordinates().row;
  pkt.col = p->getCoordinates().col;
  r_->sendPacket(pkt);
}

inline void SPlayerMsg::sendMaRemain(int old_ma_remain,
                                     int new_ma_remain, const SPlayer* p) const
{
  MsgPlayerMaRemain msg(p->getTeamId());
  msg.player_id = p->getId();
  msg.old_ma_remain = old_ma_remain;
  msg.new_ma_remain = new_ma_remain;
  r_->sendPacket(msg);
}

inline void SPlayerMsg::sendBlockResult(bool can_reroll, int dice_chooser_id, int nb_dices,
    const enum eBlockDiceFace results[], const SPlayer* defender, const SPlayer* attacker) const
{
  MsgBlockResult msg(attacker->getTeamId());
  msg.player_id = attacker->getId();
  msg.opponent_id = defender->getId();
  msg.reroll = can_reroll;
  msg.dice_chooser_id = dice_chooser_id;
  msg.nb_dices = nb_dices;
  for (int i = 0; i < nb_dices; ++i)
    msg.results[i] = results[i];
  if (can_reroll)
    r_->getMatch()->waitForCurrentOpponentChoice(attacker->getTeamId());
  else if (nb_dices > 1)
    r_->getMatch()->waitForCurrentOpponentChoice(dice_chooser_id);
  r_->sendPacket(msg);
}

inline void SPlayerMsg::sendRoll(enum eRoll type, int result, int modifier,
    int required, int reroll, enum eSkill skill, const SPlayer* p) const
{
  MsgResult msg(p->getTeamId());
  msg.player_id = p->getId();
  msg.roll_type = type;
  msg.result = result;
  msg.modifier = modifier;
  msg.required = required;
  msg.reroll = reroll;
  msg.skill = skill;
  if (reroll || (skill != SK_UNASSIGNED))
    r_->getMatch()->waitForCurrentOpponentChoice(msg.client_id);
  r_->sendPacket(msg);
}

inline void SPlayerMsg::sendSkillQuestion(enum eSkill skill, const SPlayer* p) const
{
  MsgSkill msg(p->getTeamId());
  msg.player_id = p->getId();
  msg.skill = skill;
  msg.choice = -1;
  r_->getMatch()->waitForCurrentOpponentChoice(msg.client_id);
  r_->sendPacket(msg);
}

inline void SPlayerMsg::sendSkillUsage(enum eSkill skill, const SPlayer* p) const
{
  MsgSkill msg(p->getTeamId());
  msg.player_id = p->getId();
  msg.skill = skill;
  msg.choice = 1;
  r_->sendPacket(msg);
}

inline void SPlayerMsg::sendStatus(enum eStatus old_status,
                                   enum eStatus new_status, const SPlayer* p) const
{
  MsgPlayerStatus pkt(p->getTeamId());
  pkt.player_id = p->getId();
  pkt.old_status = old_status;
  pkt.status = new_status;
  r_->sendPacket(pkt);
}

inline void SPlayerMsg::sendTouchdooown(const SPlayer* p) const
{
  MsgTouchdooown msg(p->getTeamId());
  msg.player_id = p->getId();
  r_->sendPacket(msg);
}