player_predicate.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hiroki SHIMORA, 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_PLAYER_PREDICATE_H
#define RCSC_PLAYER_PLAYER_PREDICATE_H
 
#include <rcsc/player/abstract_player_object.h>
#include <rcsc/player/world_model.h>
#include <rcsc/math_util.h>
 
#include <memory>
#include <vector>
#include <algorithm>
#include <cmath>
 
namespace rcsc {
 
class PlayerPredicate {
public:
    typedef std::shared_ptr< PlayerPredicate > Ptr; 
    typedef std::shared_ptr< const PlayerPredicate > ConstPtr; 
 
protected:
    PlayerPredicate()
      { }
 
public:
    virtual
    ~PlayerPredicate()
      { }
 
    virtual
    bool operator()( const AbstractPlayerObject & p ) const = 0;
 
    virtual
    Ptr clone() const = 0;
};
 
class AndPlayerPredicate
    : public PlayerPredicate {
private:
    std::vector< PlayerPredicate::ConstPtr > M_predicates;
 
    // not used
    AndPlayerPredicate() = delete;
public:
    // XXX: implicit_shared_ptr
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 )
        : M_predicates()
      {
          M_predicates.reserve( 2 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 )
        : M_predicates()
      {
          M_predicates.reserve( 3 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 ,
                        const PlayerPredicate * p4 )
        : M_predicates()
      {
          M_predicates.reserve( 4 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 ,
                        const PlayerPredicate * p4 ,
                        const PlayerPredicate * p5 )
        : M_predicates()
      {
          M_predicates.reserve( 5 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 ,
                        const PlayerPredicate * p4 ,
                        const PlayerPredicate * p5 ,
                        const PlayerPredicate * p6 )
        : M_predicates()
      {
          M_predicates.reserve( 6 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 ,
                        const PlayerPredicate * p4 ,
                        const PlayerPredicate * p5 ,
                        const PlayerPredicate * p6 ,
                        const PlayerPredicate * p7 )
        : M_predicates()
      {
          M_predicates.reserve( 7 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
          M_predicates.push_back( ConstPtr( p7 ) );
      }
 
    AndPlayerPredicate( const PlayerPredicate * p1 ,
                        const PlayerPredicate * p2 ,
                        const PlayerPredicate * p3 ,
                        const PlayerPredicate * p4 ,
                        const PlayerPredicate * p5 ,
                        const PlayerPredicate * p6 ,
                        const PlayerPredicate * p7 ,
                        const PlayerPredicate * p8 )
        : M_predicates()
      {
          M_predicates.reserve( 8 );
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
          M_predicates.push_back( ConstPtr( p7 ) );
          M_predicates.push_back( ConstPtr( p8 ) );
      }
 
private:
    AndPlayerPredicate( const std::vector< ConstPtr > & predicates )
        : M_predicates( predicates )
      { }
 
public:
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          for ( const ConstPtr & pred : M_predicates )
          {
              if ( ! (*pred)( p ) )
              {
                  return false;
              }
          }
 
          return true;
      }
 
    Ptr clone() const
      {
          return Ptr( new AndPlayerPredicate( M_predicates ) );
      }
};
 
class OrPlayerPredicate
    : public PlayerPredicate {
private:
    std::vector< ConstPtr > M_predicates;
 
    // not used
    OrPlayerPredicate() = delete;
public:
    // XXX: implicit_shared_ptr
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 ,
                       const PlayerPredicate * p4 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 ,
                       const PlayerPredicate * p4 ,
                       const PlayerPredicate * p5 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 ,
                       const PlayerPredicate * p4 ,
                       const PlayerPredicate * p5 ,
                       const PlayerPredicate * p6 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 ,
                       const PlayerPredicate * p4 ,
                       const PlayerPredicate * p5 ,
                       const PlayerPredicate * p6 ,
                       const PlayerPredicate * p7 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
          M_predicates.push_back( ConstPtr( p7 ) );
      }
 
    OrPlayerPredicate( const PlayerPredicate * p1 ,
                       const PlayerPredicate * p2 ,
                       const PlayerPredicate * p3 ,
                       const PlayerPredicate * p4 ,
                       const PlayerPredicate * p5 ,
                       const PlayerPredicate * p6 ,
                       const PlayerPredicate * p7 ,
                       const PlayerPredicate * p8 )
        : M_predicates()
      {
          M_predicates.push_back( ConstPtr( p1 ) );
          M_predicates.push_back( ConstPtr( p2 ) );
          M_predicates.push_back( ConstPtr( p3 ) );
          M_predicates.push_back( ConstPtr( p4 ) );
          M_predicates.push_back( ConstPtr( p5 ) );
          M_predicates.push_back( ConstPtr( p6 ) );
          M_predicates.push_back( ConstPtr( p7 ) );
          M_predicates.push_back( ConstPtr( p8 ) );
      }
 
private:
    OrPlayerPredicate( const std::vector< ConstPtr > & predicates )
        : M_predicates( predicates )
      { }
 
public:
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          for ( const ConstPtr & pred : M_predicates )
          {
              if ( (*pred)( p ) )
              {
                  return true;
              }
          }
 
          return false;
      }
 
    Ptr clone() const
      {
          return Ptr( new OrPlayerPredicate( M_predicates ) );
      }
};
 
class NotPlayerPredicate
    : public PlayerPredicate {
private:
    ConstPtr M_predicate;
 
    // not used
    NotPlayerPredicate() = delete;
public:
 
    explicit
    NotPlayerPredicate( const PlayerPredicate * predicate )
        : M_predicate( predicate )
      { }
 
    explicit
    NotPlayerPredicate( ConstPtr predicate )
        : M_predicate( predicate )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ! (*M_predicate)( p );
      }
 
    Ptr clone() const
      {
          return Ptr( new NotPlayerPredicate( M_predicate ) );
      }
};
 
class SelfPlayerPredicate
    : public PlayerPredicate {
private:
    const SideID M_our_side;
    const int M_self_unum;
 
    // not used
    SelfPlayerPredicate() = delete;
public:
    explicit
    SelfPlayerPredicate( const WorldModel & wm )
        : M_our_side( wm.ourSide() ),
          M_self_unum( wm.self().unum() )
      { }
 
    explicit
    SelfPlayerPredicate( const SideID our_side,
                         const int self_unum )
        : M_our_side( our_side ),
          M_self_unum( self_unum )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.side() == M_our_side
              && p.unum() == M_self_unum;
      }
 
    Ptr clone() const
      {
          return Ptr( new SelfPlayerPredicate( M_our_side, M_self_unum ) );
      }
};
 
class TeammateOrSelfPlayerPredicate
    : public PlayerPredicate {
private:
    const SideID M_our_side;
 
    // not used
    TeammateOrSelfPlayerPredicate() = delete;
public:
    explicit
    TeammateOrSelfPlayerPredicate( const WorldModel & wm )
        : M_our_side( wm.ourSide() )
      { }
 
    explicit
    TeammateOrSelfPlayerPredicate( const SideID our_side )
        : M_our_side( our_side )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.side() == M_our_side;
      }
 
 
    Ptr clone() const
      {
          return Ptr( new TeammateOrSelfPlayerPredicate( M_our_side ) );
      }
};
 
