types.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_RCG_TYPES_H
#define RCSC_RCG_TYPES_H
 
#include <rcsc/types.h>
 
#include <string>
#include <cmath>
#include <cstdint>
 
namespace rcsc {
namespace rcg {
 
 
typedef std::int16_t Int16;
typedef std::uint16_t UInt16;
typedef std::int32_t Int32;
typedef std::int32_t UInt32;
 
enum {
    COLOR_NAME_MAX = 64
};
 
enum DispInfoMode {
    NO_INFO     = 0, 
    SHOW_MODE   = 1, 
    MSG_MODE    = 2, 
    DRAW_MODE   = 3, 
    BLANK_MODE  = 4, 
    PM_MODE     = 5, 
    TEAM_MODE   = 6, 
    PT_MODE     = 7, 
    PARAM_MODE  = 8, 
    PPARAM_MODE = 9  
};
 
enum MsgInfoMode {
    MSG_BOARD = 1,
    LOG_BOARD = 2
};
 
enum PlayerStatus {
    DISABLE         = 0x00000000,
    STAND           = 0x00000001,
    KICK            = 0x00000002,
    KICK_FAULT      = 0x00000004,
    GOALIE          = 0x00000008,
    CATCH           = 0x00000010,
    CATCH_FAULT     = 0x00000020,
    BALL_TO_PLAYER  = 0x00000040,
    PLAYER_TO_BALL  = 0x00000080,
    DISCARD         = 0x00000100,
    LOST            = 0x00000200,
    BALL_COLLIDE    = 0x00000400,
    PLAYER_COLLIDE  = 0x00000800,
    TACKLE          = 0x00001000,
    TACKLE_FAULT    = 0x00002000,
    BACK_PASS       = 0x00004000,
    FREE_KICK_FAULT = 0x00008000,
    POST_COLLIDE    = 0x00010000, // player collided with goal posts
    FOUL_CHARGED     = 0x00020000, // player is frozen by intentional tackle foul
    YELLOW_CARD     = 0x00040000,
    RED_CARD        = 0x00080000,
    ILLEGAL_DEFENSE = 0x00100000,
};
 
 
/*-------------------------------------------------------------------*/
// monitor protocol version 1
// game log format versin 1 & version 2
 
constexpr double SHOWINFO_SCALE = 16.0; 
constexpr float SHOWINFO_SCALEF = 16.0f; 
constexpr int REC_OLD_VERSION = 1; 
constexpr int REC_VERSION_2 = 2; 
 
struct pos_t {
    Int16 enable; 
    Int16 side;   
    Int16 unum;   
    Int16 angle;  
    Int16 x;      
    Int16 y;      
};
 
struct team_t {
    char name[16]; 
    Int16 score;   
};
 
struct showinfo_t {
    char pmode;     
    team_t team[2]; 
    pos_t pos[MAX_PLAYER * 2 + 1]; 
    Int16 time; 
};
 
struct msginfo_t {
    Int16 board;  
    char message[2048]; 
};
 
struct pointinfo_t {
    Int16 x; 
    Int16 y; 
    char color[COLOR_NAME_MAX]; 
};
 
struct circleinfo_t {
    Int16 x; 
    Int16 y; 
    Int16 r; 
    char color[COLOR_NAME_MAX]; 
};
 
struct lineinfo_t {
    Int16 x1; 
    Int16 y1; 
    Int16 x2; 
    Int16 y2; 
    char color[COLOR_NAME_MAX]; 
};
 
struct drawinfo_t {
    Int16 mode; 
    union {
        pointinfo_t pinfo;
        circleinfo_t cinfo;
        lineinfo_t linfo;
    } object; 
};
 
struct dispinfo_t {
    Int16 mode; 
    union {
        showinfo_t show; 
        msginfo_t msg; 
        drawinfo_t draw; 
    } body; 
};
 
/*-------------------------------------------------------------------*/
// monitor protocol version 2
// game log format version 3
 
constexpr double SHOWINFO_SCALE2 = 65536.0;
constexpr float SHOWINFO_SCALE2F = 65536.0f;
constexpr int REC_VERSION_3 = 3;
 
struct ball_t {
    Int32 x; 
    Int32 y; 
    Int32 deltax; 
    Int32 deltay; 
};
 
struct player_t {
    Int16 mode; 
    Int16 type; 
    Int32 x; 
    Int32 y; 
    Int32 deltax; 
    Int32 deltay; 
    Int32 body_angle; 
    Int32 head_angle; 
    Int32 view_width; 
    Int16 view_quality; 
    Int32 stamina; 
    Int32 effort; 
    Int32 recovery; 
    Int16 kick_count; 
    Int16 dash_count; 
    Int16 turn_count; 
    Int16 say_count; 
    Int16 turn_neck_count; 
    Int16 catch_count; 
    Int16 move_count; 
    Int16 change_view_count; 
};
 
struct showinfo_t2 {
    char pmode; 
    team_t team[2]; 
    ball_t ball; 
    player_t pos[MAX_PLAYER * 2]; 
    Int16 time; 
};
 
struct short_showinfo_t2 {
    ball_t ball; 
    player_t pos[MAX_PLAYER * 2]; 
    Int16 time; 
};
 
struct player_type_t {
    Int16 id; 
    Int32 player_speed_max; 
    Int32 stamina_inc_max; 
    Int32 player_decay; 
    Int32 inertia_moment; 
    Int32 dash_power_rate; 
    Int32 player_size; 
    Int32 kickable_margin; 
    Int32 kick_rand; 
    Int32 extra_stamina; 
    Int32 effort_max; 
    Int32 effort_min; 
 
