A number of changes and fixes

 * Mill upgrade
 * Hexagon rotation is now odd row (to match legacy)
 * Legacy web storage now works after a fashion
 * Rotation is broken - it's unclear why at the moment
 * Added tests
 * Fixes CI

Author: hobnob

VirtualGloomhavenBoard/Indigo/.mill-version

@@ -1 +1 @@
-0.11.0
+0.11.1

VirtualGloomhavenBoard/Indigo/vgb-common/src/vgb/common/BoardOverlayType.scala

@@ -3,9 +3,27 @@ package vgb.common
 import indigo.*
 
 enum TreasureChestType:
+  override def toString(): String = this match {
+    case Goal      => "goal"
+    case Locked    => "locked"
+    case Normal(i) => i.toString()
+  }
+
   case Normal(val number: Byte) extends TreasureChestType
   case Goal, Locked
 
+object TreasureChestType:
+  def fromString(str: String) =
+    str.toLowerCase() match {
+      case "goal"   => Goal
+      case "locked" => Locked
+      case _ =>
+        str.toByteOption match {
+          case Some(b) => Normal(b)
+          case None    => Normal(0)
+        }
+    }
+
 trait BoardOverlayType:
   val baseGame: BaseGame
   val cells: Batch[Point]
@@ -16,7 +34,8 @@ trait BoardOverlayType:
     .toCharArray()
     .foldLeft("")((s, c) => if c >= '0' && c <= 'Z' then s + " " + c else s + c)
     .trim()
-  val assetName: AssetName = AssetName(s"""${baseGame.shortName}-${name.toLowerCase().replace(" ", "-")}""")
+  val codedName            = name.toLowerCase().replace(" ", "-")
+  val assetName: AssetName = AssetName(s"""${baseGame.shortName}-${codedName}""")
 
 enum DifficultTerrain(
     val baseGame: BaseGame,
@@ -48,16 +67,18 @@ enum Hazard(val baseGame: BaseGame, val cells: Batch[Point]) extends BoardOverla
   case HotCoals extends Hazard(BaseGame.Gloomhaven, Batch(Point(0, 0)))
   case Thorns   extends Hazard(BaseGame.Gloomhaven, Batch(Point(0, 0)))
 
-enum Highlight(val baseGame: BaseGame, val colour: RGB) extends BoardOverlayType:
+final case class Highlight(val baseGame: BaseGame, val colour: RGB) extends BoardOverlayType:
   val cells: Batch[Point] = Batch(Point(0, 0))
   val flag: Flag          = Flag.Highlight
   val verticalAssetName   = None
-  case Red    extends Highlight(BaseGame.Gloomhaven, RGB.Red)
-  case Orange extends Highlight(BaseGame.Gloomhaven, RGB.Orange)
-  case Yellow extends Highlight(BaseGame.Gloomhaven, RGB.Yellow)
-  case Green  extends Highlight(BaseGame.Gloomhaven, RGB.Green)
-  case Blue   extends Highlight(BaseGame.Gloomhaven, RGB.Blue)
-  case Indigo extends Highlight(BaseGame.Gloomhaven, RGB.Indigo)
+
+object Highlight:
+  val Red    = Highlight(BaseGame.Gloomhaven, RGB.Red)
+  val Orange = Highlight(BaseGame.Gloomhaven, RGB.Orange)
+  val Yellow = Highlight(BaseGame.Gloomhaven, RGB.Yellow)
+  val Green  = Highlight(BaseGame.Gloomhaven, RGB.Green)
+  val Blue   = Highlight(BaseGame.Gloomhaven, RGB.Blue)
+  val Indigo = Highlight(BaseGame.Gloomhaven, RGB.Indigo)
 
 enum Obstacle(val baseGame: BaseGame, val cells: Batch[Point]) extends BoardOverlayType:
   val flag: Flag        = Flag.Obstacle

VirtualGloomhavenBoard/Indigo/vgb-game/src/vgb/game/models/Hexagon.scala renamed to VirtualGloomhavenBoard/Indigo/vgb-common/src/vgb/common/Hexagon.scala

@@ -1,4 +1,4 @@
-package vgb.game.models
+package vgb.common
 
 import indigo.shared.datatypes.Point
 import indigo.shared.datatypes.Vector2
@@ -21,8 +21,8 @@ object Hexagon:
     )
   }
 
-  def screenPosToEvenRow(size: Int, pos: Point) =
-    axialToEvenRow(screenPosToAxial(size, pos))
+  def screenPosToOddRow(size: Int, pos: Point) =
+    axialToOddRow(screenPosToAxial(size, pos))
 
   def axialToScreenPos(size: Int, pos: Vector2) =
     val halfSize = size * 0.5;
@@ -31,26 +31,26 @@ object Hexagon:
       (halfSize * threeOver2 * pos.y).toInt
     )
 
-  def evenRowToScreenPos(size: Int, pos: Point) =
-    axialToScreenPos(size, evenRowToAxial(Vector2.fromPoint(pos)))
+  def oddRowToScreenPos(size: Int, pos: Point) =
+    axialToScreenPos(size, oddRowToAxial(Vector2.fromPoint(pos)))
 