class TeammatePlayerPredicate
    : public PlayerPredicate {
private:
    const SideID M_our_side;
    const int M_self_unum;
 
    // not used
    TeammatePlayerPredicate() = delete;
public:
    explicit
    TeammatePlayerPredicate( const WorldModel & wm )
        : M_our_side( wm.ourSide() )
        , M_self_unum( wm.self().unum() )
      { }
 
    explicit
    TeammatePlayerPredicate( const SideID our_side,
                             const int self_unum )
        : M_our_side( our_side )
        , M_self_unum( self_unum )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.side() == M_our_side
              && p.unum() != M_self_unum;
      }
 
    Ptr clone() const
      {
          return Ptr( new TeammatePlayerPredicate( M_our_side, M_self_unum ) );
      }
};
 
class OpponentPlayerPredicate
    : public PlayerPredicate {
private:
    const SideID M_our_side;
 
    // not used
    OpponentPlayerPredicate() = delete;
public:
    explicit
    OpponentPlayerPredicate( const WorldModel & wm )
        : M_our_side( wm.ourSide() )
      { }
 
    explicit
    OpponentPlayerPredicate( const SideID our_side )
        : M_our_side( our_side )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.side() != M_our_side
              && p.side() != NEUTRAL;
      }
 
    Ptr clone() const
      {
          return Ptr( new OpponentPlayerPredicate( M_our_side ) );
      }
};
 
