Merge pull request #13851 from Fox-McCloud/cleanup-datastructures

Cleans up Datastructures

code/_DATASTRUCTURES/stacks.dm

@@ -1,56 +0,0 @@
-/datum/stack
-	var/list/stack = list()
-	var/max_elements = 0
-
-/datum/stack/New(list/elements,max)
-	..()
-	if(elements)
-		stack = elements.Copy()
-	if(max)
-		max_elements = max
-
-/datum/stack/proc/Pop()
-	if(is_empty())
-		return null
-	. = stack[stack.len]
-	stack.Cut(stack.len,0)
-
-/datum/stack/proc/Push(element)
-	if(max_elements && (stack.len+1 > max_elements))
-		return null
-	stack += element
-
-/datum/stack/proc/Top()
-	if(is_empty())
-		return null
-	. = stack[stack.len]
-
-/datum/stack/proc/is_empty()
-	. = stack.len ? 0 : 1
-
-//Rotate entire stack left with the leftmost looping around to the right
-/datum/stack/proc/RotateLeft()
-	if(is_empty())
-		return 0
-	. = stack[1]
-	stack.Cut(1,2)
-	Push(.)
-
-//Rotate entire stack to the right with the rightmost looping around to the left
-/datum/stack/proc/RotateRight()
-	if(is_empty())
-		return 0
-	. = stack[stack.len]
-	stack.Cut(stack.len,0)
-	stack.Insert(1,.)
-
-
-/datum/stack/proc/Copy()
-	var/datum/stack/S=new()
-	S.stack = stack.Copy()
-	S.max_elements = max_elements
-	return S
-
-
-/datum/stack/proc/Clear()
-	stack.Cut()

code/__HELPERS/heap.dm

@@ -1,28 +1,28 @@
 
 //////////////////////
-//Heap object
+//datum/heap object
 //////////////////////
 
-/Heap
+/datum/heap
 	var/list/L
 	var/cmp
 
-/Heap/New(compare)
+/datum/heap/New(compare)
 	L = new()
 	cmp = compare
 
-/Heap/proc/IsEmpty()
+/datum/heap/proc/IsEmpty()
 	return !L.len
 
 //Insert and place at its position a new node in the heap
-/Heap/proc/Insert(atom/A)
+/datum/heap/proc/Insert(atom/A)
 
 	L.Add(A)
 	Swim(L.len)
 
 //removes and returns the first element of the heap
 //(i.e the max or the min dependant on the comparison function)
-/Heap/proc/Pop()
+/datum/heap/proc/Pop()
 	if(!L.len)
 		return 0
 	. = L[1]
@@ -33,7 +33,7 @@
 	Sink(1)
 
 //Get a node up to its right position in the heap
-/Heap/proc/Swim(var/index)
+/datum/heap/proc/Swim(var/index)
 	var/parent = round(index * 0.5)
 
 	while(parent > 0 && (call(cmp)(L[index],L[parent]) > 0))
@@ -42,7 +42,7 @@
 		parent = round(index * 0.5)
 
 //Get a node down to its right position in the heap
-/Heap/proc/Sink(var/index)
+/datum/heap/proc/Sink(var/index)
 	var/g_child = GetGreaterChild(index)
 
 	while(g_child > 0 && (call(cmp)(L[index],L[g_child]) < 0))
@@ -52,7 +52,7 @@
 
 //Returns the greater (relative to the comparison proc) of a node children
 //or 0 if there's no child
-/Heap/proc/GetGreaterChild(var/index)
+/datum/heap/proc/GetGreaterChild(var/index)
 	if(index * 2 > L.len)
 		return 0
 
@@ -65,11 +65,11 @@
 		return index * 2
 
 //Replaces a given node so it verify the heap condition
-/Heap/proc/ReSort(atom/A)
+/datum/heap/proc/ReSort(atom/A)
 	var/index = L.Find(A)
 
 	Swim(index)
 	Sink(index)
 
-/Heap/proc/List()
+/datum/heap/proc/List()
 	. = L.Copy()

code/defines/procs/AStar.dm

@@ -29,15 +29,15 @@ Actual Adjacent procs :
 //////////////////////
 
 //A* nodes variables
-/PathNode
+/datum/pathnode
 	var/turf/source //turf associated with the PathNode
