i_simulator.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_I_SIMULATOR_HPP
#define DIGITALCURLING3_I_SIMULATOR_HPP
 
#include <cstdint>
#include <array>
#include <vector>
#include <optional>
#include <memory>
#include <string>
#include "vector2.hpp"
#include "transform.hpp"
 
namespace digitalcurling3 {
 
class ISimulatorFactory;
class ISimulatorStorage;
 
class ISimulator {
public:
 
    // constants ---
 
    static constexpr std::uint8_t kStoneMax = 16;
 
    static constexpr float kStoneRadius = 0.145f;
 
 
    // types ---
 
    struct Stone : public Transform {
        Vector2 linear_velocity; 
        float angular_velocity; 
 
        Stone()
            : Transform()
            , linear_velocity()
            , angular_velocity(0.f) {}
 
        Stone(Vector2 position, float angle, Vector2 linear_velocity, float angular_velocity)
            : Transform(position, angle)
            , linear_velocity(linear_velocity)
            , angular_velocity(angular_velocity) {}
    };
 
    using AllStones = std::array<std::optional<Stone>, kStoneMax>;
 
    struct Collision {
        struct Stone {
            std::uint8_t id; 
            Transform transform; 
 
            Stone() : id(0), transform() {}
 
            Stone(std::uint8_t id, Transform const& transform) : id(id), transform(transform) {}
        };
        Stone a; 
        Stone b; 
        float normal_impulse; 
        float tangent_impulse; 
 
        Collision()
            : a()
            , b()
            , normal_impulse(0.f)
            , tangent_impulse(0.f) {}
 
        Collision(std::uint8_t a_id, std::uint8_t b_id, Transform const& a_transform, Transform const& b_transform, float normal_impulse, float tangent_impulse)
            : a(a_id, a_transform)
            , b(b_id, b_transform)
            , normal_impulse(normal_impulse)
            , tangent_impulse(tangent_impulse) {}
 
        Vector2 GetContactPoint() const
        {
            return (a.transform.position + b.transform.position) * 0.5f;
        }
    };
 
 
    // member functions ---
 
protected:
    ISimulator() = default;
    ISimulator(ISimulator const&) = default; 
    ISimulator& operator = (ISimulator const&) = default; 
 
public:
    virtual ~ISimulator() = default;
 
    virtual void SetStones(AllStones const& stones) = 0;
 
    virtual void Step() = 0;
 
    virtual AllStones const& GetStones() const = 0;
 
    virtual std::vector<Collision> const& GetCollisions() const = 0;
 
    virtual bool AreAllStonesStopped() const = 0;
 
    virtual float GetSecondsPerFrame() const = 0;
 
    virtual std::string GetSimulatorId() const = 0;
 
    virtual ISimulatorFactory const& GetFactory() const = 0;
 
    virtual std::unique_ptr<ISimulatorStorage> CreateStorage() const = 0;
 
    virtual void Save(ISimulatorStorage & storage) const = 0;
 
    virtual void Load(ISimulatorStorage const& storage) = 0;
};
 
 
// json
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    ISimulator::Stone,
    position,
    angle,
    linear_velocity,
    angular_velocity
)
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    ISimulator::Collision::Stone,
    id,
    transform
)
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(
    ISimulator::Collision,
    a,
    b,
    normal_impulse,
    tangent_impulse
)
 
} // namespace digitalcurling3
 
#endif // DIGITALCURLING3_I_SIMULATOR_HPP