body_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_BODY_SENSOR_H
#define RCSC_PLAYER_BODY_SENSOR_H
 
#include <rcsc/player/view_mode.h>
#include <rcsc/game_time.h>
#include <rcsc/types.h>
 
#include <iostream>
 
namespace rcsc {
 
class BodySensor {
public:
 
    GameTime M_time; 
 
    ViewQuality M_view_quality; 
    ViewWidth M_view_width; 
    double M_stamina; 
    double M_effort; 
    double M_stamina_capacity; 
    double M_speed_mag; 
    double M_speed_dir_relative; 
    double M_neck_relative; 
 
    int M_kick_count; 
    int M_dash_count; 
    int M_turn_count; 
    int M_say_count; 
    int M_turn_neck_count; 
    int M_catch_count; 
    int M_move_count; 
    int M_change_view_count; 
    int M_change_focus_count; 
 
    int M_arm_movable;
    int M_arm_expires;
 
    double M_pointto_dist;
 
    double M_pointto_dir;
 
    int M_pointto_count; 
 
    SideID M_attentionto_side; 
    int M_attentionto_unum; 
    int M_attentionto_count; 
 
    int M_tackle_expires; 
    int M_tackle_count; 
 
    bool M_none_collided; 
    bool M_ball_collided; 
    bool M_player_collided; 
    bool M_post_collided; 
 
    int M_charged_expires; 
    Card M_card; 
 
    // v18+
    double M_focus_dist; 
    double M_focus_dir; 
 
public:
    BodySensor();
 
    void parse( const char * msg,
                const double & version,
                const GameTime & current );
 
private:
 
    bool parseArm( const char * msg,
                   char ** next );
 
    bool parseAttentionto( const char * msg,
                           char ** next );
 
    bool parseTackle( const char * msg,
                      char ** next );
 
 
    bool parseCollision( const char * msg,
                         char ** next );
 
    bool parseFoul( const char * msg,
                    char ** next );
 
    bool parseFocusPoint( const char * msg,
                          char ** next );
 
public:
 
    const
    GameTime & time() const
      {
          return M_time;
      }
 
    const
    ViewQuality & viewQuality() const
      {
          return M_view_quality;
      }
 
    const
    ViewWidth & viewWidth() const
      {
          return M_view_width;
      }
 
    const
    double & stamina() const
      {
          return M_stamina;
      }
 
    const
    double & effort() const
      {
          return M_effort;
      }
 
    const
    double & staminaCapacity() const
      {
          return M_stamina_capacity;
      }
 
    const
    double & speedMag() const
      {
          return M_speed_mag;
      }
 
    const
    double & speedDir() const
      {
          return M_speed_dir_relative;
      }
 
    const
    double & neckDir() const
      {
          return M_neck_relative;
      }
 
    int kickCount() const
      {
          return M_kick_count;
      }
 
    int dashCount() const
      {
          return M_dash_count;
      }
 
    int turnCount() const
      {
          return M_turn_count;
      }
 
    int sayCount() const
      {
          return M_say_count;
      }
 
    int turnNeckCount() const
      {
          return M_turn_neck_count;
      }
 
    int catchCount() const
      {
          return M_catch_count;
      }
 
    int moveCount() const
      {
          return M_move_count;
      }
 
    int changeViewCount() const
      {
          return M_change_view_count;
      }
 
    int changeFocusCount() const
      {
          return M_change_focus_count;
      }
 
    int armMovable() const
      {
          return M_arm_movable;
      }
 
    int armExpires() const
      {
          return M_arm_expires;
      }
 
    const
    double & pointtoDist() const
      {
          return M_pointto_dist;
      }
 
    const
    double & pointtoDir() const
      {
          return M_pointto_dir;
      }
 
    int pointtoCount() const
      {
          return M_pointto_count;
      }
 
    SideID attentiontoSide() const
      {
          return M_attentionto_side;
      }
 
    int attentiontoUnum() const
      {
          return M_attentionto_unum;
      }
 
    int attentiontoCount() const
      {
          return M_attentionto_count;
      }
 
    int tackleExpires() const
      {
          return M_tackle_expires;
      }
 
    int tackleCount() const
      {
          return M_tackle_count;
      }
 
    bool noneCollided() const
      {
          return M_none_collided;
      }
 
    bool ballCollided() const
      {
          return M_ball_collided;
      }
 
    bool playerCollided() const
      {
          return M_player_collided;
      }
 
    bool postCollided() const
      {
          return M_post_collided;
      }
 
    int chargedExpires() const
      {
          return M_charged_expires;
      }
 
    Card card() const
      {
          return M_card;
      }
 
    double focusDist() const
      {
          return M_focus_dist;
      }
 
    double focusDir() const
      {
          return M_focus_dir;
      }
 
    std::ostream & print( std::ostream & os ) const;
};
 
}
 
#endif