ensure that only first-loaded rule is stored in cache

This ensures that our interpretation of RUL2 is the same as the one used
by the game.

Author: memo33

src/main/scala/scripts/RedundantAdjacenciesChecker.scala

@@ -42,9 +42,26 @@ object RedundantAdjacenciesChecker {
         scala.util.Using.resource(new java.util.Scanner(path.toFile(), "UTF-8")) { scanner =>
           while(scanner.hasNextLine()) {
             parseRuleWithRestrictedDriveside(scanner.nextLine(), drivesideFile) match {
-              case Some((rule, Rhd)) => rulesRhd.addOne(new EquivRule(rule), rule)
-              case Some((rule, Lhd)) => rulesLhd.addOne(new EquivRule(rule), rule)
-              case Some((rule, RhdAndLhd)) => rulesShared.addOne(new EquivRule(rule), rule)
+              // only the first matching rule is loaded by the game, so we store only the first one read
+              case Some((rule, Rhd)) =>
+                val key = new EquivRule(rule)
+                if (!rulesShared.contains(key) && !rulesRhd.contains(key))
+                  rulesRhd.addOne(key, rule)
+              case Some((rule, Lhd)) =>
+                val key = new EquivRule(rule)
+                if (!rulesShared.contains(key) && !rulesLhd.contains(key))
+                  rulesLhd.addOne(key, rule)
+              case Some((rule, RhdAndLhd)) =>
+                val key = new EquivRule(rule)
+                if (!rulesShared.contains(key)) {
+                  if (!rulesRhd.contains(key) && !rulesLhd.contains(key))
+                    rulesShared.addOne(key, rule)
+                  else
+                    require(
+                      rulesRhd.contains(key) == rulesLhd.contains(key),
+                      s"There's an unexpected rule conflict that differs between RHD and LHD: $rule"
+                    )
+                }
               case None => // ignore
             }
           }
@@ -69,9 +86,10 @@ object RedundantAdjacenciesChecker {
                 case Some((rule, Lhd)) => isRedundantAdjacency(rule, lookupRuleLhd)
                 case Some((rule, RhdAndLhd)) =>
                   val b = isRedundantAdjacency(rule, lookupRuleRhd)
-                  if (b != isRedundantAdjacency(rule, lookupRuleLhd)) {
-                    throw new AssertionError(s"Redundancies should be the same for RHD and LHD: $rule")  // hopefully this will always be the case
-                  }
+                  require(
+                    b == isRedundantAdjacency(rule, lookupRuleLhd),
+                    s"Redundancies should be the same for RHD and LHD: $rule"  // hopefully this will always be the case
+                  )
                   b
                 case None => false  // comments are not redundant
               }