coach_world_model.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_COACH_COACH_WORLD_MODEL_H
#define RCSC_COACH_COACH_WORLD_MODEL_H
 
#include <rcsc/coach/coach_world_state.h>
#include <rcsc/coach/coach_ball_object.h>
#include <rcsc/coach/coach_player_object.h>
#include <rcsc/coach/player_type_analyzer.h>
#include <rcsc/clang/types.h>
#include <rcsc/game_mode.h>
#include <rcsc/game_time.h>
#include <rcsc/types.h>
 
#include <iostream>
#include <string>
#include <vector>
#include <list>
 
namespace rcsc {
 
class AudioMemory;
class CoachVisualSensor;
 
class CoachWorldModel {
private:
 
    int M_client_version;
 
    //
    // game info
    //
 
    GameTime M_time;
    GameTime M_see_time;
 
    SideID M_our_side;
 
    std::string M_our_team_name; 
    std::string M_their_team_name; 
 
    GameTime M_last_set_play_start_time; 
    int M_setplay_count; 
 
    GameMode M_game_mode;
 
    GameTime M_training_time; 
 
    std::shared_ptr< AudioMemory > M_audio_memory;
 
    //
    // objects
    //
 
    CoachWorldState::Ptr M_current_state; 
    CoachWorldState::Ptr M_previous_state; 
 
    CoachWorldState::List M_state_list; 
    CoachWorldState::Map M_state_map; 
 
    SideID M_last_kicker_side; 
    int M_last_kicker_unum; 
 
    GameTime M_pass_time; 
    int M_passer_unum; 
    int M_receiver_unum; 
    Vector2D M_pass_start_pos; 
    Vector2D M_pass_receive_pos; 
 
    //
    // player type management
    //
 
    PlayerTypeAnalyzer M_player_type_analyzer;
 
    std::vector< int > M_available_player_type_id;
 
    int M_our_substitute_count; 
    int M_their_substitute_count; 
 
    int M_our_player_type_id[11]; 
    int M_their_player_type_id[11]; 
 
    std::vector< int > M_our_player_type_used_count;
    std::vector< int > M_their_player_type_used_count;
 
    //
    // card information
    //
 
    Card M_our_card[11]; 
    Card M_their_card[11]; 
 
    //
    // coach language management
    //
 
    long M_last_playon_start; 
 
    long M_clang_capacity_update_time; 
    int M_clang_capacity[CLANG_MAX_TYPE]; // the number of available message for each message type
 
    int M_freeform_allowed_count; 
    int M_freeform_send_count; 
 
    // not used
    CoachWorldModel( const CoachWorldModel & ) = delete;
    CoachWorldModel & operator=( const CoachWorldModel & ) = delete;
 
public:
    CoachWorldModel();
 
    void init( const std::string & team_name,
               const SideID side,
               const int client_version );
 
    void setAudioMemory( std::shared_ptr< AudioMemory > memory );
 
    const AudioMemory & audioMemory() const
      {
          return *M_audio_memory;
      }
 
    void setServerParam();
 
    void setPlayerParam();
 
 
    void setTeamName( const SideID side,
                      const std::string & name );
 
    void changePlayerType( const SideID side,
                           const int unum,
                           const int type );
 
    void setCard( const SideID side,
                  const int unum,
                  const Card card );
 
    void updateGameMode( const GameMode & game_mode,
                         const GameTime & current );
 
    void updateAfterSeeGlobal( const CoachVisualSensor & see_global,
                               const GameTime & current );
 
    void updateJustBeforeDecision( const GameTime & current );
 
 
    void updateAll( const rcg::DispInfoT & disp );
 
private:
 
    void updateCLangCapacity();
 
    void updateTeamNames( const CoachVisualSensor & see_global );
 
    void updatePlayerType();
 
    void updateLastKicker();
 
    void updateLastPasser();
 
    //
    //
    //
 
    void updateGameMode( const rcg::DispInfoT & disp );
 
    void updateState( const rcg::DispInfoT & disp,
                      const GameTime & current );
 