    Int32 kick_power_rate; 
    Int32 foul_detect_probability; 
    Int32 catchable_area_l_stretch; 
 
    //Int32 sparelong1;  replaced by kick_power_rate
    //Int32 sparelong2;  replaced by foul_detect_probability
    //Int32 sparelong3;  replaced by catchable_area_l_stretch
    Int32 sparelong4; 
    Int32 sparelong5; 
    Int32 sparelong6; 
    Int32 sparelong7; 
    Int32 sparelong8; 
    Int32 sparelong9; 
    Int32 sparelong10; 
};
 
struct server_params_t {
    Int32 goal_width; 
    Int32 inertia_moment; 
    Int32 player_size; 
    Int32 player_decay; 
    Int32 player_rand; 
    Int32 player_weight; 
    Int32 player_speed_max; 
    Int32 player_accel_max; 
    Int32 stamina_max; 
    Int32 stamina_inc; 
    Int32 recover_init; 
    Int32 recover_dec_thr; 
    Int32 recover_min; 
    Int32 recover_dec; 
    Int32 effort_init; 
    Int32 effort_dec_thr; 
    Int32 effort_min; 
    Int32 effort_dec; 
    Int32 effort_inc_thr; 
    Int32 effort_inc; 
    Int32 kick_rand;  
    Int16 team_actuator_noise; 
    Int32 player_rand_factor_l; 
    Int32 player_rand_factor_r; 
    Int32 kick_rand_factor_l; 
    Int32 kick_rand_factor_r; 
    Int32 ball_size; 
    Int32 ball_decay; 
    Int32 ball_rand; 
    Int32 ball_weight; 
    Int32 ball_speed_max; 
    Int32 ball_accel_max; 
    Int32 dash_power_rate; 
    Int32 kick_power_rate; 
    Int32 kickable_margin; 
    Int32 control_radius; 
    Int32 control_radius_width; 
    Int32 max_power; 
    Int32 min_power; 
    Int32 max_moment; 
    Int32 min_moment; 
    Int32 max_neck_moment; 
    Int32 min_neck_moment; 
    Int32 max_neck_angle; 
    Int32 min_neck_angle; 
    Int32 visible_angle; 
    Int32 visible_distance; 
    Int32 wind_dir; 
    Int32 wind_force; 
    Int32 wind_ang; 
    Int32 wind_rand; 
    Int32 kickable_area; 
    Int32 catch_area_l; 
    Int32 catch_area_w; 
    Int32 catch_probability; 
    Int16 goalie_max_moves; 
    Int32 corner_kick_margin; 
    Int32 offside_active_area; 
    Int16 wind_none; 
    Int16 use_wind_random; 
    Int16 coach_say_count_max; 
    Int16 coach_say_msg_size; 
    Int16 clang_win_size; 
    Int16 clang_define_win; 
    Int16 clang_meta_win; 
    Int16 clang_advice_win; 
    Int16 clang_info_win; 
    Int16 clang_mess_delay; 
    Int16 clang_mess_per_cycle; 
    Int16 half_time; 
    Int16 simulator_step; 
    Int16 send_step; 
    Int16 recv_step; 
    Int16 sense_body_step; 
    Int16 lcm_step; 
    Int16 player_say_msg_size; 
    Int16 player_hear_max; 
    Int16 player_hear_inc; 
    Int16 player_hear_decay; 
    Int16 catch_ban_cycle; 
    Int16 slow_down_factor; 
    Int16 use_offside; 
    Int16 kickoff_offside; 
    Int32 offside_kick_margin; 
    Int32 audio_cut_dist; 
    Int32 dist_quantize_step; 
    Int32 landmark_dist_quantize_step; 
    Int32 dir_quantize_step; 
    Int32 dist_quantize_step_l; 
    Int32 dist_quantize_step_r; 
    Int32 landmark_dist_quantize_step_l; 
    Int32 landmark_dist_quantize_step_r; 
    Int32 dir_quantize_step_l; 
    Int32 dir_quantize_step_r; 
    Int16 coach_mode; 
    Int16 coach_with_referee_mode; 
    Int16 use_old_coach_hear; 
    Int16 online_coach_look_step; 
    Int32 slowness_on_top_for_left_team;  
    Int32 slowness_on_top_for_right_team; 
 