-  def axialToEvenRow(pos: Vector2) =
+  def axialToOddRow(pos: Vector2) =
     Vector2(
-      pos.x + (pos.y + (pos.y.toInt & 1)) * 0.5,
+      pos.x + (pos.y - (pos.y.toInt & 1)) * 0.5,
       pos.y
     )
 
-  def evenRowToAxial(pos: Vector2) =
+  def oddRowToAxial(pos: Vector2) =
     Vector2(
-      pos.x - (pos.y + (pos.y.toInt & 1)) * 0.5,
+      pos.x - (pos.y - (pos.y.toInt & 1)) * 0.5,
       pos.y
     )
 
-  def cubeToEvenRow(pos: Vector3) =
-    Vector2(pos.x + (pos.y + (pos.y.toInt & 1)) * 0.5, pos.y)
+  def cubeToOddRow(pos: Vector3) =
+    Vector2(pos.x + (pos.y - (pos.y.toInt & 1)) * 0.5, pos.y)
 
-  def evenRowToCube(pos: Vector2) =
-    val newX = pos.x - (pos.y + (pos.y.toInt & 1)) * 0.5
+  def oddRowToCube(pos: Vector2) =
+    val newX = pos.x - (pos.y - (pos.y.toInt & 1)) * 0.5
     Vector3(newX, pos.y, -newX - pos.y)
 
   def cubeToAxial(pos: Vector3) =
@@ -74,22 +74,22 @@ object Hexagon:
       else Vector3(q, r, -q - r)
   }
 
-  def evenRowRotate(origin: Vector2, rotationPoint: Vector2, numTurns: Byte): Vector2 =
-    val rotateResult = evenRowSingleRotate(origin, rotationPoint)
+  def oddRowRotate(origin: Vector2, rotationPoint: Vector2, numTurns: Byte): Vector2 =
+    val rotateResult = oddRowSingleRotate(origin, rotationPoint)
     numTurns match
       case 0 => origin
       case 1 => rotateResult
       case other if other < 0 =>
-        evenRowRotate(rotateResult, rotationPoint, (other + 1).toByte)
+        oddRowRotate(rotateResult, rotationPoint, (other + 1).toByte)
       case other =>
-        evenRowRotate(rotateResult, rotationPoint, (other - 1).toByte)
+        oddRowRotate(rotateResult, rotationPoint, (other - 1).toByte)
 
-  def evenRowSingleRotate(origin: Vector2, rotationPoint: Vector2): Vector2 =
-    val (originX, originY, originZ) = evenRowToCube(origin) match
+  def oddRowSingleRotate(origin: Vector2, rotationPoint: Vector2): Vector2 =
+    val (originX, originY, originZ) = oddRowToCube(origin) match
       case v => (v.x, v.y, v.z)
-    val (rotateX, rotateY, rotateZ) = evenRowToCube(rotationPoint) match
+    val (rotateX, rotateY, rotateZ) = oddRowToCube(rotationPoint) match
       case v => (v.x, v.y, v.z)
     val (rX, rY, rZ) =
       (-(originY - rotateY), -(originZ - rotateZ), -(originX - rotateX))
 
-    cubeToEvenRow(Vector3(rX + rotateX, rY + rotateY, rZ + rotateZ))
+    cubeToOddRow(Vector3(rX + rotateX, rY + rotateY, rZ + rotateZ))

VirtualGloomhavenBoard/Indigo/vgb-common/src/vgb/common/MonsterLevel.scala

@@ -2,3 +2,9 @@ package vgb.common
 
 enum MonsterLevel:
   case None, Normal, Elite
+
+object MonsterLevel:
+  def fromString(str: String) =
+    MonsterLevel.values
+      .find(l => l.toString().toLowerCase() == str)
+      .getOrElse(None)

VirtualGloomhavenBoard/Indigo/vgb-common/src/vgb/common/RoomType.scala

@@ -11,15 +11,15 @@ enum RoomType(val baseGame: BaseGame, val mapRef: String, val offset: Point, val
         "a1a",
         Point(-13, -34),
         Batch(
-          Point(0, 0),
-          Point(1, 0),
-          Point(2, 0),
-          Point(3, 0),
           Point(0, 1),
           Point(1, 1),
           Point(2, 1),
           Point(3, 1),
-          Point(4, 1)
+          Point(0, 2),
+          Point(1, 2),
+          Point(2, 2),
+          Point(3, 2),
+          Point(4, 2)
         ),
         Size(432, 244)
       )

VirtualGloomhavenBoard/Indigo/vgb-common/test/src/vgb/common/HexagonTests.scala

