game_state.hpp

Go to the documentation of this file.

// MIT License
// 
// Copyright (c) 2022 UEC Takeshi Ito Laboratory
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
 
#ifndef DIGITALCURLING3_GAME_STATE_HPP
#define DIGITALCURLING3_GAME_STATE_HPP
 
#include <cstdint>
#include <array>
#include <optional>
#include <vector>
#include <chrono>
#include "json/common.hpp"
#include "vector2.hpp"
#include "transform.hpp"
#include "constants.hpp"
#include "game_result.hpp"
#include "game_setting.hpp"
#include "i_simulator.hpp"
 
namespace digitalcurling3 {
 
 
 
 
struct GameState {
 
    static constexpr std::uint8_t kExtraEndMax = 255;
 
    static constexpr size_t kShotPerEnd = 16;
 
    using Stones = std::array<
        std::array<std::optional<Transform>, kShotPerEnd / 2>,
        2>;
 
    GameState();
 
    GameState(GameSetting const& setting);
 
    GameState(GameState const&) = default;
 
    GameState(GameState &&) = default;
 
    GameState& operator = (GameState const&) = default;
 
    GameState& operator = (GameState &&) = default;
 
    std::uint8_t end;
 
    std::uint8_t shot;
 
    Team hammer;
 
    Stones stones;
 
    std::array<
        std::vector<std::optional<std::uint8_t>>,
        2> scores;
 
    std::array<std::optional<std::uint8_t>, 2> extra_end_score;
 
    std::array<std::chrono::milliseconds, 2> thinking_time_remaining;
 
    std::optional<GameResult> game_result;
 
    std::uint32_t GetTotalScore(Team team) const;
 
    Team GetNextTeam() const;
 
    bool IsGameOver() const
    {
        return game_result.has_value();
    }
 
    static std::pair<Team, size_t> StonesIndexFromAllStonesIndex(size_t all_stones_index);
 
    static size_t StonesIndexToAllStonesIndex(Team team, size_t team_stone_index);
 
    static Stones StonesFromAllStones(ISimulator::AllStones const& all_stones, std::uint8_t end);
 
    static ISimulator::AllStones StonesToAllStones(Stones const& stones, std::uint8_t end);
};
 
 
// json
void to_json(nlohmann::json &, GameState const&);
void from_json(nlohmann::json const&, GameState &);
 
} // namespace digitalcurling3
 
#endif // DIGITALCURLING3_GAME_STATE_HPP