#228 Setting coastal sides.

EGrid/src/eg220/Terr220E0.scala

@@ -87,6 +87,7 @@ object Terr220E0 extends Long220Terrs
 
     res
   }
+
   val help = new WTerrSetter(grid, terrs, sTerrs, corners)
   {
     override val rowDatas: RArr[TRow] = RArr(

EGrid/src/eg320/Terr320E0.scala

@@ -95,6 +95,14 @@ object Terr320E0 extends Long320Terrs
 
     res
   }
+  val help = new WTerrSetter(grid, terrs, sTerrs, corners)
+  { override val rowDatas: RArr[TRow] = RArr(
+     // TRow(134, sea, Head2Land(5, Hilly, Desert), desertHills, desert * 10),
+      //TRow(132, sea, desert * 12)
+    )
+  }
+  help.run
+
 }
 
 object BritReg

EGrid/src/eg320/Terr320E30.scala

@@ -1,10 +1,6 @@
 /* Copyright 2018-23 Richard Oliver. Licensed under Apache Licence version 2.0. */
 package ostrat; package eg320
-import prid._
-import phex._
-import egrid._
-import WTile._
-import ostrat.eg220.WTerrSetter
+import prid.phex._, egrid._, WTile._
 
 object Terr320E30 extends Long320Terrs
 {

EGrid/src/egrid/WTerrSetter.scala

@@ -1,6 +1,6 @@
 /* Copyright 2018-23 Richard Oliver. Licensed under Apache Licence version 2.0. */
-package ostrat; package eg220
-import prid._, phex._, egrid._
+package ostrat; package egrid
+import prid._, phex._
 
 /** Helper class for setting  [[HCenLayer]][WTile], [[HSideLayer]][WSide] and [[HCornerLayer]] at the same time." */
 abstract class WTerrSetter(gridIn: HGrid, val terrs: HCenLayer[WTile], val sTerrs: HSideLayer[WSide], val corners: HCornerLayer)
@@ -17,8 +17,20 @@ abstract class WTerrSetter(gridIn: HGrid, val terrs: HCenLayer[WTile], val sTerr
       multi.foreach { tile =>
         if (c > grid.rowRightCenC(row)) excep("Too many tiles for row.")
         terrs.set(row, c, tile)
-        tile match {
-          case ct: Coastal => corners.setNCornersIn(row, c, ct.numIndentedVerts, ct.indentStartIndex, 7)
+        tile match
+        { case ct: Coastal =>
+          { corners.setNCornersIn(row, c, ct.numIndentedVerts, ct.indentStartIndex, 7)
+            ct.indentedSideIndexForeach{ i =>
+              val side = HCen(row, c).side(i)
+              side match {
+                case _: WSideMid =>
+                case _: WSideLt if i >= 3 => sTerrs.set(side, WSideBoth(ct.sideTerrs))
+                case _ if i >= 3 => sTerrs.set(side, WSideRt(ct.sideTerrs))
+                case _: WSideRt => sTerrs.set(side, WSideBoth(ct.sideTerrs))
+                case _ => sTerrs.set(side, WSideLt(ct.sideTerrs))
+              }
+            }
+          }
           case _ =>
         }
         c += 4

Tiling/srcHex/HCen.scala

@@ -70,6 +70,33 @@ class HCen(val r: Int, val c: Int) extends HCenOrSide with TCen
   def vertsIn(magnitude: Int): PolygonHVAndOffset =
     PolygonHVAndOffset(v0In(magnitude), v1In(magnitude), v2In(magnitude), v3In(magnitude), v4In(magnitude), v5In(magnitude))
 
+  /** Up right side. From vert 0 to vert 1. */
+  def s0: HSide = HSide(r + 1, c + 1)
+
+  /** Right side. From vert 1 to vert 2. */
+  def s1: HSide = HSide(r, c + 2)
+
+  /** Down right side. From vert 2 to vert 3. */
+  def s2: HSide = HSide(r - 1, c - 1)
+
+  /** Down left side. From vert 3 to vert 4. */
+  def s3: HSide = HSide(r - 1, c - 1)
+
+  /** Left side. From vert 4 to vert 5. */
+  def s4: HSide = HSide(r, c - 2)
+
+  /** Up left side. From vert 5 to vert 0. */
+  def s5: HSide = HSide(r + 1, c - 1)
+
+  def side(index: Int): HSide = (index %% 6) match
+  { case 0 => s0
+    case 1 => s1
+    case 2 => s2
+    case 3 => s3
+    case 4 => s4
+    case 5 => s5
+  }
+
   def fill(colour: Colour): PolygonFill = polygonReg.fill(colour)
   def active(id: AnyRef = this): PolygonActive = polygonReg.active(id)
   override def typeStr: String = "HCen"

Tiling/srcHex/HIndentN.scala

@@ -8,19 +8,23 @@ trait HIndentN
 
   /** Hex sides are numbered from 0 to 5 in a clockwise direction starting at the top right. This is the index of the first indented vertex. */
   def indentStartIndex: Int
+
+  def indentedSideIndexForeach(f: Int => Unit): Unit
 }
 
 /** Hex tile indented on 6 of its sides, representing an island and its surrounding waters or similarly geometrically structured terrain where the
  *  main land area of the tile is surrounded by water on all 6 sides. */
 trait HIndent6 extends HIndentN
 { override def numIndentedVerts: Int = 6
   override def indentStartIndex: Int = 0
+
+  override def indentedSideIndexForeach(f: Int => Unit): Unit = iUntilForeach(6)(f)
 }
 
 /** Hex tile indented on 5 or less of its vertices, representing a headland and its surrounding waters or similarly geometrically structured terrain#
  *  where the main land area of the tile is surrounded by water on a number of its sides */
 trait HIndent5Minus extends HIndentN
-{
+{ override def indentedSideIndexForeach(f: Int => Unit): Unit = iToForeach(numIndentedVerts){i => f((indentStartIndex + i - 1) %% 6) }
 }
 
 /** Hex tile indented on 4 of its vertices, representing a headland and its surrounding waters or similarly geometrically structured terrain where the