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_
 
#include <array>
#include <cassert>
#include <iostream>
#include <utility>
#include <vector>
 
#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) : val{_x, _y} { }

        Point(Point const & rhs) : val{rhs.val[0], rhs.val[1]} { }

        Point(Point&& rhs) noexcept : val{rhs.val} { }

        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[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_