private static void UpdateLinks(HashSet <int> dirty_nav_cells, NavTable nav_table, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { foreach (int dirty_nav_cell in dirty_nav_cells) { CreateLinksForCell(dirty_nav_cell, nav_table, max_links_per_cell, links, transitions_by_nav_type); } }
public NavigationService(TilemapNavData navData) { NavRegionGenerationFunctions.InitialiseNavRegionsFromData(navData); _navigationTable = navData.NavigationTable; _navigationTable.Initialise(); }
public NavGrid(string id, Transition[] transitions, NavTypeData[] nav_type_data, CellOffset[] bounding_offsets, NavTableValidator[] validators, int update_range_x, int update_range_y, int max_links_per_cell) { this.id = id; Validators = validators; navTypeData = nav_type_data; this.transitions = transitions; boundingOffsets = bounding_offsets; List <NavType> list = new List <NavType>(); updateRangeX = update_range_x; updateRangeY = update_range_y; maxLinksPerCell = max_links_per_cell + 1; for (int i = 0; i < transitions.Length; i++) { DebugUtil.Assert(i >= 0 && i <= 255); transitions[i].id = (byte)i; if (!list.Contains(transitions[i].start)) { list.Add(transitions[i].start); } if (!list.Contains(transitions[i].end)) { list.Add(transitions[i].end); } } ValidNavTypes = list.ToArray(); DebugViewLinkType = new bool[ValidNavTypes.Length]; DebugViewValidCellsType = new bool[ValidNavTypes.Length]; NavType[] validNavTypes = ValidNavTypes; foreach (NavType nav_type in validNavTypes) { GetNavTypeData(nav_type); } Links = new Link[maxLinksPerCell * Grid.CellCount]; NavTable = new NavTable(Grid.CellCount); this.transitions = transitions; transitionsByNavType = new Transition[10][]; for (int k = 0; k < 10; k++) { List <Transition> list2 = new List <Transition>(); NavType navType = (NavType)k; for (int l = 0; l < transitions.Length; l++) { Transition item = transitions[l]; if (item.start == navType) { list2.Add(item); } } transitionsByNavType[k] = list2.ToArray(); } foreach (NavTableValidator navTableValidator in validators) { NavTableValidator navTableValidator2 = navTableValidator; navTableValidator2.onDirty = (Action <int>)Delegate.Combine(navTableValidator2.onDirty, new Action <int>(AddDirtyCell)); } potentialScratchPad = new PathFinder.PotentialScratchPad(maxLinksPerCell); InitializeGraph(); NavGraph = new NavGraph(Grid.CellCount, this); }
private static void CreateLinks(int cell, NavTable nav_table, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { int num = cell * max_links_per_cell; int num2 = 0; for (int i = 0; i < 10; i++) { NavType nav_type = (NavType)i; NavGrid.Transition[] array = transitions_by_nav_type[i]; if (array != null && nav_table.IsValid(cell, nav_type)) { NavGrid.Transition[] array2 = array; for (int j = 0; j < array2.Length; j++) { NavGrid.Transition transition = array2[j]; int num3 = transition.IsValid(cell, nav_table); if (num3 != Grid.InvalidCell) { links[num] = new NavGrid.Link(num3, transition.start, transition.end, transition.id, transition.cost); num++; num2++; } } } } if (num2 >= max_links_per_cell) { Debug.LogError("Out of nav links. Need to increase maxLinksPerCell:" + max_links_per_cell); } links[num].link = Grid.InvalidCell; }
public MarkValidCellWorkItem(int start_cell, NavTable nav_table, CellOffset[] bounding_offsets, NavTableValidator[] validators) { startCell = start_cell; navTable = nav_table; boundingOffsets = bounding_offsets; this.validators = validators; }
public CreateLinkWorkItem(int start_cell, NavTable nav_table, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { startCell = start_cell; navTable = nav_table; maxLinksPerCell = max_links_per_cell; this.links = links; transitionsByNavType = transitions_by_nav_type; }
public override void UpdateCell(int cell, NavTable nav_table, CellOffset[] bounding_offsets) { bool flag = ScaffoldingValidator.IsWalkableCell(cell); if (flag && base.IsClear(cell, bounding_offsets, false)) { nav_table.SetValid(cell, NavType.Floor, true); } }
private static void UpdateValidCells(HashSet <int> dirty_solid_cells, NavTable nav_table, NavType[] valid_nav_types, NavTableValidator[] validators, CellOffset[] bounding_offsets) { foreach (int dirty_solid_cell in dirty_solid_cells) { foreach (NavTableValidator navTableValidator in validators) { navTableValidator.UpdateCell(dirty_solid_cell, nav_table, bounding_offsets); } } }
public void NavTable_NotInitialised_NullLookup() { _nodeAMin.NeighbourRefs = new[] { _nodeBMin }; var table = new NavTable(new List <NavRegion> { _regionA, _regionB }); Assert.IsNull(table.GetRegionRouteForPoints(_nodeAMin.Position, _nodeBMin.Position)); }
protected override void OnSpawn() { base.OnSpawn(); NavGrid navGrid = Pathfinding.Instance.GetNavGrid("MinionNavGrid"); NavGrid navGrid2 = navGrid; navGrid2.OnNavGridUpdateComplete = (Action <HashSet <int> >)Delegate.Combine(navGrid2.OnNavGridUpdateComplete, new Action <HashSet <int> >(OnNavGridUpdateComplete)); NavTable navTable = navGrid.NavTable; navTable.OnValidCellChanged = (Action <int, NavType>)Delegate.Combine(navTable.OnValidCellChanged, new Action <int, NavType>(OnValidNavCellChanged)); }
private static void CreateLinks(NavTable nav_table, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { WorkItemCollection <CreateLinkWorkItem, object> workItemCollection = new WorkItemCollection <CreateLinkWorkItem, object>(); workItemCollection.Reset(null); for (int i = 0; i < Grid.HeightInCells; i++) { workItemCollection.Add(new CreateLinkWorkItem(Grid.OffsetCell(0, new CellOffset(0, i)), nav_table, max_links_per_cell, links, transitions_by_nav_type)); } GlobalJobManager.Run(workItemCollection); }
private static void MarkValidCells(NavTable nav_table, NavType[] valid_nav_types, NavTableValidator[] validators, CellOffset[] bounding_offsets) { WorkItemCollection <MarkValidCellWorkItem, object> workItemCollection = new WorkItemCollection <MarkValidCellWorkItem, object>(); workItemCollection.Reset(null); for (int i = 0; i < Grid.HeightInCells; i++) { workItemCollection.Add(new MarkValidCellWorkItem(Grid.OffsetCell(0, new CellOffset(0, i)), nav_table, bounding_offsets, validators)); } GlobalJobManager.Run(workItemCollection); }
public void NavTable_Initialised_CorrectLookupForSameRegionTraversal() { var table = new NavTable(new List <NavRegion> { _regionA, _regionB }); table.Initialise(); var result = table.GetRegionRouteForPoints(_nodeAMin.Position, _nodeAMax.Position); Assert.AreEqual(1, result.Count); Assert.AreSame(_regionA, result[0]); }
/// <summary> /// GameNavGrids.SwimValidator.UpdateCell Prefix /// </summary> static bool Prefix(GameNavGrids.SwimValidator __instance, int cell, NavTable nav_table, CellOffset[] bounding_offsets) { bool?isClear = SwimValidatorHelper.NavTableValidator_IsClear(__instance, cell, bounding_offsets, false); if (!isClear.HasValue) // failed to access base method { return(true); // skip patch and call original method } bool is_swimmable = Grid.IsWorldValidCell(cell) && (Grid.IsSubstantialLiquid(cell, 0.9f) || (Grid.IsLiquid(cell) && (SwimValidatorHelper.IsLiquidAbove(cell) || SwimValidatorHelper.IsLiquidBelow(cell)))) && isClear.Value; nav_table.SetValid(cell, NavType.Swim, is_swimmable); return(false); // skip execution of the original method }
public void NavTable_Initialised_CorrectAdjacencyLookup() { _nodeAMin.NeighbourRefs = new[] { _nodeBMin }; var table = new NavTable(new List <NavRegion> { _regionA, _regionB }); table.Initialise(); var result = table.GetRegionRouteForPoints(_nodeAMin.Position, _nodeBMin.Position); Assert.AreEqual(2, result.Count); Assert.AreSame(_regionA, result[0]); Assert.AreSame(_regionB, result[1]); }
private void DebugDrawValidCells() { Color color = Color.white; int cellCount = Grid.CellCount; for (int i = 0; i < cellCount; i++) { for (int j = 0; j < 10; j++) { NavType nav_type = (NavType)j; if (NavTable.IsValid(i, nav_type) && DrawNavTypeCell(nav_type, ref color)) { DebugExtension.DebugPoint(NavTypeHelper.GetNavPos(i, nav_type), color, 1f, 0f, false); } } } }
private static void CreateLinksForCell(int cell, NavTable nav_table, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { CreateLinks(cell, nav_table, max_links_per_cell, links, transitions_by_nav_type); }
public static void UpdateNavGrid(NavTable nav_table, NavType[] valid_nav_types, NavTableValidator[] validators, CellOffset[] bounding_offsets, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type, HashSet <int> dirty_nav_cells) { UpdateValidCells(dirty_nav_cells, nav_table, valid_nav_types, validators, bounding_offsets); UpdateLinks(dirty_nav_cells, nav_table, max_links_per_cell, links, transitions_by_nav_type); }
public int IsValid(int cell, NavTable nav_table) { if (!Grid.IsCellOffsetValid(cell, x, y)) { return(Grid.InvalidCell); } int num = Grid.OffsetCell(cell, x, y); if (!nav_table.IsValid(num, end)) { return(Grid.InvalidCell); } Grid.BuildFlags buildFlags = Grid.BuildFlags.Solid | Grid.BuildFlags.DupeImpassable; if (isCritter) { buildFlags |= Grid.BuildFlags.CritterImpassable; } CellOffset[] array = voidOffsets; for (int i = 0; i < array.Length; i++) { CellOffset cellOffset = array[i]; int num2 = Grid.OffsetCell(cell, cellOffset.x, cellOffset.y); if (Grid.IsValidCell(num2) && (Grid.BuildMasks[num2] & buildFlags) != 0) { if (isCritter) { return(Grid.InvalidCell); } if ((Grid.BuildMasks[num2] & Grid.BuildFlags.DupePassable) == (Grid.BuildFlags) 0) { return(Grid.InvalidCell); } } } CellOffset[] array2 = solidOffsets; for (int j = 0; j < array2.Length; j++) { CellOffset cellOffset2 = array2[j]; int num3 = Grid.OffsetCell(cell, cellOffset2.x, cellOffset2.y); if (Grid.IsValidCell(num3) && !Grid.Solid[num3]) { return(Grid.InvalidCell); } } NavOffset[] array3 = validNavOffsets; for (int k = 0; k < array3.Length; k++) { NavOffset navOffset = array3[k]; int cell2 = Grid.OffsetCell(cell, navOffset.offset.x, navOffset.offset.y); if (!nav_table.IsValid(cell2, navOffset.navType)) { return(Grid.InvalidCell); } } NavOffset[] array4 = invalidNavOffsets; for (int l = 0; l < array4.Length; l++) { NavOffset navOffset2 = array4[l]; int cell3 = Grid.OffsetCell(cell, navOffset2.offset.x, navOffset2.offset.y); if (nav_table.IsValid(cell3, navOffset2.navType)) { return(Grid.InvalidCell); } } if (start == NavType.Tube) { if (end == NavType.Tube) { GameObject gameObject = Grid.Objects[cell, 9]; GameObject gameObject2 = Grid.Objects[num, 9]; TravelTubeUtilityNetworkLink travelTubeUtilityNetworkLink = (!(bool)gameObject) ? null : gameObject.GetComponent <TravelTubeUtilityNetworkLink>(); TravelTubeUtilityNetworkLink travelTubeUtilityNetworkLink2 = (!(bool)gameObject2) ? null : gameObject2.GetComponent <TravelTubeUtilityNetworkLink>(); if ((bool)travelTubeUtilityNetworkLink) { travelTubeUtilityNetworkLink.GetCells(out int linked_cell, out int linked_cell2); if (num != linked_cell && num != linked_cell2) { return(Grid.InvalidCell); } UtilityConnections utilityConnections = UtilityConnectionsExtensions.DirectionFromToCell(cell, num); if (utilityConnections == (UtilityConnections)0) { return(Grid.InvalidCell); } UtilityConnections connections = Game.Instance.travelTubeSystem.GetConnections(num, false); if (connections != utilityConnections) { return(Grid.InvalidCell); } } else if ((bool)travelTubeUtilityNetworkLink2) { travelTubeUtilityNetworkLink2.GetCells(out int linked_cell3, out int linked_cell4); if (cell != linked_cell3 && cell != linked_cell4) { return(Grid.InvalidCell); } UtilityConnections utilityConnections2 = UtilityConnectionsExtensions.DirectionFromToCell(num, cell); if (utilityConnections2 == (UtilityConnections)0) { return(Grid.InvalidCell); } UtilityConnections connections2 = Game.Instance.travelTubeSystem.GetConnections(cell, false); if (connections2 != utilityConnections2) { return(Grid.InvalidCell); } } else { bool flag = startAxis == NavAxis.X; int cell4 = cell; for (int m = 0; m < 2; m++) { if ((flag && m == 0) || (!flag && m == 1)) { int num4 = (x > 0) ? 1 : (-1); for (int n = 0; n < Mathf.Abs(x); n++) { UtilityConnections connections3 = Game.Instance.travelTubeSystem.GetConnections(cell4, false); if (num4 > 0 && (connections3 & UtilityConnections.Right) == (UtilityConnections)0) { return(Grid.InvalidCell); } if (num4 < 0 && (connections3 & UtilityConnections.Left) == (UtilityConnections)0) { return(Grid.InvalidCell); } cell4 = Grid.OffsetCell(cell4, num4, 0); } } else { int num5 = (y > 0) ? 1 : (-1); for (int num6 = 0; num6 < Mathf.Abs(y); num6++) { UtilityConnections connections4 = Game.Instance.travelTubeSystem.GetConnections(cell4, false); if (num5 > 0 && (connections4 & UtilityConnections.Up) == (UtilityConnections)0) { return(Grid.InvalidCell); } if (num5 < 0 && (connections4 & UtilityConnections.Down) == (UtilityConnections)0) { return(Grid.InvalidCell); } cell4 = Grid.OffsetCell(cell4, 0, num5); } } } } } else { UtilityConnections connections5 = Game.Instance.travelTubeSystem.GetConnections(cell, false); if (y > 0) { if (connections5 != UtilityConnections.Down) { return(Grid.InvalidCell); } } else if (x > 0) { if (connections5 != UtilityConnections.Left) { return(Grid.InvalidCell); } } else if (x < 0) { if (connections5 != UtilityConnections.Right) { return(Grid.InvalidCell); } } else { if (y >= 0) { return(Grid.InvalidCell); } if (connections5 != UtilityConnections.Up) { return(Grid.InvalidCell); } } } } else if (start == NavType.Floor && end == NavType.Tube) { int cell5 = Grid.OffsetCell(cell, x, y); UtilityConnections connections6 = Game.Instance.travelTubeSystem.GetConnections(cell5, false); if (connections6 != UtilityConnections.Up) { return(Grid.InvalidCell); } } return(num); }
public static void InitializeNavGrid(NavTable nav_table, NavType[] valid_nav_types, NavTableValidator[] validators, CellOffset[] bounding_offsets, int max_links_per_cell, NavGrid.Link[] links, NavGrid.Transition[][] transitions_by_nav_type) { MarkValidCells(nav_table, valid_nav_types, validators, bounding_offsets); CreateLinks(nav_table, max_links_per_cell, links, transitions_by_nav_type); }
public virtual void UpdateCell(int cell, NavTable nav_table, CellOffset[] bounding_offsets) { }