point.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause
// SPDX-FileCopyrightText: 2004 - 2008 Olof Naessén and Per Larsson
// SPDX-FileCopyrightText: 2013 - 2026 Fifengine contributors
 
#ifndef INCLUDE_FIFECHAN_POINT_HPP_
#define INCLUDE_FIFECHAN_POINT_HPP_
 
// Standard library includes
#include <array>
#include <cassert>
#include <iostream>
#include <utility>
#include <vector>
 
// Platform config include
#include "fifechan/platform.hpp"
 
// Project headers (subdirs before local)
#include "fifechan/math.hpp"
 
namespace fcn
{

    class Point
    {
        public:
            union
            {
                    std::array<int, 2> val;
                    struct
                    {
                            int x, y;
                    };
            };

            explicit Point(int _x = 0, int _y = 0) : x(_x), y(_y)
            {
            }
 
            ~Point() = default;

            Point(Point const & rhs) : x(rhs.x), y(rhs.y)
            {
            }

            Point(Point&& rhs) noexcept : x(rhs.x), y(rhs.y)
            {
            }

            Point& operator=(Point const & rhs)
            {
                if (this != &rhs) {
                    val = rhs.val;
                }
                return *this;
            }

            Point& operator=(Point&& rhs) noexcept
            {
                if (this != &rhs) {
                    val = rhs.val;
                }
                return *this;
            }

            Point operator+(Point const & p) const
            {
                return Point(x + p.x, y + p.y);
            }

            Point operator-(Point const & p) const
            {
                return Point(x - p.x, y - p.y);
            }

            Point& operator+=(Point const & p)
            {
                x += p.x;
                y += p.y;
                return *this;
            }

            Point& operator-=(Point const & p)
            {
                x -= p.x;
                y -= p.y;
                return *this;
            }

            Point operator*(int const & i) const
            {
                return Point(x * i, y * i);
            }

            Point operator/(int const & i) const
            {
                return Point(x / i, y / i);
            }

            bool operator==(Point const & p) const
            {
                return x == p.x && y == p.y;
            }

            bool operator!=(Point const & p) const
            {
                return x != p.x || y != p.y;
            }

            int length() const
            {
                double const sq = (static_cast<double>(x) * x) + (static_cast<double>(y) * y);
                return static_cast<int>(Mathf::Sqrt(sq));
            }

            void normalize()
            {
                float const len = length();
 
                if (len > Mathf::zeroTolerance()) {
                    float const invLength = 1.0F / len;
 
                    x = static_cast<int>(x * invLength);
                    y = static_cast<int>(y * invLength);
                } else {
                    x = 0;
                    y = 0;
                }
            }

            Point rotated(int angle) const
            {
                double const theta = static_cast<double>(angle) * Mathd::pi() / 180.0;
 
                double const c = Mathd::Cos(theta);
                double const s = Mathd::Sin(theta);
 
                return Point(
                    static_cast<int>(std::round((c * x) - (s * y))), static_cast<int>(std::round((s * x) + (c * y))));
            }

            void rotate(double angle)
            {
                double const theta = angle * Mathd::pi() / 180.0;
 
                double const costheta = Mathd::Cos(theta);
                double const sintheta = Mathd::Sin(theta);
 
                double const nx = static_cast<double>(x);
                double const ny = static_cast<double>(y);
 
                x = static_cast<int>((costheta * nx) - (sintheta * ny));
                y = static_cast<int>((sintheta * nx) + (costheta * ny));
            }

            void rotate(Point const & origin, int angle)
            {
                // 1. Translate point to origin-relative coordinates (promote to double)
                double const nx = static_cast<double>(x - origin.x);
                double const ny = static_cast<double>(y - origin.y);
 
                // 2. Rotate point by angle (in radians)
                double const theta = static_cast<double>(angle) * Mathd::pi() / 180.0;
 
                // 3. Calculate rotation using standard 2D rotation matrix
                double const costheta = Mathd::Cos(theta);
                double const sintheta = Mathd::Sin(theta);
 
                // 4. Apply rotation to point
                double const rx = (costheta * nx) - (sintheta * ny);
                double const ry = (sintheta * nx) + (costheta * ny);
 
                // 5. Translate back to world coordinates AND cast to int (with rounding)
                x = static_cast<int>(std::round(origin.x + rx));
                y = static_cast<int>(std::round(origin.y + ry));
            }

            void set(int _x, int _y)
            {
                x = _x;
                y = _y;
            }

            int& operator[](int ind)
            {
                assert(ind > -1 && ind < 2);
                return val.at(static_cast<size_t>(ind));
            }

            friend std::ostream& operator<<(std::ostream& os, Point const & p)
            {
                return os << "(" << p.x << ":" << p.y << ")";
            }
    };

    using PointVector = std::vector<Point>;
} // namespace fcn
 
#endif // INCLUDE_FIFECHAN_POINT_HPP_