referee.h

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

// -*-c++-*-

/***************************************************************************
                                   referee.h  
                              Refereeing module
                             -------------------
    begin                : 16-May-2002
    copyright            : (C) 2001 by The RoboCup Soccer Server 
                           Maintenance Group.
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#ifndef REFEREE_H
#define REFEREE_H

// later on I want this to produce a library that can be dlopened by
// the server. This way different referring modules could be used
// without having to recompile the server

#include "types.h"
#include "object.h"
#include<set>

class Stadium;
class Player;

class Referee
{
protected:
  Stadium& M_stadium;
public:
  Referee( Stadium& stadium )
    : M_stadium( stadium )
  {}

  virtual
  ~Referee()
  {}

  virtual
  void
  kickTaken( Player& )
  {}

    virtual
    void
    ballCaught( Player& )
    {}


  virtual
  void
  ballTouched( Player& )
  {}

  virtual
  void
  analyse()
  {}

  virtual
  void
  playModeChange( PlayMode )
  {}

  class
  doKickTaken
  {
  private:
    Player& M_kicker;
  public:
    doKickTaken( Player& kicker )
      : M_kicker( kicker )
    {}

    void
    operator()( Referee* ref )
    { ref->kickTaken( M_kicker ); }
  };

  class
  doCaughtBall
  {
  private:
    Player& M_catcher;
  public:
    doCaughtBall( Player& catcher )
      : M_catcher( catcher )
    { }

    void
    operator()( Referee* ref )
    { ref->ballCaught( M_catcher ); }
  };

  static
  void
  doAnalyse( Referee* ref )
  { ref->analyse(); }

  class
  doPlayModeChange
  {
  private:
    PlayMode M_pm;
  public:
    doPlayModeChange( PlayMode pm )
      : M_pm( pm )
    {}

    void
    operator()( Referee* ref )
    { ref->playModeChange( M_pm ); }
  };

  class
  doBallTouched
  {
  private:
    Player& M_player;
  public:
    doBallTouched( Player& player )
      : M_player( player )
    {}

    void
    operator()( Referee* ref )
    { ref->ballTouched( M_player ); }
  };


protected:
  PVector
  truncateToPitch( PVector pos );

  PVector
  moveOutOfPenalty( Side side, PVector pos );

    PVector
    moveIntoPenalty( Side side, PVector pos );

  void
  awardFreeKick( Side side, PVector pos );

  void
  callCatchFault( Side side, PVector pos );

  void
  callFreeKickFault( Side side, PVector pos );

  void
  awardGoalKick( Side side, PVector pos );

  void
  awardDropBall( PVector pos );

  void
  awardKickIn( Side side, PVector pos );

  void
  awardCornerKick( Side side, PVector pos );

    bool
    inPenaltyArea( Side side, PVector pos );

};

class FreeKickRef
  : public Referee
{
private:
  bool M_kick_taken;
  int M_goal_kick_count;
  Player* M_kick_taker;
  int M_kick_taker_dashes;
  int M_timer;
    Side m_indirect_side;
public:
  FreeKickRef( Stadium& stadium )
    : Referee( stadium ),
      M_kick_taken( false ),
      M_goal_kick_count( 0 ),
      M_kick_taker( 0 ),
      M_kick_taker_dashes( 0 ),
      M_timer( -1 ),
      m_indirect_side( NEUTRAL )
  {}

  virtual
  ~FreeKickRef()
  {}

  virtual
  void
  kickTaken( Player& kicker );

  virtual
  void
  ballTouched( Player& player );

  virtual
  void
  analyse();

  virtual
  void
  playModeChange( PlayMode pm );

private:
  bool
  goalKick( PlayMode pm );

  bool
  freeKick( PlayMode pm );

  bool
  indirectFreeKick( PlayMode pm );

  bool
  ballStopped();

  bool
  ballInPenaltyArea();

  bool
  tooManyGoalKicks();

};


class TouchRef
  : public Referee
{
private:
  Player* M_last;

public:
  TouchRef( Stadium& stadium )
    : Referee( stadium ),
      M_last( NULL )
  {}

  virtual
  ~TouchRef()
  {}

  virtual
  void
  analyse();

  virtual
  void
  kickTaken( Player& kicker );

  virtual
  void
  ballTouched( Player& player );
  
  virtual
  void
  playModeChange( PlayMode pm );
};


class KeepawayRef
  : public Referee
{
private:
  static char* trainingMsg;
  static const int TURNOVER_TIME;
  int M_episode;
  int M_keepers, M_takers;
  TheNumber M_time;
  TheNumber M_take_time;
  time_t M_start_time;
public:
  KeepawayRef( Stadium& stadium )
    : Referee( stadium ),
      M_episode( 0 ),
      M_keepers( 0 ),
      M_takers( 0 ),
      M_time( 0 ),
      M_take_time( 0 ),
      M_start_time( time( NULL ) )
  {}

  virtual
  ~KeepawayRef()
  {}

  virtual
  void
  analyse();

  virtual
  void
  kickTaken( Player& kicker );

  virtual
  void
  ballTouched( Player& player );

  virtual
  void
  playModeChange( PlayMode pm );

private:
  bool
  ballInKeepawayArea();

  void
  logHeader();

  void
  logEpisode( const char *endCond );

  void
  resetField();
};

class CatchRef
    : public Referee
{
public:
    CatchRef( Stadium& stadium )
        : Referee( stadium )
    {}

    virtual
    ~CatchRef()
    {}

    virtual
    void
    analyse();

    virtual
    void
    ballCaught( Player& );
};


class PenaltyRef
    : public Referee
{
private:
  int M_timer;
  int M_pen_nr_taken;
  Side M_pen_side;
  bool M_bDebug;
  Side M_cur_pen_taker;
  set<int> M_sLeftPenTaken;
  set<int> M_sRightPenTaken;


public:
    PenaltyRef( Stadium& stadium )
        : Referee( stadium ),
          M_timer( -1 ),
          M_pen_nr_taken( 0 ),
          M_bDebug(false)
    {}

    virtual
    ~PenaltyRef()
    {}

    virtual
    void
    analyse();

    virtual
    void
    kickTaken( Player& kicker );

    virtual
    void
    playModeChange( PlayMode pm );

    virtual
    void
    ballCaught( Player& );
    


  void penalty_init();
  void penalty_foul( Side side );
  void penalty_check_score( );
  bool penalty_check_players( Side side, int *iPenaltyTaker = NULL  );
  void penalty_place_all_players( Side side, int *iPenaltyTaker = NULL  );
  void penalty_miss( Side side );
  void penalty_score( Side side );

};


#endif //REFEREE_H