add RHW networks to NWM turn paths generating script

Author: memo33

src/main/scala/pathing/nwmpaths/NetworkConfig.scala

@@ -115,6 +115,17 @@ object NetworkConfig {
     add(Tla7m, NS)(-7f-16)(0.5f-16, 5.5f-16, -5.5f, -1.125f)(17.125f-16, 21.5f-16, 16-5.5f, 16-0.5f)(23f)
     add(Tla7m, ES, SE)(-32+1.5f)(-16-5.5f, -16+1.5f, -16+7.5f, -0.1f)(0.1f, 16-7.5f, 16-1.5f, 16+5.5f)(32-1.5f)
 
+    add(Dirtroad, NS)(-6.4f)(-2.5f)(2.5f)(6.5f)
+    add(Dirtroad, ES)(-7.1f)(-3.2f)(3.2f)(7.1f)
+    add(Rhw3, NS)(-7.5f)(-4.5f, 0f)(4.5f)(7.5f)  // pedestrian paths are made up, needed for defining the boundary of the intersection
+    add(Rhw3, ES, SE)(-7.99f)(-5.5f, 0f)(5.5f)(7.99f)
+    add(Mis, NS)(-6.39f)(0f)()(6.39f)
+    add(Mis, ES, SE)(-7.3f)(0f)()(7.3f)
+    add(Rhw4, NS)(-6.5f)(-2.5f, 2.5f)()(6.5f)
+    add(Rhw4, ES, SE)(-7.3f)(-3.2f, 3.2f)()(7.3f)
+    // add(Rhw6s, NS)(-7.99f)(-7f, -2.5f, 2.5f)()(6.5f)
+    // add(Rhw6s, ES, SE)(-7.99f)(-7.875f, -3.2f, 3.2f)()(7.1f)
+
     m.toMap
   }
 

src/main/scala/pathing/nwmpaths/PathCreator.scala

@@ -25,17 +25,26 @@ object PathCreator {
   def generateNwmPaths(implicit resolver: IdResolver): Iterable[BufferedEntry[Sc4Path]] = {
     val ids = scala.collection.mutable.Map.empty[Int, (Sc4Path, Boolean)]
     // TODO provisional
-    val mainNetworks = NwmNetworks -- Set(Ave8)
+    val mainNetworks = NwmNetworks -- Set(Ave8) ++ Set(Dirtroad, Rhw3, Mis, Rhw4)
     val minorNetworks = NwmNetworks ++ Set(Road, Street, Onewayroad, Avenue) -- Set(Ave8)
     for {
       main <- mainNetworks
       minor <- minorNetworks
+      if {
+        if (NetworkProperties.intersectionAllowed(main, minor)) {
+          true
+        } else {
+          println(s"intersections between $main and $minor are not allowed yet(?)")
+          false
+        }
+      }
     } /*do*/ {
       import Flags._, Implicits._
       def add(seg1: Segment, seg2: Segment, modelBased: Boolean) = {
         val tile0 = NetworkProperties.transformSharedDiagonals(seg1 & seg2)
         if (!seg1.network.isTla && !seg2.network.isTla) {
           val idTile = resolver(tile0)
+          // require(!idTile.rf.flipped, s"unexpected mirrored tile ${tile0}")
           if (!ids.contains(idTile.id)) {
             val intersection = new PlusIntersection(seg1, seg2)
             ids(idTile.id) = (intersection.buildSc4Path * (R0F0 / idTile.rf), modelBased)
@@ -57,7 +66,7 @@ object PathCreator {
           }
         }
       }
-      def hasDiagonalOverhangs(n: Network): Boolean = n.isNwm && NetworkProperties.isSingleTile(n) && n != Owr1
+      def hasDiagonalOverhangs(n: Network): Boolean = n.isNwm && NetworkProperties.isSingleTile(n) && n != Owr1 || n.isRhw
       // In the following, it is important to choose the same directions as in
       // the IID scheme, since otherwise the uk flags can end up flipped.
       for { // OxD

src/main/scala/pathing/nwmpaths/plusIntersection.scala

@@ -71,21 +71,23 @@ class PlusIntersection(major: Segment, minor: Segment) extends CommonIntersectio
     val n = network(c)
     n == Network.Onewayroad || n.base.exists(_ == Network.Onewayroad)
   }
+  private def hasPedestrianPaths(n: Network): Boolean = !n.isRhw || n == Network.Dirtroad
 
   override val MaxRadius =
     if (NP.isTripleTile(major.network) || NP.isTripleTile(minor.network)) 6.0
     else if (NP.isDoubleTile(major.network) && NP.isDoubleTile(minor.network)) 14.0
     else 8.5  // single/single or mixed double/single
 
-  protected def rightTurnPaths(c: Cardinal, tt: TT) = if (tt == TT.Sim || tt == TT.Car) {
+  protected def rightTurnPaths(c: Cardinal, tt: TT) = if (tt == TT.Sim && hasPedestrianPaths(network(c)) || tt == TT.Car) {
     sortedPaths(c).find(_.tt == tt).toSeq
   } else Nil
   protected def leftTurnPaths(c: Cardinal, tt: TT) = if (tt == TT.Car) {
     sortedPaths(c).reverseIterator.find(_.tt == tt).toSeq
   } else Nil
   protected def straightPaths(c: Cardinal, tt: TT, dropRedundantPaths: Boolean) = {
     val paths = sortedPaths(c).filter(_.tt == tt)
-    if (tt != TT.Car) paths
+    if (tt == TT.Sim && !hasPedestrianPaths(network(c))) Nil
+    else if (tt != TT.Car) paths
     else if (dropRedundantPaths && hasTurningLane(c)) paths.dropRight(1) // TLA networks have one thru-lane less
     else if (dropRedundantPaths && isBidirectionalOneway(c)) paths.dropRight(paths.length / 2) // OWR networks have duplicated thru-lanes, we need only half of them
     else paths