visual.cc

在LINUX下运行的仿真机器人服务器源代码

            case MPObject::OT_GOAL:
            {
                static const char name[] = "(Goal)";
                return name;
            }
            case MPObject::OT_FLAG:
            {
                static const char name[] = "(Flag)";
                return name;
            }
            case MPObject::OT_BALL:
            {
                static const char name[] = "(Ball)";
                return name;
            }
            case MPObject::OT_PLAYER:
            {
                static const char name[] = "(Player)";
                return name;
            }
            case MPObject::OT_LINE:
            {
                static const char name[] = "(Line)";
                return name;
            }
            default:
                // this should never execute
            {
                static const char name[] = "(Unknown)";
                return name;
            }
        }
    }

    const char*
    VisualSenderPlayerV1::calcTFarName( const Player& obj ) const
    { return obj.name_toofar; }

    const char*
    VisualSenderPlayerV1::calcUFarName( const Player& obj ) const
    { return obj.name_far; }

/*!
//===================================================================
//
//  CLASS: VisualSenderPlayerV4
//
//  DESC: Class for the version 4 visual protocol.  This version
//        introduced body directions of players. Everything else is
//        the same.
//
//===================================================================
*/

    VisualSenderPlayerV4::VisualSenderPlayerV4( const Params& params )
        : VisualSenderPlayerV1( params )
    {}

    VisualSenderPlayerV4::~VisualSenderPlayerV4()
    {}

    void
    VisualSenderPlayerV4::serializePlayer( const Player& player,
                                           double dist, int dir, 
                                           double dist_chg, double dir_chg )
    {
        serializer().serializeVisualObject( transport(), 
                                            calcName( player ),
                                            dist, dir, dist_chg, dir_chg,
                                            calcBodyDir( player ) );
    }

    int 
    VisualSenderPlayerV4::calcBodyDir( const Player& player ) const
    {
        return rad2Deg ( normalize_angle ( player.angle 
                                           - self().angle 
                                           - self().angle_neck_committed ) );
    } 

/*!
//===================================================================
//
//  CLASS: VisualSensorPlayerV5
//
//  DESC: Class for the version 5 visual protocol.  This version
//        introduced head directions of players. Everything else is
//        the same
//
//===================================================================
*/


    VisualSenderPlayerV5::VisualSenderPlayerV5( const Params& params )
        : VisualSenderPlayerV4( params )
    {}


    VisualSenderPlayerV5::~VisualSenderPlayerV5()
    {}

    void
    VisualSenderPlayerV5::serializePlayer( const Player& player,
                                           double dist, int dir, 
                                           double dist_chg, double dir_chg )
    {
        serializer().serializeVisualObject( transport(), 
                                            calcName( player ),
                                            dist, dir, dist_chg, dir_chg,
                                            calcBodyDir( player ),
                                            calcHeadDir( player ) );
    }

    int
    VisualSenderPlayerV5::calcHeadDir( const Player& player ) const
    {
        return rad2Deg( normalize_angle( player.angle_neck_committed 
                                         + player.angle
                                         - self().angle 
                                         - self().angle_neck_committed ) );
    }

/*!
//===================================================================
//
//  CLASS: VisualSensorPlayerV6
//
//  DESC: Class for the version 6 visual protocol.  This version
//        introduced shortened names for all the objects meaning the
//        name calculation must be redefined.
//
//===================================================================
*/
   
    VisualSenderPlayerV6::VisualSenderPlayerV6( const Params& params )
        : VisualSenderPlayerV5( params )
    {}

    VisualSenderPlayerV6::~VisualSenderPlayerV6()
    {}

    const char*
    VisualSenderPlayerV6::calcName( const PObject& obj ) const
    {
        return obj.short_name;
    }

    const char*
    VisualSenderPlayerV6::calcCloseName( const PObject& obj ) const
    {
        switch ( obj.getObjectType() )
        {
            case MPObject::OT_GOAL:
            {
                static const char name[] = "(G)";
                return name;
            }
            case MPObject::OT_FLAG:
            {
                static const char name[] = "(F)";
                return name;
            }
            case MPObject::OT_BALL:
            {
                static const char name[] = "(B)";
                return name;
            }
            case MPObject::OT_PLAYER:
            {
                static const char name[] = "(P)";
                return name;
            }
            case MPObject::OT_LINE:
            {
                static const char name[] = "(L)";
                return name;
            }
            default:
                // this should never execute
            {
                static const char name[] = "(Unknown)";
                return name;
            }
        }
    }


    const char*
    VisualSenderPlayerV6::calcUFarName( const Player& obj ) const
    {
        return obj.short_name_far;
    }

    const char*
    VisualSenderPlayerV6::calcTFarName( const Player& obj ) const
    {
        return obj.short_name_toofar;
    }

