Match.hxx

/*
** TowBowlTactics, a turn-based strategy football game.
** 
** Copyright (C) 2008-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 "rules/BaseRules.hh"
#include "Weather.hh"

template <typename T>
Match<T>::Match() :
  field_(NULL),
  ball_(NULL),
  weather_(NULL),
  cur_half_(0),
  cur_turn_(0),
  active_team_id_(0),
  beginning_team_id_(-1),
  receiving_team_id_(-1),
  scoring_team_id_(-1),
  turnover_(TOM_UNASSIGNED),
  timer_()
{
  team_[0] = NULL;
  team_[1] = NULL;
}

template <typename T>
Match<T>::~Match()
{
  delete team_[0];
  delete team_[1];
  delete field_;
  delete ball_;
  delete weather_;
}

template <typename T>
inline Team<T>* Match<T>::getTeam(int team_id)
{
  if (team_id == 0 || team_id == 1)
    return team_[team_id];
  return NULL;
}

template <typename T>
inline Field<T>* Match<T>::getField()
{
  return field_;
}

template <typename T>
inline Ball<T>* Match<T>::getBall()
{
  return ball_;
}

template <typename T>
inline Weather* Match<T>::getWeather()
{
  return weather_;
}

template <typename T>
inline int Match<T>::getHalf() const
{
  return cur_half_;
}

template <typename T>
inline int Match<T>::getTurn() const
{
  return cur_turn_;
}

template <typename T>
inline int Match<T>::getActiveTeamId() const
{
  return active_team_id_;
}

template <typename T>
inline int Match<T>::getBeginningTeamId() const
{
  return beginning_team_id_;
}

template <typename T>
inline int Match<T>::getReceivingTeamId() const
{
  return receiving_team_id_;
}

template <typename T>
inline int Match<T>::getScoringTeamId() const
{
  return scoring_team_id_;
}

template <typename T>
enum eTurnOverMotive Match<T>::getTurnoverMotive() const
{
  return turnover_;
}

template <typename T>
inline const Timer& Match<T>::getTimer() const
{
  return timer_;
}

template <typename T>
inline const char* Match<T>::tokenToString(unsigned token)
{
  if (token >= sizeof (bb5_token_str) / sizeof (const char *))
    return "(overflow)";
  return bb5_token_str[token];
}

template <typename T>
inline const char* Match<T>::stringify(enum eTurnOverMotive motive)
{
  if (TOM_UNASSIGNED <= motive && motive <= TOM_LAST)
    {
      return bb5_turnovermotive_str[motive];
    }
  return "Undefined motive";
}

template <typename T>
inline const char* Match<T>::stringify(enum eError error)
{
  if (ERR_UNASSIGNED <= error && error <= ERR_LAST)
    {
      return bb5_error_str[error];
    }
  return "Undefined error";
}

template <typename T>
inline const char* Match<T>::stringifyGameState(int game_state)
{
  if (GS_UNASSIGNED < game_state && game_state <= GS_LAST)
    {
      return bb5_gamestate_str[game_state];
    }
  return BaseRules::stringifyGameState(game_state);
}

template <typename T>
inline const char* Match<T>::stringifyPeriod(int period)
{
  if (0 <= period && period <= MAX_PERIOD)
    {
      return bb5_period_str[period];
    }
  return "Undefined period";
}

template <typename U>
inline std::ostream& operator<< (std::ostream& os, const Match<U>& m)
{
  m.printDebug(os);
  return os;
}

template <typename T>
inline void Match<T>::printDebug(std::ostream& os) const
{
  os
    << "Half-time `" << cur_half_ << "', "
    << "turn `" << cur_turn_ << "' of "
    << "team `" << active_team_id_ << "'."
    << std::endl
    << "Team `" << beginning_team_id_ << "' begins the half-time."
    << std::endl
    << "Team `" << receiving_team_id_ << "' receives the half-time."
    << std::endl
    << "Turnover motive is set to `" << Match<T>::stringify(turnover_) << "'"
    << std::endl;
  os
    << "Timer is "
    << (timer_.isPaused()
        ? "paused"
        : (timer_.isTimeElapsed()
          ? "stopped"
          : "running")) << "."
    << std::endl;
  if (ball_ != NULL)
    os << *ball_;
  if (team_[0] != NULL)
    os << *team_[0];
  if (team_[1] != NULL)
    os << *team_[1];
  os << std::endl;
}