Snakenet.rb now applies modifications to the weights in both directions (e.g. positive and negative), creating two new AIs.

.gitignore

@@ -10,3 +10,4 @@ include/config.h
 .pioenvs
 .DS_Store
 .vscode
+src/tools/snakenet/data_set.dat

include/Window.h

@@ -29,7 +29,7 @@ public:
 	void setSubPixel(accum88 x, accum88 y, CRGB* color, SubpixelRenderingMode m = SUBPIXEL_RENDERING_ADD);
 	void setPixelByIndex(uint16_t index, CRGB* color);
 	void raisePixel(uint8_t x, uint8_t y, CRGB* color);
-	void line(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, CRGB* color);
+	void line(accum88 x1, accum88 y1, accum88 x2, accum88 y2, CRGB* color);
 	void lineWithAngle(uint8_t x, uint8_t y, uint8_t angle, uint8_t length, CRGB* color);
 	void lineWithAngle(uint8_t x, uint8_t y, uint8_t angle, uint8_t startdist, uint8_t length, CRGB* color);
 	void circle(uint8_t x, uint8_t y, uint8_t r, CRGB* color);

include/effect_snake.h

@@ -8,6 +8,8 @@
 #define SNAKE_DIR_SOUTH 2
 #define SNAKE_DIR_WEST  3
 