    void updateTeamNames( const rcg::DispInfoT & disp );
 
    void updatePlayerType( const rcg::DispInfoT & disp );
 
    void updateCard( const rcg::DispInfoT & disp );
 
public:
 
    void setTrainingTime( const GameTime & t )
      {
          M_training_time = t;
      }
 
    void decCLangCapacity( const CLangType type );
 
    void incFreeformSendCount();
 
    int clientVersion() const
      {
          return M_client_version;
      }
 
    SideID ourSide() const
      {
          return M_our_side;
      }
 
    SideID theirSide() const
      {
          return ( M_our_side == RIGHT ? LEFT : RIGHT );
      }
 
    const std::string & ourTeamName() const
      {
          return M_our_team_name;
      }
 
    const std::string & theirTeamName() const
      {
          return M_their_team_name;
      }
 
    const std::string & teamNameLeft() const
      {
          return ( M_our_side == RIGHT
                   ? M_their_team_name
                   : M_our_team_name );
      }
 
    const std::string & teamNameRight() const
      {
          return ( M_our_side == RIGHT
                   ? M_our_team_name
                   : M_their_team_name );
      }
 
    const GameTime & time() const
      {
          return M_time;
      }
 
    const GameTime & seeTime() const
      {
          return M_see_time;
      }
 
    const GameTime & lastSetPlayStartTime() const { return M_last_set_play_start_time; }
 
    int getSetPlayCount() const { return M_setplay_count; }
 
    const GameMode & gameMode() const
      {
          return M_game_mode;
      }
 
    const GameTime & trainingTime() const
      {
          return M_training_time;
      }
 
    const CoachWorldState & currentState() const
      {
          return *M_current_state;
      }
 
    CoachWorldState::ConstPtr currentStatePtr() const
      {
          return M_current_state;
      }
 
    const CoachWorldState::List & stateList() const
      {
          return M_state_list;
      }
 
    const CoachWorldState::Map & stateMap() const
      {
          return M_state_map;
      }
 
    CoachWorldState::ConstPtr getState( const int time ) const
      {
          if ( time < 0 )
          {
              return M_current_state;
          }
 
          CoachWorldState::Map::const_iterator it = M_state_map.find( GameTime( time, 0 ) );
          if ( it == M_state_map.end() )
          {
              return CoachWorldState::ConstPtr();
          }
          return it->second;
      }
 
    CoachWorldState::ConstPtr getState( const GameTime & time ) const
      {
          if ( time.cycle() < 0 )
          {
              return M_current_state;
          }
 
          CoachWorldState::Map::const_iterator it = M_state_map.find( time );
          if ( it == M_state_map.end() )
          {
              return CoachWorldState::ConstPtr();
          }
          return it->second;
      }
 
    const CoachBallObject & ball() const
      {
          return M_current_state->ball();
      }
 
    BallStatus getBallStatus() const
      {
          return M_current_state->getBallStatus();
      }
 
    const CoachPlayerObject::Cont & allPlayers() const
      {
          return M_current_state->allPlayers();
      }
 
    const CoachPlayerObject::Cont & playersLeft() const
      {
          return ( M_our_side == RIGHT
                   ? M_current_state->opponents()
                   : M_current_state->teammates() );
      }
 
    const CoachPlayerObject::Cont & playersRight() const
      {
          return ( M_our_side == RIGHT
                   ? M_current_state->teammates()
                   : M_current_state->opponents() );
      }
 
    const CoachPlayerObject::Cont & teammates() const
      {
          return M_current_state->teammates();
      }
 
    const CoachPlayerObject::Cont & opponents() const
      {
          return M_current_state->opponents();
      }
 
    const CoachPlayerObject * teammate( const int unum ) const
      {
          return M_current_state->teammate( unum );
      }
 
    const CoachPlayerObject * opponent( const int unum ) const
      {
          return M_current_state->opponent( unum );
      }
 
    SideID lastKickerSide() const
      {
          return M_last_kicker_side;
      }
 