    Int32 ka_length; 
    Int32 ka_width;  
 
    Int32 ball_stuck_area; 
 
    Int32 max_tackle_power; 
    Int32 max_back_tackle_power; 
 
    Int32 tackle_dist; 
    Int32 tackle_back_dist; 
    Int32 tackle_width; 
 
    Int16 start_goal_l; 
    Int16 start_goal_r; 
    Int16 fullstate_l; 
    Int16 fullstate_r; 
    Int16 drop_ball_time; 
    Int16 synch_mode; 
    Int16 synch_offset; 
    Int16 synch_micro_sleep; 
    Int16 point_to_ban; 
    Int16 point_to_duration; 
 
    /*
      Int16 pen_before_setup_wait;
      Int16 pen_setup_wait;
      Int16 pen_ready_wait;
      Int16 pen_taken_wait;
      Int16 pen_nr_kicks;
      Int16 pen_max_extra_kicks;
      Int32 pen_dist_x;
      Int16 pen_random_winner;
      Int32 pen_max_goalie_dist_x;
      Int16 pen_allow_mult_kicks;
    */
};
 
struct player_params_t {
    Int16 player_types; 
    Int16 substitute_max; 
    Int16 pt_max; 
    Int32 player_speed_max_delta_min; 
    Int32 player_speed_max_delta_max; 
    Int32 stamina_inc_max_delta_factor; 
    Int32 player_decay_delta_min; 
    Int32 player_decay_delta_max; 
    Int32 inertia_moment_delta_factor; 
    Int32 dash_power_rate_delta_min; 
    Int32 dash_power_rate_delta_max; 
    Int32 player_size_delta_factor; 
    Int32 kickable_margin_delta_min; 
    Int32 kickable_margin_delta_max; 
    Int32 kick_rand_delta_factor; 
    Int32 extra_stamina_delta_min; 
    Int32 extra_stamina_delta_max; 
    Int32 effort_max_delta_factor; 
    Int32 effort_min_delta_factor; 
    Int32 random_seed; 
    Int32 new_dash_power_rate_delta_min; 
    Int32 new_dash_power_rate_delta_max; 
    Int32 new_stamina_inc_max_delta_factor; 
 