+#define SNAKE_DEBUG false
+
 class SnakeEffect : public Effect {
 private:
 	Coords _pos;
@@ -18,17 +20,32 @@ private:
 	uint8_t _length;
 	unsigned long _last_apple_at;
 	unsigned long _last_move_at;
-	// The following code is a handwritten "ai". Useful for testing and stuff.
+	uint16_t _round;
-	//int8_t _decisions[64] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,0,0,0,0,-1,-1,0,0,0,1,0,0,-1,-1,0,0};
+	
-	int8_t _decisions[64] = {0, 1, 1, -1, 0, 1, 1, -1, 0, -1, 1, -1, -1, 0, 1, -1, -1, 0, 0, 1, -1, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, -1, -1, 0, 0, -1, -1, 0, 1, -1, -1, 1, 1, -1, -1, 1, -1, 0, 0, 1, 0, 1, -1, -1, 0, 0, 0, -1, 0, 1, 0, -1, 0, -1};
+	// Neural net config
-	//int8_t _decisions[64] = {1, 1, 0, 0, 1, 1, -1, -1, 0, -1, 0, -1, -1, 0, -1, 1, 1, -1, 0, 0, 1, -1, 0, 1, 0, -1, 0, -1, 0, 1, 1, 1, -1, 0, 0, 0, -1, -1, -1, 1, -1, -1, 1, 1, -1, 0, 1, 1, 1, 0, 0, -1, -1, 0, -1, 1, 0, 0, 0, -1, 0, -1, 1, 1};
+	// These are actually float values. But in order to prevent rounding errors and stuff, they are provided
+	// in form of the raw binary data of the IEE754 floating point numbers.
+	// In _decide() there's code to memcpy()-convert them to a float.
+	//   Round 340, 223.4 points, length 39, 36% stopped, 64% died
+	// const uint32_t _weights[36] = {0xbd8e626e, 0xbee2cd2c, 0x3e4d5cab, 0x3eceb8c3, 0xbed0a514, 0x3ec62438, 0x3e947ed4, 0xbe4b8bf2, 0xbf301113, 0xbf3f0a75, 0x3f1868f7, 0xbf0253ca, 0xbedca2f2, 0xbd547c6d, 0x3edd6a8a, 0xbd4b97b6, 0x3f64ec26, 0xbe5323c1, 0x3eccf87d, 0xbf2d4796, 0xbf62b6e8, 0xbf71daf6, 0xbf03f08e, 0xbf222609, 0x3e26c03c, 0xbf497837, 0xbee4d175, 0x3ec601de, 0x3e4e0695, 0x3eef2619, 0xbe849370, 0xbf18fb2b, 0x3f25bbd1, 0xbf3dcd78, 0x3f37a58d, 0x3ef4a25b};
+	//   Round 630, 221.0 points, length 38, 36% stopped, 64% died
+	const uint32_t _weights[36] = {0xbd25943f, 0xbf279d81, 0x3e25d128, 0x3ec62438, 0x3f0e719c, 0x3eefbea9, 0x3e947ed4, 0xbe5323c1, 0xbf2d4796, 0xbf3f0a75, 0x3f0e45d9, 0xbf0253ca, 0xbedca2f2, 0xbd79073c, 0x3ede80ec, 0xbd4b97b6, 0x3f69a6be, 0xbe4b8bf2, 0x3eccf87d, 0xbf301113, 0xbf62b6e8, 0xbf71daf6, 0xbf204130, 0xbf222609, 0x3e26c03c, 0xbf497837, 0xbee4d175, 0x3ec601de, 0x3e4954eb, 0x3eef2619, 0xbe849370, 0xbf18fb2b, 0x3f25bbd1, 0xbf3b4e44, 0x3f484d59, 0x3edd6a8a};
+	//   Round 193, 164.8 points, length  36,  6% stopped, 94% died
+	//const uint32_t _weights[36] = {0x3e872ffb, 0xbea57262, 0xbee269bf, 0x3ed790a3, 0xbf54014f, 0x3ecde0a6, 0xbf240a93, 0xbe9e4782, 0x3f205106, 0xbf4465c2, 0xbf79579a, 0xbf07f122, 0x3ed0e1bc, 0xbf7a5a09, 0xbf0fc70b, 0xbf6d1971, 0xbe0f5585, 0xbec94b12, 0x3f51f7a9, 0x3eaac42b, 0xbe6aafa6, 0x3d3e3ce3, 0xbf7c4232, 0xbe634103, 0x3f800000, 0x3eff886c, 0x3deae1e8, 0x3eea6988, 0xbf800000, 0xbf426a20, 0x3e3a0a45, 0xbe848803, 0x3e84e8c9, 0x3ef9fabc, 0xbe7733e6, 0xbecda633};
+	  
+	const uint8_t _net_layout[3] = {6, 4, 3};
+	const uint8_t _net_layers = 3;
+	const uint8_t _net_total_size = 36;
+	
+	
 	uint16_t _xy2i(uint8_t x, uint8_t y);
 	uint16_t _xy2i(Coords c);
 	Coords _i2xy(uint16_t i);
 	Coords _new_pos(uint8_t dir);
 	uint8_t _dying = 0;
 	bool _is_free(uint8_t dir);
-	bool _to_apple(uint8_t dir);
+	uint8_t _free_spaces(uint8_t dir);
+	uint8_t _to_apple(uint8_t dir);
 	void _place_apple();
 	void _init();
 	void _decide();

include/settings.h

@@ -81,7 +81,7 @@ struct Settings {
 		} snake;
 
 		struct /* tv_static */ {
-			uint16_t black_bar_speed = 3500;
+			uint16_t black_bar_speed = 12;
 		} tv_static;
 	} effects;
 };

src/Window.cpp

@@ -150,26 +150,27 @@ void Window::fadeToBlackBy(fract8 speed) {
 	}
 }
 
