player_type_analyzer.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_PLAYER_TYPE_ANALYZER_H
#define RCSC_COACH_PLAYER_TYPE_ANALYZER_H
 
#include <rcsc/coach/coach_ball_object.h>
 
#include <rcsc/geom/vector_2d.h>
#include <rcsc/game_time.h>
#include <rcsc/types.h>
 
#include <vector>
 
namespace rcsc {
 
class CoachWorldModel;
 
class PlayerTypeAnalyzer {
private:
 
    struct Data {
        bool turned_; 
        bool kicked_; 
        bool tackling_; 
        bool maybe_referee_; 
        bool maybe_collide_; 
        bool maybe_kick_;  
        Vector2D pos_; 
        Vector2D vel_; 
        double body_; 
 
        std::vector< int > invalid_flags_;
 
        int type_; 
 
        Data();
        void setDefaultType();
        void setUnknownType();
    };
 
    const CoachWorldModel & M_world;
 
    GameTime M_updated_time; 
    PlayMode M_playmode; 
 
    CoachBallObject M_prev_ball; 
    Data M_teammate_data[11]; 
    Data M_opponent_data[11]; 
 
    std::vector< int > M_opponent_type_used_count;
 
    PlayerTypeAnalyzer() = delete;
    PlayerTypeAnalyzer( const PlayerTypeAnalyzer & ) = delete;
    PlayerTypeAnalyzer & operator=( const PlayerTypeAnalyzer & ) = delete;
public:
    explicit
    PlayerTypeAnalyzer( const CoachWorldModel & world );
 
    const GameTime & updatedTime() const
      {
          return M_updated_time;
      }
 
    void update();
 
 
    void reset( const int unum );
 
    int playerTypeId( const int unum ) const
      {
          if ( unum < 1 || 11 < unum )
          {
              std::cerr << "PlayerTypeAnalyzer::playerTypeId() Illegal unum "
                        << unum << std::endl;
              return Hetero_Unknown;
          }
          return M_opponent_data[ unum - 1 ].type_;
      }
 
private:
 
    void updateLastData();
 
    void analyze();
 
    void checkTurn();
 
    void checkTackle();
 
    void checkReferee();
 
    void checkCollisions();
 
    void checkKick();
 
    void checkPlayerDecay();
 
    void checkPlayerSpeedMax();
 
    void checkTurnMoment();
};
 
}
 
#endif