    Int32 kick_power_rate_delta_min;
    Int32 kick_power_rate_delta_max;
    Int32 foul_detect_probability_delta_factor;
 
    Int32 catchable_area_l_stretch_min;
    Int32 catchable_area_l_stretch_max;
 
    //Int32 sparelong5;  replaced by kick_power_rate_delta_min
    //Int32 sparelong6;  replaced by kick_power_rate_delta_max
    //Int32 sparelong7;  replaced by foul_detect_probability_delta_factor
    //Int32 sparelong8;  replaced by catchable_area_l_stretch_min
    //Int32 sparelong9;  replaced by catchable_area_l_stretch_max
    Int32 sparelong10; 
 
    Int16 allow_mult_default_type; 
 
    Int16 spareshort2; 
    Int16 spareshort3; 
    Int16 spareshort4; 
    Int16 spareshort5; 
    Int16 spareshort6; 
    Int16 spareshort7; 
    Int16 spareshort8; 
    Int16 spareshort9; 
    Int16 spareshort10; 
};
 
struct dispinfo_t2 {
    Int16 mode; 
    union {
        showinfo_t2 show; 
        msginfo_t msg; 
        player_type_t ptinfo; 
        server_params_t sparams; 
        player_params_t pparams; 
    } body; 
};
 
//
// Data structures for the text based monitor protocl
//
 
struct BallT {
    float x_; 
    float y_; 
    float vx_; 
    float vy_; 
 
    BallT()
        : x_( 0.0 ),
          y_( 0.0 ),
          vx_( SHOWINFO_SCALE2F ),
          vy_( SHOWINFO_SCALE2F )
      { }
 
    bool hasVelocity() const
      {
          return vx_ != SHOWINFO_SCALE2F;
          //&& vy_ != SHOWINFO_SCALE2F;
      }
 
    double x() const { return x_; }
    double y() const { return y_; }
    double deltaX() const { return vx_; }
    double deltaY() const { return vy_; }
};
 
struct PlayerT {
    char side_; 
    Int16 unum_; 
    Int16 type_; 
 
    char view_quality_; 
 
    char focus_side_; 
    Int16 focus_unum_; 
 
    Int32 state_; 
 
    float x_; 
    float y_; 
    float vx_; 
    float vy_; 
    float body_; 
    float neck_; 
    float point_x_; 
    float point_y_; 
 
    float view_width_; 
 
    float focus_dist_; 
    float focus_dir_; 
 
    float stamina_; 
    float effort_; 
    float recovery_; 
    float stamina_capacity_; 
 
    UInt16 kick_count_; 
    UInt16 dash_count_; 
    UInt16 turn_count_; 
    UInt16 catch_count_; 
    UInt16 move_count_; 
    UInt16 turn_neck_count_; 
    UInt16 change_view_count_; 
    UInt16 say_count_; 
    UInt16 tackle_count_; 
    UInt16 pointto_count_; 
    UInt16 attentionto_count_; 
    UInt16 change_focus_count_; 
 
