public override void ClearConnections(bool alsoReverse)
{
if (alsoReverse)
{
GridGraph gg = GetGridGraph(GraphIndex);
for (int i = 0; i < 8; i++)
{
GridNode other = gg.GetNodeConnection(this, i);
if (other != null)
{
//Remove reverse connection
other.SetConnectionInternal(i < 4 ? ((i + 2) % 4) : (((5 - 2) % 4) + 4), false);
}
}
}
ResetConnectionsInternal();
if (alsoReverse)
{
if (connections != null)
{
for (int i = 0; i < connections.Length; i++)
{
connections[i].RemoveConnection(this);
}
}
}
connections = null;
connectionCosts = null;
}
public override void ClearConnections(bool alsoReverse)
{
if (alsoReverse)
{
GridGraph gridGraph = GridNode.GetGridGraph(base.GraphIndex);
for (int i = 0; i < 8; i++)
{
GridNode nodeConnection = gridGraph.GetNodeConnection(this, i);
if (nodeConnection != null)
{
nodeConnection.SetConnectionInternal((i >= 4) ? 7 : ((i + 2) % 4), false);
}
}
}
this.ResetConnectionsInternal();
if (alsoReverse && this.connections != null)
{
for (int j = 0; j < this.connections.Length; j++)
{
this.connections[j].RemoveConnection(this);
}
}
this.connections = null;
this.connectionCosts = null;
}
// Token: 0x06002566 RID: 9574 RVA: 0x0019FD90 File Offset: 0x0019DF90
public override void ClearConnections(bool alsoReverse)
{
if (alsoReverse)
{
for (int i = 0; i < 8; i++)
{
GridNode gridNode = this.GetNeighbourAlongDirection(i) as GridNode;
if (gridNode != null)
{
gridNode.SetConnectionInternal((i < 4) ? ((i + 2) % 4) : ((i - 2) % 4 + 4), false);
}
}
}
this.ResetConnectionsInternal();
}
public override void ClearConnections(bool alsoReverse)
{
if (alsoReverse)
{
GridGraph gridGraph = GetGridGraph(base.GraphIndex);
for (int i = 0; i < 8; i++)
{
GridNode nodeConnection = gridGraph.GetNodeConnection(this, i);
if (nodeConnection != null)
{
nodeConnection.SetConnectionInternal((i >= 4) ? 7 : ((i + 2) % 4), false);
}
}
}
this.ResetConnectionsInternal();
}
public override void ClearConnections(bool alsoReverse)
{
if (alsoReverse)
{
GridGraph gg = GetGridGraph(GraphIndex);
for (int i = 0; i < 8; i++)
{
GridNode other = gg.GetNodeConnection(this, i);
if (other != null)
{
//Remove reverse connection
other.SetConnectionInternal(i < 4 ? ((i + 2) % 4) : (((5 - 2) % 4) + 4), false);
}
}
}
ResetConnectionsInternal();
#if !ASTAR_GRID_NO_CUSTOM_CONNECTIONS
base.ClearConnections(alsoReverse);
#endif
}
/** Calculates the grid connections for a single node */
public virtual void CalculateConnections (GridNode[] nodes, int x, int z, GridNode node) {
//Reset all connections
//node.flags = node.lags & -256;
node.ResetConnectionsInternal ();
//All connections are disabled if the node is not walkable
if (!node.Walkable) {
return;
}
int index = node.NodeInGridIndex;
if (corners == null) {
corners = new int[4];
} else {
for (int i = 0;i<4;i++) {
corners[i] = 0;
}
}
for (int i=0, j = 3; i<4; j = i, i++) {
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
GridNode other = nodes[index+neighbourOffsets[i]] as GridNode;
if (IsValidConnection (node, other)) {
node.SetConnectionInternal (i, true);
//SetNodeConnection (node, i, true);
corners[i]++;
corners[j]++;
} else {
node.SetConnectionInternal (i, false);
//SetNodeConnection (node, i, false);
}
}
if (neighbours == NumNeighbours.Eight) {
if (cutCorners) {
for (int i=0; i<4; i++) {
if (corners[i] >= 1) {
int nx = x + neighbourXOffsets[i+4];
int nz = z + neighbourZOffsets[i+4];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
//SetNodeConnection (node, i+4, IsValidConnection (node,other));
}
}
} else {
for (int i=0; i<4; i++) {
//We don't need to check if it is out of bounds because if both of the other neighbours are inside the bounds this one must be too
if (corners[i] == 2) {
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
//SetNodeConnection (node, i+4, IsValidConnection (node,other));
}
}
}
}
}
/** Calculates the grid connections for a single node.
* The x and z parameters are assumed to be the grid coordinates of the node.
*
* \see CalculateConnections(GridNode)
*/
public virtual void CalculateConnections (int x, int z, GridNode node) {
// All connections are disabled if the node is not walkable
if (!node.Walkable) {
// Reset all connections
// This makes the node have NO connections to any neighbour nodes
node.ResetConnectionsInternal();
return;
}
// Internal index of where in the graph the node is
int index = node.NodeInGridIndex;
if (neighbours == NumNeighbours.Four || neighbours == NumNeighbours.Eight) {
// Bitpacked connections
// bit 0 is set if connection 0 is enabled
// bit 1 is set if connection 1 is enabled etc.
int conns = 0;
// Loop through axis aligned neighbours (down, right, up, left) or (-Z, +X, +Z, -X)
for (int i = 0; i < 4; i++) {
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
// Check if the new position is inside the grid
// Bitwise AND (&) is measurably faster than &&
// (not much, but this code is hot)
if (nx >= 0 & nz >= 0 & nx < width & nz < depth) {
var other = nodes[index+neighbourOffsets[i]];
if (IsValidConnection(node, other)) {
// Enable connection i
conns |= 1 << i;
}
}
}
// Bitpacked diagonal connections
int diagConns = 0;
// Add in the diagonal connections
if (neighbours == NumNeighbours.Eight) {
if (cutCorners) {
for (int i = 0; i < 4; i++) {
// If at least one axis aligned connection
// is adjacent to this diagonal, then we can add a connection.
// Bitshifting is a lot faster than calling node.GetConnectionInternal.
// We need to check if connection i and i+1 are enabled
// but i+1 may overflow 4 and in that case need to be wrapped around
// (so 3+1 = 4 goes to 0). We do that by checking both connection i+1
// and i+1-4 at the same time. Either i+1 or i+1-4 will be in the range
// from 0 to 4 (exclusive)
if (((conns >> i | conns >> (i+1) | conns >> (i+1-4)) & 1) != 0) {
int directionIndex = i+4;
int nx = x + neighbourXOffsets[directionIndex];
int nz = z + neighbourZOffsets[directionIndex];
if (nx >= 0 & nz >= 0 & nx < width & nz < depth) {
GridNode other = nodes[index+neighbourOffsets[directionIndex]];
if (IsValidConnection(node, other)) {
diagConns |= 1 << directionIndex;
}
}
}
}
} else {
for (int i = 0; i < 4; i++) {
// If exactly 2 axis aligned connections is adjacent to this connection
// then we can add the connection
// We don't need to check if it is out of bounds because if both of
// the other neighbours are inside the bounds this one must be too
if ((conns >> i & 1) != 0 && ((conns >> (i+1) | conns >> (i+1-4)) & 1) != 0) {
GridNode other = nodes[index+neighbourOffsets[i+4]];
if (IsValidConnection(node, other)) {
diagConns |= 1 << (i+4);
}
}
}
}
}
// Set all connections at the same time
node.SetAllConnectionInternal(conns | diagConns);
} else {
// Hexagon layout
// Reset all connections
// This makes the node have NO connections to any neighbour nodes
node.ResetConnectionsInternal();
// Loop through all possible neighbours and try to connect to them
for (int j = 0; j < hexagonNeighbourIndices.Length; j++) {
var i = hexagonNeighbourIndices[j];
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
if (nx >= 0 & nz >= 0 & nx < width & nz < depth) {
var other = nodes[index+neighbourOffsets[i]];
node.SetConnectionInternal(i, IsValidConnection(node, other));
}
}
}
}
/** Calculates the grid connections for a single node */
public virtual void CalculateConnections (GridNode[] nodes, int x, int z, GridNode node) {
//Reset all connections
// This makes the node have NO connections to any neighbour nodes
node.ResetConnectionsInternal ();
//All connections are disabled if the node is not walkable
if (!node.Walkable) {
return;
}
// Internal index of where in the graph the node is
int index = node.NodeInGridIndex;
if (corners == null) {
corners = new int[4];
} else {
for (int i = 0;i<4;i++) {
corners[i] = 0;
}
}
// Loop through axis aligned neighbours (up, down, right, left)
for (int i=0, j = 3; i<4; j = i, i++) {
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
GridNode other = nodes[index+neighbourOffsets[i]] as GridNode;
if (IsValidConnection (node, other)) {
node.SetConnectionInternal (i, true);
corners[i]++;
corners[j]++;
} else {
node.SetConnectionInternal (i, false);
}
}
// Add in the diagonal connections
if (neighbours == NumNeighbours.Eight) {
if (cutCorners) {
for (int i=0; i<4; i++) {
if (corners[i] >= 1) {
int nx = x + neighbourXOffsets[i+4];
int nz = z + neighbourZOffsets[i+4];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
}
}
} else {
for (int i=0; i<4; i++) {
//We don't need to check if it is out of bounds because if both of the other neighbours are inside the bounds this one must be too
if (corners[i] == 2) {
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
}
}
}
}
}
/** Calculates the grid connections for a single node */
public virtual void CalculateConnections (GridNode[] nodes, int x, int z, GridNode node) {
//Reset all connections
// This makes the node have NO connections to any neighbour nodes
node.ResetConnectionsInternal ();
//All connections are disabled if the node is not walkable
if (!node.Walkable) {
return;
}
// Internal index of where in the graph the node is
int index = node.NodeInGridIndex;
if (neighbours == NumNeighbours.Four || neighbours == NumNeighbours.Eight) {
// Reset the buffer
if (corners == null) {
corners = new int[4];
} else {
for (int i = 0;i<4;i++) {
corners[i] = 0;
}
}
// Loop through axis aligned neighbours (up, down, right, left)
for (int i=0, j = 3; i<4; j = i, i++) {
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
var other = nodes[index+neighbourOffsets[i]];
if (IsValidConnection (node, other)) {
node.SetConnectionInternal (i, true);
// Mark the diagonal/corner adjacent to this connection as used
corners[i]++;
corners[j]++;
} else {
node.SetConnectionInternal (i, false);
}
}
// Add in the diagonal connections
if (neighbours == NumNeighbours.Eight) {
if (cutCorners) {
for (int i=0; i<4; i++) {
// If at least one axis aligned connection
// is adjacent to this diagonal, then we can add a connection
if (corners[i] >= 1) {
int nx = x + neighbourXOffsets[i+4];
int nz = z + neighbourZOffsets[i+4];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
}
}
} else {
for (int i=0; i<4; i++) {
// If exactly 2 axis aligned connections is adjacent to this connection
// then we can add the connection
//We don't need to check if it is out of bounds because if both of the other neighbours are inside the bounds this one must be too
if (corners[i] == 2) {
GridNode other = nodes[index+neighbourOffsets[i+4]];
node.SetConnectionInternal (i+4, IsValidConnection (node,other));
}
}
}
}
} else {
// Hexagon layout
// Loop through all possible neighbours and try to connect to them
for (int j = 0; j < hexagonNeighbourIndices.Length; j++) {
var i = hexagonNeighbourIndices[j];
int nx = x + neighbourXOffsets[i];
int nz = z + neighbourZOffsets[i];
if (nx < 0 || nz < 0 || nx >= width || nz >= depth) {
continue;
}
var other = nodes[index+neighbourOffsets[i]];
node.SetConnectionInternal (i, IsValidConnection (node, other));
}
}
}