/*!
//===================================================================
//
//  CLASS: VisualSensorPlayerV7
//
//  DESC: Class for the version 7 visual protocol.  This version
//        fixed a bug in the generation of directions in that they
//        were truncated to int, rather than rounded.  This meant
//        error in the direction pointed was at most times between
//        -0.5 and +0.5 degrees, but occationally between -1.0 and
//        +1.0 degrees and at other times exact.  With the new method
//        of rounding, the error is always between -0.5 and +0.5.
//
//===================================================================
*/

    VisualSenderPlayerV7::VisualSenderPlayerV7( const Params& params )
        : VisualSenderPlayerV6( params )
    {}

    VisualSenderPlayerV7::~VisualSenderPlayerV7()
    {}

    int
    VisualSenderPlayerV7::rad2Deg( double rad ) const
    { return Rad2IDegRound( rad ); }

/*!
//===================================================================
//
//  CLASS: VisualSensorPlayerV8
//
//  DESC: Class for the version 8 visual protocol.  This version
//        introduced observation of the a new arm feature, that
//        allows plays to point to different spots, however, on
//        direction the arm is pointing to is visable, not the
//        distance to the spot the arm is pointing to.
//
//===================================================================
*/

    VisualSenderPlayerV8::VisualSenderPlayerV8( const Params& params )
        : VisualSenderPlayerV7( params )
    {}

    VisualSenderPlayerV8::~VisualSenderPlayerV8()
    {}

    int
    VisualSenderPlayerV8::calcPointDir( const Player& player )
    {
        double dir = 0.0;
        if( player.getArmDir( dir ) )
        {
            dir += player.angle_neck_committed 
                + player.angle
                - self().angle 
                - self().angle_neck_committed;
            
            // add random noise

            // With a normal distribution, 95% of the values are within 2
            // std deviations of the mean, so if we set sigma to 1/2 our
            // desired range, then 95% of values will be in that range.
            // NOTE: This means that 5% of the time it will be outside
            // of this range.
            double sigma = self().pos.distance( player.pos ) 
                / 60.0; // this should be replaced by the line below.
            //        / ServerParam::instance().getTeamTooFarLength ();
            sigma = pow( sigma, 4 ); // 4 should be parameterized
            // sigma is now a range between 0 and 1.0

            double min_noise_level = Deg2Rad(2.5) * 0.5; 
            // 5.0 should be parameterized.  It is halved for the same
            // reason we want sigma to be half the desired range
            sigma *= PI - min_noise_level; 
            sigma += min_noise_level; 

            //sigma is now in a range of 2.5 to 180 degrees, dependant on
            //the distance of the player.  95% of the returned random values
            //will be within +- 2*sigma of dir
            boost::normal_distribution< rcss::random::DefaultRNG > rng( rcss::random::DefaultRNG::instance(), 
                                                                        dir, sigma);

            return rad2Deg( normalize_angle( rng() ) );
        }
        else
            return 0;
    }

    void
    VisualSenderPlayerV8::serializePlayer( const Player& player,
                                           const char* name,
                                           double dist, int dir, 
                                           double dist_chg, double dir_chg )
    {
        if( player.getArm().isPointing() )
        {
            int point_dir = calcPointDir( player );
            serializer().serializeVisualObject( transport(), 
                                                name,
                                                dist, dir,
                                                dist_chg, dir_chg,
                                                calcBodyDir( player ),
                                                calcHeadDir( player ),
                                                point_dir,
                                                player.isTackling() );
        }
        else
            serializer().serializeVisualObject( transport(), 
                                                name,
                                                dist, dir,
                                                dist_chg, dir_chg,
                                                calcBodyDir( player ),
                                                calcHeadDir( player ),
                                                player.isTackling() );
    }

    void
    VisualSenderPlayerV8::serializePlayer( const Player& player,
                                           const char* name,
                                           double dist, int dir )
    {
        if( player.getArm().isPointing() )
        {
            int point_dir = calcPointDir( player );
            serializer().serializeVisualObject( transport(), 
                                                name,
                                                dist,
                                                dir,
                                                point_dir,
                                                player.isTackling() );
        }
        else
            serializer().serializeVisualObject( transport(), 
                                                name,
                                                dist,
                                                dir,
                                                player.isTackling() );
    }
  
/*!
//===================================================================
//
//  Register senders for different versions
//
//===================================================================
*/
    
    namespace visual
    {
        template< typename Sender >
        std::auto_ptr< VisualSenderPlayer >
        create( const VisualSenderPlayer::Params& params )
        { return std::auto_ptr< VisualSenderPlayer >( new Sender( params ) ); }
        
        lib::RegHolder vp1 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV1 >, 1 );
        lib::RegHolder vp2 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV1 >, 2 );
        lib::RegHolder vp3 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV1 >, 3 );
        lib::RegHolder vp4 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV4 >, 4 );
        lib::RegHolder vp5 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV5 >, 5 );
        lib::RegHolder vp6 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV6 >, 6 );
        lib::RegHolder vp7 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV7 >, 7 );
        lib::RegHolder vp8 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV8 >, 8 );
        lib::RegHolder vp9 = VisualSenderPlayer::factory().autoReg( &create< VisualSenderPlayerV8 >, 9 );
    }
}