HexPosition class added

Author: juna8001

LICENSE.meta

@@ -1,4 +1,5 @@
 # HexEngine
 HexEngine is a library for working with hex coordinates for Unity.
 
-It is inspired by http://www.redblobgames.com/grids/hexagons/.
+Inspired by http://www.redblobgames.com/grids/hexagons/.
+

README.md

@@ -13,27 +13,27 @@ public static class HexMath {
         /// Returns HexCoords of hex on given point (ignoring point.y value).
         /// </summary>
         public static HexCoords PointToHexCoords(Vector3 point, float gridScale = 1f) {
-            return RoundAxialToHex(PointToAxial(point, gridScale));
+            return RoundPositionToCoords(PointToHexPosition(point, gridScale));
         }
 
         /// <summary>
         /// Converts 3D point to Vector2 containing axial position.
         /// </summary>
-        public static Vector2 PointToAxial(Vector3 point, float gridScale = 1f) {
+        public static HexPosition PointToHexPosition(Vector3 point, float gridScale = 1f) {
             var x = B * point.x;
             var y = (A * point.x + point.z);
-            return new Vector2(x, y) / gridScale;
+            return new HexPosition(x / gridScale, y / gridScale);
         }
 
         /// <summary>
         /// Rounds axial coordinates and converts them to the HexCoords.
         /// </summary>
-        public static HexCoords RoundAxialToHex(Vector2 axial) {
-            var x = axial.x;
-            var y = axial.y;
-            var z = -axial.x - axial.y;
-            var xr = Mathf.RoundToInt(axial.x);
-            var yr = Mathf.RoundToInt(axial.y);
+        public static HexCoords RoundPositionToCoords(HexPosition position) {
+            var x = position.X;
+            var y = position.Y;
+            var z = position.Z;
+            var xr = Mathf.RoundToInt(x);
+            var yr = Mathf.RoundToInt(y);
             var zr = Mathf.RoundToInt(z);
 
             var diffX = Mathf.Abs(x - xr);

Runtime/HexMath.cs

@@ -0,0 +1,75 @@
+using System;
+using UnityEngine;
+
+namespace HexEngine {
+    public struct HexPosition : IEquatable<HexPosition> {
+        public static readonly HexPosition Zero = new HexPosition();
+
+        [SerializeField]
+        private float _x;
+        [SerializeField]
+        private float _y;
+        
+        public float X {
+            get => _x;
+            set => _x = value;
+        }
+
+        public float Y {
+            get => _y;
+            set => _y = value;
+        }
+
+        public float Z => -X - Y;
+
+        public HexPosition(float x, float y) {
+            _x = x;
+            _y = y;
+        }
+        
+        public static HexPosition operator +(HexPosition a, HexPosition b)
+            => new HexPosition(a.X + b.X, a.Y + b.Y);
+
+        public static HexPosition operator +(HexPosition a, HexDirection b)
+            => a + b.Coords();
+        
+        public static HexPosition operator -(HexPosition a, HexPosition b)
+            => new HexPosition(a.X - b.X, a.Y - b.Y);
+
+        public static HexPosition operator -(HexPosition a, HexDirection b)
+            => a - b.Coords();
+        
+        public static implicit operator HexPosition(HexCoords coords) => new HexPosition(coords.X, coords.Y);
+
+        /// <summary>
+        /// The offset from the Vector3.zero to the center of the hex.
+        /// </summary>
+        public Vector3 Offset() {
+            return HexDirection.NE.Direction() * X + HexDirection.N.Direction() * Y;
+        }
+
+        public bool Equals(HexPosition other) {
+            return other.X == X && other.Y == Y;
+        }
+
+        public override bool Equals(object obj) {
+            return obj is HexCoords coords && Equals(coords);
+        }
+        
+        public override int GetHashCode() {
+            return Tuple.Create(_x, _y).GetHashCode();
+        }
+
+        public override string ToString() {
+            return $"({X}, {Y}, {Z})";
+        }
+
+        public static bool operator ==(HexPosition a, HexPosition b) {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(HexPosition a, HexPosition b) {
+            return !(a == b);
+        }
+    }
+}

Runtime/HexPosition.cs

@@ -1,7 +1,7 @@
 {
   "name": "com.juna8001.hexengine",
   "displayName": "Hex Engine",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "unity": "2018.1",
   "description": "HexEngine is a library for working with hex coordinates for Unity.",
   "keywords": [