class OpponentOrUnknownPlayerPredicate
    : public PlayerPredicate {
private:
    const SideID M_our_side;
 
    // not used
    OpponentOrUnknownPlayerPredicate() = delete;
public:
    explicit
    OpponentOrUnknownPlayerPredicate( const WorldModel & wm )
        : M_our_side( wm.ourSide() )
      { }
 
    explicit
    OpponentOrUnknownPlayerPredicate( const SideID our_side )
        : M_our_side( our_side )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.side() != M_our_side;
      }
 
    Ptr clone() const
      {
          return Ptr( new OpponentOrUnknownPlayerPredicate( M_our_side ) );
      }
};
 
class GoaliePlayerPredicate
    : public PlayerPredicate {
public:
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.goalie();
      }
 
    Ptr clone() const
      {
          return Ptr( new GoaliePlayerPredicate() );
      }
};
 
class FieldPlayerPredicate
    : public PlayerPredicate {
public:
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ! p.goalie();
      }
 
    Ptr clone() const
      {
          return Ptr( new FieldPlayerPredicate() );
      }
};
 
class CoordinateAccuratePlayerPredicate
    : public PlayerPredicate {
private:
    const int M_threshold;
 
    // not used
    CoordinateAccuratePlayerPredicate() = delete;
public:
    explicit
    CoordinateAccuratePlayerPredicate( const int threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.posCount() <= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new CoordinateAccuratePlayerPredicate( M_threshold ) );
      }
};
 
class GhostPlayerPredicate
    : public PlayerPredicate {
private:
 
public:
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.isGhost();
      }
 
    Ptr clone() const
      {
          return Ptr( new GhostPlayerPredicate() );
      }
};
 
class NoGhostPlayerPredicate
    : public PlayerPredicate {
private:
    const int M_threshold;
 
    // not used
    NoGhostPlayerPredicate() = delete;
public:
    explicit
    NoGhostPlayerPredicate( const int threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ! p.isGhost()
              && p.posCount() <= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new NoGhostPlayerPredicate( M_threshold ) );
      }
};
 
class XCoordinateForwardPlayerPredicate
    : public PlayerPredicate {
private:
    const double M_threshold;
 
    // not used
    XCoordinateForwardPlayerPredicate() = delete;
public:
    explicit
    XCoordinateForwardPlayerPredicate( const double & threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.pos().x >= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new XCoordinateForwardPlayerPredicate( M_threshold ) );
      }
};
 
class XCoordinateBackwardPlayerPredicate
    : public PlayerPredicate {
private:
    const double M_threshold;
 
    // not used
    XCoordinateBackwardPlayerPredicate() = delete;
public:
    explicit
    XCoordinateBackwardPlayerPredicate( const double & threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.pos().x <= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new XCoordinateBackwardPlayerPredicate( M_threshold ) );
      }
};
 
class YCoordinatePlusPlayerPredicate
    : public PlayerPredicate {
private:
    const double M_threshold;
 
    // not used
    YCoordinatePlusPlayerPredicate() = delete;
public:
    explicit
    YCoordinatePlusPlayerPredicate( const double & threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.pos().y >= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new YCoordinatePlusPlayerPredicate( M_threshold ) );
      }
};
 
class YCoordinateMinusPlayerPredicate
    : public PlayerPredicate {
private:
    const double M_threshold;
 
    // not used
    YCoordinateMinusPlayerPredicate() = delete;
public:
    explicit
    YCoordinateMinusPlayerPredicate( const double & threshold )
        : M_threshold( threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return p.pos().y <= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new YCoordinateMinusPlayerPredicate( M_threshold ) );
      }
};
 
class PointFarPlayerPredicate
    : public PlayerPredicate {
private:
    const Vector2D M_base_point;
    const double M_threshold2;
 
    // not used
    PointFarPlayerPredicate() = delete;
public:
    PointFarPlayerPredicate( const Vector2D & base_point,
                             const double & threshold )
        : M_base_point( base_point )
        , M_threshold2( threshold * threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ( p.pos() - M_base_point ).r2() >= M_threshold2;
      }
 
    Ptr clone() const
      {
          return Ptr( new PointFarPlayerPredicate( M_base_point, M_threshold2 ) );
      }
};
 