@@ -0,0 +1,91 @@
+package vgb.common
+
+import indigo.shared.datatypes.Vector2
+
+class HexagonTests extends munit.FunSuite {
+
+  test("should rotate (0, 2) 0 turn around 0, 0") {
+    assertEquals(
+      Vector2(0, 2),
+      Hexagon.oddRowRotate(Vector2(0, 2), Vector2(0, 0), 0)
+    )
+  }
+
+  test("should rotate (0, 2) 1 turn around 0, 0") {
+    assertEquals(
+      Vector2(-2, 1),
+      Hexagon.oddRowRotate(Vector2(0, 2), Vector2(0, 0), 1)
+    )
+  }
+
+  test("should rotate (-1, 0) 1 turns around 0, 0") {
+    assertEquals(
+      Vector2(-1, -1),
+      Hexagon.oddRowRotate(Vector2(-1, 0), Vector2(0, 0), 1)
+    )
+  }
+
+  test("should rotate (0, 1) 6 turns around 0, 0") {
+    assertEquals(
+      Vector2(0, 1),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 6)
+    )
+  }
+
+  test("should rotate (0, 1) 5 turns around 0, 0") {
+    assertEquals(
+      Vector2(1, 0),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 5)
+    )
+  }
+
+  test("should rotate (0, 1) 4 turns around 0, 0") {
+    assertEquals(
+      Vector2(0, -1),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 4)
+    )
+  }
+
+  test("should rotate (0, 1) 3 turns around 0, 0") {
+    assertEquals(
+      Vector2(-1, -1),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 3)
+    )
+  }
+
+  test("should rotate (0, 1) 2 turns around 0, 0") {
+    assertEquals(
+      Vector2(-1, 0),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 2)
+    )
+  }
+
+  test("should rotate (0, 1) 1 turn around 0, 0") {
+    assertEquals(
+      Vector2(-1, 1),
+      Hexagon.oddRowRotate(Vector2(0, 1), Vector2(0, 0), 1)
+    )
+  }
+
+  test("should rotate (0, 2) 1 turn around 0, 3") {
+    assertEquals(
+      Vector2(1, 2),
+      Hexagon.oddRowRotate(Vector2(0, 2), Vector2(0, 3), 1)
+    )
+  }
+
+  test("should rotate (0, 2) 3 turns around 0, 3") {
+    assertEquals(
+      Vector2(1, 4),
+      Hexagon.oddRowRotate(Vector2(0, 2), Vector2(0, 3), 3)
+    )
+  }
+
+  test("should rotate (-1, 6) 1 turn around 0, 6") {
+    assertEquals(
+      Vector2(-1, 5),
+      Hexagon.oddRowRotate(Vector2(-1, 6), Vector2(0, 6), 1)
+    )
+
+  }
+}

VirtualGloomhavenBoard/Indigo/vgb-game/src/vgb/game/models/BoardOverlay.scala

@@ -2,6 +2,7 @@ package vgb.game.models
 
 import indigo.*
 import vgb.common.BoardOverlayType
+import vgb.common.Hexagon
 import vgb.common.RoomType
 
 final case class BoardOverlay(
@@ -17,7 +18,7 @@ final case class BoardOverlay(
 
   def rotate() =
     val rotatedOrigin =
-      Hexagon.evenRowRotate(Vector2.fromPoint(origin), Vector2.fromPoint(rotationPoint), 1)
+      Hexagon.oddRowRotate(Vector2.fromPoint(origin), Vector2.fromPoint(rotationPoint), 1)
 
     this.copy(
       origin = rotatedOrigin.toPoint,

VirtualGloomhavenBoard/Indigo/vgb-game/src/vgb/game/models/Placeable.scala

@@ -1,6 +1,7 @@
 package vgb.game.models
 
 import indigo.*
+import vgb.common.Hexagon
 
 trait Placeable:
   val rotation: TileRotation
@@ -14,7 +15,7 @@ trait Placeable:
 
   def localToWorld(localPoint: Point) =
     val rotatedPoint = Hexagon
-      .evenRowRotate(
+      .oddRowRotate(
         Vector2.fromPoint(localPoint),
         Vector2.fromPoint(minPoint),
         rotation.toByte()

VirtualGloomhavenBoard/Indigo/vgb-game/src/vgb/game/models/Room.scala

@@ -1,6 +1,7 @@
 package vgb.game.models
 
 import indigo.*
+import vgb.common.Hexagon
 import vgb.common.RoomType
 
 final case class Room(
@@ -14,7 +15,7 @@ final case class Room(
 
   def rotate() =
     val rotatedOrigin =
-      Hexagon.evenRowRotate(Vector2.fromPoint(origin), Vector2.fromPoint(rotationPoint), 1)
+      Hexagon.oddRowRotate(Vector2.fromPoint(origin), Vector2.fromPoint(rotationPoint), 1)
     this.copy(
       origin = rotatedOrigin.toPoint,
       rotation = rotation.nextRotation(false)

VirtualGloomhavenBoard/Indigo/vgb-game/src/vgb/game/models/TileRotation.scala

@@ -52,3 +52,10 @@ object TileRotation:
       case "diagonal-right-reverse" => DiagonalRightReverse
       case _                        => Default
     }
+
+  def fromByte(i: Byte) =
+    TileRotation.values
+      // We can't discern vertical just from the byte, so don't try
+      .filter(t => t != Vertical && t != VerticalReverse)
+      .find(t => t.toByte() == i)
+      .getOrElse(Default)