self_object.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_SELF_OBJECT_H
#define RCSC_PLAYER_SELF_OBJECT_H
 
#include <rcsc/player/abstract_player_object.h>
#include <rcsc/player/view_mode.h>
#include <rcsc/player/fullstate_sensor.h>
 
#include <rcsc/common/stamina_model.h>
#include <rcsc/geom/vector_2d.h>
#include <rcsc/game_time.h>
#include <rcsc/types.h>
 
namespace rcsc {
 
class BodySensor;
class ActionEffector;
class BallObject;
 
class SelfObject
    : public AbstractPlayerObject {
private:
    static int S_pos_count_thr;
    static int S_vel_count_thr;
    static int S_face_count_thr;
 
    GameTime M_time;
    GameTime M_sense_body_time;
 
 
    // status on field
    Vector2D M_pos_error; 
    Vector2D M_pos_prev; 
 
    Vector2D M_vel_error; 
 
    AngleDeg M_neck; 
    double M_face_error; 
 
    ViewWidth M_view_width; 
    ViewQuality M_view_quality; 
 
    double M_focus_dist; 
    AngleDeg M_focus_dir; 
 
    StaminaModel M_stamina; 
 
    // some action effect
    GameTime M_last_catch_time; 
 
    int M_tackle_expires; 
    int M_charged_expires; 
 
    int M_arm_movable; 
    int M_arm_expires; 
    Vector2D M_pointto_rpos; 
    Vector2D M_pointto_pos; 
    GameTime M_last_pointto_time; 
 
    SideID M_attentionto_side; 
    int M_attentionto_unum; 
 
    Vector2D M_last_move;
    Vector2D  M_last_moves[4];
 
    bool M_collision_estimated; 
    bool M_collides_with_none; 
    bool M_collides_with_ball; 
    bool M_collides_with_player; 
    bool M_collides_with_post; 
 
    // status values for action
    bool M_kickable; 
    double M_kick_rate; 
    double M_catch_probability; 
    double M_tackle_probability; 
    double M_foul_probability; 
 
    SelfObject( const SelfObject & self ) = delete;
    SelfObject & operator=( const SelfObject & self ) = delete;
 
public:
 
    SelfObject();
    ~SelfObject() = default;
 
    static
    void set_count_thr( const int pos_thr,
                        const int vel_thr,
                        const int face_thr );
 
    void init( const SideID side,
               const int unum,
               const bool goalie );
 
    virtual
    bool isSelf() const
      {
          return true;
      }
 
    virtual
    void setPlayerType( const int type );
 
    const PlayerType & playerType() const
      {
          return *M_player_type;
      }
 
    bool posValid() const;
 
    bool velValid() const;
 
    bool faceValid() const;
 
 
    const Vector2D & posError() const
      {
          return M_pos_error;
      }
 
    const Vector2D & posPrev() const
      {
          return M_pos_prev;
      }
 
    double speed() const
      {
          return M_vel.r();
      }
 
    const Vector2D & velError() const
      {
          return M_vel_error;
      }
 
    const AngleDeg & neck() const
      {
          return M_neck;
      }
 
    const double & faceError() const
      {
          return M_face_error;
      }
 
    const ViewWidth & viewWidth() const
      {
          return M_view_width;
      }
 
    const ViewQuality & viewQuality() const
      {
          return M_view_quality;
      }
 
    double focusDist() const
      {
          return M_focus_dist;
      }
 
    const AngleDeg & focusDir() const
      {
          return M_focus_dir;
      }
 
    Vector2D focusPoint() const;
 
    const GameTime & catchTime() const
      {
          return M_last_catch_time;
      }
 
    int tackleExpires() const
      {
          return M_tackle_expires;
      }
 
    int chargedExpires() const
      {
          return M_charged_expires;
      }
 
    bool isFrozen() const
      {
          return M_tackle_expires > 0
              || M_charged_expires > 0;
      }
 
    bool isTackling() const
      {
          return M_tackle_expires > 0;
      }
 
    int armMovable() const
      {
          return M_arm_movable;
      }
 
    int armExpires() const
      {
          return M_arm_expires;
      }
 
    const Vector2D & pointtoPos() const
      {
          return M_pointto_pos;
      }
 
    const GameTime & pointtoTime() const
      {
          return M_last_pointto_time;
      }
 
    SideID attentiontoSide() const
      {
          return M_attentionto_side;
      }
 
    int attentiontoUnum() const
      {
          return M_attentionto_unum;
      }
 
    const StaminaModel & staminaModel() const
      {
          return M_stamina;
      }
 
    double stamina() const
      {
          return M_stamina.stamina();
      }
 
    double staminaCapacity() const
      {
          return M_stamina.capacity();
      }
 
    double effort() const
      {
          return M_stamina.effort();
      }
 
    double recovery() const
      {
          return M_stamina.recovery();
      }
 
    bool collisionEstimated() const
      {
          return M_collision_estimated;
      }
 
    bool hasSensedCollision() const
      {
          return M_collides_with_none
              || M_collides_with_ball
              || M_collides_with_player
              || M_collides_with_post;
      }
 
    bool collidesWithNone() const
      {
          return M_collides_with_none;
      }
 
    bool collidesWithBall() const
      {
          return M_collides_with_ball;
      }
 
    bool collidesWithPlayer() const
      {
          return M_collides_with_player;
      }
 
    bool collidesWithPost() const
      {
          return M_collides_with_post;
      }
 
    const Vector2D & lastMove() const
      {
          return M_last_move;
      }
 
    const Vector2D & lastMove( const int i ) const
      {
          if ( i < 0 || 2 < i ) return M_last_moves[3];
          return M_last_moves[i];
      }
 
    bool isKickable() const
      {
          return M_kickable;
      }
 
    double kickRate() const
      {
          return M_kick_rate;
      }
 
    double dashRate() const
      {
          return effort() * playerType().dashPowerRate();
      }
 
    double catchProbability() const
      {
          return M_catch_probability;
      }
 
    double tackleProbability() const
      {
          return M_tackle_probability;
      }
 
    double foulProbability() const
      {
          return M_foul_probability;
      }
 
 
 
    void update( const ActionEffector & act,
                 const GameTime & current );
 
private:
    void updateWindEffect();
 
public:
    void updateAfterSenseBody( const BodySensor & sense,
                               const ActionEffector & act,
                               const GameTime & current );
 
    void updateAfterFullstate( const FullstateSensor::PlayerT & my_state,
                               const ActionEffector & act,
                               const GameTime & current );
 
    void updatePosBySee( const Vector2D & pos,
                         const Vector2D & pos_err,
                         const double & face,
                         const double & face_err,
                         const GameTime & current );
 
    void updateByCollision( const Vector2D & pos,
                            const Vector2D & pos_error );
 
    void updateAngleBySee( const double & face,
                           const double & face_err,
                           const GameTime & current );
 
    void updateVelDirAfterSee( const BodySensor & sense,
                               const GameTime & current );
 
    void updateBallInfo( const BallObject & ball );
 
    void updateKickableState( const BallObject & ball,
                              const int self_reach_cycle,
                              const int teammate_reach_cycle,
                              const int opponent_reach_cycle );
 
    // used for direct update
 
    void setViewMode( const ViewWidth & w,
                      const ViewQuality & q )
      {
          M_view_width = w;
          M_view_quality = q;
      }
 
    void setPointto( const Vector2D & point,
                     const GameTime & done_time )
      {
          M_pointto_pos = point;
          M_last_pointto_time = done_time;
          if ( pos().isValid() )
          {
              M_pointto_angle = ( point - pos() ).th();
              M_pointto_count = 0;
          }
      }
 
    void setAttentionto( const SideID side,
                         const int unum )
      {
          M_attentionto_side = side;
          M_attentionto_unum = unum;
      }
 
    // utilities
 
    double getSafetyDashPower( const double & dash_power ) const
      {
          return staminaModel().getSafetyDashPower( playerType(), dash_power );
      }
 
};
 
}
 
#endif