intercept_table.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_INTERCEPT_TABLE_H
#define RCSC_PLAYER_INTERCEPT_TABLE_H
 
#include <rcsc/player/intercept.h>
#include <rcsc/geom/vector_2d.h>
#include <rcsc/game_time.h>
#include <vector>
#include <map>
 
namespace rcsc {
 
class AbstractPlayerObject;
class PlayerObject;
class WorldModel;
 
/*-------------------------------------------------------------------*/
 
class InterceptTable {
private:
 
    GameTime M_update_time;
 
    int M_self_step;
    int M_self_exhaust_step;
    int M_teammate_step;
    int M_second_teammate_step;
    int M_our_goalie_step;
    int M_opponent_step;
    int M_second_opponent_step;
 
    const PlayerObject * M_first_teammate;
    const PlayerObject * M_second_teammate;
    const PlayerObject * M_first_opponent;
    const PlayerObject * M_second_opponent;
 
    std::vector< Intercept > M_self_results;
 
    std::map< const AbstractPlayerObject *, int > M_player_map;
 
    // not used
    InterceptTable( const InterceptTable & ) = delete;
    InterceptTable & operator=( const InterceptTable & ) = delete;
 
public:
    InterceptTable();
 
    virtual
    ~InterceptTable()
      { }
 
    void update( const WorldModel & wm );
 
    void hearTeammate( const WorldModel & wm,
                       const int unum,
                       const int step );
 
    void hearOpponent( const WorldModel & wm,
                       const int unum,
                       const int step );
 
    int selfStep() const { return M_self_step; }
 
    int selfExhaustStep() const { return M_self_exhaust_step; }
 
    int teammateStep() const { return M_teammate_step; }
 
    int secondTeammateStep() const { return M_second_teammate_step; }
 
    int ourGoalieStep() const { return M_our_goalie_step; }
 
    int opponentStep() const { return M_opponent_step; }
 
    int secondOpponentStep() const { return M_second_opponent_step; }
 
    const PlayerObject * firstTeammate() const { return M_first_teammate; }
 
    const PlayerObject * secondTeammate() const { return M_second_teammate; }
 
    const PlayerObject * firstOpponent() const { return M_first_opponent; }
 
    const PlayerObject * secondOpponent() const { return M_second_opponent; }
 
    const std::vector< Intercept > & selfResults() const
    {
        return M_self_results;
    }
 
    const std::map< const AbstractPlayerObject *, int > & playerMap() const
      {
          return M_player_map;
      }
 
private:
    void clear();
 
    void predictSelf( const WorldModel & wm );
 
    void predictTeammate( const WorldModel & wm );
 
    void predictOpponent( const WorldModel & wm );
};
 
}
 
#endif