    int lastKickerUnum() const
      {
          return M_last_kicker_unum;
      }
 
    const GameTime & passTime() const
      {
          return M_pass_time;
      }
 
    int passerUnum() const
      {
          return M_passer_unum;
      }
 
    int receiverUnum() const
      {
          return M_receiver_unum;
      }
 
    const Vector2D & passStartPos() const
      {
          return M_pass_start_pos;
      }
 
    const Vector2D & passReceivePos() const
      {
          return M_pass_receive_pos;
      }
 
    //
    // player type information
    //
 
    const std::vector< int > & availablePlayerTypeId() const
      {
          return M_available_player_type_id;
      }
 
    bool canSubstitute( const int unum,
                        const int type ) const;
 
    int substituteCount( const SideID side ) const
      {
          return ( M_our_side == side
                   || ( M_our_side == NEUTRAL
                        && side == LEFT )
                   ? M_our_substitute_count
                   : M_their_substitute_count );
      }
 
    int ourSubstituteCount() const
      {
          return M_our_substitute_count;
      }
 
    int theirSubstituteCount() const
      {
          return M_their_substitute_count;
      }
 
 
    int playerTypeId( const SideID side,
                      const int unum ) const;
 
    int ourPlayerTypeId( const int unum ) const
      {
          return playerTypeId( ourSide(), unum );
      }
 
    int theirPlayerTypeId( const int unum ) const
      {
          return playerTypeId( theirSide(), unum );
      }
 
    const std::vector< int > & playerTypeUsedCount( const SideID side ) const
      {
          return ( ourSide() == side
                   || ( ourSide() == NEUTRAL
                        && side == LEFT )
                   ? M_our_player_type_used_count
                   : M_their_player_type_used_count );
      }
 
    const std::vector< int > & ourPlayerTypeUsedCount() const
      {
          return M_our_player_type_used_count;
      }
 
    const std::vector< int > & theirPlayerTypeUsedCount() const
      {
          return M_their_player_type_used_count;
      }
 
 
    //
    // card information
    //
 
    bool isYellowCarded( const SideID side,
                         const int unum ) const;
 
 
    bool isRedCarded( const SideID side,
                      const int unum ) const;
 
    bool isTeammateYellowCarded( const int unum ) const
      {
          return isYellowCarded( ourSide(), unum );
      }
 
    bool isTeammateRedCarded( const int unum ) const
      {
          return isRedCarded( ourSide(), unum );
      }
 
    bool isOpponentYellowarded( const int unum ) const
      {
          return isYellowCarded( theirSide(), unum );
      }
 
 
    bool isOpponentRedCarded( const int unum ) const
      {
          return isRedCarded( theirSide(), unum );
      }
 
 
    //
    // coach language info
    //
 
    long lastPlayOnStart() const
      {
          return M_last_playon_start;
      }
 
 
    bool canSendCLang( const CLangType type ) const;
 
 
    int freeformAllowedCount() const
      {
          return M_freeform_allowed_count;
      }
 
    int freeformSendCount() const
      {
          return M_freeform_send_count;
      }
 
    bool canSendFreeform() const;
 
    //
    // analyzed result
    //
 
    double offsideLineXForLeft() const
      {
          return ( M_our_side == RIGHT
                   ? M_current_state->theirOffsideLineX()
                   : M_current_state->ourOffsideLineX() );
      }
 
    double offsideLineXForRight() const
      {
          return ( M_our_side == RIGHT
                   ? M_current_state->ourOffsideLineX()
                   : M_current_state->theirOffsideLineX() );
      }
 
    double ourOffsideLineX() const
      {
          return M_current_state->ourOffsideLineX();
      }
 
    double theirOffsideLineX() const
      {
          return M_current_state->theirOffsideLineX();
      }
 
 
    bool existKickablePlayer() const;
 
    const CoachPlayerObject * getPlayerNearestTo( const Vector2D & point ) const;
 
    std::ostream & print( std::ostream & os ) const;
 
};
 
}
 
#endif