Exemplo n.º 1
0
 private bool CheckRegionBasedReachability(TraverseParms traverseParams)
 {
     while (this.openQueue.Count > 0)
     {
         Region region = this.openQueue.Dequeue();
         for (int i = 0; i < region.links.Count; i++)
         {
             RegionLink regionLink = region.links[i];
             for (int j = 0; j < 2; j++)
             {
                 Region region2 = regionLink.regions[j];
                 if (region2 != null && region2.reachedIndex != this.reachedIndex && region2.type.Passable() && region2.Allows(traverseParams, false))
                 {
                     if (this.destRegions.Contains(region2))
                     {
                         for (int k = 0; k < this.startingRegions.Count; k++)
                         {
                             this.cache.AddCachedResult(this.startingRegions[k].Room, region2.Room, traverseParams, true);
                         }
                         return(true);
                     }
                     this.QueueNewOpenRegion(region2);
                 }
             }
         }
     }
     for (int l = 0; l < this.startingRegions.Count; l++)
     {
         for (int m = 0; m < this.destRegions.Count; m++)
         {
             this.cache.AddCachedResult(this.startingRegions[l].Room, this.destRegions[m].Room, traverseParams, false);
         }
     }
     return(false);
 }
Exemplo n.º 2
0
        public RegionLink LinkFrom(EdgeSpan span)
        {
            ulong key = span.UniqueHashCode();

            if (!links.TryGetValue(key, out var value))
            {
                value      = new RegionLink();
                value.span = span;
                links.Add(key, value);
            }
            return(value);
        }
Exemplo n.º 3
0
        public RegionLink LinkFrom(EdgeSpan span)
        {
            ulong      key = span.UniqueHashCode();
            RegionLink regionLink;

            if (!this.links.TryGetValue(key, out regionLink))
            {
                regionLink      = new RegionLink();
                regionLink.span = span;
                this.links.Add(key, regionLink);
            }
            return(regionLink);
        }
 public void BreadthFirstTraverseWork(Region root, RegionEntryPredicate entryCondition, RegionProcessor regionProcessor, int maxRegions, RegionType traversableRegionTypes)
 {
     if ((root.type & traversableRegionTypes) == 0)
     {
         return;
     }
     closedIndex++;
     open.Clear();
     numRegionsProcessed = 0;
     QueueNewOpenRegion(root);
     while (open.Count > 0)
     {
         Region region = open.Dequeue();
         if (DebugViewSettings.drawRegionTraversal)
         {
             region.Debug_Notify_Traversed();
         }
         if (regionProcessor != null && regionProcessor(region))
         {
             FinalizeSearch();
             return;
         }
         if (ShouldCountRegion(region))
         {
             numRegionsProcessed++;
         }
         if (numRegionsProcessed >= maxRegions)
         {
             FinalizeSearch();
             return;
         }
         for (int i = 0; i < region.links.Count; i++)
         {
             RegionLink regionLink = region.links[i];
             for (int j = 0; j < 2; j++)
             {
                 Region region2 = regionLink.regions[j];
                 if (region2 != null && region2.closedIndex[closedArrayPos] != closedIndex && (region2.type & traversableRegionTypes) != 0 && (entryCondition == null || entryCondition(region, region2)))
                 {
                     QueueNewOpenRegion(region2);
                 }
             }
         }
     }
     FinalizeSearch();
 }
Exemplo n.º 5
0
 public void BreadthFirstTraverseWork(Region root, RegionEntryPredicate entryCondition, RegionProcessor regionProcessor, int maxRegions, RegionType traversableRegionTypes)
 {
     if ((root.type & traversableRegionTypes) != RegionType.None)
     {
         this.closedIndex += 1u;
         this.open.Clear();
         this.numRegionsProcessed = 0;
         this.QueueNewOpenRegion(root);
         while (!this.open.Empty)
         {
             Region region = this.open.PopFront();
             if (DebugViewSettings.drawRegionTraversal)
             {
                 region.Debug_Notify_Traversed();
             }
             if (regionProcessor != null)
             {
                 if (regionProcessor(region))
                 {
                     this.FinalizeSearch();
                     return;
                 }
             }
             this.numRegionsProcessed++;
             if (this.numRegionsProcessed >= maxRegions)
             {
                 this.FinalizeSearch();
                 return;
             }
             for (int i = 0; i < region.links.Count; i++)
             {
                 RegionLink regionLink = region.links[i];
                 for (int j = 0; j < 2; j++)
                 {
                     Region region2 = regionLink.regions[j];
                     if (region2 != null && region2.closedIndex[this.closedArrayPos] != this.closedIndex && (region2.type & traversableRegionTypes) != RegionType.None && (entryCondition == null || entryCondition(region, region2)))
                     {
                         this.QueueNewOpenRegion(region2);
                     }
                 }
             }
         }
         this.FinalizeSearch();
     }
 }