class PointNearPlayerPredicate
    : public PlayerPredicate {
private:
    const Vector2D M_base_point;
    const double M_threshold2;
 
    // not used
    PointNearPlayerPredicate() = delete;
public:
    PointNearPlayerPredicate( const Vector2D & base_point,
                              const double & threshold )
        : M_base_point( base_point ),
          M_threshold2( threshold * threshold )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ( p.pos() - M_base_point ).r2() <= M_threshold2;
      }
 
    Ptr clone() const
      {
          return Ptr( new PointNearPlayerPredicate( M_base_point, M_threshold2 ) );
      }
};
 
class AbsAngleDiffLessPlayerPredicate
    : public PlayerPredicate {
private:
    const Vector2D M_base_point;
    const AngleDeg M_base_angle;
    const double M_threshold;
 
    // not used
    AbsAngleDiffLessPlayerPredicate() = delete;
public:
    AbsAngleDiffLessPlayerPredicate( const Vector2D & base_point,
                                     const AngleDeg & base_angle,
                                     const double & degree_threshold )
        : M_base_point( base_point ),
          M_base_angle( base_angle ),
          M_threshold( std::fabs( degree_threshold ) )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ( ( p.pos() - M_base_point ).th() - M_base_angle ).abs() <= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new AbsAngleDiffLessPlayerPredicate( M_base_point, M_base_angle, M_threshold ) );
      }
};
 
class AbsAngleDiffGreaterPlayerPredicate
    : public PlayerPredicate {
private:
    const Vector2D M_base_point;
    const AngleDeg M_base_angle;
    const double M_threshold;
 
    // not used
    AbsAngleDiffGreaterPlayerPredicate() = delete;
public:
    AbsAngleDiffGreaterPlayerPredicate( const Vector2D & base_point,
                                        const AngleDeg & base_angle,
                                        const double & threshold )
        : M_base_point( base_point ),
          M_base_angle( base_angle ),
          M_threshold( std::fabs( threshold ) )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return ( ( p.pos() - M_base_point ).th() - M_base_angle ).abs() >= M_threshold;
      }
 
    Ptr clone() const
      {
          return Ptr( new AbsAngleDiffGreaterPlayerPredicate( M_base_point, M_base_angle, M_threshold ) );
      }
};
 
class OffsidePositionPlayerPredicate
    : public PlayerPredicate {
private:
    const WorldModel & M_world;
 
    // not used
    OffsidePositionPlayerPredicate() = delete;
public:
    OffsidePositionPlayerPredicate( const WorldModel & wm )
        : M_world( wm )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          if ( p.side() == M_world.self().side() )
          {
              return p.pos().x > M_world.offsideLineX();
          }
          else if ( p.side() == NEUTRAL )
          {
              return false;
          }
          else
          {
              return p.pos().x < bound( M_world.ball().pos().x, M_world.ourDefenseLineX(), 0.0 );
          }
      }
 
    Ptr clone() const
      {
          return Ptr( new OffsidePositionPlayerPredicate( M_world ) );
      }
};
 
class ExistNearPlayerPlayerPredicate
    : public PlayerPredicate {
 
private:
    const rcsc::WorldModel & M_world;
 
    ConstPtr M_predicate;
 
    double M_threshold2;
 
public:
    ExistNearPlayerPlayerPredicate( const WorldModel & wm,
                                    ConstPtr predicate,
                                    const double & threshold )
        : M_world( wm ),
          M_predicate( predicate ),
          M_threshold2( threshold * threshold )
      { }
 
    bool operator() ( const AbstractPlayerObject & p ) const
      {
          for ( const AbstractPlayerObject * target : M_world.allPlayers() )
          {
              if ( ( target->pos() - p.pos() ).r2() <= M_threshold2
                   && (*M_predicate)( *target ) )
              {
                  return true;
              }
          }
 
          return false;
      }
 
    Ptr clone() const
      {
          return Ptr( new ExistNearPlayerPlayerPredicate( M_world,
                                                          M_predicate->clone(),
                                                          std::sqrt( M_threshold2 ) ) );
      }
};
 
template< typename T >
class ContainsPlayerPredicate
    : public PlayerPredicate {
private:
    T M_region;
 
public:
 
    ContainsPlayerPredicate( const T & region )
        : M_region( region )
      { }
 
    bool operator()( const AbstractPlayerObject & p ) const
      {
          return M_region.contains( p.pos() );
      }
 
    PlayerPredicate::Ptr clone() const
      {
          return Ptr( new ContainsPlayerPredicate( M_region ) );
      }
};
 
}
 
#endif