Illogical Code Performance

'entityList is merely a list of TEntities
Local renderList:TList = entityList.Copy()
renderList.AddLast(player)
Local sorted:TEntity[] = sortEntityList(renderList)
For Local e:TEntity = EachIn sorted
	e.Render()
Next


' FUNCTION USED FOR ABOVE CODE

'sort an entity list using quicksort
Function sortEntityList:TEntity[] (l:TList)
	Local arr:Object[]
	arr = ListToArray(l)
	Local arr2:TEntity[] = New TEntity[arr.Length]
	For Local g:Int = 0 To arr.Length - 1
		arr2[g] = TEntity(arr[g])
	Next
	arr2.Sort()
	Return arr2
End Function

		'need to add the player to make sure they are rendered in the right order
		entityMap.addEntity(player) 'add the player for rendering
For Local l:TList = EachIn entityMap.map
	For Local e:TEntity = EachIn l
		e.Render()
	Next
Next
entityMap.removeEntity(player) 'get the player out of the map




'a data structure used to map entites to y locations
'it is adaptive in that most recently moved entites are at the top
'hence statics float to the bottom
'it doesnt need to be sorted, thus giving better performance than a standard list
Type TAdaptiveEntityMap
	'an array of lists, representing each y location
	Field map:TList[]
	
	'creates a new map
	Function construct:TAdaptiveEntityMap(mapSize:Int)
		Local temp:TAdaptiveEntityMap = New TAdaptiveEntityMap
		temp.map = New TList[mapSize]
		For Local i:Int = 0 To mapSize - 1
			temp.map[i] = New TList
		Next
		Return temp
	End Function
	
	'gets a list for a given y value, this can be used for iterating through
	Method getList:TList(val:Int)
		Return map[val]
	End Method
	
	'gets a certain entity out of the map, then retruns it
	Method removeEntity:TEntity(e:TEntity)
		map[e.yLocation].Remove(e)
	End Method
	
	'adds a given entity (e) to the map
	Method addEntity(e:TEntity)
		'addfirst is important, it forms the "adaptive" part of this data structure
		'it ensures recently moves entites are always near the front
		map[e.yLocation].AddFirst(e)
	End Method
EndType

Function Compare:int(o1:Object, o2:Object)
	Local t1:TEntity=TEntity(o1)
	Local t2:TEntity=TEntity(o2)
	If t1=Null Or t2=Null Then Return 1 
	Return t1.yLocation- t2.yLocation
EndFunction

'compare, used for sorting
	Method Compare:Int(withObject:Object)
		Local temp:TEntity = TEntity(withObject)
		If Self.yLocation - temp.yLocation = 0
			Return Self.xLocation - temp.xLocation
		End If
		Return Self.yLocation - temp.yLocation
	End Method

Method Render()
	
		'Check and see if we are rendering within screen bounds
		If (Self.xLocation < offsetX) Or (Self.xLocation > (screenWidth / TILESIZE) + offsetX - 1) Or (Self.yLocation < offsetY) Or (Self.yLocation > (screenHeight / TILESIZE) + offsetY - 1)
			Return
		End If
		
		DrawImage(imgSet.GetImage(), ((xLocation - Width + 1)) * TILESIZE - offsetX * TILESIZE, ((yLocation - Height + 1)) * TILESIZE - offsetY * TILESIZE)
		DrawRect(xLocation, yLocation, 2, 2) 'super cool minimap
	End Method
	

Method Compare:Int(withObject:Object)
		Local temp:TEntity = TEntity(withObject)
		If Not temp Then Return Super.Compare(withObject)
		If Self.yLocation > temp.yLocation
			Return 1
		Else If Self.yLocation < temp.yLocation
			Return -1
		Else
			If Self.xLocation > temp.xLocation
				Return 1
			Else If Self.xLocation < temp.xLocation
				Return -1
			Else
				Return 0
			End If
		End If
	End Method

Function sortEntityList:TEntity[] (l:TList)
	Local arr:Object[]
	arr = ListToArray(l)
	Local arr2:TEntity[] = New TEntity[arr.Length]
	For Local g:Int = 0 To arr.Length - 1
		arr2[g] = TEntity(arr[g])
	Next
	arr2.Sort()
	Return arr2
End Function

l.Sort()

Local arr:TEntity[]
arr = TEntity[](ListToArray(l))

SuperStrict
SeedRnd MilliSecs()
Local arr:String[]
Local list:TList = New TList
arr = New String[100000]
For Local i:Int = 0 To Len(arr) - 1
	arr[i] = String(Rnd(0, 2000))
	list.AddFirst(String(Rnd(0, 2000)))
Next

Local t1:Int = MilliSecs()
arr.Sort()
Print "Time Taken to sort array: " + (MilliSecs() - t1)

t1:Int = MilliSecs()
list.Sort()
Print "Time Taken to sort list: " + (MilliSecs() - t1)

list = New TList

For Local i:Int = 0 To Len(arr) - 1
	list.AddFirst(String(Rnd(0, 2000)))
Next

t1:Int = MilliSecs()
Local arr2:Object[] = New Object[100000]
arr2 = ListToArray(list)
arr2.Sort()
Print "Time Taken to sort convert to array and sort: " + (MilliSecs() - t1)

t1:Int = MilliSecs()
Local arr2:Object[] = New Object[testnum]
arr2 = ListToArray(list)
arr2.Sort()