Exemplo n.º 6
0
 private bool CheckRegionBasedReachability(TraverseParms traverseParams)
 {
     while (openQueue.Count > 0)
     {
         Region region = openQueue.Dequeue();
         for (int i = 0; i < region.links.Count; i++)
         {
             RegionLink regionLink = region.links[i];
             for (int j = 0; j < 2; j++)
             {
                 Region region2 = regionLink.regions[j];
                 if (region2 == null || region2.reachedIndex == reachedIndex || !region2.type.Passable() || !region2.Allows(traverseParams, isDestination: false))
                 {
                     continue;
                 }
                 if (destRegions.Contains(region2))
                 {
                     for (int k = 0; k < startingRegions.Count; k++)
                     {
                         cache.AddCachedResult(startingRegions[k].Room, region2.Room, traverseParams, reachable: true);
                     }
                     return(true);
                 }
                 QueueNewOpenRegion(region2);
             }
         }
     }
     for (int l = 0; l < startingRegions.Count; l++)
     {
         for (int m = 0; m < destRegions.Count; m++)
         {
             cache.AddCachedResult(startingRegions[l].Room, destRegions[m].Room, traverseParams, reachable: false);
         }
     }
     return(false);
 }
Exemplo n.º 7
0
 private void SweepInTwoDirectionsAndTryToCreateLink(Rot4 potentialOtherRegionDir, IntVec3 c)
 {
     if (potentialOtherRegionDir.IsValid)
     {
         HashSet <IntVec3> hashSet = this.linksProcessedAt[potentialOtherRegionDir.AsInt];
         if (!hashSet.Contains(c))
         {
             IntVec3 c2 = c + potentialOtherRegionDir.FacingCell;
             if (c2.InBounds(this.map) && this.regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(c2) == this.newReg)
             {
                 return;
             }
             RegionType expectedRegionType = c2.GetExpectedRegionType(this.map);
             if (expectedRegionType != 0)
             {
                 Rot4 rot = potentialOtherRegionDir;
                 rot.Rotate(RotationDirection.Clockwise);
                 int num  = 0;
                 int num2 = 0;
                 hashSet.Add(c);
                 if (!expectedRegionType.IsOneCellRegion())
                 {
                     while (true)
                     {
                         IntVec3 intVec = c + rot.FacingCell * (num + 1);
                         if (intVec.InBounds(this.map) && this.regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(intVec) == this.newReg && (intVec + potentialOtherRegionDir.FacingCell).GetExpectedRegionType(this.map) == expectedRegionType)
                         {
                             if (!hashSet.Add(intVec))
                             {
                                 Log.Error("We've processed the same cell twice.");
                             }
                             num++;
                             continue;
                         }
                         break;
                     }
                     while (true)
                     {
                         IntVec3 intVec2 = c - rot.FacingCell * (num2 + 1);
                         if (intVec2.InBounds(this.map) && this.regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(intVec2) == this.newReg && (intVec2 + potentialOtherRegionDir.FacingCell).GetExpectedRegionType(this.map) == expectedRegionType)
                         {
                             if (!hashSet.Add(intVec2))
                             {
                                 Log.Error("We've processed the same cell twice.");
                             }
                             num2++;
                             continue;
                         }
                         break;
                     }
                 }
                 int           length = num + num2 + 1;
                 SpanDirection dir;
                 IntVec3       root;
                 if (potentialOtherRegionDir == Rot4.North)
                 {
                     dir  = SpanDirection.East;
                     root = c - rot.FacingCell * num2;
                     root.z++;
                 }
                 else if (potentialOtherRegionDir == Rot4.South)
                 {
                     dir  = SpanDirection.East;
                     root = c + rot.FacingCell * num;
                 }
                 else if (potentialOtherRegionDir == Rot4.East)
                 {
                     dir  = SpanDirection.North;
                     root = c + rot.FacingCell * num;
                     root.x++;
                 }
                 else
                 {
                     dir  = SpanDirection.North;
                     root = c - rot.FacingCell * num2;
                 }
                 EdgeSpan   span       = new EdgeSpan(root, dir, length);
                 RegionLink regionLink = this.map.regionLinkDatabase.LinkFrom(span);
                 regionLink.Register(this.newReg);
                 this.newReg.links.Add(regionLink);
             }
         }
     }
 }
Exemplo n.º 8
0
 public void Notify_LinkHasNoRegions(RegionLink link)
 {
     this.links.Remove(link.UniqueHashCode());
 }