#!/usr/bin/env ruby
require 'rubygems'
require 'pp'
require 'thread/pool'

GAMES_PER_ROUND = 50

class Game
	WIDTH = 16
	HEIGHT = 10
	
	POINTS_APPLE = 10
	POINTS_MOVING_CLOSER = 1
	POINTS_MOVING_FAR = -1.5
	
	attr_reader :points, :dead, :ai, :length
	
	def initialize(a)
		@ai = a
		@data = [0]*(WIDTH*HEIGHT)
		@dir = 0
		@pos = [WIDTH/2, HEIGHT/2]
		@data[(@pos[1]  )*WIDTH + @pos[0]]=1
		@data[(@pos[1]+1)*WIDTH + @pos[0]]=2
		@data[(@pos[1]+2)*WIDTH + @pos[0]]=3
		@data[(@pos[1]+3)*WIDTH + @pos[0]]=4
		@length = 4
		@points = 0.0
		@dead = false
		@round = 0
		@last_apple_at = 0
		place_apple()
	end
	
	def place_apple
		x=-1
		while @data[x]!=0 || x==-1
			x = rand(WIDTH*HEIGHT)
		end
		@apple = [x%WIDTH, x/WIDTH]
		@old_distance = apple_distance()
	end
	
	def apple_distance
		return (@pos[0] - @apple[0]).abs + (@pos[1] - @apple[1]).abs
	end
	
	def to_s
		str = @data.join("").gsub("0", " ")
		str[@apple[1]*WIDTH+@apple[0]] = "*"
		s = "+" + "-"*(WIDTH-@points.to_s.length-1)+" "+@points.to_s+"+\n"
		(0...HEIGHT).each do |y|
			s += "|" + str[y*WIDTH, WIDTH] + "|\n"
		end
		s += "+" + "-"*WIDTH+"+\n"
		return s
	end
	
	def draw; puts to_s; puts; end
	
	def loop
		#puts "Loop. Position: #{@pos}"
		return if @dead
		decision = @ai.decide(free?(@dir-1), free?(@dir), free?(@dir+1), apple?(@dir-1), apple?(@dir), apple?(@dir+1))
		#puts "Decision: #{decision}"
		@dir = (@dir + decision) % 4
		if (free?(@dir)==0)
			#puts "Dead."
			die()
			return
		end
		
		move
	end
	
	def ranking; @length*10 - (@dead ? 200 : 0) - (since_last_apple >= 160 ? 100 : 0); end
	
	def move
		newpos = calc_new_pos(@pos, @dir)
		#puts "Newpos: #{newpos}"
		if newpos==@apple
			@length+=1
			@points += POINTS_APPLE
			@last_apple_at = @round
			place_apple
		end
		@data.each_with_index do |value, key|
			@data[key]=value+1 if value>0
			@data[key]=0 if value>=@length
		end
		@data[newpos[1]*WIDTH + newpos[0]] = 1
		@pos = newpos
		ad_d = apple_distance - @old_distance
		@old_distance = apple_distance()
		if (ad_d < 0)
			@points += POINTS_MOVING_CLOSER
		elsif (ad_d > 0)
			@points += POINTS_MOVING_FAR
		end
		@round+=1
	end
	
	def since_last_apple; @round - @last_apple_at; end
	
	def calc_new_pos(p, d)
		d = d%4
		np = p.dup
		case d
			when 0 then np[1]-=1
			when 1 then np[0]+=1
			when 2 then np[1]+=1
			when 3 then np[0]-=1
		end	
		return np
	end
	
	def free?(dir)
		# count the free fields from @pos in dir until a wall or something
		dir = dir % 4
		x=y=0
		case dir
			when 0 then y=-1
			when 1 then x=+1
			when 2 then y=+1
			when 3 then x=-1
		end
		i = 0
		pos = @pos.dup
		
		[WIDTH, HEIGHT].max.times do
			pos[0]+=x
			pos[1]+=y
			break if pos[0]<0 || pos[0]>=WIDTH || pos[1]<0 || pos[1]>=HEIGHT || @data[pos[1]*WIDTH + pos[0]]!=0
			i+=1
		end
		return i
	end

	def apple?(dir)
		dir = dir%4
		d_x = @apple[0] - @pos[0]
		d_y = @apple[1] - @pos[1]
		case dir
			when 0 then return @apple[1]<@pos[1] ? -d_y : 0
			when 1 then return @apple[0]>@pos[0] ? d_x : 0
			when 2 then return @apple[1]>@pos[1] ? d_y : 0
			when 3 then return @apple[0]<@pos[0] ? -d_x : 0
			#when 0 then return d_y<0 && d_x.abs<d_y.abs
			#when 1 then return d_x>0 && d_x.abs>d_y.abs
			#when 2 then return d_y>0 && d_x.abs<d_y.abs
			#when 3 then return d_x<0 && d_x.abs>d_y.abs
		end
	end
	
	def die
		@dead = true
	end
	
	def stopped?; since_last_apple >= WIDTH*HEIGHT*1.5; end
	
	def ai_ranking; ai.ranking; end
