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

template <typename T>
inline Field<T>::Field()
{
  for (int i = 0; i < COLS * ROWS; i++)
    tab_[i] = NULL;
}

template <typename T>
inline Field<T>::~Field()
{
}

template <typename T>
inline bool Field<T>::intoField(const Coordinates& coord) const
{
  return coord.row >= 0 && coord.row < ROWS
    && coord.col >= 0 && coord.col < COLS;
}

template <typename T>
inline Coordinates Field<T>::dirToCoord(enum eDirection d) const
{
  switch(d)
  {
    case DIR_NORTHWEST: return Coordinates(-1, -1); break;
    case DIR_NORTH:     return Coordinates(-1,  0); break;
    case DIR_NORTHEAST: return Coordinates(-1, +1); break;
    case DIR_EAST:      return Coordinates( 0, +1); break;
    case DIR_SOUTHEAST: return Coordinates(+1, +1); break;
    case DIR_SOUTH:     return Coordinates(+1,  0); break;
    case DIR_SOUTHWEST: return Coordinates(+1, -1); break;
    case DIR_WEST:      return Coordinates( 0, -1); break;
    default:            return Coordinates( 0,  0); break;
  }
}

template <typename T>
inline void Field<T>::setPlayer(const Coordinates& coord, T* p)
{
  // Desynchronization between field and players for coordinates can be
  // _very_ critical.
  if (p != NULL && tab_[coord.row * COLS + coord.col] != NULL)
    WARN("Desynchronization bewteen field and players!");
      
  tab_[coord.row * COLS + coord.col] = p;
}

template <typename T>
inline T* Field<T>::getPlayer(const Coordinates& coord) const
{
    if (!intoField(coord))
        return NULL;
  return tab_[coord.row * COLS + coord.col];
}

template <typename T>
inline int Field<T>::getNbPlayersInOppositeHalf(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the other half of the field
  for (c.row = (1 - team_id) * (ROWS / 2);
      c.row <= (1 - team_id) * (ROWS / 2) + (ROWS / 2) - 1;
      c.row++)
    for (c.col = 0; c.col <= COLS - 1; c.col++)
      if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
        nb_players++;

  return nb_players;
}

template <typename T>
inline int Field<T>::getNbPlayersInLeftWideZone(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the left wide zone
  for (c.row = team_id * ((ROWS / 2) - 1) + 1;
      c.row <= team_id * ((ROWS / 2) - 1) + ((ROWS / 2) - 1);
      c.row++)
    for (c.col = 0; c.col <= SIDE - 1; c.col++)
      if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
        nb_players++;
  
  return nb_players;
}

template <typename T>
inline int Field<T>::getNbPlayersInRightWideZone(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the right wide zone
  for (c.row = team_id * ((ROWS / 2) - 1) + 1;
      c.row <= team_id * ((ROWS / 2) - 1) + ((ROWS / 2) - 1);
      c.row++)
    for (c.col = COLS - SIDE; c.col <= COLS - 1; c.col++)
      if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
        nb_players++;

  return nb_players;
}

template <typename T>
inline int Field<T>::getNbPlayersOnLineOfScrimmage(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the LoS
  c.row = team_id + (ROWS / 2) - 1;
  for (c.col = SIDE; c.col <= (COLS - 1) - SIDE; c.col++)
    if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
      nb_players++;

  return nb_players;
}

template <typename T>
inline int Field<T>::getNbPlayersInEndZone(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the end zone
  c.row = team_id * (ROWS - 1);
  for (c.col = 0; c.col <= COLS - 1; c.col++)
    if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
      nb_players++;

  return nb_players;
}

template <typename T>
inline int Field<T>::getNbPlayersInMiddle(int team_id) const
{
  Coordinates c;
  int nb_players = 0;

  // Check the middle of the field
  for (c.row = team_id * (ROWS / 2) + 1;
      c.row <= (team_id + 1) * (ROWS / 2) - 2;
      c.row++)
    for (c.col = SIDE; c.col <= (COLS - 1) - SIDE; c.col++)
      if (getPlayer(c) != NULL && getPlayer(c)->getTeamId() == team_id)
        nb_players++;

  return nb_players;
}

template <typename T>
inline int Field<T>::isPlacementValid(int team_id) const
{
  int n, nb_players;
  
  nb_players = getNbPlayersInOppositeHalf(team_id);
  if (nb_players > 0)
    return false;

  n = getNbPlayersInLeftWideZone(team_id);
  if (n > 2)
    return false;
  nb_players += n;

  n = getNbPlayersInRightWideZone(team_id);
  if (n > 2)
    return false;
  nb_players += n;

  nb_players += getNbPlayersInEndZone(team_id);
  nb_players += getNbPlayersInMiddle(team_id);

  n = getNbPlayersOnLineOfScrimmage(team_id);
  nb_players += n;

  // The case where the team has less than 11 players is treated in Team
  return (nb_players < 12 && (n >= 3 || n == nb_players));
}

template <typename T>
inline bool Field<T>::hasAdjacentEmptySquare(const Coordinates& coord) const
{
  Coordinates next_square;
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      next_square = coord + dirToCoord(dir);
      if (intoField(next_square)
          && getPlayer(next_square) == NULL)
        return true;
    }
  return false;
}

template <typename T>
inline CoordList Field<T>::getAdjacentEmptySquares(const Coordinates& coord) const
{
  CoordList squares;
  Coordinates next_square;
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      next_square = coord + dirToCoord(dir);
      if (intoField(next_square)
          && getPlayer(next_square) == NULL)
        squares.push_back(next_square);
    }
  return squares;
}

