coordinate.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_COORDINATE_HPP
#define DIGITALCURLING3_COORDINATE_HPP
 
#include <cassert>
#include "vector2.hpp"
 
namespace digitalcurling3::coordinate {
 
namespace detail {
 
constexpr float kHogLineYOnSimulation = 10.9725f;
constexpr float kTeeLineYOnSimulation = 17.3735f;
constexpr float kBackLineYOnSimulation = 19.2025f;
constexpr float kHackYOnSimulation = 21.0315f;
constexpr float kBackBoardYOnSimulation = 22.8605f;
 
} // namespace detail
 
 
 
constexpr float kHouseRadius = 1.829f;
 
 
 
enum class Id {
    kSimulation,
 
    kShot0,
 
    kShot1,
};
 
 
 
constexpr Id GetShotSide(std::uint8_t end) noexcept
{
    if (end % 2 == 0) {
        return Id::kShot0;
    } else {
        return Id::kShot1;
    }
}
 
 
 
constexpr Vector2 TransformPosition(Vector2 position, Id from, Id to) noexcept
{
    if (from == to) return position;
 
    switch (to) {
        case Id::kSimulation:
            switch (from) {
                case Id::kShot0:
                    return { position.x, position.y - detail::kHackYOnSimulation };
                case Id::kShot1:
                    return { -position.x, -position.y + detail::kHackYOnSimulation };
                default:
                    assert(false);
                    return Vector2();
            }
            break;
 
        case Id::kShot0:
            switch (from) {
                case Id::kSimulation:
                    return { position.x, position.y + detail::kHackYOnSimulation };
                case Id::kShot1:
                    return { -position.x, -position.y + 2 * detail::kHackYOnSimulation };
                default:
                    assert(false);
                    return Vector2();
            }
            break;
 
        case Id::kShot1:
            switch (from) {
                case Id::kSimulation:
                    return { -position.x, -position.y + detail::kHackYOnSimulation };
                case Id::kShot0:
                    return { -position.x, -position.y + 2 * detail::kHackYOnSimulation };
                default:
                    assert(false);
                    return Vector2();
            }
            break;
 
        default:
            assert(false);
            return Vector2();
    }
}
 
 
 
constexpr Vector2 TransformVelocity(Vector2 velocity, Id from, Id to) noexcept
{
    if (from == to) return velocity;
 
    // 軸の方向が変化するのはどちらかがKShot1の場合のみ
    if (from == Id::kShot1 || to == Id::kShot1) {
        return -velocity;
    }
    return velocity;
}
 
 
 
constexpr float TransformAngle(float angle, Id from, Id to) noexcept
{
    if (from == to) return angle;
 
    // 軸の方向が変化するのはfrom/toのどちらかがkShot1の場合のみ
    if (from == Id::kShot1) {
        return angle - kPi;
    }
    if (to == Id::kShot1) {
        return angle + kPi;
    }
    return angle;
}
 
 
 
constexpr float TransformAngularVelocity(float angular_velocity, Id from, Id to) noexcept
{
    // 角速度は座標系が変化しても同じ
    return angular_velocity;
}
 
 
 
constexpr float GetCenterLineX(Id coord) noexcept
{
    return 0.f;
}
 
 
 
constexpr float GetHogLineY(bool side, Id coord) noexcept
{
    auto y_simulation = side ? detail::kHogLineYOnSimulation : -detail::kHogLineYOnSimulation;
    return TransformPosition(Vector2(0.f, y_simulation), Id::kSimulation, coord).y;
}
 
 
 
constexpr float GetTeeLineY(bool side, Id coord) noexcept
{
    auto y_simulation = side ? detail::kTeeLineYOnSimulation : -detail::kTeeLineYOnSimulation;
    return TransformPosition(Vector2(0.f, y_simulation), Id::kSimulation, coord).y;
}
 
 
 
constexpr float GetBackLineY(bool side, Id coord) noexcept
{
    auto y_simulation = side ? detail::kBackLineYOnSimulation : -detail::kBackLineYOnSimulation;
    return TransformPosition(Vector2(0.f, y_simulation), Id::kSimulation, coord).y;
}
 
 
 
constexpr float GetHackY(bool side, Id coord) noexcept
{
    auto y_simulation = side ? detail::kHackYOnSimulation : -detail::kHackYOnSimulation;
    return TransformPosition(Vector2(0.f, y_simulation), Id::kSimulation, coord).y;
}
 
 
 
constexpr float GetBackBoardY(bool side, Id coord) noexcept
{
    auto y_simulation = side ? detail::kBackBoardYOnSimulation : -detail::kBackBoardYOnSimulation;
    return TransformPosition(Vector2(0.f, y_simulation), Id::kSimulation, coord).y;
}
 
 
 
} // namespace digitalcurling3::coordinate
 
#endif // DIGITALCURLING3_COORDINATE_HPP