fix TLA orientations in metarules

This adds a bandaid to prevent that mirrored orientations of orth/diag
TLA tiles get added to the tile orientation cache. This avoids some
ambiguity between the two flavors of turning lanes (`0x5...` vs
`0x7...`) in the metarule-generated RUL2 code.

Additionally, this adjust the preprocessor to duplicate rules involving
TLA by their upside-down variant (`R2F1`). This is necessary, as the two
rules might resolve to different IDs (`0x5...` vs `0x7...`).

Author: memo33

src/main/scala/module/Main.scala

@@ -30,6 +30,8 @@ abstract class AbstractMain {
     }
   }
 
+  private lazy val shouldIgnoreMirroredOrientations: Set[Int] = MirrorVariants.ignoreMirroredOrientations(resolve)
+
   def main(args: Array[String]): Unit = start()
 
   /** Creates a generator with a new context, runs its start method and outputs the resulting RUL2 code to file. */
@@ -54,6 +56,14 @@ abstract class AbstractMain {
           printer.println(rule.toRul2String)
         }
       }
+      // finally remove accumulated orientations that we want to ignore (like accidentally mirrored TLAs)
+      tileOrientationCache.accum.mapValuesInPlace { (id, repr) =>
+        if (shouldIgnoreMirroredOrientations(id)) repr.filterNot(_.flipped)
+        else repr
+      }
+      tileOrientationCache.accum.filterInPlace { (id, repr) =>  // remove from accum if equal to cache (so that regenerateTileOrientationCache stabilizes eventually)
+        !tileOrientationCache.cache.get(id).contains(repr)
+      }
     }
   }
 }

src/main/scala/module/MirrorVariants.scala

@@ -54,23 +54,43 @@ object MirrorVariants {
     case _ => tile
   }
 