end

class AI
	attr_reader :weights
	attr_accessor :ranking, :rounds, :count_dead, :count_stopped, :sum_length
	
	def initialize(w=nil)
		reset()
		@rounds = 1
		if w==nil
			@weights = Array.new(18) { rand() * 2.0 - 1.0 }
		else
			@weights = w
		end
	end
	
	def reset
		@ranking = 0.0
		@count_dead = 0
		@count_stopped = 0
		@sum_length = 0
	end
	
	def add_ranking(g)
		@ranking += g.ranking
		@count_dead += 1 if g.dead
		@count_stopped += 1 if g.stopped?
		@sum_length += g.length
	end
	
	def decide(left_free, straight_free, right_free, apple_left, apple_straight, apple_right)
		inputs = [left_free, straight_free, right_free, apple_left, apple_straight, apple_right]
		#pp inputs
		outputs = [0, 0, 0]
		(0...18).each do |x|
			o = x/6
			i = x%6
			outputs[o] += inputs[i] * @weights[x]
		end
		max = 0
		take = 0
		(0...3).each do |x|
			if outputs[x]>max
				max = outputs[x]
				take = x
			end
		end
		return take-1
	end
	
	def evolve
		w = @weights.dup
		action = rand(4)
		if action==0 #swap
			i1 = rand(18)
			i2 = rand(18)
			temp = w[i1]
			w[i1] = w[i2]
			w[i2] = temp
		elsif action==1 #change single value
			i = rand(18)
			w[i] = rand() * 2 - 1.0
		elsif action==2 #invert single value
			i = rand(18)
			w[i] *= -1.0
		else #change multiple values
			(0...18).each do |i|
				if (rand(5)==0)
					w[i] = rand() * 2 - 1
				end
			end
		end
		
		return AI.new(w)
	end
	
	def merge(ai)
		w = @weights.dup
		w2 = ai.weights.dup
		(0...18).each do |i|
			if rand(2)==0
				w[i] = w2[i]
			end
		end
		return AI.new(w)
	end
	
	def average(ai)
		w = @weights.dup
		w2 = ai.weights
		(0...18).each do |i|
			w[i] = (w[i] + w2[i]) / 2.0
		end
		return AI.new(w)
	end
	
	def dump
		puts "Data:"
		puts "float _weights[18] = {#{@weights.join(", ")}};"
		#puts "Simplified: #{simplified}"
	end
end

graph = File.open(File.dirname(__FILE__) + "/data_set.dat", "w")
graph.puts("# Round -  Points -  Length -  Stopped -  Dead")

ais = []
round = 1
games = []
(0...50).each do |x|
	ais[x] = AI.new#(SEEDS.sample)
end

best_old_ai = nil
begin
loop do
	GAMES_PER_ROUND.times do
		(0...50).each do |x|
			games[x] = Game.new(ais[x])
		end
		
		pool = Thread.pool(16)
		games.each do |g|
			
			pool.process do
		15_000.times do
			g.loop
			break if g.dead || g.stopped?
		end 
		g.ai.add_ranking(g)
			
		end
		end
		pool.shutdown
	end
	
	games_sorted = games.sort_by(&:ai_ranking).reverse.take(5)
	g = games_sorted[0]

	puts "Round %5d: %7.1f points, length %3.0f, %3.0f%% stopped, %3.0f%% dead - {%s}" % [round, g.ai_ranking / GAMES_PER_ROUND, g.ai.sum_length.to_f / GAMES_PER_ROUND, g.ai.count_stopped.to_f / GAMES_PER_ROUND * 100, g.ai.count_dead.to_f / GAMES_PER_ROUND * 100, g.ai.weights.map{|v| v.truncate(1).to_s.rjust(4)}.join(", ")]
	graph.puts("%d %f %f %f %f" % [round, g.ai_ranking / GAMES_PER_ROUND, g.ai.sum_length.to_f / GAMES_PER_ROUND, g.ai.count_stopped.to_f / GAMES_PER_ROUND * 100, g.ai.count_dead.to_f / GAMES_PER_ROUND * 100])
	graph.flush
	
	if round%10==0
		g.ai.dump
	end
	
	best_old_ai = g.ai
	
	ais = []
	games_sorted.each do |g|
		g.ai.reset
		g.ai.rounds += 1
		ais << g.ai
		9.times do
			ais << g.ai.evolve
		end
	end
	
	5.times do
		ais << games_sorted[0].ai.merge(games_sorted[1].ai)
	end
	5.times do
		ais << games_sorted[1].ai.merge(games_sorted[0].ai)
	end
	ais << games_sorted[0].ai.average(games_sorted[1].ai)
	10.times do
		ais << AI.new
	end
	round+=1
end
rescue SystemExit, Interrupt
	best_old_ai.dump
	graph.close
end