-	var/PathNode/prevNode //link to the parent PathNode
+	var/datum/pathnode/prevNode //link to the parent PathNode
 	var/f		//A* Node weight (f = g + h)
 	var/g		//A* movement cost variable
 	var/h		//A* heuristic variable
 	var/nt		//count the number of Nodes traversed
 
-/PathNode/New(s,p,pg,ph,pnt)
+/datum/pathnode/New(s,p,pg,ph,pnt)
 	source = s
 	prevNode = p
 	g = pg
@@ -46,7 +46,7 @@ Actual Adjacent procs :
 	source.PNode = src
 	nt = pnt
 
-/PathNode/proc/calc_f()
+/datum/pathnode/proc/calc_f()
 	f = g + h
 
 //////////////////////
@@ -54,11 +54,11 @@ Actual Adjacent procs :
 //////////////////////
 
 //the weighting function, used in the A* algorithm
-/proc/PathWeightCompare(PathNode/a, PathNode/b)
+/proc/PathWeightCompare(datum/pathnode/a, datum/pathnode/b)
 	return a.f - b.f
 
 //reversed so that the Heap is a MinHeap rather than a MaxHeap
-/proc/HeapPathWeightCompare(PathNode/a, PathNode/b)
+/proc/HeapPathWeightCompare(datum/pathnode/a, datum/pathnode/b)
 	return b.f - a.f
 
 //wrapper that returns an empty list if A* failed to find a path
@@ -82,13 +82,13 @@ Actual Adjacent procs :
 			return 0
 		maxnodedepth = maxnodes //no need to consider path longer than maxnodes
 
-	var/Heap/open = new /Heap(/proc/HeapPathWeightCompare) //the open list
+	var/datum/heap/open = new /datum/heap(/proc/HeapPathWeightCompare) //the open list
 	var/list/closed = new() //the closed list
 	var/list/path = null //the returned path, if any
-	var/PathNode/cur //current processed turf
+	var/datum/pathnode/cur //current processed turf
 
 	//initialization
-	open.Insert(new /PathNode(start,null,0,call(start,dist)(end),0))
+	open.Insert(new /datum/pathnode(start,null,0,call(start,dist)(end),0))
 
 	//then run the main loop
 	while(!open.IsEmpty() && !path)
@@ -125,7 +125,7 @@ Actual Adjacent procs :
 
 			var/newg = cur.g + call(cur.source,dist)(T)
 			if(!T.PNode) //is not already in open list, so add it
-				open.Insert(new /PathNode(T,cur,newg,call(T,dist)(end),cur.nt+1))
+				open.Insert(new /datum/pathnode(T,cur,newg,call(T,dist)(end),cur.nt+1))
 			else //is already in open list, check if it's a better way from the current turf
 				if(newg < T.PNode.g)
 					T.PNode.prevNode = cur
@@ -137,7 +137,7 @@ Actual Adjacent procs :
 	}
 
 	//cleaning after us
-	for(var/PathNode/PN in open.L)
+	for(var/datum/pathnode/PN in open.L)
 		PN.source.PNode = null
 	for(var/turf/T in closed)
 		T.PNode = null

code/game/turfs/turf.dm

@@ -25,7 +25,7 @@
 
 	var/blocks_air = 0
 
-	var/PathNode/PNode = null //associated PathNode in the A* algorithm
+	var/datum/pathnode/PNode = null //associated PathNode in the A* algorithm
 
 	flags = 0
 

paradise.dme

@@ -87,6 +87,7 @@
 #include "code\__HELPERS\files.dm"
 #include "code\__HELPERS\game.dm"
 #include "code\__HELPERS\global_lists.dm"
+#include "code\__HELPERS\heap.dm"
 #include "code\__HELPERS\icon_smoothing.dm"
 #include "code\__HELPERS\icons.dm"
 #include "code\__HELPERS\lists.dm"
@@ -108,8 +109,6 @@
 #include "code\__HELPERS\sorts\InsertSort.dm"
 #include "code\__HELPERS\sorts\MergeSort.dm"
 #include "code\__HELPERS\sorts\TimSort.dm"
-#include "code\_DATASTRUCTURES\heap.dm"
-#include "code\_DATASTRUCTURES\stacks.dm"
 #include "code\_globalvars\configuration.dm"
 #include "code\_globalvars\game_modes.dm"
 #include "code\_globalvars\genetics.dm"