-  private val tlaPreprocessor: Rule[SymTile] => Iterator[Rule[SymTile]] = rule => {
-    if (!rule.exists(containsTlaFlags)) {
-      Iterator(rule)
-    } else if (rule.forall(shouldProjectTlaLeftOnly)) {
-      Iterator(rule.map(projectTlaLeft))
-    } else {
-      Iterator(rule.map(projectTlaLeft), rule.map(projectTlaRight))
-    }
+  val preprocessor: Rule[SymTile] => Iterator[Rule[SymTile]] = rule => {
+    val hasMirrorVariant = rule.exists(tile => mirrorVariants.contains(tile))
+    for {
+      rule <- if (hasMirrorVariant) Iterator(  // yield the two projected rules
+                rule.map(tile => mirrorVariants.get(tile).map(_._1).getOrElse(tile)),
+                rule.map(tile => mirrorVariants.get(tile).map(_._2).getOrElse(tile)),
+              )
+              else Iterator(rule)
+      hasTlaFlags = rule.exists(containsTlaFlags)
+      rule <- if (!hasTlaFlags) Iterator(rule)
+              else if (rule.forall(shouldProjectTlaLeftOnly)) Iterator(rule.map(projectTlaLeft))
+              else Iterator(rule.map(projectTlaLeft), rule.map(projectTlaRight))
+      // We duplicate the rule by its R2F1 variant if there are TLAs or mirror
+      // variants involved, as the left/right distinction can make them resolve
+      // to different IDs (and the generators do not necessarily account for
+      // this). For example, this is needed for Tla5/Avenue D×D.
+      rule <- if (hasMirrorVariant || hasTlaFlags) Iterator(rule, rule.map(_ * R2F1)).distinct
+              else Iterator(rule)
+    } yield rule
   }
 
-  val preprocessor: Rule[SymTile] => Iterator[Rule[SymTile]] = rule => {
-    if (!rule.exists(tile => mirrorVariants.contains(tile))) {
-      Iterator(rule)
-    } else {
-      Iterator(  // yield the two projected rules
-        rule.map(tile => mirrorVariants.get(tile).map(_._1).getOrElse(tile)),
-        rule.map(tile => mirrorVariants.get(tile).map(_._2).getOrElse(tile)))
+  /* For plain orthogonal and diagonal tiles of TLA networks, we ignore any
+   * remapping defined in `tileOrientationCache` that leads to mirroring, as
+   * that would amplify the mirroring problems due to the presence of turning
+   * lanes. Not a perfect solution, as occasional mirroring problems will remain.
+   */
+  def ignoreMirroredOrientations(resolve: IdResolver): Set[Int] = {
+    val ids = Set.newBuilder[Int]
+    for {
+      n <- Seq(Tla3, Tla5, Tla7m, Road, Onewayroad)  // TODO consider adding all the networks
+      dir <- Seq(NS, ES, SE)  // these are arbitrary orth/diag directions to allow us find the IDs
+      tile <- Seq(NetworkProperties.projectTlaLeft(n~dir), NetworkProperties.projectTlaRight(n~dir))
+      idTile <- resolve.lift(tile)
+    } {
+      ids += idTile.id
     }
-  }.flatMap(tlaPreprocessor)
+    ids.result()
+  }
+
 }

src/test/scala/meta/RuleTransducerSpec.scala

@@ -22,7 +22,7 @@ class RuleTransducerSpec extends AnyWordSpec with Matchers {
 
       context.preprocess( Tla3~WE & Road~NS | (Road ~> Tla3)~WE ).toSeq should have size (1)
       val diag = context.preprocess( Tla3~WE & Road~WS | (Road ~> Tla3)~WE ).toSeq
-      diag should have size (2)
+      diag should have size (4)
       for (r <- diag) {
         createRules(r.map(_.toIdSymTile(resolver)), context.tileOrientationCache.cache, context.tileOrientationCache.accum).toSeq should have size (2)
       }

src/test/scala/module/MirrorVariantsSpec.scala

@@ -56,29 +56,29 @@ class MirrorVariantsSpec extends AnyWordSpec with Matchers {
 
     "produce expected results for TLA network crossings" in {
       implicit val context = RuleTransducer.Context(resolve, preprocess = MirrorVariants.preprocessor)
-      RuleTransducer(Tla3~WE | (Road~>Tla3)~WE & Rail~ES).toSeq shouldBe Seq(
+      RuleTransducer(Tla3~WE | (Road~>Tla3)~WE & Rail~ES).toSeq should contain theSameElementsAs Seq(
         Rule(0x51000000,1,0, 0x03010200,1,0, 0x51000000,1,0, 0x51005500,3,0),
         Rule(0x51000000,3,0, 0x03010200,1,0, 0x51000000,3,0, 0x51005500,3,0),
         Rule(0x51000000,3,0, 0x03020500,3,1, 0x51000000,3,0, 0x51005500,1,1),
         Rule(0x51000000,1,0, 0x03020500,3,1, 0x51000000,1,0, 0x51005500,1,1))
-      RuleTransducer(Tla5~WE | (Road~>Tla5)~WE & Rail~ES).toSeq shouldBe Seq(
+      RuleTransducer(Tla5~WE | (Road~>Tla5)~WE & Rail~ES).toSeq should contain theSameElementsAs Seq(
         Rule(0x51100000,3,0, 0x03010200,1,0, 0x51100000,3,0, 0x51105500,3,0),
         Rule(0x51100000,1,0, 0x03020500,3,1, 0x51100000,1,0, 0x51105500,1,1))
-      RuleTransducer(Tla5~WE | (Road~>Tla5)~WE & Road~ES).toSeq shouldBe Seq(
+      RuleTransducer(Tla5~WE | (Road~>Tla5)~WE & Road~ES).toSeq should contain theSameElementsAs Seq(
         Rule(0x51100000,3,0, 0x00003900,1,0, 0x51100000,3,0, 0x51105100,3,0),
         Rule(0x51100000,1,0, 0x00003900,3,1, 0x51100000,1,0, 0x71105100,1,1))  // 0x71... variant
-      RuleTransducer(Tla3~WE | (Road~>Tla3)~WE & Lightrail~ES).toSeq shouldBe Seq(
+      RuleTransducer(Tla3~WE | (Road~>Tla3)~WE & Lightrail~ES).toSeq should contain theSameElementsAs Seq(
         Rule(0x51000000,1,0, 0x08DD1600,1,1, 0x51000000,1,0, 0x51005600,3,0),
         Rule(0x51000000,3,0, 0x08DD1600,1,1, 0x51000000,3,0, 0x51005600,3,0),
         Rule(0x51000000,3,0, 0x08DD1600,3,0, 0x51000000,3,0, 0x51005600,1,1),
         Rule(0x51000000,1,0, 0x08DD1600,3,0, 0x51000000,1,0, 0x51005600,1,1))
-      RuleTransducer(Tla5~EW | (Avenue~>Tla5)~EW & Avenue~NS).toSet shouldBe Set(
+      RuleTransducer(Tla5~EW | (Avenue~>Tla5)~EW & Avenue~NS).toSeq should contain theSameElementsAs Seq(
         Rule(0x51100000,3,0, 0x04009000,0,0, 0x51100000,3,0, 0x71101300,2,1),
         Rule(0x51100000,1,0, 0x04009000,1,0, 0x51100000,1,0, 0x51101300,0,0))
-      RuleTransducer(Tla5~EW & Avenue~NS | (Avenue~>Tla5)~EW & Avenue~SN).toSet shouldBe Set(
+      RuleTransducer(Tla5~EW & Avenue~NS | (Avenue~>Tla5)~EW & Avenue~SN).toSeq should contain theSameElementsAs Seq(
         Rule(0x71101300,2,1, 0x04009000,3,0, 0x71101300,2,1, 0x51101300,2,0),
         Rule(0x51101300,0,0, 0x04009000,2,0, 0x51101300,0,0, 0x71101300,0,1))
-      RuleTransducer(Tla5~EW & Avenue~SN | (Avenue~>Tla5)~EW).toSet shouldBe Set(
+      RuleTransducer(Tla5~EW & Avenue~SN | (Avenue~>Tla5)~EW).toSeq should contain theSameElementsAs Seq(
         Rule(0x51101300,2,0, 0x04006100,3,0, 0x51101300,2,0, 0x51100000,3,0),
         Rule(0x71101300,0,1, 0x04006100,1,0, 0x71101300,0,1, 0x51100000,1,0))
     }