template <typename T>
inline bool Field<T>::hasAdjacentPlayer(const Coordinates& coord) const
{
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      if (getPlayer(coord + dirToCoord(dir)) != NULL)
        return true;
    }
  return false;
}

template <typename T>
inline bool Field<T>::hasAdjacentPlayer(const Coordinates& coord, enum eStatus s, int team_id) const
{
  T* player;
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      player = getPlayer(coord + dirToCoord(dir));
      if (player != NULL
          && player->getStatus() == s
          && player->getTeamId() == team_id)
        return true;
    }
  return false;
}

template <typename T>
inline std::vector<T*> Field<T>::getAdjacentPlayers(const Coordinates& coord) const
{
  std::vector<T*> neighbours;
  T* player;
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      player = getPlayer(coord + dirToCoord(dir));
      if (player != NULL)
        neighbours.push_back(player);
    }
  return neighbours;
}

template <typename T>
inline std::vector<T*> Field<T>::getAdjacentPlayers(const Coordinates& coord, enum eStatus s, int team_id) const
{
  std::vector<T*> neighbours;
  T* player;
  enum eDirection dir;
  for (dir = DIR_LAST; dir > DIR_UNASSIGNED; dir = static_cast<enum eDirection>(dir - 1))
    {
      player = getPlayer(coord + dirToCoord(dir));
      if (player != NULL
          && player->getStatus() == s
          && player->getTeamId() == team_id)
        neighbours.push_back(player);
    }
  return neighbours;
}

template <typename T>
inline int Field<T>::getNbTackleZones(int team_id, const Coordinates& coord) const
{
  int res = 0;
  Coordinates c;
  std::vector<T*> tacklers = getAdjacentPlayers(coord, STA_STANDING, team_id);
  for (unsigned i = 0; i < tacklers.size(); i++)
    if (tacklers[i]->hasTackleZone())
      res++;
  return res;
}

template <typename T>
inline int Field<T>::getTackleZonesMalus(int team_id, const Coordinates& coord) const
{
  int res = 0;
  Coordinates c;
  std::vector<T*> tacklers = getAdjacentPlayers(coord, STA_STANDING, team_id);
  for (unsigned i = 0; i < tacklers.size(); i++)
    if (tacklers[i]->hasTackleZone() && !tacklers[i]->hasSkill(SK_TITCHY))
      res++;
  return res;
}

template <typename T>
inline bool Field<T>::canAssist(const Coordinates& coord_assister, int team_id,
    enum eEffort effort, const Coordinates& coord_target) const
{
  return (coord_assister.isNear(coord_target)
      && getPlayer(coord_assister)->getStatus() == STA_STANDING
      && getPlayer(coord_assister)->hasTackleZone()
      && ((effort == EFF_BLOCK
          && (getPlayer(coord_assister)->hasSkill(SK_GUARD)
            || (getNbTackleZones(team_id, coord_assister) ==
              getPlayer(coord_target)->hasTackleZone())))
        || (effort == EFF_FOUL
          && (getNbTackleZones(team_id, coord_assister) ==
            getPlayer(coord_target)->hasTackleZone()))));
}

template <typename T>
inline int Field<T>::getNbAssister(const Coordinates& coord_assisted,
    int team_id, enum eEffort effort, const Coordinates& coord_target) const
{
  int res = 0;
  Coordinates c;

  for (c.row = coord_target.row - 1; c.row <= coord_target.row + 1; c.row++)
    for (c.col = coord_target.col - 1; c.col <= coord_target.col + 1; c.col++)
      if (intoField(c)
          && getPlayer(c) != NULL
          && c != coord_assisted
          && getPlayer(c)->getTeamId() == team_id
          && canAssist(c, (team_id + 1) % 2, effort, coord_target))
        res++;
  return res;
}
template <typename T>
inline int Field<T>::getNbBlockDices(const Coordinates& coord_attacker,
    const Coordinates& coord_target) const
{
  T* attacker;
  T* target;

  attacker = getPlayer(coord_attacker);
  target = getPlayer(coord_target);
  if (attacker == NULL || target == NULL) {
    return 0;
  }

  int mod_st_atk = attacker->getSt()
    + ((attacker->hasSkill(SK_HORNS) && attacker->getAction() == ACT_BLITZ) ? 1 : 0)
    + getNbAssister(coord_attacker, attacker->getTeamId(),
        EFF_BLOCK, coord_target);
  int mod_st_df = target->getSt()
    + getNbAssister(coord_target, target->getTeamId(),
        EFF_BLOCK, coord_attacker);

  return (mod_st_atk < mod_st_df ? -1 : 1) *
    ((mod_st_atk > 2 * mod_st_df || mod_st_df > 2 * mod_st_atk) ? 3 :
     (mod_st_atk != mod_st_df ? 2 : 1 ));
}

template <typename T>
inline int Field<T>::getFoulModifier(const Coordinates& coord_attacker,
    const Coordinates& coord_target) const
{
  T* attacker;
  T* target;

  attacker = getPlayer(coord_attacker);
  target = getPlayer(coord_target);
  if (attacker == NULL || target == NULL) {
    return 0;
  }

  int atk_mod = getNbAssister(coord_attacker, attacker->getTeamId(),
        EFF_FOUL, coord_target);
  int def_mod = getNbAssister(coord_target, target->getTeamId(),
        EFF_FOUL, coord_attacker);

  return atk_mod - def_mod;
}