fullstate_sensor.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_FULLSTATE_SENSOR_H
#define RCSC_PLAYER_FULLSTATE_SENSOR_H
 
#include <rcsc/geom/vector_2d.h>
#include <rcsc/game_time.h>
#include <rcsc/types.h>
 
#include <vector>
#include <iostream>
 
namespace rcsc {
 
class FullstateSensor {
public:
 
    struct BallT {
        Vector2D pos_; 
        Vector2D vel_; 
    };
 
    struct PlayerT {
        SideID side_; 
        int unum_; 
        bool goalie_; 
 
        int type_; 
 
        Vector2D pos_; 
        Vector2D vel_; 
        double body_; 
        double neck_; 
 
        double stamina_; 
        double effort_; 
        double recovery_; 
        double stamina_capacity_; 
 
        double focus_dist_;
        double focus_dir_;
 
        double pointto_dist_;
        double pointto_dir_;
 
        bool kicked_;
        bool tackle_;
 
        bool charged_;
        Card card_;
 
        PlayerT()
            : side_( NEUTRAL ),
              unum_( Unum_Unknown ),
              goalie_( false ),
              type_( 0 ),
              pos_( Vector2D::INVALIDATED ),
              vel_( 0.0, 0.0 ),
              body_( 0.0 ),
              neck_( 0.0 ),
              stamina_( 0.0 ),
              effort_( 0.0 ),
              recovery_( 0.0 ),
              focus_dist_( 0.0 ),
              focus_dir_( 0.0 ),
              pointto_dist_( -1.0 ),
              pointto_dir_( 0.0 ),
              kicked_( false ),
              tackle_( false ),
              charged_( false ),
              card_( NO_CARD )
          { }
 
        std::ostream & print( std::ostream & os ) const;
    };
 
 
    typedef std::vector< PlayerT > PlayerCont; 
 
private:
 
    GameTime M_time; 
 
    /*
    // Because sense_body message have the following information,
    // it is not necessary to analyze these data.
 
    std::string M_playmode_string; //!< playmode string
 
    ViewQuality M_view_quality; //!< agent's view quality
    ViewWidth M_view_width; //!< agent's view width
 
    int M_kick_count; //!< executed command count
    int M_dash_count; //!< executed command count
    int M_turn_count; //!< executed command count
    int M_catch_count; //!< executed command count
    int M_move_count; //!< executed command count
    int M_turn_neck_count; //!< executed command count
    int M_change_view_count; //!< executed command count
    int M_say_count; //!< executed command count
 
    int M_arm_movable; //!< after this step, player can move the arm.
    int M_arm_expires; //!< while this step, player continue to point out.
    double M_pointto_dist; //!< pointing distance
    double M_pointto_dir; //!< pointing angle. this is relative to face
    int M_pointto_count; //!< sensed command count
    */
 
    // set the information of left-hand-side orientation
 
    BallT M_ball; 
    PlayerCont M_our_players; 
    PlayerCont M_their_players; 
 
    int M_our_score; 
    int M_their_score; 
 
 
public:
 
    FullstateSensor();
 
private:
 
    void parseV7( const char * msg,
                  const SideID our_side );
 
    void parseV8( const char * msg,
                  const SideID our_side );
 
    void reverseSide();
 
public:
    void parse( const char * msg,
                const SideID our_side,
                const double version,
                const GameTime & current );
 
    // accessor method
 
    const GameTime & time() const
      {
          return M_time;
      }
 
    const BallT & ball() const
      {
          return M_ball;
      }
 
    const PlayerCont & ourPlayers() const
      {
          return M_our_players;
      }
 
    const PlayerCont & theirPlayers() const
      {
          return M_their_players;
      }
 
    int ourScore() const
      {
          return M_our_score;
      }
 
    int theirScore() const
      {
          return M_their_score;
      }
 
    std::ostream & print( std::ostream & os ) const;
 
};
 
}
 
#endif