require "drawlib"
require "drawtext"

levelname = "1-1"

savestateSlotMap = 1 --savestate slot to save the map selection from.
savestateSlotLevel = 2
savestateSlotBOSS = 3
savestateObj = savestate.object(savestateSlotMap)
savestate.load(savestateObj)
LM = memory.readbyte(0x0726)
Player = 1 + LM

BoxRadius = 6 --The radius of the vision box around Luigi
InitialOscillations = {50,60,90} --Initial set of oscillation timers
BoxWidth = BoxRadius*2+1 --Full width of the box
BoxSize = BoxWidth*BoxWidth --Number of neurons in the box
Inputs = BoxSize + 3 + #InitialOscillations

InitialMutationRates = {
	linkInputBox=0.1,
	linkBottomRow=0.05,
	linkLayers=0.1,
	linkRandom=2.0,
	node=0.5,
	disable=0.4,
	enable=0.2,
	oscillation=0.2,
	nswitch=0.01,
	step=0.1
}

FramesPerEval = 5 --Number of frames between each network update

ButtonNames = {"A","B","up","down","left","right"}
ButtonNumbers = {A=1,B=2,up=3,down=4,left=5,right=6}

DeltaDisjoint = 4.0 --multiplier for disjoint in same species function
DeltaWeights = 0.4 --multiplier for weights in same species function
DeltaThreshold = 1.0 --threshold for delta to be in the same species
DeltaSwitch = 0.6 --threshold for delta of the network switch location

DisplaySlots = false --Display the sprite slots?
DisplaySprites = false --Display the sprite hitboxes?
DisplayGrid = 0 --Display a large network inputs grid?
DisplayNetwork = true --Display the neural network state?
DisplayStats = true --Display top stats bar?
DisplayRanges = false --Display special fitness ranges?
DisplayCounters = false --Display death/time counter?
ScrollWalkPause = false

Replay = false

ManualInput = false --Input manually rather than by network?

--Penalty coeffs for fitness rank of netswitched species
NetworkPenaltyInner = 0.8
NetworkPenaltyOuter = 0.87

CrossoverChance = 0.75 --Chance of crossing 2 genomes rather than copying 1

MajorBreakFitness = 30 --Fitness before a breakthrough is not counted as minor

BaseInterbreedChance = 0.07 --base interbreed chance per species
InterbreedCutoff = 2.86 --average species size when interbreed is turned off
InterbreedDegree = 1.0 --degree of interbreed curve

TimeBeforePopOscil = 6 --time in each oscillation before the population changes

MaxStaleness = 25 --max staleness before death

FramesOfDeathAnimation = 50 --amount of the death animation to show

WeightPerturbChance = 0.9
WeightResetChance = 0.9

MaxNodes = 1000000

FPS = 60

TurboMin = 0
TurboMax = 0
CompleteAutoTurbo = false
currentTurbo = false
emu.speedmode("normal")
marioAutoscroll = 0
basescroll = 0
marioWhiteblock = 0
boss = false
battle = false
basetimeout = 120
roottimeout = 120
preloaded = false
cardDistance = 9999
powerupFitness = 150
roottimeoutboss = 900

dirsep = "\\" --forward or backward slash for file separation? depends on OS

ProgramStartTime = os.time()
Startlocations={["0-1-2"]=true,["1-1-5"]=true,["2-1-5"]=true,["3-1-2"]=true,["4-1-4"]=true,["5-1-3"]=true,["6-1-1.5"]=true,["7-1-2.5"]=true}

marioPrevWhiteblock = 0
marioPrevAutoscroll = 0
scrollBonus = 0
scrollBonusAdjust = 0
lockBound = false
function getPositions(initial) 
	local marioHiX = memory.readbyte(0x0075)
	local marioLoX = memory.readbyte(0x0090)
	marioX = marioLoX+256*marioHiX
	marioScreenX = memory.readbyte(0x00AB)
	marioXVel = memory.readbyte(0x00BD)
	marioY = 400-(memory.readbyte(0x00A2)+256*memory.readbyte(0x0087))
	marioScreenY = memory.readbyte(0xB4)--memory.readbyte(0x0228)
	marioYVel = memory.readbyte(0x00CF)
	marioScore = memory.readbyte(0x0716)*2560 + memory.readbyte(0x0717)*10
	marioActive = memory.readbyte(0x00CE) == 0 and memory.readbyte(0x03DE) == 0 --loading and using pipe/door
	local marioWhiteblock = memory.readbyte(0x0570)
	local marioAutoscroll = memory.readbyte(0x7A0C)
	--print(marioScreenY)
	--local marioAutoscrollY = memory.readbyte(0x7A0D)
	marioHold = memory.readbyte(0x06A4)
	marioPower = memory.readbyte(0x00ED)
	marioMusic = memory.readbyte(0x04E5)
	koopalingDefeated = memory.readbyte(0x07BD)
	kingconvo = memory.readbyte(0x0728)
	local whiteblockAdjustment = 0
	if (not marioActive and marioScreenY > 184) or doorflag then
		doorflag = true
		marioOutOfBound = false
		if marioActive and marioScreenY < 184 then
			doorflag = false
		end
	else
		marioOutOfBound = (marioY < 0 or (marioScreenY > 184 and memory.readbyte(0x0544) == 0 and cardDistance > 0.5)) and marioActive -- byte is for above screen
	end
	if marioPrevWhiteblock >100 and marioWhiteblock < -100 then
		whiteblockAdjustment = 256
	else
		whiteblockAdjustment = 0
	end
	marioPrevWhiteblock = marioWhiteblock
	WhiteblockBonus = whiteblockAdjustment + marioWhiteblock*10
	if scrollBonus == 0 and not marioActive then
		-- scrollBonusAdjust = -marioAutoscroll
		memory.writebyte(0x7A0C,0)
		--basemarioA
		local marioAutoscroll = 0
	end
	if marioAutoscroll == 0 and marioPrevAutoscroll ~= 0 and scrollBonus > 0 then
		basescroll = basescroll + marioPrevAutoscroll
	-- elseif marioAutoscroll == marioPrevAutoscroll and scrollBonus > 0 then
		-- scrollBonus = 0
		-- basescroll = 0
	end
	scrollBonus = basescroll + marioAutoscroll + scrollBonusAdjust
	marioPrevAutoscroll = marioAutoscroll
	local numSprites = 6
	sprites = {}
	for s=1,numSprites do
		local sprite = {}
		sprite.x = memory.readbyte(0x0090+s)+256*memory.readbyte(0x0075+s)
		sprite.y = 416-(memory.readbyte(0x00A2+s)+256*memory.readbyte(0x0087+s))
		sprite.state = memory.readbyte(0x0660+s)
		sprite.type = memory.readbyte(0x670+s)
		if sprite.type == 54 then
			table.insert(sprites,{x=sprite.x+16,y=sprite.y,state=256})
			table.insert(sprites,{x=sprite.x+32,y=sprite.y,state=256})
			--print(sprite)
		end
		if sprite.type == 14 then
			marioScore = marioScore + memory.readbyte(0x0083)*1000
		end
		if sprite.type == 74 or sprite.type == 82 then --added this because luigi does not want to pick up the ball once he defeats boomboom
			if sprite.x - marioX > 0 then
				for a=1,30 do
					joypad.set(Player,{right=true})
					
					coroutine.yield()
				end
			else
				for a=1,30 do
					joypad.set(Player,{left=true})
					coroutine.yield()
				end
			end
		end
		table.insert(sprites,sprite)
	end
	for s=1,8 do --special sprites
		local sprite = {}
		local id = memory.readbyte(0x7FC5+s)
		if id ~= 0 then
			sprite.type = id
			sprite.y = 416-memory.readbyte(0x05BE+s)+256*memory.readbyte(0x7FD4+s)
			local xlow = memory.readbyte(0x05C8+s)
			local xhigh = 0
			local differ = xlow-marioLoX
			if differ > 128 then
				xhigh = marioHiX -1
			elseif differ < -128 then
				xhigh = marioHiX +1
			else
				xhigh = marioHiX
			end
			sprite.x = xlow + 256*xhigh
			sprite.state=256
			table.insert(sprites,sprite)
		end
	end
end

function getTile(dx,dy)
	local x = math.floor((marioX + dx + 8)/16)
	local y = math.floor((432-marioY + dy - 8)/16)
	local page = math.floor(x/16)
	local px = x % 16
	local tile = memory.readbyte(0x6000+px+y*16+page*432)
	--print(x .. " " .. marioScreenX/16)
	local scrollX = (marioX-marioScreenX)/16
	local scrollY = (marioY+marioScreenY-161)/16
	if x < scrollX or x > scrollX + 16 or 26-y < scrollY or 26-y > scrollY + 11 then return 0 end
	return tile
end

CollisionTileSet = {}
-- CollisionTileArrays[1]={air=128,0x25,0x26,0x27,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0xA0,0xA1,0xA2,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB4,0xB5,0xB5,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xE2,0xE3,0xE4,0xF0,0xF1,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9}
-- CollisionTileArrays[3]={air=134,0x2E,0x2F,0x30,0x31,0x32,0x48,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x87,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xF0,0xF1,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9}
-- CollisionTileArrays[4]={air=128,0x11,0x12,0x13,0x22,0x23,0x24,0x25,0x2C,0x2E,0x2F,0x30,0x31,0x32,0x34,0x35,0x36,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x5B,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8E,0x8F,0x90,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xFA,0xFB}
CollisionTileArray= {0x80,0x02,0x86,0x80,0x80,0x8C,0x42,0x80,0x80,0x80,0x80,0x80,0xCC,0x86,0x09,0x09,0x09,0x02} 

function getTileset()
	local tileset = memory.readbyte(0x070A)
	local x1a = memory.readbyte(0x7E94)
	local x1b = memory.readbyte(0x7E95)
	local x1c = memory.readbyte(0x7E96)
	local x1d = memory.readbyte(0x7E97)
	card_x = nil
	for j=1,48 do
		local id = memory.readbyte(0x07B3E+(3*j))
		if id == 0x41 then --0x41 is end card
		
			card_x = memory.readbyte(0x07B3E+(3*j)+1)*16
			card_y = memory.readbyte(0x07B3E+(3*j)+2)*16
		end
		if id == 0xFF then --ff indicates last entry
			if card_x == nil then
				card_x = 9999
				card_y = 9999
			end
			break
		end
	end
	CollisionTileSet = {a=x1a,b=x1b,c=x1c,d=x1d}
	CollisionTileSet.air=CollisionTileArray[tileset]
end