    PlayerT()
        : side_( 'n' ),
          unum_( 0 ),
          type_( -1 ),
          view_quality_( 'h' ),
          focus_side_( 'n' ),
          focus_unum_( 0 ),
          state_( 0 ),
          x_( 0.0f ),
          y_( 0.0f ),
          vx_( SHOWINFO_SCALE2F ),
          vy_( SHOWINFO_SCALE2F ),
          body_( 0.0f ),
          neck_( SHOWINFO_SCALE2F ),
          point_x_( SHOWINFO_SCALE2F ),
          point_y_( SHOWINFO_SCALE2F ),
          view_width_( SHOWINFO_SCALE2F ),
          focus_dist_( 0.0f ),
          focus_dir_( 0.0f ),
          stamina_( SHOWINFO_SCALE2F ),
          effort_( SHOWINFO_SCALE2F ),
          recovery_( SHOWINFO_SCALE2F ),
          stamina_capacity_( -1.0f ),
          kick_count_( 0xFFFF ),
          dash_count_( 0xFFFF ),
          turn_count_( 0xFFFF ),
          catch_count_( 0xFFFF ),
          move_count_( 0xFFFF ),
          turn_neck_count_( 0xFFFF ),
          change_view_count_( 0xFFFF ),
          say_count_( 0xFFFF ),
          tackle_count_( 0xFFFF ),
          pointto_count_( 0xFFFF ),
          attentionto_count_( 0xFFFF ),
          change_focus_count_( 0xFFFF )
      { }
 
    SideID side() const
      {
          return ( side_ == 'l' ? LEFT
                   : side_ == 'r' ? RIGHT
                   : NEUTRAL );
      }
 
    int unum() const
      {
          return unum_;
      }
 
    int type() const
      {
          return type_;
      }
 
    //
    // information level
    //
 
    bool hasType() const
      {
          return type_ >= 0;
      }
 
    bool hasVelocity() const
      {
          return vx_ != SHOWINFO_SCALE2F;
          //&& vy_ != SHOWINFO_SCALE2F;
      }
 
    bool hasNeck() const
      {
          return neck_ != SHOWINFO_SCALE2F;
      }
 
    bool hasView() const
      {
          return view_width_ != SHOWINFO_SCALE2F;
      }
 
    bool hasStamina() const
      {
          return stamina_ != SHOWINFO_SCALE2F;
      }
 
    bool hasStaminaCapacity() const
      {
          return stamina_capacity_ >= 0.0f;
      }
 
    bool hasCommandCount() const
      {
          return kick_count_ != 0xFFFF;
      }
 
    bool hasArm() const
      {
          return point_x_ != SHOWINFO_SCALE2F;
      }
 
    //
    // player state
    //
 
    bool isAlive() const
      {
          return state_ != 0;
      }
 
    bool isKicking() const
      {
          return state_ & KICK
              && !( state_ & KICK_FAULT );
      }
 
    bool isKickingFault() const
      {
          return state_ & KICK_FAULT;
      }
 
    bool isGoalie() const
      {
          return state_ & GOALIE;
      }
 
    bool isCatching() const
      {
          return state_ & CATCH
              && !( state_ & CATCH_FAULT );
      }
 
    bool isCatchingFault() const
      {
          return state_ & CATCH_FAULT;
      }
 
    bool isCollidedBall() const
      {
          return state_ & BALL_COLLIDE
              || state_ & BALL_TO_PLAYER
              || state_ & PLAYER_TO_BALL;
      }
 
    bool isCollidedPlayer() const
      {
          return state_ & PLAYER_COLLIDE;
      }
 
    bool isTackling() const
      {
          return state_ & TACKLE
              && !( state_ & TACKLE_FAULT );
      }
 
    bool isTacklingFault() const
      {
          return state_ & TACKLE_FAULT;
      }
 
    bool isPointing() const
      {
          return point_x_ != SHOWINFO_SCALE2F
              && point_y_ != SHOWINFO_SCALE2F;
      }
 
    bool isFocusing() const
      {
          return focus_side_ != 'n';
      }
 
    bool isFoulCharged() const
      {
          return state_ & FOUL_CHARGED;
      }
 
    bool hasYellowCard() const
      {
          return state_ & YELLOW_CARD;
      }
 
    bool hasRedCard() const
      {
          return state_ & RED_CARD;
      }
 
