solve exceptional case of three-network intersection by defining an ID

Author: memo33

src/main/scala/module/MiscResolver.scala

@@ -271,6 +271,7 @@ class MiscResolver extends IdResolver {
     add(0x5F502500, Road~CES & Street~NE)
     add(0x5F072300, Road~(0,0,1,3) & Street~(2,2,0,0))
     add(0x04008900, Road~WE & Avenue~NS)
+    add(0x04008900, Road~CE & Avenue~NS & Onewayroad~WC)
     add(0x04001300, Road~ES & Avenue~SN)
     add(0x04001900, Road~WN & Avenue~SN)
     add(0x04005700, Road~NS & Avenue~ES)

src/main/scala/module/ReverseResolver.scala

@@ -73,13 +73,16 @@ object ReverseResolver {
       true
     } else if (isDiagonalTAmbuigity(tile1, tile2)) {
       true
-    } else if (idTile.id == 0x5D7E0800) {  // L1Dtr->L2Dtr upper HT uses same ID as L0Dtr->L2Dtr
-      true
     } else {
-      false
+      ignorableConflicts.contains(idTile.id)
     }
   }
 
+  private val ignorableConflicts = Set[Int](
+    0x5D7E0800,  // L1Dtr->L2Dtr upper HT uses same ID as L0Dtr->L2Dtr
+    0x04008900,  // also functions as three-network crossing
+  )
+
   def create(): ReverseResolver = {
     val maps = Seq(
       (new MiscResolver).tileMap,

src/main/scala/scripts/SegmentOrientationChecker.scala

@@ -161,11 +161,7 @@ object SegmentOrientationChecker extends Rul2Checker {
   }
 
   private val dxdDirtroadTiles = Set(IdTile(0x5700aa00, R0F0), IdTile(0x5700aa00, R2F0))
-  private val badConnectionsFalsePositives = Set[Rule[IdTile]](
-    // triple crossings between Road×Avenue (O×O) and orth OWR
-    Rule(0x04008800,0,0,0x09000300,3,0,0x04008900,2,0,0x09004b00,3,0),
-    Rule(0x04008800,0,0,0x09004b00,3,0,0x04008900,2,0,0x09004b00,3,0),
-  )
+  private val badConnectionsFalsePositives = Set.empty[Rule[IdTile]]  // currently none
 
   def areSegmentsBadlyConnected(tile1: Tile, tile2: Tile, rule: Rule[IdTile]): Boolean = {
     val connectingSegs1 = tile1.segs.filter(_.flags(2) != 0)

src/test/scala/scripts/SegmentOrientationCheckerSpec.scala

@@ -22,11 +22,12 @@ class SegmentOrientationCheckerSpec extends AnyWordSpec with Matchers {
       SegmentOrientationChecker.areSegmentsBadlyConnected(Ave2~(11,0,2,0), Road~WS & Ard3~SE, null).shouldBe(true)
     }
     "avoid false positives" in {
-      Seq(
+      Seq[(Tile, Tile, Rule[IdTile])](
         (Rhw4~WE & Mis~ES, Mis~NW & Dirtroad~EN, Rule(0x57127d05,0,0,0x5700aa00,2,0,0x57127d05,0,0,0x5712aa80,2,0)),
         (Rhw4~EW & Mis~EN, Mis~SW & Dirtroad~ES, Rule(0x57127d05,2,1,0x5700aa00,0,0,0x57127d05,2,1,0x5712aa80,0,1)),
         (Rhw4~WE & Mis~SE, Mis~WN & Dirtroad~EN, Rule(0x57127d85,0,0,0x5700aa00,2,0,0x57127d85,0,0,0x5712aa00,2,0)),
         (Rhw4~EW & Mis~NE, Mis~WS & Dirtroad~ES, Rule(0x57127d85,2,1,0x5700aa00,0,0,0x57127d85,2,1,0x5712aa00,0,1)),
+        (Road~CW & Avenue~SN & Onewayroad~EC, Onewayroad~EW, Rule(0x04008800,0,0,0x09000300,3,0,0x04008900,2,0,0x09004b00,3,0)),
       ).foreach { case (t1, t2, rule) =>
         SegmentOrientationChecker.areSegmentsBadlyConnected(t1, t2, rule).shouldBe(false)
       }