function getInputs() --Create the grid around Mario that is the network's vision
    getPositions() --Get all required memory data
    local inputs = {} --Grid around Mario that shows blocks/sprites
	--Loop through each space in the grid
	local BoxRadius = BoxRadius
	local BoxWidth = BoxWidth
	local CollisionTileSet = CollisionTileSet
	local marioX = marioX
	local marioY = marioY
	local sprites = sprites
    for dy=-BoxRadius*16,BoxRadius*16,16 do
        for dx=-BoxRadius*16,BoxRadius*16,16 do
            inputs[#inputs+1] = 0
			--If the tile contains a block, set to 1
            local tile = getTile(dx, dy)
            if tile ~= CollisionTileSet.air and marioY+dy < 0x1B0 then
				if (tile >= CollisionTileSet.a and tile < 0x40) or (tile >= CollisionTileSet.b and tile < 0x80) or (tile >= CollisionTileSet.c and tile < 0xC0) or (tile >= CollisionTileSet.d and tile < 0xFF) then inputs[#inputs] = 1
                else inputs[#inputs] = 0.5
				end
            end
        end
    end
	--for each sprite set it's location to -1
	local spriteNearlocal = false
	for i,sprite in ipairs(sprites) do
		if sprite.state ~= 0 then
			local distx = math.floor((sprite.x - marioX)/16 + 0.5)
			if math.abs(distx) < 3.5 then
				spriteNearlocal = true
			end
			local disty = math.floor((-sprite.y + marioY)/16 + 0.5)
			if math.abs(distx)<=BoxRadius and math.abs(disty)<=BoxRadius then
				inputs[distx+BoxRadius+1+(disty+BoxRadius)*BoxWidth] = -1
			end
		end
	end
	spriteNear = spriteNearlocal
	return inputs
end

--Initialization for the genetic system
function initPool(Boss) --The pool contains all data for the genetics of the AI
    local poolold = pool
	pool = {}
    pool.species = {} --List of species
    pool.generation = 0 --Generation number
    pool.innovation = 1 --Innovation tracks genes that are copies of each other vs unique
    pool.currentGenome = 1 --current genome/species to display on top bar
	pool.currentSpecies = 1
    pool.maxFitness = 0 --Maximum fitness
	pool.bestSpecies = 1 --best species
	pool.secondFitness = 0 --Second best fitness
    pool.maxCounter = 0 --Number of times it has gotten close to max fitness
    pool.gsid = 0 --GSID tracks species so each one gets a unique id
	pool.bottleneck = 0 --Number of gens since last breakthrough
	pool.bottleneckloops = 0 --Number of oscillation loops in the bottleneck
	pool.population = 999 --Number of genomes
	pool.lastMajorBreak = 0 --Last breakthrough of more than majorBreakFitness
	pool.current = 0
	pool.total = 0
	pool.average = 0
	pool.lastbreaktime = 0
	if not Boss then
		pool.attempts = 1 --number of attempts
		pool.deaths = 0 --number of deaths (auto timeouts do not count)
		pool.totalTime = 0 --total time elapsed in-game
		pool.realTime = 0 --total time elapsed out of game
		
		pool.history = "" --breakthrough tracker
		pool.breakthroughX = 0 --indicator stuff
		pool.breakthroughZ = ""
		pool.maphistogram = {}
		pool.breakthroughfiles = {}
	else
		pool.attempts = poolold.attempts
		pool.deaths = poolold.deaths
		pool.totalTime = poolold.totalTime
		pool.realTime = poolold.realTime
		pool.history = poolold.history
		pool.breakthroughX = poolold.breakthroughX
		pool.breakthroughZ = poolold.breakthroughZ
		pool.maphistogram = poolold.maphistogram
		pool.breakthroughfiles = poolold.breakthroughfiles
	end
end

function newSpecies() --Each species is a group of genomes that are similar
    local species = {}
    species.maxFitness = 0 --farthest the species has gotten
    species.maxRightmost = 0 --Farthest the species has gotten, ignoring time
    species.averageFitness = 0 --Average fitness of the species
    species.staleness = 0 --Number of gens since the species improved
    species.genomes = {} --List of genomes
    species.nick = '' --nickname of the species
	species.turbo = true --whether the species will use turbo or not
    species.gsid = pool.gsid --give the species a unique GSID
	pool.gsid = pool.gsid + 1
	species.breakthroughX = 0 --indicator stuff
	species.breakthroughZ = ""
    return species
end

function newGene() --A gene is a link between two neurons
    local gene = {}
    gene.into = 0 --input neuron
    gene.out = 0 --output neuron
    gene.weight = 0.0 --multiplier
    gene.enabled = true --gene is turned on
    gene.innovation = 0 --gene ID to find duplicates
	gene.delay = 0
    return gene
end

function copyGene(gene) --copy a gene
	local newGene = {}
	newGene.into = gene.into
	newGene.out = gene.out
	newGene.weight = gene.weight
	newGene.enabled = gene.enabled
	newGene.innovation = gene.innovation
	newGene.delay = gene.delay
	return newGene
end

function newGenome(numNetworks) --Each genome is an evolved 'player' that attempts the level
    local genome = {}
    genome.genes = {} --List of networks in raw gene form
    genome.networks = {} --List of networks in neuron form
    genome.oscillations = {} --Periods of each of 3 oscillating nodes
    genome.maxNeuron = Inputs --Index of largest neuron
	for n=1,numNetworks do --Initialize these as blank arrays for each network
		genome.genes[n] = {}
		genome.oscillations[n] = {}
		for i=1,#InitialOscillations do --Initialize periods to default values
			genome.oscillations[1][i] = InitialOscillations[i]
		end
	end
    genome.fitstate = {} --information about the genome's final state
    genome.globalRank = 0 --Ranking of the genome (low is worse)
    genome.networkswitch = {} --List of positions where the network switches
	for n=1,numNetworks-1 do
		genome.networkswitch[n] = 0.0
	end
    genome.mutationRates = {} --List of mutation rates
	for name,rate in pairs(InitialMutationRates) do
		genome.mutationRates[name] = rate
	end
    return genome
end

function copyGenome(genome) --copy a genome
	local ngenome = newGenome(#genome.genes) --create basic new genome
	for n=1,#genome.genes do --copy each network over
		for i,gene in pairs(genome.genes[n]) do
			table.insert(ngenome.genes[n],copyGene(gene))
		end
		for i=1,#genome.oscillations[n] do
			ngenome.oscillations[n][i] = genome.oscillations[n][i]
		end
	end
	ngenome.maxNeuron = genome.maxNeuron
	for n=1,#genome.genes-1 do
		ngenome.networkswitch[n] = genome.networkswitch[n]
	end
	for name,rate in pairs(genome.mutationRates) do
		ngenome.mutationRates[name] = rate
	end
	return ngenome
end

function newNeuron() --A neuron is a stored value that is calculated based on inputs and broadcasts to its outputs
    local neuron = {}
    neuron.incoming = {} --list of incoming genes
	neuron.queues = {} -- incoming queues for delay
    neuron.value = 0.0 --current value
	neuron.layer = 0 --What layer the neuron is in (0 means it has not been calculated)
    return neuron
end

--Evaluation of networks
function generateNetwork(genome)
    for n=1,#genome.genes do --For each network
		local neurons = {}
		for i=1,Inputs do --Put in input nodes
			neurons[i] = newNeuron()
		end
		for g=1,#genome.genes[n] do --Loop through each gene
            local gene = genome.genes[n][g]
            if gene.enabled then --Only add enabled genes
                --If either side of gene is not added to neurons yet then add it
                if neurons[gene.into] == nil then
                    neurons[gene.into] = newNeuron()
                end
                if neurons[gene.out] == nil then
                    neurons[gene.out] = newNeuron()
                end
                if gene.into > 0 then
                    table.insert(neurons[gene.out].incoming,gene) --Add gene to the output neuron's incoming
                    queue = {}
                    for i=1,gene.delay do
                        table.insert(queue,0)
                    end
                    table.insert(neurons[gene.out].queues,queue)
                end
            end
        end
		
		local layers = {}
		while true do --loop until all layers found
			local layer = {}
			local finished = true --if all have been sorted
			for i,neuron in pairs(neurons) do --loop through and find all possible for calculation
				if neuron.layer == 0 then --Dont re-check already placed neurons
					local possible = true
					for j,gene in pairs(neuron.incoming) do --see if any incoming genes are not calculated yet
						if neurons[gene.into].layer == 0 then
							possible = false
							break
						end
					end
					if possible then --if has enough information to evaluate
						table.insert(layer,i)
						finished = false --a neuron was placed so it has not been all sorted yet
					end
				end
			end
			if finished then --exit the loop
				break
			end
			for i=1,#layer do --For each neuron in the new layer set it to now be sorted
				neurons[layer[i]].layer = #layers+1
			end
			table.insert(layers,layer)
		end
		local network = {}
		network.neurons = neurons
		network.layers = layers
		network.genes = genome.genes[n]
		genome.networks[n] = network
	end
end


function sigmoid(x)
    return 2/(1+math.exp(-4.9*x))-1
end
		

function evaluateNetwork(network, inputs, oscillating, frame)
    table.insert(inputs,1.0) --Bias node
	local marioXVel = marioXVel
	local marioYVel = marioYVel
	local ScrollWalkPauselocal = ScrollWalkPause
	local marioScreenX = marioScreenX
	local endscroll = endscroll
	local spriteNear = spriteNear
	local ButtonNames = ButtonNames
	local scrollBonus = scrollBonus
	local Inputs = Inputs
	local mmax = math.max
	for i=1,#oscillating do --Oscillating nodes
		if frame % (oscillating[i]*2) < oscillating[i] then
			table.insert(inputs,1.0)
		else
			table.insert(inputs,-1.0)
		end
	end
	--Speed nodes
	if (marioXVel < 100) then
		table.insert(inputs,marioXVel / 56)
	else
		table.insert(inputs,(marioXVel - 256) / 56)
	end
	if (marioYVel < 70) then
		table.insert(inputs,marioYVel / 69)
	else
		table.insert(inputs,mmax((marioYVel - 256) / 69,1))
	end
	
    if #inputs ~= Inputs then
        emu.print("Incorrect number of neural network inputs.")
        return {}
    end
   
    for i=1,Inputs do
        network.neurons[i].value = inputs[i]
    end
   
    -- for _,neuron in pairs(network.neurons) do
        -- local sum = 0
        -- for j = 1,#neuron.incoming do
            -- local incoming = neuron.incoming[j]
            -- local other = network.neurons[incoming.into]
            -- sum = sum + incoming.weight * other.value
        -- end
       
    -- end
	for l=2,#network.layers do
        local layer = network.layers[l]
        for n=1,#layer do
            local neuron = network.neurons[layer[n]]
            local sum = 0.0
            for j = 1,#neuron.incoming do
                local incoming = neuron.incoming[j]
                local other = network.neurons[incoming.into]
                if incoming.delay == 0 then
                    sum = sum + incoming.weight * other.value
                else
                    sum = sum + incoming.weight * neuron.queues[j][1]
                    for i=1,#neuron.queues[j]-1 do
                        neuron.queues[j][i] = neuron.queues[j][i+1]
                    end
                    neuron.queues[j][#neuron.queues[j]] = other.value
                end
            end
            neuron.value = sigmoid(sum)
        end
    end
	local output = {}
	--print("Yvel " .. marioYVel)
	--print("Xvel " .. marioXVel)
	--print("x " .. marioScreenX)
	if (ScrollWalkPauselocal and (marioScreenX < 45 or (marioYVel > 5 and marioYVel < 100) or spriteNear)) or endscroll then
		ScrollWalkPause = false
		ScrollWalkPauselocal = false
		--print("off")
	end
	if ((scrollBonus > 0 and marioScreenX > 200 and (marioYVel >240 or marioYVel < 5)) or ScrollWalkPauselocal) and not endscroll then
		--print("first")
		for o=1,#ButtonNames do
			output[ButtonNames[o]] = false
		end
		if marioXVel > 10 and marioXVel < 128 then
			output["left"] = true
		end
		if marioXVel > 128 and marioXVel < 245 then
			output["right"] = true
		end
		ScrollWalkPause = true
		ScrollWalkPauselocal = true
	elseif (scrollBonus > 0 and marioScreenX > 155 and marioYVel ==0) and not spriteNear and not endscroll then
		--print("second")
		for o=1,#ButtonNames do
			output[ButtonNames[o]] = false
		end
		if marioXVel > 10 and marioXVel < 128 then
			output["left"] = true
		end
		if marioXVel > 128 and marioXVel < 245 then
			output["right"] = true
		end
		ScrollWalkPause = true
		ScrollWalkPauselocal = true
	else
		--print("1")
		for o=1,#ButtonNames do --Find neural network outputs
			output[ButtonNames[o]] = network.neurons[-o] ~= nil and network.neurons[-o].value > 0
		end
	end
	--print(ScrollWalkPause)
	--Disable opposite d-pad presses
	if forcebutton ~= nil then
		for k,v in pairs(forcebutton) do
			output[k]=v
		end
		--print(output)
	end
	if output["up"] and output["down"] then
		output["up"] = false
		output["down"] = false
	end
	if output["left"] and output["right"] then
		output["left"] = false
		output["right"] = false
	end
	return output
end

--Mutation and evolution
function genomeDelta(genes1, genes2) --sees the delta between 2 networks.
    local i2 = {} --i2 maps the innovation of a gene to the gene, for the second genome.
    for i = 1,#genes2 do
        local gene = genes2[i]
        i2[gene.innovation] = gene
    end

    local sum = 0 --total weight difference among matching genes
    local coincident = 0 --number of matching genes
    for i,gene in pairs(genes1) do
        if i2[gene.innovation] ~= nil then
            local gene2 = i2[gene.innovation]
            sum = sum + math.abs(gene.weight - gene2.weight)
            coincident = coincident + 1
        end
    end
    if coincident == 0 then --if there are no matching genes it does not match so return a very large value
        return 100
    end
	local total = #genes1 + #genes2 --number of total genes
	local disjoint = total - (coincident*2) --number of non-matching genes
    return DeltaWeights * sum / coincident + DeltaDisjoint * disjoint / total --return the delta
end

function sameSpecies(genome1,genome2) --sees whether 2 genomes are in the same species or not.
	if #genome1.networkswitch ~= #genome2.networkswitch then
        return false --must have same number of networks
    end
    for n=1,#genome1.networkswitch do
        if math.abs(genome1.networkswitch[n] - genome2.networkswitch[n]) > DeltaSwitch then
            return false --if the network switches are too far apart they are different
        end
    end
    for n=1,#genome1.genes do
        delta = genomeDelta(genome1.genes[n],genome2.genes[n])
        if delta > DeltaThreshold then
            return false --if the delta between corresponding networks is too great they are different
        end
    end
	return true --otherwise, same species
end

function shuffle(num) --shuffles an array from 1 to num.
	local output = {}
	for i=1,num do
		local offset = i - 1
		local randomIndex = offset*math.random()
		local flooredIndex = randomIndex - randomIndex%1
		if flooredIndex == offset then
			output[#output + 1] = i
		else
			output[#output + 1] = output[flooredIndex + 1]
			output[flooredIndex + 1] = i
		end
	end
	return output
end

function addToSpecies(genome)

    local foundSpecies = false
	
	local order = shuffle(#pool.species) --Used to go through in random order so as to avoid feeding patterns.
	
    for i=1,#order do
        local species = pool.species[order[i]]
        if sameSpecies(genome, species.genomes[1]) and not foundSpecies then
            table.insert(species.genomes, genome)
            foundSpecies = true
        end
    end

    if not foundSpecies then --create new species
        local newSpecies = newSpecies()
        table.insert(newSpecies.genomes, genome)
        table.insert(pool.species, newSpecies)
    end
end

function randomNeuron(genes, nonInput, nonOutput) --pick a random neuron number
    local neurons = {}
    if not nonInput then --If inputs are an option add them
        for i=1,Inputs do
            neurons[i] = true
        end
    end
	if not nonOutput then --If outputs are an option add them
		for o=1,#ButtonNames do
			neurons[-o] = true
		end
	end
    for i,gene in pairs(genes) do --Add input and output of each gene
        if not nonInput or gene.into > Inputs then --add input as long as it is valid
            neurons[genes[i].into] = true
        end
        if not nonOutput or gene.out > 0 then --add output as long as it is valid
            neurons[genes[i].out] = true
        end
    end
    local count = 0
    for _,_ in pairs(neurons) do --count number of neuron possibilities
        count = count + 1
    end
	if count == 0 then return 0 end --return 0 means that there were no possibilities
    local n = math.random(1, count) --pick a random possibility
    for k,v in pairs(neurons) do
        n = n-1 --count down until you get to correct #
        if n == 0 then
            return k
        end
    end
end

function linkDirection(genes, link) --Finds a connection's status. 0 means already exists, 1 means >, -1 means < or incomparable
    for i=1,#genes do --check each gene
        local gene = genes[i] --if the new added gene already exists return 0
        if gene.into == link.into and gene.out == link.out then
            return 0
        end
    end
	--Attempt to find a connection opposing the suggested one (that would create a loop)
	local afterNodes = {} --each node that is >= than the link.out
	afterNodes[link.out] = true
	local readAll = false --has seen every gene without adding any to the list of nodes after link.into
	while not readAll do --loop until each gene has been read and used
		readAll = true
		for i,gene in pairs(genes) do --loop through the list of genes
			if afterNodes[gene.into] == true and afterNodes[gene.out] == nil then --if new connection found
				afterNodes[gene.out] = true
				readAll = false
				if gene.out == link.into then --connection found
					return -1
				end
			end
		end
	end
	return 1 --Has not found that link.into >= link.out so it is a fine direction
end

function linkMutate(genome, which, force) --Create a random new gene
	local genes = genome.genes[which]
	--create two random neurons
	local neuronInto
	if force == 0 then --only input box
		neuronInto = math.random(1,BoxSize)
	elseif force == 1 then --only bottom row
		neuronInto = BoxSize + math.random(1,3+#InitialOscillations)
	elseif force == 2 then --non-input
		neuronInto = randomNeuron(genes, true, true)
		if neuronInto == 0 then return end --no valid non-input nodes
	else --anything
		neuronInto = randomNeuron(genes, false, true)
	end
    local neuronOut = randomNeuron(genes, true, false)
	--Create a new link
	local newLink = newGene()
    newLink.into = neuronInto
    newLink.out = neuronOut
	if neuronInto == neuronOut then return end --must not be the same neuron
	connectionStatus = linkDirection(genes,newLink) --find current status of that link
	if connectionStatus == 0 then return end --if link already exists then return
	--opposite direction
	if connectionStatus == -1 then
		newLink.out = neuronInto
		newLink.into = neuronOut
	end
	--create new innovation value and weight
	newLink.innovation = pool.innovation
    pool.innovation = pool.innovation + 1
    newLink.weight = math.random()*4-2
    newLink.delay = 0
    if math.random()>0.85 then
        newLink.delay = math.min(5,math.ceil(math.log(math.random())/math.log(0.5)))
    end
	--add to the genes
	table.insert(genes,newLink)
end

function nodeMutate(genome, which) --Split a random gene and put a neuron in the middle
	local genes = genome.genes[which]
	if #genes == 0 then return end --cannot make a node with no genes
	local gene = genes[math.random(1,#genes)] --pick a random gene
	--create the new genes
	local geneI = newGene()
	local geneO = newGene()
	geneI.into = gene.into
	geneI.out = genome.maxNeuron + 1
	geneO.into = genome.maxNeuron + 1
	geneO.out = gene.out
	--set innovation
	geneI.innovation = pool.innovation
	geneO.innovation = pool.innovation + 1
	pool.innovation = pool.innovation + 2
	--set weights
	geneI.weight = math.sqrt(math.abs(gene.weight))
    if math.random() < 0.5 then
        geneI.weight = -geneI.weight --half the time first one is negative
        geneI.delay = gene.delay
    end
	if geneI.weight == 0 then
		geneI.weight = 0.001
	end
    geneO.weight = gene.weight / geneI.weight --they should multiply to original weight
    geneO.delay = gene.delay - geneI.delay
            
    genome.maxNeuron = genome.maxNeuron + 1
    gene.enabled = false --disable old gene
    --insert the new genes
    table.insert(genes,geneI)
    table.insert(genes,geneO)
end

function enableDisableMutate(genome, which, enable) --changes a random gene to enabled or disabled
    local candidates = {} --list of genes that would be changed by this mutation
    for _,gene in pairs(genome.genes[which]) do
        if gene.enabled == not enable then --only insert if the current enabling is different from what we will set it to
            table.insert(candidates, gene)
        end
    end

    if #candidates == 0 then return end --if no valid genes then do nothing

    local gene = candidates[math.random(1,#candidates)] --pick random from candidates
    gene.enabled = enable --enable that gene
end

function oscillationMutate(genome, which) --change an oscillation node timer
    i = math.random(1,#InitialOscillations) --pick a random oscillation to change
	genome.oscillations[which][i] = genome.oscillations[which][i] + math.random(-10,10) --change by random amount
    if genome.oscillations[which][i]<0 then --no negative oscillation values
        genome.oscillations[which][i] = 0
    end
end

function nswitchMutate(genome) --change the position of a network switch
    which = #genome.networkswitch --most of the time pick the most recent switch
    if math.random() < 0.15 then
        which = math.random(1,#genome.networkswitch) --occasionally pick a random other one
    end
    genome.networkswitch[which] = genome.networkswitch[which] + math.random(-250,250) --change by random amount
	local netlimit = 0
	for i,species in ipairs(pool.species) do
		if species.maxRightmost > netlimit then
			netlimit = species.maxRightmost
		end
	end
    if genome.networkswitch[which] < 0 or genome.networkswitch[which] > netlimit then --if out of range of where genome can reach
		table.remove(genome.networkswitch) --remove the latest network
		table.remove(genome.genes)
	end
    table.sort(genome.networkswitch, function(a,b) --make sure network switches are in order through the level
        return (a < b)
    end)
end

function weightsMutate(genome, which) --change the weights of genes around a node
	local genes = genome.genes[which]
	local node = randomNeuron(genes,false,false) --pick a random neuron to change weights in the area of
	local step = genome.mutationRates["step"]
	for i,gene in pairs(genes) do
		if gene.into == node or gene.out == node then --if either end 
			if math.random() < WeightPerturbChance then --modify the weight slightly
				gene.weight = gene.weight + (math.random()-0.5) * step * 2
			elseif math.random() < WeightResetChance then --reset weight entirely
				gene.weight = math.random()*4 - 2
			end
		end
	end
end

MutationFunctions = {} --each mutation function, sorted by name

MutationFunctions.linkInputBox = function(genome, which) return linkMutate(genome, which, 0) end
MutationFunctions.linkBottomRow = function(genome, which) return linkMutate(genome, which, 1) end
MutationFunctions.linkLayers = function(genome, which) return linkMutate(genome, which, 2) end
MutationFunctions.linkRandom = function(genome, which) return linkMutate(genome, which, 3) end
MutationFunctions.node = nodeMutate
MutationFunctions.enable = function(genome, which) return enableDisableMutate(genome, which, true) end
MutationFunctions.disable = function(genome, which) return enableDisableMutate(genome, which, false) end
MutationFunctions.oscillation = oscillationMutate
MutationFunctions.nswitch = function(genome, which) if which>1 then nswitchMutate(genome,which-1) end end
MutationFunctions.weights = weightsMutate

function mutate(genome, which) --Mutates a genome's network based on all it's mutation rates
	for name,rate in pairs(genome.mutationRates) do --For each mutation type
		local p = rate --Number of times to do that mutation type
		if MutationFunctions[name] ~= nil then --is a mutation and not another rate like STEP
			while p > 0 do --Loop until all mutations are done
				if math.random() < p then --when p > 1 always do it, if it is a fraction then it is random
					if genome.genes[which] ~= nil then --if network exists
						MutationFunctions[name](genome,which) --call that rate
					end
				end
				p = p - 1 --reduce p
			end
		end
	end
end

function crossover(g1,g2)
	if g2.fitstate.fitness > g1.fitstate.fitness then
		g2, g1 = g1, g2 --switch so that g1 is always the greater fitness
	end
	local numnets = math.min(#g1.genes,#g2.genes) --take the smaller # of networks
    local child = newGenome(numnets)
	for n=1,numnets do --for each network to be calculated
		local i2 = {} --map from gene2 innovations to gene innovations
		for i,gene in ipairs(g2.genes[n]) do
			i2[gene.innovation] = gene
		end
		local i1 = {} --map from gene1 innovations to gene innovations
		for i,gene in ipairs(g1.genes[n]) do
			i1[gene.innovation] = gene
		end
		for i=1,#g1.oscillations[n] do
			child.oscillations[n][i] = g1.oscillations[n][i] --set oscillations to g1's oscillations
		end
        for i,gene1 in ipairs(g1.genes[n]) do --some version of every gene from best genome
            local gene2 = i2[gene1.innovation] --use innovations2 to find the copied gene in g1
			if gene2 ~= nil and math.random(1,2) == 1 and gene2.enabled then
				table.insert(child.genes[n], copyGene(gene2)) --if the copied gene exists pick randomly
			else
				table.insert(child.genes[n], copyGene(gene1)) --otherwise take the version from the best genome
			end
        end
		if n > 1 then
			child.networkswitch[n-1] = g1.networkswitch[n-1]
		end
		for i,gene in ipairs(g2.genes[n]) do
			if i1[gene.innovation] == nil and math.random() < 0.01 then --low chance for every gene in g2 only
				table.insert(child.genes[n], copyGene(gene)) --add those genes to the child as well
			end
		end
	end
	child.maxNeuron = math.max(g1.maxNeuron,g2.maxNeuron)
	return child
end

function rankGlobally() --Give each species a global rank, 1 is lowest Population is highest
    local globalRanks = {}
    for s = 1,#pool.species do
        local species = pool.species[s]
        for g = 1,#species.genomes do
            table.insert(globalRanks, species.genomes[g]) --Insert every genome into the table
        end
    end
    table.sort(globalRanks, function (a,b) --Sort based on fitness
        return (a.fitstate.fitness < b.fitstate.fitness)
    end)

    for g=1,#globalRanks do --Put position of each genome into that genome's data
        globalRanks[g].globalRank = g
    end
end

function calculatePoolStats() --Calculate avg and avg deviation of max fitness
	local total = 0 --Average of each species max fitness
    for i,species in ipairs(pool.species) do
        total = total + species.maxFitness
    end
    pool.averagemaxfitness = total / #pool.species
	
    local deviationtotal = 0 --Average distance between max fit and avg max fit
    for i,species in ipairs(pool.species) do
        deviationtotal = deviationtotal + math.abs(species.maxFitness - pool.averagemaxfitness)
    end
    pool.avgDeviation = deviationtotal / #pool.species
end

function calculateFitnessRank(species) --Returns a number for each species showing how well that species did
    local totalRank = 0

    for g=1,#species.genomes do --Total rank is equal to the average of the ranks of each genome
        local genome = species.genomes[g]
        totalRank = totalRank + genome.globalRank
    end
	totalRank = totalRank / #species.genomes 
	
	local multiplier = 1.0 --multiplier based on how many avg deviations from the mean the top fitness is
	if species.maxFitness < pool.averagemaxfitness - (pool.avgDeviation *2) then
		multiplier = 0.25
	elseif species.maxFitness < pool.averagemaxfitness - pool.avgDeviation then
		multiplier = 0.4
	elseif species.maxFitness > pool.averagemaxfitness + (pool.avgDeviation *3) then
		multiplier = 2.0
	elseif species.maxFitness > pool.averagemaxfitness + (pool.avgDeviation *2) then
		multiplier = 1.5
	end
	
	--Penalty for having multiple networks, to cancel out the benefit of consistency that they give
	local netMulti = math.pow(NetworkPenaltyOuter*math.pow(NetworkPenaltyInner,#species.genomes[1].networkswitch),#species.genomes[1].networkswitch)
	
	species.fitnessRank = totalRank * multiplier * netMulti
end

function totalPoolRank() --Sums each species fitness rank
    local total = 0
    for i,species in ipairs(pool.species) do
        total = total + species.fitnessRank
    end
    return total
end

function cullSpecies(cutToOne) --Cuts down each species, either to a percent based on bottleneck, or only to it's top genome.
	for i,species in ipairs(pool.species) do
		table.sort(species.genomes, function (a,b) --sorts the genomes by how well they did
            return (a.fitstate.fitness > b.fitstate.fitness)
        end)

        local percent = 0.5 --calculate percent
		local minpercent = math.max(0.15,0.5-0.1*pool.bottleneckloops) --min and max of oscillation
		local maxpercent = math.min(0.85,0.5+0.1*pool.bottleneckloops)
		
		local length = math.min(10,(5 + 2*pool.bottleneckloops)) --length used in pop oscillation

		local totallength = length*3 + TimeBeforePopOscil --total length of oscillation
		
		if pool.bottleneck < totallength/2 then --if in first half go up to max
			percent = minpercent + (0.1+maxpercent-minpercent)*(pool.bottleneck*2/totallength)
		else --if in second half go down to min
			percent = 0.1+maxpercent - (0.2+maxpercent-minpercent)*(pool.bottleneck*2/totallength-1)
		end
		
        local remaining = math.ceil(#species.genomes*percent) --number that remain
        if cutToOne or remaining < 1 then --always keep at least 1
            remaining = 1
        end
        while #species.genomes > remaining do --remove all that do not survive
            table.remove(species.genomes)
        end
    end
end

function breedChild(species) --makes an offspring from a species
	local child = {}
	if math.random() < CrossoverChance then --chance to cross over two genomes or just copy one
        g1 = species.genomes[math.random(1, #species.genomes)]
        g2 = species.genomes[math.random(1, #species.genomes)]
        child = crossover(g1, g2)
	else
        g = species.genomes[math.random(1, #species.genomes)]
        child = copyGenome(g)
    end
	
	local which = #child.genes -- mutate usually at the latest network
    if which > 1 and species.maxRightmost > 0 then --if there are multiple networks possibly modify one before most recent based on distance past that
        local mutatePrevNetworkChance = 0.5 + (child.networkswitch[#child.networkswitch]-species.maxRightmost)/500
        if math.random() < mutatePrevNetworkChance then
            which = #child.genes - 1
        end
    end
    mutate(child,which) --mutate the child in that network

    return child
end

function removeStaleSpecies() --update staleness and remove stale species
	local survived = {} --species that survive
	for i,species in ipairs(pool.species) do
		species.staleness = species.staleness + 1
		if species.staleness < MaxStaleness or species.maxFitness >= pool.secondFitness then --non stale species and top 2 species survive
			table.insert(survived,species)
		end
	end
	pool.species = survived
end

function removeWeakSpecies() 
	local survived = {} --species that survive
    local sum = totalPoolRank()
    for s = 1,#pool.species do
        local species = pool.species[s]
        local breed = math.floor(species.fitnessRank / sum * pool.population)
		
        if breed+1 >= 999/pool.population or species.fitnessRank > sum / #pool.species then
            table.insert(survived, species)
        end
    end
    pool.species = survived
end

function replaceNetwork(g1,g2) --replaces the most recent network of g1 with a random network of g2
	local child = copyGenome(g1) --mostly a copy of genome 1
	child.genes[#child.genes] = {} --clear out the most recent network
    which = math.random(1,#g2.genes) --pick a random network to copy from which
	for i,gene in ipairs(g2.genes[which]) do --copy each gene
		table.insert(child.genes[#child.genes], copyGene(gene))
	end
    return child
end	

function writescene(scene)
	local f = io.open('currentscene.txt','w')
	if scene == 1 then
		f:write("1")
	elseif scene == 2 then
		f:write("2")
	else
		f:write("3")
	end
	f:close()
end

function writetable(file,tbl) --writes a string of a table to a file
	function tablestring(a)
		if type(a)=='number' then
			local s = string.gsub(tostring(a),",",".")
			file:write(s)
		elseif type(a)=='boolean' then
			file:write(tostring(a))
		elseif type(a)=='string' then
			file:write('"')
			for i=1,string.len(a) do
				local c = string.sub(a,i,i)
				if c=="\n" then
					file:write("\\n")
				else
					local s = string.gsub(c,'\\','\\\\')
					file:write(s)
				end
			end
			file:write('"')
		else
			file:write('{')
			for key,value in pairs(a) do
				file:write('[')
				tablestring(key)
				file:write(']=')
				tablestring(value)
				file:write(',')
			end
			file:write('}')
		end
	end
	tablestring(tbl)
end
savgx={0}
function searchstaff()
	getPositions()
	local marioScreenX = marioScreenX
	local koopalingDefeated = koopalingDefeated
	local cont = {}
	cont['B'] = true
	cont['down'] = false
	if marioScreenX < 122 then
		cont['right'] = true
		
	else
		cont['left'] = true
	end
	if marioScreenX - savgx[1] < 5 then
		cont['A'] = true
		table.insert(savgx,0)
	else
		cont['A'] = false
	end
	table.insert(savgx,marioScreenX)
	if #savgx > 120 then
		table.remove(savgx,1)
	end
	joypad.set(Player,cont)
	coroutine.yield()
end

function file_exists(name)
   local f=io.open(name,"r")
   if f~=nil then io.close(f) return true else return false end
end

function saveGenome(name,winner) --saves a species containing the winning genome to a file
	local lvlf=io.open("level.txt","r")
	local lvl = lvlf:read("*line")
	lvlf:close()
	local levelname = lvl --name of level in the file name
	local file = io.open("backups"..dirsep..levelname..dirsep..name..".lua","w")
	spec = pool.species[pool.currentSpecies]
	genome = spec.genomes[pool.currentGenome]
	genome.nick = spec.nick
	genome.gen = pool.generation
	genome.s = pool.currentSpecies
	genome.g = pool.currentGenome
	print("backups"..dirsep..levelname..dirsep..name..".lua")
	if not winner then
		if boss then
			file:write("boss=true\nloadedgenome=")
		else
			file:write("boss=false\nloadedgenome=")
		end
	else
		file:write("loadedgenome=")
	end
	writetable(file,genome)
	file:close()
	if winner then
		file = io.open("backups"..dirsep.."winners.txt","a")
		file:write("backups"..dirsep..levelname..dirsep..name..".lua\n")
		file:close()
	else
		table.insert(pool.breakthroughfiles,"backups"..dirsep..levelname..dirsep..name..".lua")
	end
end

function savePool(filename) --saves the pool into a file
	local file = io.open(filename,"w")
	file:write("pool=")
	writetable(file,pool)
	file:close()
end

function loadPool(filename) --loads the pool from a file
	dofile(filename)
	ProgramStartTime = ProgramStartTime - pool.realTime
end

maxNewGenProgress = -1
function newgenProgress(progress) --draws a progress bar for new gen calculation
	if math.floor(progress)>maxNewGenProgress then
		maxNewGenProgress=math.floor(progress)
		text = "Calculating Generation"
		white = toRGBA(0xFFFFFFFF)
		blue = toRGBA(0xFF003FFF)
		black = toRGBA(0xFF000000)
		gui.drawbox(38,98,218,122,black,blue)
		drawtext.draw(text,40,100,white,black)
		prog = "["
		for i=1,progress do prog=prog.."#" end
		for i=progress,19 do prog=prog.." " end
		prog=prog.."]"
		drawtext.draw(prog,40,112,blue,black)
		coroutine.yield()
	end
end

function newGeneration() --runs the evolutionary algorithms to advance a generation
	local mfloor = math.floor
	maxNewGenProgress = -1
	newgenProgress(0)
	autoturbo()
	generationTime = pool.realTime
	
	os.remove("backups"..dirsep..levelname..dirsep.."gen"..(pool.generation+1)..".lua")
	savePool("backups"..dirsep..levelname..dirsep.."gen"..pool.generation..".lua")
	
    local length = math.min(10,(5 + 2*pool.bottleneckloops)) --Length used for the population oscillation
	local targetPop = math.min(900,500 + 100*pool.bottleneckloops) --population to rise to
    local targetPopLower = math.min(300,600 - targetPop/2) --population to fall back down to
    local currentPopLower = math.min(300,targetPopLower+50) --population starting at
	
	if pool.bottleneck <= TimeBeforePopOscil and pool.bottleneckloops == 0 then --decrease very rapidly after a bottleneck reset
		pool.population = math.max(math.floor(pool.population * 0.8),300)
	end
	
	if pool.bottleneck > TimeBeforePopOscil then --perform the oscillation
        if pool.bottleneck < TimeBeforePopOscil + length then --increase up
            pool.population = currentPopLower + math.floor((targetPop - currentPopLower)/length*(pool.bottleneck-TimeBeforePopOscil))
        elseif pool.bottleneck == TimeBeforePopOscil + length then --peak
            pool.population = targetPop
        elseif pool.bottleneck <= TimeBeforePopOscil + length*3 then --go back down
            pool.population = targetPopLower + math.floor((targetPop - targetPopLower)/length/2*(TimeBeforePopOscil+length*3-pool.bottleneck))
        end
        if pool.bottleneck == TimeBeforePopOscil + length*3 then --go to next loop
            pool.bottleneck = 0
            pool.bottleneckloops = pool.bottleneckloops + 1
        end
    end
	newgenProgress(1)
	cullSpecies(false) --cut down each species
	newgenProgress(2)
	rankGlobally() --rank all genomes
	newgenProgress(3)
	removeStaleSpecies() --remove stale species
	newgenProgress(4)
	calculatePoolStats() --find pool maxes avg/deviation
	newgenProgress(5)
	for i,species in ipairs(pool.species) do --find the fitness rank for each species
        calculateFitnessRank(species)
    end
	newgenProgress(6)
	removeWeakSpecies() --remove species without a good fitness rank
	newgenProgress(7)
	local rankSum = totalPoolRank() --used to see how good a fitness rank is in comparison to everything
	
	local children = {} --new genomes that will be added this generation
	
	for i,species in ipairs(pool.species) do --generate children for each species
        local breed = mfloor(species.fitnessRank / rankSum * pool.population) - 1 --num of children to generate
        for j=1,breed do
			table.insert(children, breedChild(species))
        end
		newgenProgress(7+3*i/#pool.species)
    end
	newgenProgress(10)
	local interbreedchance = BaseInterbreedChance --base interbreed chance
    if pool.generation > 5 then --do not reduce interbreed at very beginning, we want lots of it in first 5 gens
		--reduce interbreed when there are lots of species with low average size
		interbreedchance = interbreedchance * math.pow(1/InterbreedCutoff-math.min(1/InterbreedCutoff,#pool.species/pool.population),InterbreedDegree)
	end
	
	local replacechance = interbreedchance/3 --replacements rarer than interbreeds
	
	local minnetwork = 10000 --minimum number of networks a species eligible for a NS has
	local netspecies = {} --list of species eligible for a NS with min networks
	
	for i,species in ipairs(pool.species) do --apply interbreed chance to each species
		if math.random() < interbreedchance then
			--pick which species to breed with, proportional to fitness rank
			local ibcheck = math.random() * rankSum
			for j,species2 in ipairs(pool.species) do
				ibcheck = ibcheck - species2.fitnessRank --reduce by the fitness rank
				if ibcheck < 0 then --the higher it is reduced by greater chance it goes below 0 this time
					table.insert(children, crossover(species.genomes[1],species2.genomes[1])) --interbreed
					break
				end
			end
		end
		
		if math.random() < replacechance then
			--pick which species to get network from
			local species2 = pool.species[math.random(1,#pool.species)]
			table.insert(children, replaceNetwork(species.genomes[1],species2.genomes[1])) --replace network
		end
		
		local numnet = #species.genomes[1].genes --number of networks
		if math.min(numnet,3) <= pool.bottleneckloops and numnet <= minnetwork and species.maxFitness + 150 > pool.maxFitness then
			if numnet < minnetwork then --even smaller network found, clear old array
				minnetwork = numnet
				netspecies = {}
			end
			table.insert(netspecies,species)
		end
		newgenProgress(10+3*i/#pool.species)
	end
	
	if #netspecies > 0 then --at least one species eligible for a network switch
		local species = netspecies[math.random(1,#netspecies)] --pick random eligible species
		local child = copyGenome(species.genomes[1]) --make a copy of best genome
		local switchloc = species.maxRightmost - 150 - 150*math.random() --pick a switch location
		table.insert(child.networkswitch,switchloc)
		table.insert(child.oscillations,{})
		for i=1,#InitialOscillations do
			child.oscillations[#child.oscillations][i] = InitialOscillations[i]
		end
		table.insert(child.genes,{})
		
		table.insert(children,child) --add child
		
		mutate(child,#child.genes)
		mutate(child,#child.genes)
		
		table.sort(child.networkswitch, function(a,b) --make sure network splits are in order
			return (a < b)
		end)
	end
	newgenProgress(13)
	while #children+#pool.species < pool.population do --fill from random species
		table.insert(children, breedChild(pool.species[math.random(1, #pool.species)]))
	end
	newgenProgress(14)
	cullSpecies(true) --remove all but the best of each species
	newgenProgress(15)
	for i,child in ipairs(children) do --add all children to species
		addToSpecies(child)
		newgenProgress(15+3*i/#children)
	end
	newgenProgress(18)
	for i,species in ipairs(pool.species) do --limit size of species
		local limit = pool.population/12 --cap on the species size
		if species.maxFitness >= pool.secondFitness then --if top two then larger cap
			limit = pool.population/7
		end
		while #species.genomes > limit do --remove
			table.remove(species.genomes)
		end
	end
	
	pool.generation = pool.generation + 1
	pool.bottleneck = pool.bottleneck + 1
	newgenProgress(19)
	savePool("backups/current.lua")
	newgenProgress(20)
end

Ranges = {
['0-3-3-1']= {{yrange={}, xrange={min=360, max=480}, timeout=900}},
["1-2-3-0"]= {{yrange={}, xrange={min=1173, max=1300}, coeffs={x=1,y=2,c=0}}, {yrange={}, xrange={min=1300, max=1303}, resetoffset=true}, {yrange={min=10, max=95}, xrange={min=1281, max=1450}, coeffs={x=0,y=0,c=0}, P=0},{yrange={min=10, max=36}, xrange={min=1181, max=1290}, coeffs={x=0,y=0,c=0}, P=0}},
["1-6-2-0"]= {{yrange={}, xrange={min=2167, max=2300}, timeout=900}, {yrange={min=80,max=96}, xrange={min=2230, max=2249}, coeffs={x=1,y=-1,c=700}},{yrange={min=96,max=112}, xrange={min=2220, max=2279}, coeffs={x=1,y=-1,c=600}},{yrange={min=112,max=128}, xrange={min=2230, max=2249}, coeffs={x=1,y=-1,c=500}},{yrange={min=128,max=144}, xrange={min=2230, max=2249}, coeffs={x=1,y=-1,c=400}}, {yrange={min=144,max=160}, xrange={min=2256,max=2272},coeffs={x=1,y=-1,c=250}},{yrange={}, xrange={min=2272,max=2300},coeffs={x=0,y=0,c=0}},{yrange={min=170}, xrange={min=2200,max=2300},coeffs={x=0,y=0,c=0}},{yrange={min=80,max=90}, xrange={min=2274, max=2300}}},
}

function fitness(fitstate) --Returns the distance into the level - the non-time component of fitness
	local coeffs={x=1,y=1,c=0} --position base coefficients
	local marioX = marioX
	local marioY = marioY
	local marioYVel = marioYVel
	local marioScore = marioScore
	local marioScreenX = marioScreenX
	local marioPower = marioPower
	local boss = boss
	local battle = battle
	local marioActive = marioActive
	local scrollBonus = scrollBonus
	local mmax = math.max
	local mfloor = math.floor
	local mabs = math.abs
	local card_x = card_x
	local card_y = card_y
	local lspecialBonus = specialBonus
	local CardDistance = cardDistance
	local levelname = levelname
	local pStatus = math.sqrt(memory.readbyte(0x03DD))

	local ranges = Ranges[levelname .. "-" .. fitstate.area]
	--[[local levelstring = "" --string to represent the level and subworld, to index Ranges
	if LostLevels == 1 then levelstring = "LL" end
	levelstring = levelstring .. currentWorld .. "-" .. currentLevel .. " " .. fitstate.area
	local ranges = Ranges[levelstring] ]]
	if boss then
		basetimeout = roottimeoutboss
	else
		basetimeout = roottimeout
	end
	forcebutton = nil
	if ranges ~= nil then
		for r=1,#ranges do --for each special fitness range
			local range = ranges[r]
			if (range.xrange.min == nil or marioX > range.xrange.min) and (range.xrange.max == nil or marioX <= range.xrange.max) then --in x range
				if (range.yrange.min == nil or marioY >= range.yrange.min) and (range.yrange.max == nil or marioY < range.yrange.max) then --in y range
					if range.coeffs ~= nil then
						coeffs = range.coeffs --replace default coefficients
					end
					if range.P ~= nil then
						pStatus = pStatus * range.P
					end
					if range.area ~= nil then
						fitstate.area = range.area
					end
					if range.timeout ~= nil then
						basetimeout = range.timeout
					else
						basetimeout = 120
					end
					if range.turbo ~= nil then
						if range.turbo then
							currentTurbo = true
							emu.speedmode("turbo")
						else
							currentTurbo = false
							emu.speedmode("normal")
						end
					end
					if range.forcebutton ~= nil then
						forcebutton = range.forcebutton
					else
						forcebutton = nil
					end
					if range.resetoffset ~= nil then
						fitstate.offset = fitstate.rightmost - fitstate.position
					end
				end
			end
		end
	end
	if marioXVel ~= 0 and not (marioYVel > 0 and marioYVel < 70) then
		pBonus = pBonus + pStatus/5
	end
	local distance
	if boss or battle then
		for i,sprite in ipairs(sprites) do
			if sprite.state ~= 0 then
				local distx = math.floor((sprite.x - marioX)/16 + 0.5)
				distance = 16 - mabs(distx)
			end
			if distance == nil then
				distance = 0
			end
		end
	end
	local currentCardDistance = math.sqrt(mabs(card_x-marioX)*mabs(card_y-marioY))/50
	if currentCardDistance < CardDistance and not battle and not boss then
		CardDistance = currentCardDistance
		cardDistance = CardDistance
		if CardDistance < 0.4 then
			--roottimeout = 600
			basetimeout = 600
		end
		
	end
	if CardDistance == 0 then
		CardDistance = 0.1
	end
	fitstate.position = coeffs.x*marioX + coeffs.y*marioY + coeffs.c --set the position value
	if marioActive then
		prevPower = marioPower
		if not fitstate.lastActive then --update offset
			fitstate.area = memory.readbyte(0x03DF)
			--print(500/CardDistance)
			fitstate.offset = fitstate.rightmost - fitstate.position
			--print(fitstate.offset)
			--print("adjusted offset: " .. fitstate.offset)
			if battle then fitstate.offset = - (marioScore * 3 + distance * 10) end
			getTileset()
		end
		fitstate.lastright = fitstate.position --update lastright when in control of mario
		if scrollBonus > 0 and scrollBonus == prevScrollBonus then
			fitstate.timeout = fitstate.timeout + 1
			--endscroll = true
			--print(scrollBonus)
			--print(prevScrollBonus)
		elseif boss then
			if marioScore == prevscore then
				fitstate.timeout = fitstate.timeout + 1 --increase timeout
			else
				fitstate.timeout = 0
			end
			prevscore = marioScore
		elseif scrollBonus > 0 then
			fitstate.timeout = 0
			endscroll = false
		elseif battle then
			if marioScore == prevscore then
				fitstate.timeout = fitstate.timeout + 1 --increase timeout
			else
				fitstate.timeout = 0
			end
			if distance > 9 then
				basetimeout = 600
			else
				basetimeout = 120
			end
			prevscore = marioScore
			prevscreenx = marioScreenX
		else
			fitstate.timeout = fitstate.timeout + 1 --increase timeout
		end
		if fitstate.timeout > basetimeout then --if has been idle for a second, start penalizing
			fitstate.timepenalty = fitstate.timepenalty + 1
			endscroll = true
		end		
		if pipe then
			pipe = false
		end
		--print("scrollBonus: " .. scrollBonus)
		--print("prev: " .. prevScrollBonus)
		prevScrollBonus = scrollBonus
	else
		fitstate.position = fitstate.lastright --freeze position when not in control of mario
		if prevPower == marioPower then
			if scrollBonus >0 and not pipe then
				specialBonus = specialBonus + 200
				lspecialBonus = specialBonus
				--fitstate.fitness = scrollBonus + fitstate.rightmost*0.6 + 150
				fitstate.rightmost = fitstate.fitness
				scrollBonus = 0
				basescroll = 0
				memory.writebyte(0x7A0C,0)
				
				--fitstate.rightmost = fitstate.rightmost + fitstate.offset
				pipe = true
				--pipeflip = true
				--print("pipe")
				--fitstate.rightmost = fitstate.offset + 0.6*fitstate.rightmost
			
			elseif scrollBonus >0 and pipe then
				scrollBonus = 0
				basescroll = 0
				memory.writebyte(0x7A0C,0)
			end
			
		else
			marioActive = true
		end
	end
	fitstate.lastActive = marioActive
	if not (marioYVel > 0 and marioYVel < 70) and fitstate.position + fitstate.offset > fitstate.rightmost then
		fitstate.timeout = mmax(0,fitstate.timeout + (fitstate.rightmost - fitstate.position - fitstate.offset)*2) --decrease timeout
		fitstate.rightmost = fitstate.position + fitstate.offset --rightmost is maximum that the position+offset has ever been
		--fitstate.savedtimepenalty = fitstate.timepenalty DISABLED FOR AUTOSCROLLER TEST
	end
	if boss then
		fitstate.fitness = marioScore + fitstate.frame + distance
	elseif battle then
		fitstate.fitness = marioScore * 3 + distance * 10 + fitstate.offset
	elseif scrollBonus > 0 then
		fitstate.fitness = scrollBonus + fitstate.rightmost*0.6 + pBonus/10
		--print("scrollBonus")
		-- if lspecialBonus > 0 then
			-- print("scrollBonus: " .. scrollBonus)
			-- print("marioX: " .. marioX)
		-- end
	else
		fitstate.fitness = fitstate.rightmost - mfloor(fitstate.savedtimepenalty / 2) + WhiteblockBonus + lspecialBonus + 100/CardDistance +pBonus/10 + powerupFitness * math.min(marioPower, 2)  --+ marioScore --return fitness
		-- if fitstate.offset ~= -104 then
			-- print("after pipe fitness: " .. fitstate.fitness)
		-- end
		--print("right: " .. fitstate.rightmost .. " penalty: " .. mfloor(fitstate.savedtimepenalty / 2) .. " whiteblock: " .. WhiteblockBonus .. " special: " .. lspecialBonus .. " card: " .. 500/CardDistance .. " pBonus: " .. pBonus/10)
	end
end



function autoturbo() --Determines the automatic turbo 
	local pool = pool
	if (pool.realTime - pool.lastbreaktime) > 14400 then
		if (pool.realTime - generationTime) > 5400 then
			TurboMax = TurboMax + 30
			autoTurbo = TurboMax
		elseif (pool.realTime - generationTime) < 3600 and autoTurbo == TurboMax and autoTurboCounter > 1 then
			TurboMax = TurboMax - 50
			if TurboMax < 0 then
				TurboMax = 0
			end
			autoTurbo = TurboMax
		elseif (pool.realTime - generationTime) < 3600 and autoTurbo == TurboMax then
			autoTurboCounter = autoTurboCounter + 1
		else
			autoTurboCounter = 0
		end
	end
	if (pool.realTime - pool.lastbreaktime) < 43200 then
		automaticturboswitch = 0
	elseif (pool.realTime - pool.lastbreaktime) > 43200 and automaticturboswitch == 0 then
		local increase = math.ceil(pool.maxFitness / 10)
		if TurboMax < increase then
			TurboMax = increase
			autoTurbo = increase
		end
		automaticturboswitch = 1
	elseif (pool.realTime - pool.lastbreaktime) > 86400 and automaticturboswitch == 1  then
		local increase = math.ceil(pool.maxFitness / 5)
		if TurboMax < increase then
			TurboMax = increase
			autoTurbo = increase
		end
		automaticturboswitch = 2
	elseif (pool.realTime - pool.lastbreaktime) > 172800 and automaticturboswitch == 2 then
		local increase = math.ceil(pool.maxFitness / 3)
		if TurboMax < increase then
			TurboMax = increase
			autoTurbo = increase
		end
		automaticturboswitch = 3
	end
end

function playGenome(genome) --Run a genome through an attempt at the level
	local mmax = math.max
	local boss = boss
	local Replay = Replay
	local FramesPerEval = FramesPerEval
	if boss then
		savestate.load(bosssavestateObj) --load boss savestate
	else
		savestate.load(savestateObj) --load savestate
	end
	--local falseload = false
	--[[while memory.readbyte(0x0787) == 0 do --wait until the game has fully loaded in mario
		coroutine.yield()
		falseload = true
	end
	if falseload then --move a savestate forward so that it doesn't have any load frames
		local groundtime = 0 --must not be falling for a certain time to be on ground
		while groundtime < 10 do --wait for mario to hit the ground
			coroutine.yield()
			if memory.readbyte(0x009F) == 0 then
				groundtime = groundtime + 1
			else
				groundtime = 0
			end
		end
		savestate.save(savestateObj)
	end]]--
	
	local fitstate = genome.fitstate
	fitstate.frame = 0 --frame counter for the run
	fitstate.position = 0 --current position
	fitstate.rightmost = 0 --max it has gotten to the right
	fitstate.offset = 0 --offset to make sure fitness doesn't jump upon room change
	fitstate.lastright = 0 --last position before a transition.cancel()
	fitstate.lastActive = false --mario's state the previous frame (to check state transitions)
	fitstate.fitness = 0 --current fitness score
	fitstate.timeout = 0 --time increasing when mario is idle, kills him if it is too much
	fitstate.timepenalty = 0 --number of frames mario was too idle, to subtract from his fitness
	--fitstate.area = "Level"
	--fitstate.lastarea = ""
	fitstate.savedtimepenalty = 0 --does not save time penalty until mario moves forward
	basescroll = 0
	prevScrollBonus = scrollBonus
	marioPrevAutoscroll = 0
	specialBonus = 0
	cardDistance = 9999
	pBonus = 0
	lockBound = false
	getPositions()
	
	specialBonus = - scrollBonus - 500/cardDistance - powerupFitness * math.min(marioPower, 2)
	local nsw = 1 --network switch
	generateNetwork(genome) --generate the network
	local controller = {} --inputs to the controller
	getTileset()
	fitstate.area = memory.readbyte(0x03DF)
	while true do --main game loop
		local koopalingDefeated = koopalingDefeated
		local marioMusic = marioMusic
		local manualControl = keyboardInput()
		local ManualInput = ManualInput
		local marioX = marioX
		local card_x = card_x
		local marioScreenY = marioScreenY
		local marioYVel = marioYVel
		--Get inputs to the network
		
		if fitstate.frame % FPS == 0 and not Replay then
			timerOutput()
		end
		
		if fitstate.frame % FramesPerEval == 0 then
			local inputs = getInputs()
			--Find the current network to be using
			local nscompare = fitstate.rightmost
			nsw = 1
			for n=1,#genome.networkswitch do
				if nscompare > genome.networkswitch[n] then
					nsw = n+1
				end
			end
			--Put outputs to the controller
			if marioX > card_x -74 and marioX < card_x -64 then
				forcebutton = {right=true,A=false,B=true}
			elseif marioX <= card_x-8 and marioX >= card_x -64 then
				forcebutton = {right=true,A=true,B=true}
			elseif marioX > card_x+8 then
				forcebutton = {left=true,right=false}
			end
			controller = evaluateNetwork(genome.networks[nsw], inputs, genome.oscillations[nsw], fitstate.frame)
		else
			getPositions()
		end
		
		if ManualInput then
			joypad.set(Player,manualControl)
		else
			if fitstate.frame % (FramesPerEval*2) == 0 then
				if (marioPower == 3 or marioPower == 5) and controller['A'] then
					if memory.readbyte(0x03DD) == 127 then
						controller['A'] = false --allows mario to fly with tanooki suit. this type of network would otherwise not be capable of switching that fast
					end
				end
			end
			joypad.set(Player,controller)
		end
		
		fitness(fitstate) --update the fitness
		if pool.generation == 0 and not Replay then
			TurboMax = 1
		elseif TurboMax == 1 then
			TurboMax = 0
		end
		local turbocompare = mmax(0,fitstate.rightmost)
		if CompleteAutoTurbo or (turbocompare >= TurboMin and turbocompare < TurboMax and pool.species[pool.currentSpecies].turbo) then
			if not currentTurbo then
				currentTurbo = true
				emu.speedmode("turbo")
			end
		else
			if currentTurbo then
				currentTurbo = false
				emu.speedmode("normal")
			end
		end
			
		--Display the GUI
		displayGUI(genome.networks[nsw], fitstate)
		--Advance a frame
		coroutine.yield() --coroutine.yield()
		fitstate.frame = fitstate.frame + 1
		
		--exit if dead or won
		if memory.readbyte(0x00EE) == 75 or marioOutOfBound then --if he dies to an enemy or a pit
			if Replay then
				genome.networks = {}
				return false
			end
			pool.attempts = pool.attempts + 1
			pool.deaths = pool.deaths + 1
			addToHistogram()
			deathCounterOutput()
			for frame=1,FramesOfDeathAnimation do
				displayGUI(genome.networks[nsw], fitstate)
				coroutine.yield() --coroutine.yield()
			end
			genome.networks = {} --reset networks to save on RAM
			pool.totalTime = pool.totalTime + fitstate.frame
			turboOutput()
			timerOutput()
			return false
		end
		if fitstate.timeout > fitstate.rightmost/3+basetimeout and not ManualInput then --timeout threshold increases throughout level. kill if timeout is enabled and timer is not frozen
			genome.networks = {} --reset networks to save on RAM
			if Replay then return false end
			pool.attempts = pool.attempts + 1
			addToHistogram()
			deathCounterOutput()
			turboOutput()
			timerOutput()
			pool.totalTime = pool.totalTime + fitstate.frame
			return false
		end
		if memory.readbyte(0x0014) == 1 then --if he beats the level
			print("beat level")
			genome.fitstate.fitness = genome.fitstate.fitness + 1000
			genome.networks = {} --reset networks to save on RAM
			if Replay then return true end
			pool.totalTime = pool.totalTime + fitstate.frame
			addToHistogram()
			TurboMin = 0
			TurboMax = 0
			turboOutput()
			battle = false
			return true
		end
		if (marioMusic == 0x50 or marioMusic == 0xB0) and not boss then
			print('activate final state')
			genome.fitstate.fitness = genome.fitstate.fitness + 1000
			genome.networks = {} --reset networks to save on RAM
			if Replay then return true end
			pool.totalTime = pool.totalTime + fitstate.frame
			addToHistogram()
			TurboMin = 0
			TurboMax = 0
			turboOutput()
			--print('playboss')
			memory.writebyte(0x0715,0) --set score to 0
			memory.writebyte(0x0716,0)
			memory.writebyte(0x0717,0)
			bosssavestateObj = savestate.object(savestateSlotBOSS)
			savestate.save(bosssavestateObj)
			savestate.persist(bosssavestateObj)
			startboss = true
			return false
		end
		if (marioMusic ~= 0x50 and marioMusic ~= 0xB0 and koopalingDefeated == 0) and boss then
			genome.fitstate.fitness = genome.fitstate.fitness + 1000
			genome.networks = {} --reset networks to save on RAM
			for x=1,800 do
				coroutine.yield()
			end
			
			if Replay then return true end
			pool.totalTime = pool.totalTime + fitstate.frame
			addToHistogram()
			TurboMin = 0
			TurboMax = 0
			turboOutput()
			return true
		end
		if koopalingDefeated > 0 and boss then
			print("second")
			-- print(marioMusic)
			-- print(koopalingDefeated)
			genome.fitstate.fitness = genome.fitstate.fitness + 1000
			genome.networks = {} --reset networks to save on RAM
			while koopalingDefeated == 1 do
				koopalingDefeated = memory.readbyte(0x07BD)
				coroutine.yield()
			end
			while koopalingDefeated == 2 do
				koopalingDefeated = memory.readbyte(0x07BD)
				searchstaff()
			end
			while koopalingDefeated > 1 do
				koopalingDefeated = memory.readbyte(0x07BD)
				coroutine.yield()
			end
			while kingconvo < 4 do
				getPositions()
				coroutine.yield()
			end
			if kingconvo == 4 then
				for a=1,60 do
					coroutine.yield()
				end
				joypad.set(Player,{A = true})
				coroutine.yield()
				joypad.set(Player,{A = false})
			end
			if Replay then return true end
			pool.totalTime = pool.totalTime + fitstate.frame
			addToHistogram()
			TurboMin = 0
			TurboMax = 0
			turboOutput()
			return true
		end
	end
end

function playSpecies(species,showBest) --Plays through all members of a species
	spindicatorOutput(species)
	local startGenome = 2 --which genome to start showing from
	local oldBest = 0
	if showBest or not species.genomes[1].fitstate.fitness then
		startGenome = 1
		oldBest = species.maxFitness --used to make sure staleness does not reset every run if showBest is toggled on always
		species.maxFitness = 0
		species.maxRightmost = 0
	end
	speciesDataOutput()
	for g=startGenome,#species.genomes do --loop through each genome
		local genome = species.genomes[g]
		pool.currentGenome = g
		local won = playGenome(genome) --test the genome
		if genome.fitstate.fitness + 30 > pool.maxFitness then --if it has gotten very close to the max
			pool.maxCounter = pool.maxCounter + 1
		end
		if genome.fitstate.fitness > pool.maxFitness then --if the fitness is the new best
			if species.gsid ~= pool.bestSpecies then --change the second best if the current best is a different species
				pool.secondFitness = pool.maxFitness
			end
			if genome.fitstate.fitness > pool.maxFitness + MajorBreakFitness or genome.fitstate.fitness > pool.lastMajorBreak + MajorBreakFitness*4 then
				--Counts as a major breakthrough
				pool.lastMajorBreak = genome.fitstate.fitness
				pool.bottleneck = 0
				pool.bottleneckloops = 0
				pool.lastbreaktime = pool.realTime
			end
			pool.bestSpecies = species.gsid --update the best species number
			pool.maxFitness = genome.fitstate.fitness --update the best fitness
			writeBreakthroughOutput()
		elseif genome.fitstate.fitness > pool.secondFitness then --if the fitness is the new second best
			if species.gsid ~= pool.bestSpecies then --change the second best if this is not the current best species
				pool.secondFitness = genome.fitstate.fitness
			end
		end
		--print("end calculation fitness: " .. genome.fitstate.fitness)
		if genome.fitstate.fitness > species.maxFitness then --update the species max fitness
			species.maxFitness = genome.fitstate.fitness
			species.breakthroughX = marioX
			species.breakthroughZ = genome.fitstate.area
			spindicatorOutput(species)
			if genome.fitstate.fitness > oldBest then
				species.staleness = 0 --reset the staleness
			end
		end
		if genome.fitstate.rightmost > species.maxRightmost then --update the species max right
			species.maxRightmost = genome.fitstate.rightmost
		end
		if startboss then
			saveGenome("winner",true)
			startboss = false
			PlayBoss()
			won = true
		end
		pool.current = pool.current +1
		pool.total = pool.total + genome.fitstate.fitness
		pool.average = math.ceil(pool.total/pool.current)
		if won then return true end --return true if we won
	end
	return false --return false otherwise
end

function playGeneration(showBest) --Plays through the entire generation
	local NumberWinner = numberWinner
	pool.maxCounter = 0
	pool.current = 0
	pool.total = 0
	for s=1,#pool.species do
		local species = pool.species[s]
		
		pool.currentSpecies = s
		if s > NumberWinner and NumberWinner ~= -1 then
			if not currentTurbo then
				currentTurbo = true
				emu.speedmode("turbo")
			end
			numberWinner = -1
		end
		if playSpecies(species,showBest) then
			return true
		end
	end
	return false
end

--File Outputs
function deathCounterOutput()
	fileDeaths = io.open("deaths.txt","w")
	fileDeaths:write(pool.deaths)
	fileDeaths:close()
	fileAttempts = io.open("attempts.txt","w")
	fileAttempts:write(pool.attempts)
	fileAttempts:close()
end

function speciesDataOutput()
	local species = pool.species[pool.currentSpecies]
	speciesdata = "GSID: "..species.gsid.." SMax: "..species.maxFitness.." Stale: "..species.staleness
	if species.nick ~= "" then
		speciesdata = speciesdata.." Nick: "..species.nick
	end
	fileSData = io.open("speciesdata.txt","w")
	fileSData:write(speciesdata)
	fileSData:close()
end

function mapupdate()
	io.open("../mapupdate.txt","w"):close()
end

function mapupdateHist()
	local f = io.open("../mapupdate.txt","w")
	f:write("hist")
	f:close()
end

function spindicatorOutput(species)
	fileIPos = io.open("spindicatorpos.txt","w")
	fileIPos:write(species.breakthroughX.." "..species.breakthroughZ)
	fileIPos:close()
	pcall(mapupdate)
end

function indicatorOutput()
	fileIPos = io.open("indicatorpos.txt","w")
	fileIPos:write(pool.breakthroughX.." "..pool.breakthroughZ)
	fileIPos:close()
	pcall(mapupdate)
end

function addToHistogram()
	local i = math.floor(marioX/32)
	key = i.." "..pool.species[pool.currentSpecies].genomes[pool.currentGenome].fitstate.area
	if not pool.maphistogram[key] then
		pool.maphistogram[key] = 0
	end
	pool.maphistogram[key] = pool.maphistogram[key] + 1
end

function histogramOutput()
	fileHistogram = io.open("histogram.txt","w")
	for key,count in pairs(pool.maphistogram) do
		fileHistogram:write(key.." "..count.."\n")
	end
	fileHistogram:close()
end

function writeBreakthroughOutput()
	local species = pool.species[pool.currentSpecies]
	local genome = species.genomes[pool.currentGenome]
	info = tostring(pool.generation)
	for i=1 ,4-string.len(info) do info=info.." " end
	info = info..tostring(pool.currentSpecies)
	for i=1,9-string.len(info) do info=info.." " end
	info = info..tostring(pool.currentGenome)
	for i=1,13-string.len(info) do info=info.." " end
	info = info..tostring(species.gsid)
	for i=1,18-string.len(info) do info=info.." " end
	info = info..tostring(math.floor(genome.fitstate.fitness))
	for i=1,23-string.len(info) do info=info.." " end
	local seconds = pool.realTime
	local minutes = math.floor(seconds/60)
	seconds = seconds - minutes*60
	local hours = math.floor(minutes/60)
	minutes = minutes - hours*60
	local days = math.floor(hours/24)
	hours = hours - days*24
	if pool.realTime < 3600 then
		info=info..minutes.."m"..seconds.."s"
	elseif pool.realTime < 86400 then
		info=info..hours.."h"..minutes.."m"
	else
		info=info..days.."d"..hours.."h"
	end
	pool.history=pool.history..info.."\n"
	fileFTracker = io.open("fitnesstracker.txt","w")
	fileFTracker:write(pool.history)
	fileFTracker:close()
	
	pool.breakthroughX = marioX
	pool.breakthroughZ = genome.fitstate.area
	if boss then
		saveGenome("Boss-G"..pool.generation.."s"..pool.currentSpecies.."g"..pool.currentGenome,false)
	else
		saveGenome("G"..pool.generation.."s"..pool.currentSpecies.."g"..pool.currentGenome,false)
	end
	
	indicatorOutput()
end

function levelNameOutput()
	getPositions()
	fileLevel = io.open("level.txt","w")
	
	fileLevel:write(levelname)
	fileLevel:close()
end

function turboOutput()
	fileTurbo = io.open("turbo.txt","w")
	if TurboMin == 0 then
		fileTurbo:write("T="..TurboMax)
	else
		fileTurbo:write("T="..TurboMin.."\nto "..TurboMax)
	end
	fileTurbo:close()
end

function twoDigit(num)
	str = tostring(num)
	if string.len(str) == 1 then
		str = "0"..str
	end
	return str
end

function numToTime(seconds)
	local minutes = math.floor(seconds/60)
	seconds = seconds - minutes*60
	local hours = math.floor(minutes/60)
	minutes = minutes - hours*60
	local days = math.floor(hours/24)
	hours = hours - days*24
	return days.."d "..twoDigit(hours)..":"..twoDigit(minutes)..":"..twoDigit(seconds)
end

function timerOutput()
	fileRealTime = io.open("realtime.txt","w")
	fileGameTime = io.open("gametime.txt","w")
	pool.realTime = os.time()-ProgramStartTime
	fileRealTime:write(numToTime(pool.realTime))
	fileGameTime:write(numToTime(math.floor(pool.totalTime/FPS)))
	fileRealTime:close()
	fileGameTime:close()
end

function fitnessDataOutput()
	rankGlobally()
	local fitnesses = {}
	local genAvg = 0
	local smaxAvg = 0
	local minGsid = 1000000
	local maxGsid = 0
	for s,species in pairs(pool.species) do
		for g,genome in pairs(species.genomes) do
			fitnesses[genome.globalRank] = genome.fitstate.fitness
			genAvg = genAvg + genome.fitstate.fitness
		end
		smaxAvg = smaxAvg + species.maxFitness
		if species.gsid > maxGsid then maxGsid = species.gsid end
		if species.gsid < minGsid then minGsid = species.gsid end
	end
	local genMin = fitnesses[1]
	local genBqt = fitnesses[math.floor(#fitnesses/4)]
	local genMed = fitnesses[math.floor(#fitnesses/2)]
	local genTqt = fitnesses[math.floor(3*#fitnesses/4)]
	local genMax = fitnesses[#fitnesses]
	local genAvg = genAvg / #fitnesses
	local smaxAvg = smaxAvg / #pool.species
	local smaxSdv = 0
	for s,species in pairs(pool.species) do
		smaxSdv = smaxSdv + (species.maxFitness - smaxAvg)*(species.maxFitness - smaxAvg)
	end
	smaxSdv = math.sqrt(smaxSdv / #pool.species)
	local avgSdv = 0
	for f,fitness in pairs(fitnesses) do
		avgSdv = avgSdv + (fitness-genAvg)*(fitness-genAvg)
	end
	avgSdv = math.sqrt(avgSdv / #fitnesses)
	os.remove("data"..dirsep..levelname..dirsep.."data"..(pool.generation+1)..".drd")
	fileDRD = io.open("data"..dirsep..levelname..dirsep.."data"..pool.generation..".drd","w")
	fileDOut = io.open("discorddataout.txt","w")
	fileDRD:write(#fitnesses.." "..pool.population.." "..#pool.species.." ")
	fileDOut:write("**Generation: `"..pool.generation.."`** Target Pop: `"..pool.population.."` Actual Pop: `"..#fitnesses.."` Number of Species: `"..#pool.species.."` ")
	fileDRD:write(genMin.." "..genBqt.." "..genMed.." "..genTqt.." "..genMax.." ")
	fileDOut:write("Minimum: `"..genMin.."` Median: `"..genMed.."` Maximum: `"..genMax.."` ")
	fileDRD:write(genAvg.." "..avgSdv.." "..smaxAvg.." "..smaxSdv.."\n")
	fileDOut:write("Average: `"..genAvg.."` Standard Deviation: `"..avgSdv.."` Average Max: `"..smaxAvg.."`\n")
	for gsid=minGsid,maxGsid do
		for s,species in pairs(pool.species) do
			if species.gsid == gsid then
				local speciesRanks = {}
				for g,genome in pairs(species.genomes) do
					table.insert(speciesRanks, genome) --Insert every genome into the table
				end
				table.sort(speciesRanks, function (a,b) --Sort based on fitness
					return (a.fitstate.fitness < b.fitstate.fitness)
				end)
				local specAvg = 0
				local sfitnesses = {}
				for g=1,#speciesRanks do --Put position of each genome into that genome's data
					sfitnesses[g] = speciesRanks[g].fitstate.fitness
					specAvg = specAvg + speciesRanks[g].fitstate.fitness 
				end
				local specMin = sfitnesses[1]
				local specBqt = sfitnesses[math.ceil(#sfitnesses/4)]
				local specMed = sfitnesses[math.ceil(#sfitnesses/2)]
				local specTqt = sfitnesses[math.ceil(3*#sfitnesses/4)]
				local specMax = sfitnesses[#sfitnesses]
				specAvg = specAvg / #sfitnesses
				local specSdv = 0
				for f,fitness in pairs(sfitnesses) do
					specSdv = specSdv + (fitness-specAvg)*(fitness-specAvg)
				end
				specSdv = math.sqrt(specSdv / #sfitnesses)
				fileDRD:write(species.gsid.." "..#species.genomes.." "..#species.genomes[1].genes.." ")
				fileDRD:write(specMin.." "..specBqt.." "..specMed.." "..specTqt.." "..specMax.." "..specAvg.." "..specSdv)
				for f,fitness in pairs(sfitnesses) do
					fileDRD:write(" "..fitness)
				end
				fileDRD:write("\n")
				if species.nick ~= "" then
					fileDOut:write("Nickname: `"..species.nick.."` Maximum: `"..specMax.."` ")
					fileDOut:write("Staleness: `"..species.staleness.."` Average: `"..specAvg.."` ")
					fileDOut:write("Number of Genomes: `"..#sfitnesses.."` Num Networks: `"..#species.genomes[1].genes.."`\n")					
				end
			end
		end
	end
	fileDRD:close()
	fileDOut:close()
end

keyFlag = false
function keyboardInput()
	local keyboard = input.get()
	if keyboard['N'] and keyFlag == false then --N toggles the network display
        DisplayNetwork = not DisplayNetwork
    end
	if keyboard['R'] and keyFlag == false then --R toggles the sprite hitboxes
        DisplaySprites = not DisplaySprites
    end
	if keyboard['G'] and keyFlag == false then --G toggles the large grid display
        DisplayGrid = (DisplayGrid + 1) % 3
    end
	if keyboard['O'] and keyFlag == false then --O toggles the sprite slots
		DisplaySlots = not DisplaySlots
	end
	if keyboard['A'] and keyFlag == false then --A toggles the top stats bar
		DisplayStats = not DisplayStats
	end
	if keyboard['M'] and keyFlag == false then --M toggles manual vs network input
		ManualInput = not ManualInput
	end
	if keyboard['E'] and keyFlag == false then --E toggles 
		DisplayRanges = not DisplayRanges
	end
	if keyboard['C'] and keyFlag == false then --E toggles 
		DisplayCounters = not DisplayCounters
	end
	if keyboard['L'] and keyFlag == false then --L loads
		--to load put an interrupt that will restart the program and initialize with the previous pool
		local interrupt = io.open("interrupt.lua","w")
		interrupt:write("restartprog = luigiofilename")
		interrupt:close()
		local initialize = io.open("initialize.lua","w")
		initialize:write("loadPool('backups' .. dirsep .. 'current.lua')")
		initialize:close()
	end
	local controller = {}
	controller['A'] = keyboard['F']
	controller['B'] = keyboard['D']
	controller['up'] = keyboard['up']
	controller['down'] = keyboard['down']
	controller['left'] = keyboard['left']
	controller['right'] = keyboard['right']
	if controller["up"] and controller["down"] then
		controller["up"] = false
		controller["down"] = false
	end
	if controller["left"] and controller["right"] then
		controller["left"] = false
		controller["right"] = false
	end
	local allkeys = {'N','R','G','O','A','M','E','C','L'}
	keyFlag = false --Set keyflag to true if any keys were pressed otherwise it is false
	for k=1,#allkeys do
		if keyboard[allkeys[k]] then
			keyFlag = true
		end
	end
	return controller
end

function drawStatsBox(fitstate)
	local genimage = {' ####  #### ##  ## ','##---##----#--##--#','#--####--###---#--#','#--#--#----#------#','#--#--#--###--#---#','##----#----#--##--#','  #### #### ##  ## '}
	local specimage = {' ##### ##### ####  ### ## ####  #### ','##----#----##----##---#--#----##----#','#--####--#--#--###--###--#--###--### ','##---##----##----#--###--#----##---##','####--#--## #--###--###--#--######--#','#----##--#  #----##---#--#----#----# ',' ##### ##    ####  ### ## #### ####  '}
	local gnmimage = {' ##### #### ##  ## #####  ######  #### ','##---##----#--##--##---####--#--##----#','#--####--###---#--#--#--#--------#--###','#--#--#----#------#--#--#--#--#--#----#','#--#--#--###--#---#--#--#--#--#--#--###','##----#----#--##--##---##--#--#--#----#','  #### #### ##  ## ##### ## ## ## #### '}
	local popimage = {' ##### ##### ##### ','#----###---##----##','#--#--#--#--#--#--#','#----##--#--#----##','#--####--#--#--##  ','#--#  ##---##--#   ',' ##    ##### ##    '}
	local fitimage = {' #### ## ###### ##  ## ####  #### #### ','#----#--#------#--##--#----##----#----#','#--###--###--###---#--#--###--###--### ','#----#--# #--# #------#----##---##---##','#--###--# #--# #--#---#--######--###--#','#--###--# #--# #--##--#----#----#----# ',' ##   ##   ##  #### ####### #### ##### '}
	local firstimage = {' ###   #### ###### ','#---###----#------#','##--##--### ##--## ','##--###---#  #--#  ','##--#####--# #--#  ','#----#----#  #--#  ',' #### ####    ##   '}
	local secondimage = {'  ####  ##   ## ####   ','##----##--###--#----## ','#--##--#---##--#--#--# ','###--###----#--#--##--#','##--####--#----#--#--# ','#-----##--##---#----## ',' #####  ##  ### ####   '}
	local maxnumimage = {' #####  #####    ####  ##  ## ','##-#-###--#--####----##--##--#','#-----#--------#--##--#--##--#','##-#-##--#--#--#------##----##','#-----#--#--#--#--##--#--##--#','##-#-##--#--#--#--##--#--##--#',' ##### #######################'}
	local avgxbar = {' #######                 ','#-------#                ',' #######                 ','#--# #--# #### ## ###### ','#--###--##----#--#------#',' #--#--# #--###--###--## ','  #---#  #----#--# #--#  ',' #--#--# #--###--# #--#  ','#--###--##--###--# #--#  ','#--###--##--###--# #--#  ',' ### ###  ##   ##   ##   '}
	local draw = draw
	local pool = pool 
	local fl = math.floor
	if currentTurbo then
		gui.drawrect(8,194,254,230,draw.CYAN,draw.WHITE)
		gui.text(10, 197, "GEN "..pool.generation .. " Species "..pool.currentSpecies.." Genome "..pool.currentGenome, draw.GRAYSCALE, draw.CYAN)
		gui.text(10, 210, "Fitness "..math.max(0,fl(fitstate.fitness)) .. " 1ST "..fl(pool.maxFitness).." 2ND "..fl(pool.secondFitness), draw.GRAYSCALE, draw.CYAN)
		gui.text(10, 222, "#Max "..pool.maxCounter .. " XFit "..pool.average, draw.GRAYSCALE, draw.CYAN)
	else
		-- draw.rect(8,194,32,1,draw.BLACK)
		-- draw.rect(9,195,246,36,draw.WHITE)
		-- draw.rect(10,196,244,34,draw.CYAN)
		gui.drawrect(8,194,254,230,draw.CYAN,draw.WHITE)
		gui.drawrect(230,204,251,207,draw.GRAYSCALE,draw.CYAN)
		--draw.rect(230,205,21,2,draw.BLACK)
		draw.image(10,197,genimage,draw.GRAYSCALE)
		draw.number(31,197,pool.generation,3)
		draw.image(65,197,specimage,draw.GRAYSCALE)
		draw.number(104,197,pool.currentSpecies,3)
		draw.image(138,197,gnmimage,draw.GRAYSCALE)
		draw.number(179,197,pool.currentGenome,3)
		--draw.image(176,198,brackets,draw.GRAYSCALE)
		--draw.number(182,198,19,2)
		draw.image(207,202,popimage,draw.GRAYSCALE)
		draw.number(229,197,pool.current,3)
		draw.number(229,208,pool.population,3)
		draw.image(10,210,fitimage,draw.GRAYSCALE)
		draw.number(50,210,math.max(0,fitstate.fitness),4)
		draw.image(88,210,firstimage,draw.GRAYSCALE)
		draw.number(108,210,pool.maxFitness,4)
		draw.image(147,210,secondimage,draw.GRAYSCALE)
		draw.number(171,210,pool.secondFitness,4)
		draw.image(10,222,maxnumimage,draw.GRAYSCALE)
		draw.number(43,222,pool.maxCounter,3)
		draw.image(81,218,avgxbar,draw.GRAYSCALE)
		draw.number(109,222,pool.average,4)
	end
end

arrowimage = {'###     ','#--##   ','#----## ','#------#','#----## ','#--##   ','###     '}
pmeterimage = {' ############# ','##-----------##','#----#####----#','#----#---#----#','#----####-----#','##---#-------##',' ############# '}
reversePalette = {[' ']=0,['#']=draw.WHITE,['-']=draw.BLACK}
function drawPMeter(x,y)
	local pStatus = memory.readbyte(0x03DD)
	local currentPalette = draw.GRAYSCALE
	for i=1,6 do
		if pStatus < math.pow(2,i)-1 then
			currentPalette = reversePalette
		end
		draw.image(x-8+i*12,y,arrowimage,currentPalette)
	end
	if pStatus < 127 then currentPalette = reversePalette end
	draw.image(x+75,y,pmeterimage,currentPalette)
end

clockimage = {'  ####  ',' #-#--# ','#--#---#','#--###-#','#------#',' #----# ','  ####  '}
function drawClock(x,y)
	local timeLeft = memory.readbyte(0x05EE)*100+memory.readbyte(0x05EF)*10+memory.readbyte(0x05F0)
	draw.image(x,y,clockimage,draw.GRAYSCALE)
	draw.number(x+8,y,timeLeft,3)
end

function drawNeuron(network,neuron)
	if neuron.x then
		inside = draw.tcolor(0x01010100*math.floor(127*(neuron.value+1))+0xE6)
		border = draw.tcolor(0x01010100*math.floor(127*(1-neuron.value))+0xE6)
		if neuron.blocked then inside = draw.tcolor(0xFF3F00E6) end
		if neuron.value ~= 0 then
			draw.rect(neuron.x,neuron.y,5,5,border)
			draw.rect(neuron.x+1,neuron.y+1,3,3,inside)
		else
			draw.rect(neuron.x,neuron.y,5,5,draw.tcolor(0x7F7FCFC7))
		end
		if neuron.incoming then
			for g,gene in pairs(neuron.incoming) do
				if gene.enabled then
					local n1 = network.neurons[gene.into]
					local layerdiff = neuron.layer - n1.layer
					--Green or red for positive or negative weight
					local color = 0x3FFF00
					if gene.weight < 0 then
						color = 0xFF3F00
					end
					local opacity = 0xCF
					if gene.into > BoxSize and gene.into <= Inputs then --fade or remove if bottom-row neuron
						if #network.genes > 100 then
							opacity = 0x00
						elseif #network.genes > 50 then
							opacity = 0x5F
						end
					end
					if n1.value == 0 then --fade or remove if not transmitting a value
						if #network.genes > 50 then
							opacity = 0x00
						else
							opacity = 0x5F
						end
					end
					--draw the genome
					if n1.x and n1.layer > 0 then
						gui.drawline(n1.x+4,n1.y+2,neuron.x,neuron.y+2, draw.tcolor(256*color+opacity))
					end
				end
			end
		end
	end
end

charAimage = {' #### ','##--##','#-##-#','#----#','#-##-#','#-##-#',' #### '}
charBimage = {' #### ','#---##','#-##-#','#---##','#-##-#','#---##',' #### '}
charUimage = {' #### ','#-##-#','#-##-#','#-##-#','#-##-#','##--##',' #### '}
charDimage = {' #### ','#---##','#-##-#','#-##-#','#-##-#','#---##',' #### '}
charLimage = {' #### ','#-####','#-####','#-####','#-####','#----#',' #### '}
charRimage = {' #### ','#---##','#-##-#','#---##','#-#-##','#-##-#',' #### '}
buttonImages = {charAimage,charBimage,charUimage,charDimage,charLimage,charRimage}
function drawNetwork(network)
	local neurons = {} --Array that will contain the position and value of each displayed neuron
	local i = 1
	local ButtonNumbers = ButtonNumbers
	local buttonImages = buttonImages
	for dy=-BoxRadius,BoxRadius do --Add the input box neurons
		for dx=-BoxRadius,BoxRadius do
			network.neurons[i].x = 8+5*(dx+BoxRadius)
			network.neurons[i].y = 20+5*(dy+BoxRadius)
			i = i + 1
		end
	end
	
	local botRowSpacing = 10 --Number of pixels between oscillating nodes
		
	local botRowSize = (3 + #InitialOscillations)*2 - 1
	if botRowSize > BoxWidth then
		botRowSpacing = 5 --If bottom row can't fit then have no spacing
	end
	
	for j=0,#InitialOscillations do --Add the bias and oscillation neurons
		network.neurons[i].x = 3+BoxWidth*5-botRowSpacing*j
		network.neurons[i].y = 25+BoxWidth*5
		i = i + 1
	end
	
	for j=0,1 do --Add the bias and oscillation neurons
		network.neurons[i].x = 8+botRowSpacing*j
		network.neurons[i].y = 25+BoxWidth*5
		i = i + 1
	end
	
	for l=1,#network.layers do --Draw each layer in the NN
		local layer = network.layers[l]
		for n=1,#layer do
			if l > 1 or layer[n] > Inputs then --display only non-inputs in layer 1
				network.neurons[layer[n]].x = math.ceil(13+BoxWidth*5+(220-BoxWidth*5)*((l-1) / (#network.layers)))
				network.neurons[layer[n]].y = math.ceil(20+(BoxWidth+1)*5*(n / (#layer+1)))
			end
		end
	end
	
	--When to block opposite directional inputs
	local blockUD = network.neurons[-3] ~= nil and network.neurons[-4] ~= nil and network.neurons[-3].value>0 and network.neurons[-4].value>0
	local blockLR = network.neurons[-5] ~= nil and network.neurons[-6] ~= nil and network.neurons[-5].value>0 and network.neurons[-6].value>0
	local fb = {}
	if forcebutton ~= nil then
		for k,v in pairs(forcebutton) do
			fb[ButtonNumbers[k]] = v
		end
	end
	local neuron = {}
	for o=1,6 do --outputs
		neuron = {}
		neuron.x = 238
		neuron.y = 25+(BoxWidth-1)*(o-1)
		neuron.value = -1
		local onode = network.neurons[-o]
		if onode and onode.value > 0 then neuron.value = 1 end
		if blockUD and (o == 3 or o == 4) then neuron.blocked = true end
		if blockLR and (o == 5 or o == 6) then neuron.blocked = true end
		if fb[o] ~= nil then
			if fb[0] then
				neuron.value = 1
			else
				neuron.value = -1
			end
		end
		drawNeuron(network,neuron)
		draw.image(246,24+(BoxWidth-1)*(o-1),buttonImages[o],draw.GRAYSCALE)
		if onode ~= nil and network.neurons[o].layer ~= 0 and onode.x then
			if neuron.value == 0 then --draw line between output and ouput box.
				gui.drawline(onode.x+4,onode.y+2,neuron.x,neuron.y+2,draw.tcolor(0x3FFF005F)) --fade if not sending anything
			else	
				gui.drawline(onode.x+4,onode.y+2,neuron.x,neuron.y+2,draw.tcolor(0x3FFF00CF))
			end
		end
	end
	
	for n,neuron in pairs(network.neurons) do
		drawNeuron(network,neuron)
	end
end

function drawRanges()
	local levelstring = levelname
	local ranges = Ranges[levelstring.."-"..fitstate.area]
	local marioX = marioX
	local marioScreenX = marioScreenX
	local marioY = marioY
	local marioScreenY = marioScreenY
	if ranges ~= nil then
		for r=1,#ranges do
			--default values for parts without ranges
			local minx = 0
			local maxx = 65536
			local miny = 0
			local maxy = 240
			local disp = true
			local range = ranges[r]
			--if range limits exist set the limits to those
			if range.xrange.min ~= nil then minx = range.xrange.min end
			if range.xrange.max ~= nil then maxx = range.xrange.max end
			if range.yrange.min ~= nil then miny = range.yrange.min end
			if range.yrange.max ~= nil then maxy = range.yrange.max end
			
			--set color based on the direction of fitness increase
			local rgb = 0x003FFF
			textcolor = toRGBA(0xFFFFFFFF)
			if range.area ~= nil then
				rgb=0xFF00FF
			elseif range.coeffs ~= nil then
				if range.coeffs.x == 1 and range.coeffs.y == 1 and range.coeffs.c ~=0 then
					rgb=0xE5FF00
					textcolor = toRGBA(0xFF000000)
				end
				if range.coeffs.x >0 and range.coeffs.y==0 then
					rgb=0X0FFF1B
				end
				if range.coeffs.y > 0 and range.coeffs.x <1 then
					rgb=0x0F37FF
				end
				if range.coeffs.x == 0 and range.coeffs.y == 0 then
					rgb=0xFF3F00
				end
				if range.coeffs.y <0 then
					rgb=0xFFBF00
				end
				if range.coeffs.x < 0 then
					rgb=0xBF7F00
				end
			elseif range.timeout ~= nil then
				rgb=0x42AAFF
			end
			if rgb~=0x003FFF then
				color = toRGBA(0xFF000000 + rgb)
				--draw the box
				if marioY + marioScreenY == 161 and memory.readbyte(0x0544) == 0 then
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny,maxx-marioX+marioScreenX-2,193-maxy-1,toRGBA(0x7F000000 + rgb),toRGBA(0x7F000000 + rgb))
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny,minx-marioX+marioScreenX-1,193-maxy-1,color,color)
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny,maxx-marioX+marioScreenX-2,193-miny,color,color)
					gui.drawbox(minx-marioX+marioScreenX-1,193-maxy-1,maxx-marioX+marioScreenX-2,193-maxy-1,color,color)
					gui.drawbox(maxx-marioX+marioScreenX-2,193-miny,maxx-marioX+marioScreenX-2,193-maxy-1,color,color)
					--draw the numbers in the corners that show the fitness values
					--local TLcorner = minx*range.coeffs.x+(208-miny)*range.coeffs.y+range.coeffs.c
					--local TRcorner = maxx*range.coeffs.x+(208-miny)*range.coeffs.y+range.coeffs.c
					--local BLcorner = minx*range.coeffs.x+(192-maxy)*range.coeffs.y+range.coeffs.c
					--local BRcorner = maxx*range.coeffs.x+(192-maxy)*range.coeffs.y+range.coeffs.c
					-- gui.drawtext(minx-marioX+marioScreenX,miny+1,TLcorner,textcolor,color)
					-- gui.drawtext(maxx-marioX+marioScreenX-6*string.len(TRcorner)-1,miny+1,TRcorner,textcolor,color)
					-- gui.drawtext(minx-marioX+marioScreenX,maxy-8,BLcorner,textcolor,color)
					-- gui.drawtext(maxx-marioX+marioScreenX-6*string.len(TRcorner)-1,maxy-8,BRcorner,textcolor,color)
				else
					local offset = 161 - (marioY + marioScreenY)
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny-offset,maxx-marioX+marioScreenX-2,193-maxy-1-offset,toRGBA(0x7F000000 + rgb),toRGBA(0x7F000000 + rgb))
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny-offset,minx-marioX+marioScreenX-1,193-maxy-1-offset,color,color)
					gui.drawbox(minx-marioX+marioScreenX-1,193-miny-offset,maxx-marioX+marioScreenX-2,193-miny-offset,color,color)
					gui.drawbox(minx-marioX+marioScreenX-1,193-maxy+1-offset,maxx-marioX+marioScreenX-2,193-maxy-1-offset,color,color)
					gui.drawbox(maxx-marioX+marioScreenX-2,193-miny-offset,maxx-marioX+marioScreenX-2,193-maxy-1-offset,color,color)
				end
			end
		end
	end
end

function displayGUI(network,fitstate)
	if DisplayRanges then
		drawRanges()
	end
	if DisplayStats then
		drawStatsBox(fitstate)
		if not currentTurbo then
			drawPMeter(159,222)
			--drawClock(222,10)
		end
	end

	if DisplayNetwork and not currentTurbo then
		drawNetwork(network)
	end
end

function worldselection()
	local selecting = true
	local selection = 1
	local color = draw.BLACK
	local z = 0
	local c = 0
	for i=1,70 do
		draw.rect(8,204-i,248,22+i,draw.BLACK)
		draw.rect(9,205-i,246,20+i,draw.WHITE)
		draw.rect(10,206-i,244,18+i,draw.CYAN)
		gui.text(12, 208-i, "Please select a world. Use !press up/down to \nnavigate and !press A to select and B to cancel", draw.BLACK, draw.CYAN)
		color = draw.BLACK
		for x=1,8 do
			if file_exists("fcs"..dirsep.."world-" .. x .. ".fcs") then
				color = draw.BLACK
			else
				color = draw.RED
			end
			if x < 5 then
				z = x
				c = 0
			else
				z = x -4
				c = 80
			end
			if x == selection then
				gui.text(12+c, 216+16*z-i, "> World: ".. x, color, draw.CYAN)
			else
				gui.text(12+c, 216+16*z-i, "World: ".. x, color, draw.CYAN)
			end
		end
		coroutine.yield()
	end
	while selecting do
		draw.rect(8,134,248,94,draw.BLACK)
		draw.rect(9,135,246,92,draw.WHITE)
		draw.rect(10,136,244,90,draw.CYAN)
		gui.text(12, 138, "Please select a world. Use !press up/down to \nnavigate and !press A to select and B to cancel", draw.BLACK, draw.CYAN)
		color = draw.BLACK
		for x=1,8 do
			if file_exists("fcs"..dirsep.."world-" .. x .. ".fcs") then
				color = draw.BLACK
			else
				color = draw.RED
			end
			if x < 5 then
				z = x
				c = 0
			else
				z = x -4
				c = 80
			end
			if x == selection then
				gui.text(12+c, 146+16*z, "> World: ".. x, color, draw.CYAN)
			else
				gui.text(12+c, 146+16*z, "World: ".. x, color, draw.CYAN)
			end
		end
		if file_exists("userinput.lua") then
			userinput=loadfile("userinput.lua")
			if userinput then
				os.remove('userinput.lua')
				uinput = {}
				pcall(userinput)
				if uinput.down then
					selection = selection + 1
					if selection > 8 then
						selection = 1
					end
				elseif uinput.up then
					selection = selection - 1
					if selection <1 then
						selection = 8
					end
				elseif uinput.left then
					selection = selection -4
					if selection <1 then
						selection = selection + 8
					end
				elseif uinput.right then
					selection = selection +4
					if selection >8 then
						selection = selection - 8
					end
				elseif uinput.A and file_exists("fcs"..dirsep.."world-" .. selection .. ".fcs") then
					local interrupt = io.open("interrupt.lua","w")
					interrupt:write("savestateObj = savestate.object('fcs"..dirsep.."world-" .. selection ..".fcs')\nprint('one point five')\nsavestate.load(savestateObj)\nprint('two')")
					interrupt:close()
					for i=1,90 do
						draw.rect(8,134+i,248,94-i,draw.BLACK)
						draw.rect(9,135+i,246,92-i,draw.WHITE)
						draw.rect(10,136+i,244,90-i,draw.CYAN)
						gui.text(12, 138+i, "Please select a world. Use !press up/down to \nnavigate and !press A to select and B to cancel", draw.BLACK, draw.CYAN)
						color = draw.BLACK
						for x=1,8 do
							if file_exists("fcs"..dirsep.."world-" .. x .. ".fcs") then
								color = draw.BLACK
							else
								color = draw.RED
							end
							if x < 5 then
								z = x
								c = 0
							else
								z = x -4
								c = 80
							end
							if x == selection then
								gui.text(12+c, 146+16*z+i, "> World: ".. x, color, draw.CYAN)
							else
								gui.text(12+c, 146+16*z+i, "World: ".. x, color, draw.CYAN)
							end
						end
						coroutine.yield()
					end
					return
				elseif uinput.B then
					for i=1,90 do
						draw.rect(8,134+i,248,94-i,draw.BLACK)
						draw.rect(9,135+i,246,92-i,draw.WHITE)
						draw.rect(10,136+i,244,90-i,draw.CYAN)
						gui.text(12, 138+i, "Please select a world. Use !press up/down to \nnavigate and !press A to select and B to cancel", draw.BLACK, draw.CYAN)
						color = draw.BLACK
						for x=1,8 do
							if file_exists("fcs"..dirsep.."world-" .. x .. ".fcs") then
								color = draw.BLACK
							else
								color = draw.RED
							end
							if x < 5 then
								z = x
								c = 0
							else
								z = x -4
								c = 80
							end
							if x == selection then
								gui.text(12+c, 146+16*z+i, "> World: ".. x, color, draw.CYAN)
							else
								gui.text(12+c, 146+16*z+i, "World: ".. x, color, draw.CYAN)
							end
						end
						coroutine.yield()
					end
					return
				end
			end
		end
		coroutine.yield()
	end
end

function SolveMemory()
	local Tset = memory.readbyte(0x070A)
	for a=1,60 do
		coroutine.yield()
	end
	while Tset == 17 do
		local index = memory.readbyte(0x428)
		local card = {}
		local selected = 0
		local selectedindex = 0
		for x=1,18 do
			card[x] = memory.readbyte(0x7E81+x)
		end
		if card[index+1] < 0x10 then
			joypad.set(Player,{A=true})
			for a=1,90 do
				coroutine.yield()
			end
			selected = card[index+1]
			selectedindex = index+1
			local desired = 0
			for i=1,#card do
				if card[i] == selected and i ~= selectedindex then
					desired = i-1
				end
			end
			while index ~= desired do
				if desired <6 then
					if index >=6 then
						joypad.set(Player,{up=true})
					elseif desired > index then
						joypad.set(Player,{right=true})
					else
						joypad.set(Player,{left=true})
					end
				elseif desired >= 12 then
					if index <12 then
						joypad.set(Player,{down=true})
					elseif desired > index then
						joypad.set(Player,{right=true})
					else
						joypad.set(Player,{left=true})
					end
				else
					if index >= 12 then
						joypad.set(Player,{up=true})
					elseif index < 6 then
						joypad.set(Player,{down=true})
					elseif desired > index then
						joypad.set(Player,{right=true})
					else
						joypad.set(Player,{left=true})
					end
				end
				for a=1,20 do
					coroutine.yield()
				end
				index = memory.readbyte(0x428)
			end
			joypad.set(Player,{A=true})
			for a=1,90 do
				coroutine.yield()
			end
		else
			joypad.set(Player,{right=true})
			for a=1,20 do
				coroutine.yield()
			end
		end
		Tset = memory.readbyte(0x070A)
	end
end

function writehumanlevel()
	local file = io.open("HumanLevelName.txt","w")
	local world = memory.readbyte(0x0727)+1
	file:write(world.."-" .. HumanLevelName)
	file:close()
end

function PlayBoss()
	boss = true
	roottimeout = roottimeoutboss
	local prevhistory
	if pool then prevhistory = pool.history end
	initPool(true)
	local file = io.open("backups"..dirsep.."winners.txt","r")
	i = 1
	if file then
		while true do
			winnername = file:read("*line")
			if not winnername then break end
			dofile(winnername)
			addToSpecies(loadedgenome)
			if pool.species[#pool.species].nick == '' then
				pool.species[#pool.species].nick = loadedgenome.nick
			else
				pool.species[#pool.species].nick = pool.species[#pool.species].nick .. "/" .. loadedgenome.nick
			end
			i=i +1
		end
	end
	for g=i,999 do
		local genome = newGenome(1)
		mutate(genome,1)
		addToSpecies(genome)
	end
	getPositions()
	local score = {memory.readbyte(0x0715),memory.readbyte(0x0716),memory.readbyte(0x0717)}
	memory.writebyte(0x0715,0) --set score to 0
	memory.writebyte(0x0716,0)
	memory.writebyte(0x0717,0)
	getTileset()
	indicatorOutput()
	if prevhistory then pool.history = prevhistory end
	redospectop = pool.generation % 10 == 0
	while not playGeneration(redospectop) do
		fitnessDataOutput()
		newGeneration()
		redospectop = pool.generation % 10 == 0
	end
	local score2 = {memory.readbyte(0x0715),memory.readbyte(0x0716),memory.readbyte(0x0717)}
	memory.writebyte(0x0715,score[1]+score2[1]) --restore score
	memory.writebyte(0x0716,score[2]+score2[2])
	memory.writebyte(0x0717,score[3]+score2[3])
	savestateBackup = savestate.object(savestateSlotMap)
	savestate.save(savestateBackup)
	savestate.persist(savestateBackup)
	histogramOutput()
	saveGenome("bosswinner",true)
end


function playLevel()
	roottimeout = 120
	boss = false
	battle = false
	writehumanlevel()
	writescene(1)
	local warppipe = false
	while memory.readbyte(0x0020) == 1 do
		coroutine.yield()
	end
	if memory.readbyte(0x05FD) == 2 then
		while memory.readbyte(0x05FD) == 2 do
			joypad.set(Player,{A = true})
			coroutine.yield()
			joypad.set(Player,{A = false})
			coroutine.yield()
		end
		for x=1,480 do
			coroutine.yield()
		end
	end
	local Tset = memory.readbyte(0x070A)
	if Tset == 7 then
		local TASTime = {0,25,50}
		if memory.readbyte(0x7971) == 1 then
			TASTime = {25}
		end
		for i=1,300 do
			coroutine.yield()
		end
		for i=1,50+TASTime[math.random(#TASTime)] do
			joypad.set(Player,{right = true})
			coroutine.yield()
		end
		joypad.set(Player,{right = false})
		joypad.set(Player,{B = true})
		coroutine.yield()
		for i=1,300 do
			joypad.set(Player,{B = false})
			coroutine.yield()
		end
		savestateBackup = savestate.object(savestateSlotMap)
		savestate.save(savestateBackup)
		savestate.persist(savestateBackup)
		return
	end

	local prevhistory
	if pool then prevhistory = pool.history end
	initPool(false)
	local file = io.open("backups"..dirsep.."winners.txt","r")
	local i = 1
	if file then
		while true do
			winnername = file:read("*line")
			if not winnername then break end
			dofile(winnername)
			addToSpecies(loadedgenome)
			if pool.species[#pool.species].nick == '' then
				pool.species[#pool.species].nick = loadedgenome.nick
			else
				pool.species[#pool.species].nick = pool.species[#pool.species].nick .. "/" .. loadedgenome.nick
			end
			i=i +1
		end
	end
	numberWinner = i
	for g=i,999 do
		local genome = newGenome(1)
		mutate(genome,1)
		addToSpecies(genome)
	end
	preloaded = false
	userreplay = false
	init = loadfile("initialize.lua")
	initializeclear = io.open("initialize.lua","w")
	if initializeclear then initializeclear:close() end
	if init then init() end
	fileFTracker = io.open("fitnesstracker.txt","w")
	fileFTracker:write(pool.history)
	fileFTracker:close()
	coroutine.yield()
	getPositions()
	local startx = marioX
	local starty = marioY
	for i,sprite in ipairs(sprites) do
		if sprite.type == 0x25 then
			warppipe = true
			userreplay = true
			preloaded = true
		end
	end
	--memory.writebyte(0x0715,0) --set score to 0
	--memory.writebyte(0x0716,0)
	--memory.writebyte(0x0717,0)
	getTileset()
	local toad = false
	if memory.readbyte(0x7965) == 1 then
		toad = true
	end
	local score = {memory.readbyte(0x0715),memory.readbyte(0x0716),memory.readbyte(0x0717)}
	if marioMusic == 0x70 then
		battle = true
		roottimeout = 900
		memory.writebyte(0x0715,0) --set score to 0
		memory.writebyte(0x0716,0)
		memory.writebyte(0x0717,0)
	end
	savestateObj = savestate.object(savestateSlotLevel)
	if not preloaded then
		savestate.save(savestateObj)
		savestate.persist(savestateObj)
		levelNameOutput()
		os.execute("mkdir backups"..dirsep..levelname)
		os.execute("mkdir data"..dirsep..levelname)
		indicatorOutput()
	end
	if prevhistory then pool.history = prevhistory end
	if warppipe then
		local cont = {}
		local avgx = {0}
		local goal = 0
		if startx < 60 then
			goal = 218
		elseif startx > 180 then
			goal = 24
		else
			goal = 122
		end
		while memory.readbyte(0x0014) ~= 1 do
			getPositions()
			if marioScreenX > goal+2 then
				cont['left'] = true
				cont['right'] = false
			elseif marioScreenX < goal-2 then
				cont['left'] = false
				cont['right'] = true
			elseif marioScreenX >= goal-2 and marioScreenX <= goal+2 then
				cont['left'] = false
				cont['right'] = false
				cont['down'] = true
			end
			
			if marioScreenX - avgx[1] < 5 then
				cont['A'] = true
				cont['up'] = true
				cont['down']=false
				table.insert(avgx,0)
			else
				cont['A'] = false
			end
			table.insert(avgx,marioScreenX)
			if #avgx > 150 then
				table.remove(avgx,1)
			end
			joypad.set(Player,cont)
			coroutine.yield()
		end
		for i=1,60 do
			coroutine.yield()
		end
	end
	if not userreplay then
		redospectop = pool.generation == 0
		while not playGeneration(redospectop) do
			fitnessDataOutput()
			newGeneration()
			redospectop = false
		end
		if battle then
			local score2 = {memory.readbyte(0x0715),memory.readbyte(0x0716),memory.readbyte(0x0717)}
			memory.writebyte(0x0715,score[1]+score2[1]) --restore score
			memory.writebyte(0x0716,score[2]+score2[2])
			memory.writebyte(0x0717,score[3]+score2[3])
		end
		for i=1,60 do
			if toad then
				memory.writebyte(0x7966,8) --coins required
			end
			coroutine.yield()
		end
		if boss then
			for i=1,600 do
				joypad.set(Player,{A = true, left = false, right = false, up = false, down = false, B = false})
				coroutine.yield()
				joypad.set(Player,{A = false, left = false, right = false, up = false, down = false, B = false})
				coroutine.yield()
			end
		end
		savestateBackup = savestate.object(savestateSlotMap)
		savestate.save(savestateBackup)
		savestate.persist(savestateBackup)
		histogramOutput()
		saveGenome("winner",true)
		mapupdateHist()
		savePool("backups".. dirsep .. levelname .. dirsep .. "winpool.lua")
	end
	if not warppipe then
		Replay = true
		for i=1,#pool.breakthroughfiles do
			print(pool.breakthroughfiles[i])
			dofile(pool.breakthroughfiles[i])
			pool.generation = loadedgenome.gen
			pool.currentSpecies = loadedgenome.s
			pool.currentGenome = loadedgenome.g
			playGenome(loadedgenome)
		end
		if preloaded then
			savestateObj = savestate.object(savestateSlotMap)
		else
			savestateObj = savestateBackup
		end
		local f = io.open("../mapupdate.txt","w")
		f:write("")
		f:close()
		savestate.load(savestateObj)
		Replay = false
		os.rename("2", 'fcs'..dirsep..levelname ..'.fcs')
		if boss then
			os.rename("3", 'fcs'..dirsep..levelname ..'BOSS.fcs')
		end
		local file = io.open("savegamebackup.txt","w")
		file:write(memory.readbyte(0x0727))
		file:close()
	end
	writescene(3)
	os.remove('userinput.lua')
end
prevLN = ''
local leveldict = {[3]="1",[4]="2",[5]="3",[6]="4",[7]="5",[8]="6",[9]="7",[10]="8",[11]="9",[12]="10",[13]="1",[14]="2",[15]="3",[16]="4",[17]="5",[18]="6",[19]="7",[20]="8",[21]="9",[95]="Tower",[103]="Fortress",[104]="Quicksand",[105]="Piramid",[201]="Castle",[204]="Bowser's castle",[223]="Tower",[229]="Start",[235]="Fortress"}
HumanLevelName = ''
while true do
	if memory.readbyte(0x00EE) ~= 0 then
		if Player == 1 then
			levelname = memory.readbyte(0x0727).."-"..(memory.readbyte(0x7978)*8+memory.readbyte(0x797A)/32).."-"..memory.readbyte(0x7976)/32
		else
			levelname = memory.readbyte(0x0727).."-"..(memory.readbyte(0x7979)*8+memory.readbyte(0x797B)/32).."-"..memory.readbyte(0x7977)/32
		end
		if levelname ~= prevLN then
			local LocFile = io.open("OPosition.txt",'w')
			LocFile:write(levelname)
			LocFile:close()
			prevLN = levelname
		end
		playLevel()
	elseif memory.readbyte(0x070A) == 17 then
		SolveMemory()
	else
		if Player == 1 then
			levelname = memory.readbyte(0x0727).."-"..(memory.readbyte(0x77)*8+memory.readbyte(0x79)/32).."-"..memory.readbyte(0x75)/32
		else
			levelname = memory.readbyte(0x0727).."-"..(memory.readbyte(0x78)*8+memory.readbyte(0x7A)/32).."-"..memory.readbyte(0x76)/32
		end
		if levelname ~= prevLN then
			local LocFile = io.open("OPosition.txt",'w')
			LocFile:write(levelname)
			LocFile:close()
			prevLN = levelname
		end
		if file_exists("userinput.lua") then
			userinput=loadfile("userinput.lua")
			if userinput then
				os.remove('userinput.lua')
				uinput = {}
				pcall(userinput)
				if leveldict[memory.readbyte(0xE5)] ~= nil then
					HumanLevelName = leveldict[memory.readbyte(0xE5)]
				end
				if uinput.A and file_exists("fcs" .. dirsep .. levelname .. ".fcs") and memory.readbyte(0x05F2) == 0 then --0x5F2 1 = item folder. 0 = map
					local interrupt = io.open("interrupt.lua","w")
					interrupt:write("os.rename('fcs/" .. levelname ..".fcs', "..savestateSlotLevel..")\nsavestateObj = savestate.object(" .. savestateSlotLevel .. ")\nprint('one point five')\nsavestate.load(savestateObj)\nprint('two')")
					
					
					if file_exists('fcs' .. dirsep .. levelname .. 'BOSS.fcs') then
						interrupt:write("os.rename('fcs/" .. levelname .."BOSS.fcs', "..savestateSlotBOSS..")\nbosssavestateObj = savestate.object(" .. savestateSlotBOSS ..")")
					end
					interrupt:close()
					local initialize = io.open("initialize.lua","w")
					initialize:write("loadPool('backups/".. levelname .. "/winpool.lua')\n")
					initialize:write("preloaded = true\nuserreplay = true\nwritescene(2)")
					initialize:close()
				elseif uinput.A and Startlocations[levelname] then
					worldselection()
				else
					joypad.set(Player,uinput)
				end
			end
		end
	end
	coroutine.yield()
end

return true