    bool isIllegalDefenseState() const
      {
          return state_ & ILLEGAL_DEFENSE;
      }
 
    bool highQuality() const
      {
          return ( view_quality_ == 'h' );
      }
 
    SideID focusSide() const
      {
          return ( focus_side_ == 'l' ? LEFT
                   : focus_side_ == 'r' ? RIGHT
                   : NEUTRAL );
      }
 
    //
    // accessor methods
    //
 
    int focusUnum() const { return focus_unum_; }
 
    double x() const { return x_; }
    double y() const { return y_; }
 
    double deltaX() const { return vx_; }
    double deltaY() const { return vy_; }
 
    double body() const { return body_; }
    double head() const { return body_ + neck_; }
 
    double pointX() const { return point_x_; }
    double pointY() const { return point_y_; }
 
    double viewWidth() const { return view_width_; }
 
    double focusDist() const { return focus_dist_; }
    double focusDir() const { return focus_dir_; }
 
    double stamina() const { return stamina_; }
    double effort() const { return effort_; }
    double recovery() const { return recovery_; }
    double staminaCapacity() const { return stamina_capacity_; }
 
    int kickCount() const { return kick_count_; }
    int dashCount() const { return dash_count_; }
    int turnCount() const { return turn_count_; }
    int catchCount() const { return catch_count_; }
    int moveCount() const { return move_count_; }
    int turnNeckCount() const { return turn_neck_count_; }
    int changeViewCount() const { return change_view_count_; }
    int sayCount() const { return say_count_; }
    int tackleCount() const { return tackle_count_; }
    int pointtoCount() const { return pointto_count_; }
    int attentiontoCount() const { return attentionto_count_; }
    int changeFocusCount() const { return change_focus_count_; }
 
    bool hasFullEffort( const double max_effort ) const
      {
          return std::fabs( max_effort - effort_ ) < 1.0e-5;
      }
 
    bool hasFullRecovery() const
      {
          return std::fabs( 1.0 - recovery_ ) < 1.0e-5;
      }
};
 
struct TeamT {
    std::string name_; 
    UInt16 score_; 
    UInt16 pen_score_; 
    UInt16 pen_miss_; 
 
    TeamT()
        : score_( 0 ),
          pen_score_( 0 ),
          pen_miss_( 0 )
      { }
 
    TeamT( const char * name,
           const UInt16 score,
           const UInt16 pen_score,
           const UInt16 pen_miss )
        : name_( name ),
          score_( score ),
          pen_score_( pen_score ),
          pen_miss_( pen_miss )
      { }
 
    void clear()
      {
          name_.erase();
          score_ = 0;
          pen_score_ = 0;
          pen_miss_ = 0;
      }
 
    const std::string & name() const
      {
          return name_;
      }
 
    int score() const
      {
          return score_;
      }
 
    int penaltyScore() const
      {
          return pen_score_;
      }
 
    int penaltyMiss() const { return pen_miss_; }
 
    int penaltyTrial() const
      {
          return pen_score_ + pen_miss_;
      }
 
    bool equals( const TeamT & other ) const
      {
          return ( name_ == other.name_
                   && score_ == other.score_
                   && pen_score_ == other.pen_score_
                   && pen_miss_ == other.pen_miss_ );
      }
 
};
 
struct ShowInfoT {
    UInt32 time_; 
    BallT ball_; 
    PlayerT player_[MAX_PLAYER * 2]; 
};
 
struct DispInfoT {
    PlayMode pmode_; 
    TeamT team_[2]; 
    ShowInfoT show_; 
};
 
 
constexpr int REC_VERSION_4 = 4;
constexpr int REC_VERSION_5 = 5;
constexpr int REC_VERSION_6 = 6;
 
constexpr int REC_VERSION_JSON = -1;
 
constexpr int DEFAULT_LOG_VERSION = REC_VERSION_6;
 
} // end namespace
} // end namespace
 
#endif