-void Window::line(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, CRGB* color) {
+void Window::line(accum88 x1, accum88 y1, accum88 x2, accum88 y2, CRGB* color) {
 	// Bresenham algorithm
-	int dx = x2-x1;
+	const uint8_t stepsize = 32;
-	int dy = y2-y1;
+	saccum78 dx = x2-x1;
+	saccum78 dy = y2-y1;
 
-	int x = x1;
+	accum88 x = x1;
-	int y = y1;
+	accum88 y = y1;
 
-	int p = 2*dy - dx;
+	saccum78 p = 2*dy - dx;
 
 	while (x < x2) {
 		if (p >= 0) {
-			setPixel(x, y, color);
+			setSubPixel(x, y, color, SUBPIXEL_RENDERING_RAISE);
-			y++;
+			y+=stepsize;
 			p = p + 2*dy - 2*dx;
 		} else {
-			setPixel(x, y, color);
+			setSubPixel(x, y, color, SUBPIXEL_RENDERING_RAISE);
 			p = p + 2*dy;
 		}
-		x++;
+		x+=stepsize;
 	}
 }
 
@@ -206,16 +207,16 @@ void Window::lineWithAngle(uint8_t x, uint8_t y, uint8_t angle, uint8_t length,
 }
 
 void Window::lineWithAngle(uint8_t x, uint8_t y, uint8_t angle, uint8_t startdist, uint8_t length, CRGB* color) {
-	int16_t x1 = x;
+	accum88 x1 = x<<8;
-	int16_t y1 = y;
+	accum88 y1 = y<<8;
 
 	if (startdist > 0) {
-		x1 = x + scale8(startdist, cos8(angle));
+		x1 = (x<<8) + (startdist<<8) * cos8(angle) / 256;
-		y1 = y + scale8(startdist, sin8(angle));
+		y1 = (y<<8) + (startdist<<8) * sin8(angle) / 256;
 	}
 
-	int16_t x2 = x + scale8(startdist + length, cos8(angle));
+	accum88 x2 = (x<<8) + (startdist + length) * cos16(angle);
-	int16_t y2 = y + scale8(startdist + length, sin8(angle));
+	accum88 y2 = (y<<8) + (startdist + length) * sin16(angle);
 
 	line(x1, y1, x2, y2, color);
 }

src/effect_analogclock.cpp

@@ -9,8 +9,9 @@ void AnalogClockEffect::loop(uint16_t ms) {
 	window->circle(8, 8, 7, &white);
 	
 	uint8_t seconds = ntpClient.getSeconds();
-	uint8_t angle = 6 * seconds;
+	uint8_t angle = seconds * 256 / 60;
-	window->lineWithAngle(8, 8, angle, 0, 10, &red);
+	window->lineWithAngle(8, 8, angle, 10, &red);
+	window->line(1<<8, 1<<8, 12<<8, 4<<8, &white);
 	/*for (uint8_t i=0; i<=12; i++) {
 		window->lineWithAngle(8, 8, 255/12*i, 5, 2, &white);
 	}

src/effect_snake.cpp

@@ -10,6 +10,7 @@ SnakeEffect::SnakeEffect() {
 
 void SnakeEffect::_init() {
 	_dying = 0;
+	_round = 0;
 	_last_apple_at = millis();
 	_last_move_at = millis();
 	_dir = SNAKE_DIR_NORTH;
@@ -17,6 +18,9 @@ void SnakeEffect::_init() {
 	_pos = {(uint8_t)(window->width/2), (uint8_t)(window->height/2)};
 	for (int i=0; i<_pixels; i++) _map[i]=0;
 	_map[_xy2i(_pos)]=1;
+	_map[_xy2i(_pos)+window->width*1]=2;
+	_map[_xy2i(_pos)+window->width*2]=3;
+	_map[_xy2i(_pos)+window->width*3]=4;
 	_place_apple();
 }
 
@@ -26,6 +30,10 @@ SnakeEffect::~SnakeEffect() {
 }
 
 void SnakeEffect::_place_apple() {
+	if (SNAKE_DEBUG) {
+		_apple = {3, 3};
+		return;
+	}
 	if (_length < _pixels) {
 		uint8_t start = random8(_pixels);
 		for (int i=0; i<_pixels; i++) {
@@ -38,16 +46,57 @@ void SnakeEffect::_place_apple() {
 }
 
 void SnakeEffect::_decide() {
-	uint8_t input = 0;
+	uint8_t f_l = _free_spaces(_dir - 1);
-	if (_is_free(_dir - 1))  input |= 1<<5;
+	uint8_t f_s = _free_spaces(_dir);
-	if (_is_free(_dir))      input |= 1<<4;
+	uint8_t f_r = _free_spaces(_dir + 1);
-	if (_is_free(_dir + 1))  input |= 1<<3;
+	uint8_t a_l = _to_apple(_dir - 1);
-	if (_to_apple(_dir - 1)) input |= 1<<2;
+	uint8_t a_s = _to_apple(_dir);
-	if (_to_apple(_dir))     input |= 1<<1;
+	uint8_t a_r = _to_apple(_dir + 1);
-	if (_to_apple(_dir + 1)) input |= 1;
 	
-	_dir += _decisions[input];
+	float* inputs = new float[6];
+	inputs[0] = f_l;
+	inputs[1] = f_s;
+	inputs[2] = f_r;
+	inputs[3] = a_l;
+	inputs[4] = a_s;
+	inputs[5] = a_r;
+	if (SNAKE_DEBUG) LOGln("SnakeEffect * Position: %d, %d - Inputs: %3.1f %3.1f %3.1f %3.1f %3.1f %3.1f", _pos.x, _pos.y, inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], inputs[5]);
+	float* outputs = NULL;
+	uint8_t i=0;
+	for (uint8_t layer=1; layer<_net_layers; layer++) {
+		outputs = new float[_net_layout[layer]];
+		for (uint8_t j=0; j<_net_layout[layer]; j++) {
+			outputs[j] = 0.0;
+		}
+		for (uint8_t idx_out=0; idx_out<_net_layout[layer]; idx_out++) {
+			for (uint8_t idx_in=0; idx_in<_net_layout[layer-1]; idx_in++) {
+				float weight;
+				memcpy(&weight, &(_weights[i]), sizeof(weight));
+				outputs[idx_out] += weight * inputs[idx_in];
+				//outputs[idx_out] += (*(float*)&(_weights[i])) * inputs[idx_in];
+				i++;
+			}
+		}
+		delete inputs;
+		inputs = outputs;
+	}
+	
+	int8_t decision = 0;
+	float last;
+	for (uint8_t i=0; i<_net_layout[_net_layers - 1]; i++) {
+		if (i==0 || outputs[i]>last) {
+			last = outputs[i];
+			decision = i;
+		}
+	}
+	decision = decision - 1;
+	delete outputs;
+	
+	if (SNAKE_DEBUG) LOGln("SnakeEffect * Decision: %d", decision);
+
+	_dir += decision;
 	if (_dir < 0) _dir += 4;
+	if (_dir > 3) _dir -= 4;
 }
 
 /**
@@ -76,19 +125,43 @@ int8_t SnakeEffect::_manual_decision() {
 }*/
 
 bool SnakeEffect::_is_free(uint8_t dir) {
-	Coords np = _new_pos(dir);
+	return _free_spaces(dir)!=0;
-	return np.x>=0 && np.x<window->width && np.y>=0 && np.y<window->height && _map[_xy2i(np)]==0;
 }
 
-bool SnakeEffect::_to_apple(uint8_t dir) {
+uint8_t SnakeEffect::_free_spaces(uint8_t dir) {
+	int8_t x=0;
+	int8_t y=0;
 	uint8_t d = dir % 4;
 	switch(d) {
-		case SNAKE_DIR_NORTH: return _apple.y<_pos.y;
+		case SNAKE_DIR_NORTH: y=-1; break;
-		case SNAKE_DIR_EAST:  return _apple.x>_pos.x;
+		case SNAKE_DIR_EAST:  x=1; break;
-		case SNAKE_DIR_SOUTH: return _apple.y>_pos.y;
+		case SNAKE_DIR_SOUTH: y=1; break;
-		case SNAKE_DIR_WEST:  return _apple.x<_pos.x;
+		case SNAKE_DIR_WEST:  x=-1; break;
 	}
-	return true;
+	Coords p(_pos);
+	uint8_t i=0;
+	while (true) {
+		p.x += x;
+		p.y += y;
+		if (p.x<0 || p.x>=window->width || p.y<0 || p.y>=window->height || _map[_xy2i(p)]!=0) {
+			return i;
+		}
+		i++;
+	}
+}
+
+uint8_t SnakeEffect::_to_apple(uint8_t dir) {
+	uint8_t d = dir % 4;
+	int8_t d_x = _apple.x - _pos.x;
+	int8_t d_y = _apple.y - _pos.y;
+	
+	switch(d) {
+		case SNAKE_DIR_NORTH: return d_y < 0 ? -d_y : 0;
+		case SNAKE_DIR_EAST:  return d_x > 0 ?  d_x : 0;
+		case SNAKE_DIR_SOUTH: return d_y > 0 ?  d_y : 0;
+		case SNAKE_DIR_WEST:  return d_x < 0 ? -d_x : 0;
+	}
+	return 0;
 }
 
 Coords SnakeEffect::_new_pos(uint8_t dir) {
@@ -116,10 +189,7 @@ Coords SnakeEffect::_i2xy(uint16_t i) {
 }
 
 void SnakeEffect::_move() {
-	if (_dying==0 && !_is_free(_dir)) {
+	
-		_dying = 150;
-		return;
-	}
 	
 	if (_dying > 0) {
 		_dying--;
@@ -132,11 +202,21 @@ void SnakeEffect::_move() {
 	}
 	
 	unsigned long now = millis();
-	if (_last_move_at < now && now - _last_move_at < 100) {
+	if (_last_move_at < now && now - _last_move_at < 0) {
 		return;
 	}
+	_round++;
 	_last_move_at = now;
+	_decide();
+	
+	if (_dying==0 && !_is_free(_dir)) {
+		_dying = 150;
+		return;
+	}
+	
 	_pos = _new_pos(_dir);
+	if (SNAKE_DEBUG) LOGln("SnakeEffect * new_pos: %d, %d", _pos.x, _pos.y);
+	if (SNAKE_DEBUG) LOGln("SnakeEffect * apple:   %d, %d", _apple.x, _apple.y);
 	if (_pos.x==_apple.x && _pos.y==_apple.y) {
 		_last_apple_at = millis();
 		_length++;
@@ -172,12 +252,9 @@ void SnakeEffect::loop(uint16_t ms) {
 	//CRGB color(CHSV(hue, 200, 255));
 	//window->setPixel(this->coords.x, this->coords.y, &color);
 	//hue++;
-	if (millis() < _last_apple_at || millis() - _last_apple_at > 30000) {
+	if (_dying==0 && (millis() < _last_apple_at || millis() - _last_apple_at > 30000)) {
 		_dying = 150;
 	}
-	if (_dying==0) {
-		_decide();
-	}
 	_move();
 	_draw();
 }

src/effect_tv_static.cpp

@@ -1,17 +1,17 @@
 #include "effect_tv_static.h"
 
 void TvStaticEffect::loop(uint16_t ms) {
-	uint8_t dark_position = (millis() % settings.effects.tv_static.black_bar_speed) * _window->width / settings.effects.tv_static.black_bar_speed;
+	//uint8_t dark_position = (millis() % settings.effects.tv_static.black_bar_speed) * _window->width / settings.effects.tv_static.black_bar_speed;
+	accum88 dark_position = (beat16(settings.effects.tv_static.black_bar_speed) * _window->width) >> 8;
 	for (uint8_t y=0; y<_window->height; y++) {
-		uint8_t row_dark_position = (dark_position + y/3) % _window->width;
+		accum88 row_dark_position = (dark_position + (y<<8)/3) % (_window->width<<8);
 		for (uint8_t x=0; x<_window->width; x++) {
 			uint8_t brightness = random8();
 			uint8_t darkening = 0;
-			uint8_t distance = x - row_dark_position;
+			accum88 distance = (x<<8) - row_dark_position;
-			if (distance == 0) darkening = random8(192, 255);
+			if (distance < 256) darkening = random8(distance, 255);
-			else if (distance == 1) darkening = random8(128, 255);
+			else if (distance < (4<<8)) darkening = random8(distance >> 2, 255);
-			else if (distance == 2) darkening = random8(92, 192);
+			
-			else if (distance == 3) darkening = random8(32, 128);
 			if (darkening > brightness) brightness = 0;
 			else brightness -= darkening;
 			CRGB color(brightness, brightness, brightness);

src/pitrix.cpp

@@ -100,8 +100,17 @@ void loop() {
 			last_loop_ago = 0;
 		}
 		
+		#ifdef MQTT_REPORT_METRICS
+		unsigned long effect_loop_started = millis();
+		#endif
+		
         current_effect->loop(last_loop_ago);
         
+        #ifdef MQTT_REPORT_METRICS
+        metrics_frame_count++;
+        metrics_frame_time += (millis() - effect_loop_started);
+        #endif
+        
         // Save the time for the next run.
         _last_effect_loop_finished_at = now;
 
@@ -109,10 +118,7 @@ void loop() {
             effect_clock.loop_with_invert(current_effect->clock_as_mask());
         }
         FastLED.show();
-        #ifdef MQTT_REPORT_METRICS
+        
-        metrics_frame_count++;
-        metrics_frame_time += (millis() - loop_started_at);
-        #endif
         
         #ifdef RECORDER_ENABLE
         recorder->loop();

src/tools/snakenet/plot

@@ -0,0 +1,6 @@
+#!/usr/bin/gnuplot -c
+set term dumb 79 49
+plot 'data_set.dat' using 1:2 title 'Points', \
+# 'data_set.dat' using 1:3 title 'Length' axes x1y2, \
+# 'data_set.dat' using 1:4 title 'Stopped' axes x1y2, \
+# 'data_set.dat' using 1:5 title 'Dead' axes x1y2

src/tools/snakenet/snakenet.rb

@@ -0,0 +1,415 @@
+#!/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
+	attr_accessor :apple
+	
+	def initialize(a, debug=false)
+		@debug = debug
+		@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
+		@count_left = @count_right = 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}"
+		@count_left += 1 if decision==-1
+		@count_right += 1 if decision==1
+		@dir = (@dir + decision) % 4
+		if (free?(@dir)==0)
+			#puts "Dead."
+			die()
+			return
+		end
+		
+		move
+	end
+	
+	def ranking; @length*10 - (@dead ? 200 : 0) - (stopped? ? 100 : 0) - (@count_right - @count_left).abs * 0.05; end
+	
+	def move
+		newpos = calc_new_pos(@pos, @dir)
+		puts "Newpos: #{newpos}" if @debug
+		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*2; end
+	
+	def ai_ranking; ai.ranking; end
+end
+
+class AI
+	NETWORK_LAYOUT = [6, 4, 3]
+	attr_reader :weights, :id
+	attr_accessor :ranking, :rounds, :count_dead, :count_stopped, :sum_length
+	
+	def initialize(w=nil, debug=false)
+		@debug = debug
+		reset()
+		@rounds = 1
+		@id = rand(0xFFFFFF)
+		if w==nil
+			@weights = Array.new(network_size()) { rand() * 2.0 - 1.0 }
+			puts "Initialized with random values: #{@weights}" if @debug
+		else
+			if w[0].is_a? Integer
+				@weights = w.map{|s| s.to_s(16).rjust(8, "0").split("").each_slice(2).to_a.map(&:join).map{|s| s.to_i(16).chr}.join.unpack("g")}.flatten
+			else
+				@weights = w
+			end
+			puts "Initialized with given values: #{@weights}" if @debug
+		end
+		
+	end
+	
+	def network_size
+		s = 0
+		(0...(NETWORK_LAYOUT.count-1)).each do |i|
+			s += NETWORK_LAYOUT[i] * NETWORK_LAYOUT[i+1]
+		end
+		return s
+	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]
+		puts "Inputs: #{inputs}" if @debug
+		outputs = nil
+		x = 0
+		(1...(NETWORK_LAYOUT.count)).each do |i|
+			c_in = NETWORK_LAYOUT[i-1]
+			c_out = NETWORK_LAYOUT[i]
+			outputs = Array.new(c_out){0.0}
+			(0...c_out).each do |o|
+				(0...c_in).each do |i|
+					outputs[o] += inputs[i] * @weights[x]
+					x+=1
+				end
+			end
+			inputs = outputs
+		end
+
+		max = 0
+		take = 0
+		(0...(NETWORK_LAYOUT.last)).each do |x|
+			if outputs[x]>max
+				max = outputs[x]
+				take = x
+			end
+		end
+		puts "Decision: #{take-1}" if @debug
+		return take-1
+	end
+	
+	def evolve
+		w = @weights.dup
+		action = rand(4)
+		#if action==0 #swap
+		#	i1 = rand(network_size())
+		#	i2 = rand(network_size())
+		#	temp = w[i1]
+		#	w[i1] = w[i2]
+		#	w[i2] = temp
+		if action==0 #change single value
+			i = rand(network_size())
+			diff = rand() * 0.2 - 0.1
+			w2 = w.dup
+			w[i] += diff
+			w[i] = 1.0 if w[i]>1.0
+			w[i] = -1.0 if w[i]<-1.0
+			w2[i] -= diff
+			w2[i] = 1.0 if w2[i]>1.0
+			w2[i] = -1.0 if w2[i]<-1.0
+			return [AI.new(w), AI.new(w2)]
+		elsif action==1 #invert single value
+			i = rand(network_size())
+			w[i] *= -1.0
+		elsif action==2
+			(0...network_size()).each do |i|
+				w[i] = rand() * 2 - 1.0 if rand(5)==0
+			end
+		else #change multiple values
+			w2 = w.dup
+			(0...network_size()).each do |i|
+				if (rand(5)==0)
+					diff = rand() * 0.2 - 0.1
+					w[i] += diff
+					w[i] = 1.0 if w[i]>1.0
+					w[i] = -1.0 if w[i]<-1.0
+					w2[i] -= diff
+					w2[i] = 1.0 if w2[i]>1.0
+					w2[i] = -1.0 if w2[i]<-1.0
+				end
+			end
+			return [AI.new(w), AI.new(w2)]
+		end
+		
+		return AI.new(w)
+	end
+	
+	def merge(ai)
+		w = @weights.dup
+		w2 = ai.weights.dup
+		(0...network_size()).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...network_size()).each do |i|
+			w[i] = (w[i] + w2[i]) / 2.0
+		end
+		return AI.new(w)
+	end
+	
+	def dump
+		puts "const uint32_t _weights[#{network_size()}] = {#{@weights.map{|x| "0x" + [x].pack('g').split("").map(&:ord).map{|i| i.to_s(16).rjust(2, '0')}.join}.join(", ")}};"
+		#puts "Simplified: #{simplified}"
+	end
+end
+
+## Simulate
+=begin
+ai = AI.new([0xbd547c6d, 0xbedc84a5, 0x3e750239, 0x3ec5ae8a, 0xbcc9a683, 0x3f18715a, 0x3e947ed4, 0xbe4b8bf2, 0xbf2ee4ec, 0xbf3f0a75,
+0x3f5392dc, 0xbf06687b, 0xbedca2f2, 0xbcde3698, 0x3edd6a8a, 0xbd7284ca, 0x3ea7bac9, 0xbe5323c1, 0x3eccf87d,
+0xbf2d4796, 0xbf62b6e8, 0xbf71daf6, 0xbeff40aa, 0xbf207014, 0x3e26c03c, 0xbf497837, 0xbee4d175, 0x3ec601de, 0x3e4e0695, 0x3eef2619,
+0xbe849370, 0xbf18fb2b, 0x3f128e17, 0xbf3dcd78, 0x3f517299, 0x3eef3270], true)
+g = Game.new(ai, true)
+g.apple = [3, 3]
+10.times do
+	g.loop
+end
+exit
+=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_game = nil
+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]
+	
+	if (round-1)%50==0
+		puts "----------------------------------------------------"
+		puts "Round |  Points | Length | Stopped | Dead | ID      "
+		puts "----------------------------------------------------"
+	end
+
+	puts "%5d | %7.1f | %6.0f | %6.0f%% | %3.0f%% | 0x%06x" % [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.id]
+	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_game = g
+	best_old_ai = g.ai.dup
+	
+	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
+	ais = ais.flatten
+	round+=1
+end
+rescue SystemExit, Interrupt
+	puts
+	puts
+	puts "//   Round %d, %5.1f points, length %3d, %2.0f%% stopped, %2.0f%% died" % [round-1, best_old_game.ai_ranking / GAMES_PER_ROUND, best_old_ai.sum_length.to_f / GAMES_PER_ROUND, best_old_ai.count_stopped.to_f / GAMES_PER_ROUND * 100, best_old_ai.count_dead.to_f / GAMES_PER_ROUND * 100]
+	best_old_ai.dump
+	graph.close
+end