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)
{
}
