game_state.h

#pragma once
 
#include "software/geom/point.h"
#include "software/util/make_enum/make_enum.hpp"
#include "software/world/ball.h"
 
// clang-format off
MAKE_ENUM(RefereeCommand,
          // these enums map to the enums in ssl_referee.proto
          HALT,
          STOP,
          NORMAL_START,
          FORCE_START,
          PREPARE_KICKOFF_US,
          PREPARE_KICKOFF_THEM,
          PREPARE_PENALTY_US,
          PREPARE_PENALTY_THEM,
          DIRECT_FREE_US,
          DIRECT_FREE_THEM,
          INDIRECT_FREE_US,
          INDIRECT_FREE_THEM,
          TIMEOUT_US,
          TIMEOUT_THEM,
          GOAL_US,
          GOAL_THEM,
          BALL_PLACEMENT_US,
          BALL_PLACEMENT_THEM);
// clang-format on
 
MAKE_ENUM(RefereeStage,
          // The first half is about to start.
          // A kickoff is called within this stage.
          // This stage ends with the NORMAL_START.
          NORMAL_FIRST_HALF_PRE,
          // The first half of the normal game, before half time.
          NORMAL_FIRST_HALF,
          // Half time between first and second halves.
          NORMAL_HALF_TIME,
          // The second half is about to start.
          // A kickoff is called within this stage.
          // This stage ends with the NORMAL_START.
          NORMAL_SECOND_HALF_PRE,
          // The second half of the normal game, after half time.
          NORMAL_SECOND_HALF,
          // The break before extra time.
          EXTRA_TIME_BREAK,
          // The first half of extra time is about to start.
          // A kickoff is called within this stage.
          // This stage ends with the NORMAL_START.
          EXTRA_FIRST_HALF_PRE,
          // The first half of extra time.
          EXTRA_FIRST_HALF,
          // Half time between first and second extra halves.
          EXTRA_HALF_TIME,
          // The second half of extra time is about to start.
          // A kickoff is called within this stage.
          // This stage ends with the NORMAL_START.
          EXTRA_SECOND_HALF_PRE,
          // The second half of extra time.
          EXTRA_SECOND_HALF,
          // The break before penalty shootout.
          PENALTY_SHOOTOUT_BREAK,
          // The penalty shootout.
          PENALTY_SHOOTOUT,
          // The game is over.
          POST_GAME);
 
class GameState
{
   public:
    enum PlayState
    {
        HALT,    // Robots must not move
        STOP,    // Robots must stay a set distance away from ball
        SETUP,   // Robots not on starting team must stay a set distance away from ball
        READY,   // A robot on the starting team may kick the ball
        PLAYING  // Normal play
    };
 
    // Types of restarts
    enum RestartReason
    {
        NONE,
        KICKOFF,
        DIRECT,
        INDIRECT,
        PENALTY,
        BALL_PLACEMENT
    };
 
    GameState()
        : play_state_(HALT),
          restart_reason_(NONE),
          command_(RefereeCommand::HALT),
          ball_(std::nullopt),
          our_restart_(false),
          ball_placement_point_(std::nullopt)
    {
    }
 
    explicit GameState(const TbotsProto::GameState& game_state_proto);
 
    void updateRefereeCommand(RefereeCommand gameState);
 
    void updateBall(const Ball& ball);
 
    void setRestartCompleted();
 
    const RefereeCommand& getRefereeCommand() const;
 
    RestartReason getRestartReason() const;
 
    /*
     * Rule queries
     *
     * See https://download.tigers-mannheim.de/rules/2018_ssl-rules.pdf
     * for more details
     */
 
    bool isHalted() const;
 
    bool isStopped() const;
 
    bool isPlaying() const;
 
    bool isKickoff() const;
 
    bool isPenalty() const;
 
    bool isBallPlacement() const;
 
    bool isOurRestart() const;
 
    bool isDirectFree() const;
 
    bool isIndirectFree() const;
 
    bool isOurKickoff() const;
 
    bool isOurPenalty() const;
 
    bool isOurDirectFree() const;
 
    bool isOurIndirectFree() const;
 
    bool isOurFreeKick() const;
 
    bool isOurBallPlacement() const;
 
    bool isTheirKickoff() const;
 
    bool isTheirPenalty() const;
 
    bool isTheirDirectFree() const;
 
    bool isTheirIndirectFree() const;
 
    bool isTheirFreeKick() const;
 
    bool isTheirBallPlacement() const;
 
    PlayState getPlayState(void) const;
 
    bool isSetupRestart() const;
 
    bool isSetupState() const;
    bool isReadyState() const;
 
    bool canKick() const;
 
    bool stayAwayFromBall() const;
 
    bool stayOnSide() const;
 
    bool stayBehindPenaltyLine() const;
 
    bool operator==(const GameState& other) const;
 
    bool operator!=(const GameState& other) const;
 
    std::optional<Point> getBallPlacementPoint(void) const;
 
    std::optional<Ball> getBall(void) const;
 
    void setBallPlacementPoint(Point placementPoint);
 
   private:
    PlayState play_state_;
    RestartReason restart_reason_;
    RefereeCommand command_;
    std::optional<Ball> ball_;
 
    // True if our team can kick the ball during a restart
    bool our_restart_;
 
    // The point at which the ball should be placed by robots before a restart. See
    // Robocup SSL Rules 9.2.
    std::optional<Point> ball_placement_point_;
};