#235 Implemented, need to check out use more.

EGrid/src/eg320/Terr320E0.scala

@@ -42,8 +42,8 @@ object Terr320E0 extends Long320Terrs
   }
   help.run
 
-  corners.setCorner(130, 526, 0, HVUL)
-  corners.setCornerPair(132, 524, 2, HVExact, HVUL)
+  corners.setCorner(130, 526, 0, HVLt)
+  corners.setCornerPair(132, 524, 2, HVExact, HVLt)
 }
 
 object BritReg

EGrid/src/egrid/EGridLongMan.scala

@@ -333,8 +333,8 @@ final case class EGridLongMan(thisInd: Int, sys: EGridLongMulti) extends EGridMa
     { case _ if grid.hCoordExists(hc) => Some(hc)
       case HVUp | HVUR | HVUL if r == grid.topSideR => None
       case HVDR | HVDn | HVDL if r == grid.bottomSideR => None
-      case HVUR | HVDR if isRightMan => None
-      case HVDL | HVUL if isLeftMan => None
+      case HVUR | HVRt | HVDR if isRightMan => None
+      case HVDL | HVLt | HVUL if isLeftMan => None
 
       case HVUp if (c < grid.rowLeftCenC(r + 1 )) & vUp => Some(HVertLow(r + 2, ltGrid.rowRightCenC(r + 1) + 2))
       case HVUp if c < grid.rowLeftCenC(r + 1) => {
@@ -375,6 +375,8 @@ final case class EGridLongMan(thisInd: Int, sys: EGridLongMulti) extends EGridMa
 
       case HVUL if vUp => Some(HCen(r + 1, ltGrid.rowRightCenC(r + 1)))
       case HVUL => Some(HVertHigh(r, ltGrid.rowRightCenC(r - 1)))
+
+    case dirn => excep(s"$dirn")
     }
   }
 }

Tiling/srcHex/HCen.scala

@@ -28,21 +28,21 @@ class HCen(val r: Int, val c: Int) extends HCenOrSide with TCen
   /** The polygon of this hex tile if it is part of a regular grid. */
   def polygonReg: Polygon = verts.mapPolygon(_.toPt2Reg)
 
-  def v0Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c, dirn, magnitude)
-  def v1Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c + 2, dirn, magnitude)
-  def v2Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c + 2, dirn, magnitude)
-  def v3Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c, dirn, magnitude)
-  def v4Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c - 2, dirn, magnitude)
-  def v5Offset(dirn: HVDirnOpt, magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c - 2, dirn, magnitude)
-
-  def v0In(magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c, HVDn, magnitude)
-  def v1In(magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c + 2, HVDL, magnitude)
-  def v2In(magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c + 2, HVUL, magnitude)
-  def v3In(magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c, HVUp, magnitude)
-  def v4In(magnitude: Int): HVAndOffset = HVAndOffset(r - 1, c - 2, HVUR, magnitude)
-  def v5In(magnitude: Int): HVAndOffset = HVAndOffset(r + 1, c - 2, HVDR, magnitude)
-
-  def vIn(vert: Int, magnitude: Int): HVAndOffset = vert %% 6 match
+  def v0Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r + 1, c, dirn, magnitude)
+  def v1Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r + 1, c + 2, dirn, magnitude)
+  def v2Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r - 1, c + 2, dirn, magnitude)
+  def v3Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r - 1, c, dirn, magnitude)
+  def v4Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r - 1, c - 2, dirn, magnitude)
+  def v5Offset(dirn: HVDirnOpt, magnitude: Int): HVOffset = HVOffset(r + 1, c - 2, dirn, magnitude)
+
+  def v0In(magnitude: Int): HVOffset = HVOffset(r + 1, c, HVDn, magnitude)
+  def v1In(magnitude: Int): HVOffset = HVOffset(r + 1, c + 2, HVDL, magnitude)
+  def v2In(magnitude: Int): HVOffset = HVOffset(r - 1, c + 2, HVUL, magnitude)
+  def v3In(magnitude: Int): HVOffset = HVOffset(r - 1, c, HVUp, magnitude)
+  def v4In(magnitude: Int): HVOffset = HVOffset(r - 1, c - 2, HVUR, magnitude)
+  def v5In(magnitude: Int): HVOffset = HVOffset(r + 1, c - 2, HVDR, magnitude)
+
+  def vIn(vert: Int, magnitude: Int): HVOffset = vert %% 6 match
   { case 0 => v0In(magnitude)
     case 1 => v1In(magnitude)
     case 2 => v2In(magnitude)
@@ -51,14 +51,14 @@ class HCen(val r: Int, val c: Int) extends HCenOrSide with TCen
     case 5 => v5In(magnitude)
   }
 
