public void load()
{
if (loaded) return;
loaded = true;
//Center, the place all enemies are going to
//nodes[0] = Reserved for the door
//Center Corners
nodes[1] = new NavCoord(2, 2, 1);
nodes[2] = new NavCoord(4, 2, 2);
nodes[3] = new NavCoord(2, 4, 3);
nodes[4] = new NavCoord(4, 4, 4);
//5-6 center doors //0-6 total
//Inner Corners
nodes[7] = new NavCoord(1, 1, 7);
nodes[8] = new NavCoord(5, 1, 8);
nodes[9] = new NavCoord(1, 5, 9);
nodes[10] = new NavCoord(5, 5, 10);
//11-16 inner doors //7-16 total // There may or may not be a 16th door, the world may never know
//Outer corners
nodes[17] = new NavCoord(0, 0, 17);
nodes[18] = new NavCoord(6, 0, 18);
nodes[19] = new NavCoord(0, 6, 19);
nodes[20] = new NavCoord(6, 6, 20);
//21-23 outer doors //17-23 total
}
public Node(NavCoord coord, Node next, Vector2 target)
{
this.pos = coord.pos;
this.id = coord.id;
this.next = next;
cost = next.cost + Vector2.Distance(coord.pos, target) + Vector2.Distance(coord.pos, next.pos);
}
public void AdjustFlame(int node, int level)
{
Flame f = flame[nextflame++];
f.killchance = level == 0 ? centerKillChance : (level == 1 ? innerKillChance : outerKillChance);
NavCoord nav = maze.nodes[node];
Vector3 v = (nav.pos - (node == 0 ? new Vector2(3, 3) : nav.n2.pos)).normalized;
bool vertical = v.y == 0;
float scale = level == 0 ? flameScale : (level == 1 ? innerFlameScale : outerFlameScale);
f.trans.localScale = new Vector3(vertical ? flameScale : scale, vertical ? scale : flameScale, 0);
f.trans.localPosition = nav.pos;
f.parent.SetActive(false);
}
public void PlaceDoor(int node)
{
NavCoord nav = maze.nodes[node];
door[next].SetActive(true);
Vector2 dir = nav.n2.pos - nav.pos;
doortrans[next++].localPosition = nav.pos + dir * .5f;
if (nav.n3 != null)
{
door[next].SetActive(true);
dir = nav.n3.pos - nav.pos;
doortrans[next++].localPosition = nav.pos + dir * .5f;
}
else
{
door[next++].SetActive(false);
}
}
private void placeCoord(int[] map, int[] nextmap, byte slot, byte nextslot, int loc, int off)
{
int div = map.Length >> 2; //fast divide by 4
if (map[loc] < 0)
{
nodes[slot] = new NavCoord(translate(div, loc, off), slot);
map[loc] = slot;
} else nodes[slot] = nodes[map[loc]];
if (nextmap != null)
{
int nextdiv = nextmap.Length >> 2;
int nextloc = 1 + ((loc / div) << 1) + loc;
nodes[nextslot] = new NavCoord(translate(nextdiv, nextloc, off - 1), nextslot);
nextmap[nextloc] = nextslot;
if(nodes[slot].n2 == null) nodes[slot].n2 = nodes[nextslot];
else nodes[slot].n3 = nodes[nextslot];
if (nodes[nextslot].n2 == null) nodes[nextslot].n2 = nodes[slot];
else nodes[nextslot].n3 = nodes[nextslot];
}
}
public Node path(Vector2 start, int avoid)
{
//Nowhere to go
if (nodes[0] == null) return null;
NavCoord adj1;
NavCoord adj2;
int tier = getTier(start);
if (tier > 7) return null;
else if (tier < 2) {
if (tier == 0) { adj1 = nodes[17]; adj2 = nodes[18]; }
else { adj1 = nodes[19]; adj2 = nodes[20]; }
for (int i = 21; i < 24; i++) {
if (nodes[i].pos.x < start.x) if (nodes[i].pos.x > adj1.pos.x && nodes[i].pos.y - start.y < 1.5f) adj1 = nodes[i];//left
else if (nodes[i].pos.x < adj2.pos.x && nodes[i].pos.y - start.y < 1.5f) adj1 = nodes[i];//right
}
} else if (tier < 4) {
if (tier == 2) { adj1 = nodes[17]; adj2 = nodes[19]; }
else { adj1 = nodes[18]; adj2 = nodes[20]; }
for (int i = 21; i < 24; i++) {
if (nodes[i].pos.y < start.y) if (nodes[i].pos.y > adj1.pos.y && nodes[i].pos.x - start.x < 1.5f) adj1 = nodes[i];//bot
else if (nodes[i].pos.y < adj2.pos.y && nodes[i].pos.x - start.x < 1.5f) adj1 = nodes[i];//top
}
} else if (tier < 6)
{
if (tier == 4) { adj1 = nodes[7]; adj2 = nodes[8]; }
else { adj1 = nodes[9]; adj2 = nodes[10]; }
for (int i = 11; i < 17; i++)
{
if (nodes[i].pos.x < start.x) if (nodes[i].pos.x > adj1.pos.x && nodes[i].pos.y - start.y < 1.5f) adj1 = nodes[i];//left
else if (nodes[i].pos.x < adj2.pos.x && nodes[i].pos.y - start.y < 1.5f) adj1 = nodes[i];//right
}
} else {
if (tier == 6) { adj1 = nodes[7]; adj2 = nodes[9]; }
else { adj1 = nodes[8]; adj2 = nodes[10]; }
for (int i = 11; i < 17; i++)
{
if (nodes[i].pos.y < start.y) if (nodes[i].pos.y > adj1.pos.y && nodes[i].pos.x - start.x < 1.5f) adj1 = nodes[i];//bot
else if (nodes[i].pos.y < adj2.pos.y && nodes[i].pos.x - start.x < 1.5f) adj1 = nodes[i];//top
}
}
Node[] visited = new Node[25]; //All the nodes + start
visited[0] = new Node(nodes[0]);
List<Node> heap = new List<Node>(10);
heap.Add(visited[0]);
NodeComparer comparer = new NodeComparer();
Node current = null;
while (heap.Count > 0)
{
current = heap[0];
heap.RemoveAt(0);
if (avoid != 0 && current.id == avoid) continue;
if (current.id == 24) return current; //redacted: ---------------YES I REALIZE THIS CHECKS THE MEMORY ADDRESS!!
NavCoord coord = nodes[current.id];
if (coord == adj1 || coord == adj2)
{
if (visited[24] == null)
{
visited[24] = new Node(start, current);
heap.Add(visited[24]);
}
else visited[24].SetIfBetter(current);
}
int id = coord.n0.id;
if (visited[id] == null)
{
visited[id] = new Node(coord.n0, current, start);
heap.Add(visited[id]);
} else visited[id].SetIfBetter(current);
id = coord.n1.id;
if (visited[id] == null)
{
visited[id] = new Node(coord.n1, current, start);
heap.Add(visited[id]);
}
else visited[id].SetIfBetter(current);
if (coord.n2 != null)
{
id = coord.n2.id;
if (visited[id] == null)
{
visited[id] = new Node(coord.n2, current, start);
heap.Add(visited[id]);
}
else visited[id].SetIfBetter(current);
}
if (coord.n3 != null)
{
id = coord.n3.id;
if (visited[id] == null)
{
visited[id] = new Node(coord.n3, current, start);
heap.Add(visited[id]);
}
else visited[id].SetIfBetter(current);
}
heap.Sort(comparer);
}
return null;
}
public Node(NavCoord node)
{
this.pos = node.pos;
this.id = node.id;
}
