say_message_builder.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_SAY_MESSAGE_BUILDER_H
#define RCSC_PLAYER_SAY_MESSAGE_BUILDER_H
 
#include <rcsc/common/say_message.h>
#include <rcsc/common/say_message_parser.h>
#include <rcsc/geom/vector_2d.h>
 
#include <string>
#include <iostream>
 
namespace rcsc {
 
/*-------------------------------------------------------------------*/
class BallMessage
    : public SayMessage {
private:
 
    Vector2D M_ball_pos; 
    Vector2D M_ball_vel; 
 
public:
 
    BallMessage( const Vector2D & ball_pos,
                 const Vector2D & ball_vel )
        : M_ball_pos( ball_pos ),
          M_ball_vel( ball_vel )
      { }
 
    char header() const
      {
          return BallMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return BallMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class PassMessage
    : public SayMessage {
private:
 
    int M_receiver_unum; 
    Vector2D M_receive_point; 
 
    Vector2D M_ball_pos; 
    Vector2D M_ball_vel; 
 
public:
 
    PassMessage( const int receiver_unum,
                 const Vector2D & receive_point,
                 const Vector2D & ball_pos,
                 const Vector2D & ball_vel )
        : M_receiver_unum( receiver_unum ),
          M_receive_point( receive_point ),
          M_ball_pos( ball_pos ),
          M_ball_vel( ball_vel )
      { }
 
    char header() const
      {
          return PassMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return PassMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class InterceptMessage
    : public SayMessage {
private:
 
    bool M_our; 
    int M_unum; 
    int M_cycle; 
 
public:
 
    InterceptMessage( const bool our,
                      const int unum,
                      const int cycle )
        : M_our( our ),
          M_unum( unum ),
          M_cycle( cycle )
      { }
 
    char header() const
      {
          return InterceptMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return InterceptMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class GoalieMessage
    : public SayMessage {
private:
 
    int M_goalie_unum; 
    Vector2D M_goalie_pos; 
    AngleDeg M_goalie_body; 
 
public:
 
    GoalieMessage( const int goalie_unum,
                   const Vector2D & goalie_pos,
                   const AngleDeg & goalie_body )
        : M_goalie_unum( goalie_unum ),
          M_goalie_pos( goalie_pos ),
          M_goalie_body( goalie_body )
      { }
 
    char header() const
      {
          return GoalieMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return GoalieMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class GoalieAndPlayerMessage
    : public SayMessage {
private:
 
    int M_goalie_unum; 
    Vector2D M_goalie_pos; 
    AngleDeg M_goalie_body; 
 
    int M_player_number; 
    Vector2D M_player_pos;
 
public:
 
    GoalieAndPlayerMessage( const int goalie_unum,
                            const Vector2D & goalie_pos,
                            const AngleDeg & goalie_body,
                            const int player_number,
                            const Vector2D & player_pos )
        : M_goalie_unum( goalie_unum ),
          M_goalie_pos( goalie_pos ),
          M_goalie_body( goalie_body ),
          M_player_number( player_number ),
          M_player_pos( player_pos )
      { }
 
    char header() const
      {
          return GoalieAndPlayerMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return GoalieAndPlayerMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class OffsideLineMessage
    : public SayMessage {
private:
 
    double M_offside_line_x; 
 
public:
 
    explicit
    OffsideLineMessage( const double & offside_line_x )
        : M_offside_line_x( offside_line_x )
      { }
 
    char header() const
      {
          return OffsideLineMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return OffsideLineMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class DefenseLineMessage
    : public SayMessage {
private:
 
    double M_defense_line_x; 
 
public:
 
    explicit
    DefenseLineMessage( const double & defense_line_x )
        : M_defense_line_x( defense_line_x )
      { }
 
    char header() const
      {
          return DefenseLineMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return DefenseLineMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class WaitRequestMessage
    : public SayMessage {
private:
 
public:
 
    WaitRequestMessage()
      { }
 
    char header() const
      {
          return WaitRequestMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return WaitRequestMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class SetplayMessage
    : public SayMessage {
private:
 
    int M_wait_step;
 
public:
 
    explicit
    SetplayMessage( const int wait_step )
        : M_wait_step( wait_step )
      { }
 
    char header() const
      {
          return SetplayMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return SetplayMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class PassRequestMessage
    : public SayMessage {
private:
 
    Vector2D M_target_point; 
 
public:
 
    explicit
    PassRequestMessage( const Vector2D & target_point )
        : M_target_point( target_point )
      { }
 
    char header() const
      {
          return PassRequestMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return PassRequestMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class StaminaMessage
    : public SayMessage {
private:
 
    double M_stamina; 
 
public:
 
    explicit
    StaminaMessage( const double & stamina )
        : M_stamina( stamina )
      { }
 
    char header() const
      {
          return StaminaMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return StaminaMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class RecoveryMessage
    : public SayMessage {
private:
 
    double M_recovery; 
 
public:
 
    explicit
    RecoveryMessage( const double & recovery )
        : M_recovery( recovery )
      { }
 
    char header() const
      {
          return RecoveryMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return RecoveryMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class StaminaCapacityMessage
    : public SayMessage {
private:
 
    double M_stamina_capacity; 
 
public:
 
    explicit
    StaminaCapacityMessage( const double value )
        : M_stamina_capacity( value )
      { }
 
    char header() const
      {
          return StaminaCapacityMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return StaminaCapacityMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class DribbleMessage
    : public SayMessage {
private:
 
    Vector2D M_target_point; 
    int M_queue_count; 
 
public:
 
    DribbleMessage( const Vector2D & target_point,
                    const int queue_count )
        : M_target_point( target_point ),
          M_queue_count( queue_count )
      { }
 
    char header() const
      {
          return DribbleMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return DribbleMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class BallGoalieMessage
    : public SayMessage {
private:
 
    Vector2D M_ball_pos; 
    Vector2D M_ball_vel; 
    Vector2D M_goalie_pos; 
    AngleDeg M_goalie_body; 
 
public:
 
    BallGoalieMessage( const Vector2D & ball_pos,
                       const Vector2D & ball_vel,
                       const Vector2D & goalie_pos,
                       const AngleDeg & goalie_body )
        : M_ball_pos( ball_pos ),
          M_ball_vel( ball_vel ),
          M_goalie_pos( goalie_pos ),
          M_goalie_body( goalie_body )
      { }
 
    char header() const
      {
          return BallGoalieMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return BallGoalieMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class OnePlayerMessage
    : public SayMessage {
private:
 
    int M_unum; 
    Vector2D M_player_pos; 
 
public:
 
    OnePlayerMessage( const int unum,
                      const Vector2D & player_pos )
        : M_unum( unum ),
          M_player_pos( player_pos )
      { }
 
    char header() const
      {
          return OnePlayerMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return OnePlayerMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class TwoPlayerMessage
    : public SayMessage {
private:
 
    int M_player_unum[2]; 
    Vector2D M_player_pos[2]; 
 
    // not usd
    TwoPlayerMessage();
public:
 
    TwoPlayerMessage( const int player0_unum,
                      const Vector2D & player0_pos,
                      const int player1_unum,
                      const Vector2D & player1_pos );
 
    char header() const
      {
          return TwoPlayerMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return TwoPlayerMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class ThreePlayerMessage
    : public SayMessage {
private:
 
    int M_player_unum[3]; 
    Vector2D M_player_pos[3]; 
 
public:
 
    ThreePlayerMessage( const int player0_unum,
                        const Vector2D & player0_pos,
                        const int player1_unum,
                        const Vector2D & player1_pos,
                        const int player2_unum,
                        const Vector2D & player2_pos );
 
    char header() const
      {
          return ThreePlayerMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return ThreePlayerMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class SelfMessage
    : public SayMessage {
private:
 
    Vector2D M_self_pos; 
    AngleDeg M_self_body; 
    double M_self_stamina; 
 
public:
 
    SelfMessage( const Vector2D & self_pos,
                 const AngleDeg & self_body,
                 const double & self_stamina )
        : M_self_pos( self_pos ),
          M_self_body( self_body ),
          M_self_stamina( self_stamina )
      { }
 
    char header() const
      {
          return SelfMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return SelfMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class TeammateMessage
    : public SayMessage {
private:
 
    int M_unum; 
    Vector2D M_player_pos; 
    AngleDeg M_player_body; 
 
public:
 
    TeammateMessage( const int unum,
                     const Vector2D & player_pos,
                     const AngleDeg & player_body )
        : M_unum( unum ),
          M_player_pos( player_pos ),
          M_player_body( player_body )
      { }
 
    char header() const
      {
          return TeammateMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return TeammateMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class OpponentMessage
    : public SayMessage {
private:
 
    int M_unum; 
    Vector2D M_player_pos; 
    AngleDeg M_player_body; 
 
public:
 
    OpponentMessage( const int unum,
                     const Vector2D & player_pos,
                     const AngleDeg & player_body )
        : M_unum( unum ),
          M_player_pos( player_pos ),
          M_player_body( player_body )
      { }
 
    char header() const
      {
          return OpponentMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return OpponentMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
/*-------------------------------------------------------------------*/
class BallPlayerMessage
    : public SayMessage {
private:
 
    Vector2D M_ball_pos; 
    Vector2D M_ball_vel; 
 
    int M_unum; 
    Vector2D M_player_pos; 
    AngleDeg M_player_body; 
 
public:
 
    BallPlayerMessage( const Vector2D & ball_pos,
                       const Vector2D & ball_vel,
                       const int unum,
                       const Vector2D & player_pos,
                       const AngleDeg & player_body )
        : M_ball_pos( ball_pos ),
          M_ball_vel( ball_vel ),
          M_unum( unum ),
          M_player_pos( player_pos ),
          M_player_body( player_body )
      { }
 
    char header() const
      {
          return BallPlayerMessageParser::sheader();
      }
 
    static
    int slength()
      {
          return BallPlayerMessageParser::slength();
      }
 
    int length() const
      {
          return slength();
      }
 
    bool appendTo( std::string & to ) const;
 
    std::ostream & printDebug( std::ostream & os ) const;
 
};
 
}
 
#endif