-  def v0Exact: HVAndOffset = HVAndOffset(r + 1, c, HVExact, 0)
-  def v1Exact: HVAndOffset = HVAndOffset(r + 1, c + 2, HVExact, 0)
-  def v2Exact: HVAndOffset = HVAndOffset(r - 1, c + 2, HVExact, 0)
-  def v3Exact: HVAndOffset = HVAndOffset(r - 1, c, HVExact, 0)
-  def v4Exact: HVAndOffset = HVAndOffset(r - 1, c - 2, HVExact, 0)
-  def v5Exact: HVAndOffset = HVAndOffset(r + 1, c - 2, HVExact, 0)
+  def v0Exact: HVOffset = HVOffset(r + 1, c, HVExact, 0)
+  def v1Exact: HVOffset = HVOffset(r + 1, c + 2, HVExact, 0)
+  def v2Exact: HVOffset = HVOffset(r - 1, c + 2, HVExact, 0)
+  def v3Exact: HVOffset = HVOffset(r - 1, c, HVExact, 0)
+  def v4Exact: HVOffset = HVOffset(r - 1, c - 2, HVExact, 0)
+  def v5Exact: HVOffset = HVOffset(r + 1, c - 2, HVExact, 0)
 
-  def vExact(vert: Int): HVAndOffset = vert %% 6 match
+  def vExact(vert: Int): HVOffset = vert %% 6 match
   { case 0 => v0Exact
     case 1 => v1Exact
     case 2 => v2Exact

Tiling/srcHex/HCorner.scala

@@ -1,7 +1,7 @@
 /* Copyright 2018-23 Richard Oliver. Licensed under Apache Licence version 2.0. */
 package ostrat; package prid; package phex
 
-/** Hex tile corner. A corner encodes 1 or 2 [[HVOffset]]s. An [[HVert]] is shared between 3 hex tiles and 3 [[HSide]]s. An [[HCoroner]] only applies
+/** Hex tile corner. A corner encodes 1 or 2 [[HVOffsetDelta]]s. An [[HVert]] is shared between 3 hex tiles and 3 [[HSide]]s. An [[HCoroner]] only applies
  *  to a single hex tile. Hence unless it is on the edge of the [[HGridSys]] there will be 3 [[HCorner]]s associated with each [[HVert]]. This class
  *  encodes a single or two [[HVertoffset]]s. */
 class HCorner(val unsafeInt: Int) extends AnyVal
@@ -10,55 +10,55 @@ class HCorner(val unsafeInt: Int) extends AnyVal
 
   override def toString: String = "HCorner " + numVerts
 
-  /** Returns the first, going clockwise and possibly only [[HVOffset]] of this corner */
-  def v1(hVert: HVert): HVAndOffset =
-  { val dirn = HVDirnOpt.fromInt((unsafeInt %% 32) / 4)
-    val magnitude = (unsafeInt %% 256) / 32
-    HVAndOffset(hVert, dirn, magnitude)
+  /** Returns the first, going clockwise and possibly only [[HVOffsetDelta]] of this corner */
+  def v1(hVert: HVert): HVOffset =
+  { val dirn = HVDirnOpt.fromInt((unsafeInt %% 64) / 4)
+    val magnitude = (unsafeInt %% 512) / 64
+    HVOffset(hVert, dirn, magnitude)
   }
 
-  /** Returns the second, going clockwise [[HVOffset]] of this corner. throws an exception if there is only 1. */
-  def v2(hVert: HVert): HVAndOffset =
+  /** Returns the second, going clockwise [[HVOffsetDelta]] of this corner. throws an exception if there is only 1. */
+  def v2(hVert: HVert): HVOffset =
   { if(numVerts < 2) excep(s"Trying to access the second HVOffset for a Corner that has only $numVerts.")
-    val dirn = HVDirnOpt.fromInt((unsafeInt %% 8192) / 1024)
-    val magnitude = (unsafeInt %% 65536) / 8192
-    HVAndOffset(hVert, dirn, magnitude)
+    val dirn = HVDirnOpt.fromInt((unsafeInt %% 32768) / 2048)
+    val magnitude = (unsafeInt %% 131072) / 32768
+    HVOffset(hVert, dirn, magnitude)
   }
 
-  /** Returns the second, going clockwise [[HVOffset]] of this corner if there is a second [[HVOffset]] on this [[HCorner]] else returns first. */
-  def vLast(hVert: HVert): HVAndOffset = ife(numVerts == 2, v2(hVert), v1(hVert))
+  /** Returns the second, going clockwise [[HVOffsetDelta]] of this corner if there is a second [[HVOffsetDelta]] on this [[HCorner]] else returns first. */
+  def vLast(hVert: HVert): HVOffset = ife(numVerts == 2, v2(hVert), v1(hVert))
 
   def verts(hVert: HVert): HVAndOffsetArr = unsafeInt %% 4 match
-  { case 0 => HVAndOffsetArr(HVAndOffset.none(hVert))
+  { case 0 => HVAndOffsetArr(HVOffset.none(hVert))
     case 1 | 3 => HVAndOffsetArr(v1(hVert))
 
     case 2 =>
-    { val r1: HVAndOffset = v1(hVert)
-      val r2: HVAndOffset = v2(hVert)
+    { val r1: HVOffset = v1(hVert)
+      val r2: HVOffset = v2(hVert)
       HVAndOffsetArr(r1, r2)
     }
     case n  => excep(s"$n is an invalid value for offsets.")
   }
 
-  /** Returns the vertices of a side feature, such as a straits or a wall. The vertices are specified as [[HVAndOffset]]. */
+  /** Returns the vertices of a side feature, such as a straits or a wall. The vertices are specified as [[HVOffset]]. */
   def sideVerts(hVert: HVert): HVAndOffsetArr = HVAndOffsetArr(v1(hVert))
 }
 
 /** Companion object for [[HCorner]], contains factory apply methods for creating no offset, single and double [[HVoffsets]]. */
 object HCorner
 { def noOffset: HCorner = new HCorner(0)
 
-  def single(dirn: HVDirnOpt, magnitude : Int): HCorner = new HCorner(1 + 4 * dirn.int1 + magnitude * 32)
+  def single(dirn: HVDirnOpt, magnitude : Int): HCorner = new HCorner(1 + 4 * dirn.int1 + magnitude * 64)
 
   def double(dirn1: HVDirnOpt, magnitude1 : Int, dirn2: HVDirnOpt, magnitude2 : Int): HCorner =
-  { val v1 = dirn1.int1 * 4 + magnitude1 * 32
-    val v2 = dirn2.int1 + magnitude2 * 8
-    new HCorner(2 + v1 + v2 * 1024)
+  { val v1 = dirn1.int1 * 4 + magnitude1 * 64
+    val v2 = dirn2.int1 + magnitude2 * 16
+    new HCorner(2 + v1 + v2 * 2048)
   }
 
   def sideDouble(dirn1: HVDirnOpt, magnitude1: Int, dirn2: HVDirnOpt, magnitude2: Int): HCorner =
-  { val v1 = dirn1.int1 * 4 + magnitude1 * 32
-    val v2 = dirn2.int1 + magnitude2 * 8
-    new HCorner(3 + v1 + v2 * 1024)
+  { val v1 = dirn1.int1 * 4 + magnitude1 * 64
+    val v2 = dirn2.int1 + magnitude2 * 16
+    new HCorner(3 + v1 + v2 * 2048)
   }
 }

Tiling/srcHex/HCornerLayer.scala

@@ -12,22 +12,22 @@ final class HCornerLayer(val unsafeArray: Array[Int])
   def unsafeIndex(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): Int = gridSys.layerArrayIndex(hCen) * 6 + vertNum
   def unsafeIndex(cenR: Int, cenC: Int, vertNum: Int)(implicit gridSys: HGridSys): Int = gridSys.layerArrayIndex(cenR, cenC) * 6 + vertNum
 
-  /** Returns the specified [[HCorner]] object which specifies, 1 or 2 [[HVAndOffset]]s. */
+  /** Returns the specified [[HCorner]] object which specifies, 1 or 2 [[HVOffset]]s. */
   def corner(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HCorner = new HCorner(unsafeArray(unsafeIndex(hCen, vertNum)))
 
-  /** Returns the specified [[HCorner]] object which specifies, 1 or 2 [[HVAndOffset]]s. */
+  /** Returns the specified [[HCorner]] object which specifies, 1 or 2 [[HVOffset]]s. */
   def corner(hCenR: Int, hCenC: Int, vertNum: Int)(implicit gridSys: HGridSys): HCorner =
     new HCorner(unsafeArray(gridSys.layerArrayIndex(hCenR, hCenC) * 6 + vertNum))
 
-  /** Returns the first and possibly only single [[HVAndOffset]] for an [[HCorner]]. This is used for drawing [[HSide]] hex side line segments. */
-  def cornerV1(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HVAndOffset = corner(hCen, vertNum).v1(hCen.verts(vertNum))
+  /** Returns the first and possibly only single [[HVOffset]] for an [[HCorner]]. This is used for drawing [[HSide]] hex side line segments. */
+  def cornerV1(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HVOffset = corner(hCen, vertNum).v1(hCen.verts(vertNum))
 
   def cornersForSide(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HVAndOffsetArr = corner(hCen, vertNum).sideVerts(hCen.verts(vertNum))
 
-  /** Returns the last [[HVAndOffset]] for an [[HCorner]]. This is used for drawing [[HSide]] hex side line segments. */
-  def cornerVLast(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HVAndOffset = corner(hCen, vertNum).vLast(hCen.verts(vertNum))
+  /** Returns the last [[HVOffset]] for an [[HCorner]]. This is used for drawing [[HSide]] hex side line segments. */
+  def cornerVLast(hCen: HCen, vertNum: Int)(implicit gridSys: HGridSys): HVOffset = corner(hCen, vertNum).vLast(hCen.verts(vertNum))
 
-  /** Produces an [[HSide]]'s line segment specified in [[HVAndOffset]] coordinates. */
+  /** Produces an [[HSide]]'s line segment specified in [[HVOffset]] coordinates. */
   def sideLineHVAndOffset(hCen: HCen, vertNum1: Int, vertNum2: Int)(implicit gridSys: HGridSys): LineSegHVAndOffset =
     LineSegHVAndOffset(cornerVLast(hCen, vertNum1), cornerV1(hCen, vertNum2))
 
@@ -48,7 +48,7 @@ final class HCornerLayer(val unsafeArray: Array[Int])
     }
   }
 
-  /** Sets a single [[HCorner]] with 1 [[HVOffset]]. Sets one vertex offset for one adjacent hex. This could leave a gap for side terrain such as straits. */
+  /** Sets a single [[HCorner]] with 1 [[HVOffsetDelta]]. Sets one vertex offset for one adjacent hex. This could leave a gap for side terrain such as straits. */
   def setCorner(hCen: HCen, vertNum: Int, dirn: HVDirnOpt, magnitude: Int)(implicit grid: HGrid): Unit =
   { if(grid.hCenExists(hCen))
     { val corner = HCorner.single(dirn, magnitude)
@@ -214,7 +214,7 @@ final class HCornerLayer(val unsafeArray: Array[Int])
    * it would be the hex tile looking at the end of the wall. The vertex for this tile would be 5. */
   def setMouth5Corner(r: Int, c: Int, magnitude: Int = 3)(implicit grid: HGrid): Unit = setCornerPair(r, c, 5, HVDL, HVUp, magnitude, magnitude)
 
-  /** Sets the corner in towards the [[HCen]] with a single [[HVOffset]]. Would like to make this protected and possibly remove altogether. */
+  /** Sets the corner in towards the [[HCen]] with a single [[HVOffsetDelta]]. Would like to make this protected and possibly remove altogether. */
   def setCornerIn(cenR: Int, cenC: Int, vertNum: Int, magnitude: Int = 3)(implicit grid: HGrid): Unit =
   { val i = vertNum %% 6
     val dirn = i match
@@ -243,22 +243,22 @@ final class HCornerLayer(val unsafeArray: Array[Int])
   def setNCornersIn(cenR: Int, cenC: Int, numIndents: Int, firstVertNum: Int, magnitude: Int)(implicit grid: HGrid): Unit =
     iUntilForeach(numIndents) { i => setCornerIn(cenR, cenC, (firstVertNum + i) %% 6, magnitude) }
 
-  /** Sets a single [[HCorner]] corner with 2 [[HVOffset]]s. */
+  /** Sets a single [[HCorner]] corner with 2 [[HVOffsetDelta]]s. */
   def setCornerPair(cenR: Int, cenC: Int, vertNum: Int, dirn1: HVDirnOpt, dirn2: HVDirnOpt, magnitude1: Int = 3, magnitude2: Int = 3)(
     implicit grid: HGrid): Unit = setCornerPair(HCen(cenR, cenC), vertNum, dirn1, magnitude1, dirn2, magnitude2)
 
-  /** Sets a single [[HCorner]] corner with 2 [[HVOffset]]s. */
+  /** Sets a single [[HCorner]] corner with 2 [[HVOffsetDelta]]s. */
   def setCornerPair(hCen: HCen, vertNum: Int, dirn1: HVDirnOpt, magnitude1: Int, dirn2: HVDirnOpt, magnitude2: Int)(implicit grid: HGrid): Unit =
   { val corner = HCorner.double(dirn1, magnitude1, dirn2, magnitude2)
     val index = unsafeIndex(hCen, vertNum)
     unsafeArray(index) = corner.unsafeInt
   }
 
-  /** Sets a single [[HCorner]] corner with 1 [[HVOffset]] for the tile 2 for the [[hSide]]. */
+  /** Sets a single [[HCorner]] corner with 1 [[HVOffsetDelta]] for the tile 2 for the [[hSide]]. */
   def setSideCorner2(cenR: Int, cenC: Int, vertNum: Int, dirn1: HVDirnOpt, dirn2: HVDirnOpt, magnitude1: Int = 3, magnitude2: Int = 3)(
     implicit grid: HGrid): Unit = setSideCorner2(HCen(cenR, cenC), vertNum, dirn1, magnitude1, dirn2, magnitude2)
 
-  /** Sets a single [[HCorner]] corner with [[HVOffset]] for the tile 2 for the HSide. */
+  /** Sets a single [[HCorner]] corner with [[HVOffsetDelta]] for the tile 2 for the HSide. */
   def setSideCorner2(hCen: HCen, vertNum: Int, dirn1: HVDirnOpt, magnitude1: Int, dirn2: HVDirnOpt, magnitude2: Int)(implicit grid: HGrid): Unit =
   { val corner = HCorner.sideDouble(dirn1, magnitude1, dirn2, magnitude2)
     val index = unsafeIndex(hCen, vertNum)
@@ -321,10 +321,10 @@ final class HCornerLayer(val unsafeArray: Array[Int])
       case Some(_) =>
       { val (hcRt, vi) = hs.tileRtAndVert
         val (hcLt, lvi) = hs.tileLtAndVertFromRt(hcRt.r)
-        val p1: HVAndOffset = cornerV1(hcRt, vi)
-        val p2: HVAndOffset = cornerV1(hcRt, (vi - 1) %% 6)
-        val p3: HVAndOffset = cornerV1(hcLt, (lvi + 1) %% 6)
-        val p4: HVAndOffset = cornerV1(hcLt, (lvi) %% 6)
+        val p1: HVOffset = cornerV1(hcRt, vi)
+        val p2: HVOffset = cornerV1(hcRt, (vi - 1) %% 6)
+        val p3: HVOffset = cornerV1(hcLt, (lvi + 1) %% 6)
+        val p4: HVOffset = cornerV1(hcLt, (lvi) %% 6)
         PolygonHVAndOffset(hcRt.vExact(vi), p1, p2, hcRt.vExact(vi - 1), p3, p4)
       }
     }

Tiling/srcHex/HGrid.scala

@@ -295,12 +295,12 @@ trait HGrid extends Any with TGrid with HGridSys
 
   /** Finds the [[HCoord]] if it exists, by taking the [[HVDirn]] from an [[HVert]]. */
   override def vertToCoordFind(hVert: HVert, dirn: HVDirn): Option[HCoord] =
-  { val hc2 = hVert.dirnTo(dirn)
+  { val hc2: HCoord = hVert.dirnTo(dirn)
     ifSome(hCoordExists(hc2), hc2)
   }
 }
 
 /** Hex grid path finding node. */
 case class HNode(val tile: HCen, var gCost: Int, var hCost: Int, var parent: OptRef[HNode])
-{ def fCost = gCost + hCost
+{ def fCost: Int = gCost + hCost
 }

Tiling/srcHex/HSysProjection.scala

@@ -24,7 +24,7 @@ trait HSysProjection extends TSysProjection
 
   /** only use for projection's known [[HCoord]]s. */
   def transCoord(hc: HCoord): Pt2
-  def transHVAndOffset(hvo: HVAndOffset): Pt2 = hvo.toPt2(transCoord)(parent)
+  def transHVAndOffset(hvo: HVOffset): Pt2 = hvo.toPt2(transCoord)(parent)
   def transPolygonHVAndOffset(inp: PolygonHVAndOffset): Polygon = inp.toPolygon(transCoord)(parent)