mario

Pika/gameplay/containers/mario/mario.cpp

@@ -383,10 +383,10 @@ void getVision(char vision[visionSizeX * visionSizeY], mario::GameplaySimulation
 bool performNeuralSimulation(PlayerSimulation &p, float deltaTime, mario::GameplaySimulation &simulator, mario::NeuralNetork
 	&network)
 {
-	if (p.p.position.position.x - p.maxFit > 0.2)
+	if (p.p.position.position.x - p.maxPosition > 0.2)
 	{
 
-		p.maxFit = p.p.position.position.x;
+		p.maxPosition = p.p.position.position.x;
 		p.killTimer = 0;
 	}
 	else
@@ -398,6 +398,8 @@ bool performNeuralSimulation(PlayerSimulation &p, float deltaTime, mario::Gamepl
 		}
 	}
 
+	p.maxFit = p.maxPosition - p.jumpCount * 5;
+
 	//simulator.moveDelta = 1;
 	//simulator.jump = 0;
 	char vision[visionSizeX * visionSizeY];
@@ -409,6 +411,7 @@ bool performNeuralSimulation(PlayerSimulation &p, float deltaTime, mario::Gamepl
 	if (simulator.jump && p.p.grounded)
 	{
 		p.jumpCount++;
+		//p.maxFit -= 1;
 	}
 
 	if (!simulator.updateFrame(deltaTime, p.p))
@@ -456,6 +459,7 @@ void renderNeuralNetwork(gl2d::Renderer2D &renderer, char vision[mario::visionSi
 			//}
 		}
 	}
+
 	renderer.renderRectangle(
 		glm::vec4(
 		1,
@@ -463,46 +467,131 @@ void renderNeuralNetwork(gl2d::Renderer2D &renderer, char vision[mario::visionSi
 		PLAYER_SIZE) *
 		(float)blockSizePreview, {0,0,1,0.5});
 
-	glm::vec2 upkeyPositions(mario::visionSizeX * blockSizePreview * 3,
+	glm::vec2 upkeyPositions(mario::visionSizeX * blockSizePreview * 4,
 		mario::visionSizeY * blockSizePreview * 0.5 - blockSizePreview * 2);
 
-	glm::vec2 leftkeyPositions(mario::visionSizeX * blockSizePreview * 3,
+	glm::vec2 leftkeyPositions(mario::visionSizeX * blockSizePreview * 4,
 		mario::visionSizeY * blockSizePreview * 0.5);
 
-	glm::vec2 rightkeyPositions(mario::visionSizeX * blockSizePreview * 3,
+	glm::vec2 rightkeyPositions(mario::visionSizeX * blockSizePreview * 4,
 		mario::visionSizeY * blockSizePreview * 0.5 + blockSizePreview * 2);
 
+	glm::vec2 firstNeuronPositions(mario::visionSizeX * blockSizePreview * 1.5,
+		mario::visionSizeY * blockSizePreview * 0.5 - blockSizePreview * 5);
+
+	glm::vec2 secondNeuronPositions(mario::visionSizeX * blockSizePreview * 2.5,
+		mario::visionSizeY * blockSizePreview * 0.5 - blockSizePreview * 5);
+	
 
 	for (int i = 0; i < 3; i++)
 	{
-		for (int j = 0; j < mario::visionTotal; j++)
+		for (int j = 0; j < mario::subLayerSize; j++)
+		{
+	
+			if (network.weights3[i][j] != 0)
+			{
+				glm::vec4 color;
+				if (network.weights3[i][j] > 0)
+				{
+					color = glm::vec4(0, 1, 0, network.weights3[i][j] / 1.5);
+				}
+				else
+				{
+					color = glm::vec4(1, 0, 0, network.weights3[i][j] / -1.5);
+				}
+	
+				color.w = glm::clamp(color.w, 0.1f, 1.f);
+	
+				glm::vec2 positions[] = {upkeyPositions, leftkeyPositions, rightkeyPositions};
+	
+				renderLine(
+					secondNeuronPositions + glm::vec2{0, 10 * j * blockSizePreview / mario::subLayerSize},
+					positions[i] + glm::vec2(blockSizePreview) / 2.f,
+					color);
+	
+			}
+		}
+	}
+
+	for (int i = 0; i < mario::subLayerSize; i++)
+	{
+		for (int j = 0; j < mario::subLayerSize; j++)
 		{
 
-			if (network.weights[i][j] != 0)
+			if (network.weights2[i][j] != 0)
 			{
 				glm::vec4 color;
-				if (network.weights[i][j] > 0)
+				if (network.weights2[i][j] > 0)
 				{
-					color = glm::vec4(0, 1, 0, network.weights[i][j] / 1.5);
+					color = glm::vec4(0, 1, 0, network.weights2[i][j] / 1.5);
 				}
 				else
 				{
-					color = glm::vec4(1, 0, 0, network.weights[i][j] / -1.5);
+					color = glm::vec4(1, 0, 0, network.weights2[i][j] / -1.5);
 				}
 
 				color.w = glm::clamp(color.w, 0.1f, 1.f);
 
-				glm::vec2 positions[] = {upkeyPositions, leftkeyPositions, rightkeyPositions};
 
-				renderLine((glm::vec2(j % mario::visionSizeX, j / mario::visionSizeX) + glm::vec2(0.5, 0.5)) * (float)blockSizePreview, positions[i] + glm::vec2(blockSizePreview) / 2.f,
+				renderLine(
+					firstNeuronPositions + glm::vec2{0, 10 * j * blockSizePreview / mario::subLayerSize},
+					secondNeuronPositions + glm::vec2{0, 10 * i * blockSizePreview / mario::subLayerSize},
 					color);
 
 			}
+		}
+	}
 
+	for (int i = 0; i < mario::subLayerSize; i++)
+	{
+		for (int j = 0; j < mario::visionTotal; j++)
+		{
 
+			if (network.weights1[i][j] != 0)
+			{
+				glm::vec4 color;
+				if (network.weights1[i][j] > 0)
+				{
+					color = glm::vec4(0, 1, 0, network.weights1[i][j] / 1.5);
+				}
+				else
+				{
+					color = glm::vec4(1, 0, 0, network.weights1[i][j] / -1.5);
+				}
+
+				color.w = glm::clamp(color.w, 0.1f, 1.f);
+
+
+				renderLine(
+					(glm::vec2(j % mario::visionSizeX, j / mario::visionSizeX) + glm::vec2(0.5, 0.5)) * (float)blockSizePreview,
+					firstNeuronPositions + glm::vec2{0, 10 * i * blockSizePreview / mario::subLayerSize},
+					color);
+
+			}
 		}
 	}
 
+
+
+	for (int i = 0; i < mario::subLayerSize; i++)
+	{
+		renderer.renderRectangle(
+			glm::vec4(firstNeuronPositions + glm::vec2{0, 10 * i * blockSizePreview/ mario::subLayerSize}, 
+			blockSizePreview/2, blockSizePreview/2)
+			, {1,0,1,0.5});
+	}
+
+
+	for (int i = 0; i < mario::subLayerSize; i++)
+	{
+		renderer.renderRectangle(
+			glm::vec4(secondNeuronPositions + glm::vec2{0, 10 * i * blockSizePreview / mario::subLayerSize},
+			blockSizePreview / 2, blockSizePreview / 2)
+			, {1,0,1,0.5});
+	}
+
+
+
 	renderer.renderRectangle(
 		glm::vec4(upkeyPositions, blockSizePreview, blockSizePreview)
 		, {0,0,1,0.5});

Pika/gameplay/containers/mario/marioCommon.h

@@ -289,6 +289,7 @@ struct GameplayRenderer
 
 static constexpr int visionSizeX = 7;
 static constexpr int visionSizeY = 15;
+static constexpr int subLayerSize = 15;
 
 static constexpr int visionTotal = visionSizeX * visionSizeY;
 
@@ -301,15 +302,15 @@ inline float getRandomFloat(std::mt19937 &rng, float min, float max)
 inline int getRandomInt(std::mt19937 &rng, int min, int max)
 {
 	std::uniform_int_distribution<int> dist(min, max);
-	return dist(rng);
+	int rez = dist(rng);
+	return rez;
 }
 
 inline bool getRandomChance(std::mt19937 &rng, float chance)
 {
-	int chanceI = glm::clamp(chance, 0.f, 1.f) * 100000;
-	int pick = getRandomInt(rng, 0, 100000);
+	float rez = getRandomFloat(rng, 0, 1);
 
-	if (pick > chanceI)
+	if (rez > chance)
 	{
 		return 0;
 	}
@@ -317,30 +318,113 @@ inline bool getRandomChance(std::mt19937 &rng, float chance)
 	{
 		return 1;
 	}
+
+	//int chanceI = glm::clamp(chance, 0.f, 1.f) * 10000;
+	//int pick = getRandomInt(rng, 0, 10000);
+	//
+	//if (pick > chanceI)
+	//{
+	//	return 0;
+	//}
+	//else
+	//{
+	//	return 1;
+	//}
 }
 
 struct NeuralNetork
 {
-	float weights[3][visionTotal] = {};
+
+
+
+	float weights1[subLayerSize][visionTotal] = {};
+	float weights2[subLayerSize][subLayerSize] = {};
+	float weights3[3][subLayerSize] = {};
+
+
+	float activationFunction(float a)
+	{
+		float sigmoid = 1.f / (1 + std::expf(-a));
+		return (sigmoid * 2.f) - 1.f;
+	}
 
 	void compute(int &moveDirection, bool &jump, char input[visionTotal])
 	{
+
 		float rezult[3] = {};
-		for (int i = 0; i < 3; i++)
+		//for (int i = 0; i < 3; i++)
+		//{
+		//	for (int j = 0; j < visionTotal; j++)
+		//	{
+		//		if (input[j] > 0)
+		//		{
+		//			rezult[i] += weights[i][j];
+		//		}
+		//		else
+		//		{
+		//			rezult[i] -= weights[i][j];
+		//		}
+		//	}
+		//}
+
+
+		//first layer
+		float resultFirstLayer[subLayerSize] = {};
+
+		for (int i = 0; i < subLayerSize; i++)
 		{
+
+			float rez = 0;
 			for (int j = 0; j < visionTotal; j++)
 			{
 				if (input[j] > 0)
 				{
-					rezult[i] += weights[i][j];
+					rez += weights1[i][j];
 				}
 				else
 				{
-					rezult[i] -= weights[i][j];
+					rez -= weights1[i][j];
 				}
 			}
+			rez = activationFunction(rez);
+			resultFirstLayer[i] = rez;
+		}
+
+		resultFirstLayer[subLayerSize - 1] = 1;
+
+		//second layer
+		float resultSecondLayer[subLayerSize] = {};
+		for (int i = 0; i < subLayerSize; i++)
+		{
+
+			float rez = 0;
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				rez += resultFirstLayer[j] * weights2[i][j];
+			}
+
+			rez = activationFunction(rez);
+			resultSecondLayer[i] = rez;
+		}
+
+
+		resultSecondLayer[subLayerSize - 1] = 1;
+
+		//final layer
+		for (int i = 0; i < 3; i++)
+		{
+			float rez = 0;
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				rez += resultSecondLayer[j] * weights3[i][j];
+			}
+
+			rezult[i] = activationFunction(rez);
+
 		}
 
+
+
 		float dir = rezult[2] - rezult[1];
 		if (std::abs(dir) < 0.2) { moveDirection = 0; }
 		else if(dir > 0)
@@ -352,7 +436,7 @@ struct NeuralNetork
 			moveDirection = -1;
 		}
 
-		if (rezult[0] > 1)
+		if (rezult[0] > 0)
 		{
 			jump = 1;
 		}
@@ -363,103 +447,253 @@ struct NeuralNetork
 
 	}
 
-	void addRandomNeuron(std::mt19937 &rng)
+	void addRandomConnection(std::mt19937 &rng)
 	{
-		std::vector<glm::ivec2> positions;
-		positions.reserve(visionTotal*3);
-		for (int i = 0; i < 3; i++)
+		std::vector<glm::ivec2> positions1;
+		positions1.reserve(visionTotal* subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
 			for (int j = 0; j < visionTotal; j++)
 			{
-				if (weights[i][j] == 0)
+				if (weights1[i][j] == 0)
+				{
+					positions1.push_back({i,j});
+				}
+			}
+
+		std::vector<glm::ivec2> positions2;
+		positions2.reserve(subLayerSize * subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights2[i][j] == 0)
+				{
+					positions2.push_back({i,j});
+				}
+			}
+
+		std::vector<glm::ivec2> positions3;
+		positions3.reserve(3 * subLayerSize);
+		for (int i = 0; i < 3; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights3[i][j] == 0)
 				{
-					positions.push_back({i,j});
+					positions3.push_back({i,j});
 				}
 			}
 
-		if (!positions.empty())
+
+		if (!positions1.empty() && getRandomChance(rng, 0.6))
 		{
-			auto index = getRandomInt(rng, 0, positions.size() - 1);
-			weights[positions[index].x][positions[index].y] = getRandomFloat(rng, -1.5, 1.5);
+			auto index = getRandomInt(rng, 0, positions1.size() - 1);
+			weights1[positions1[index].x][positions1[index].y] = getRandomFloat(rng, -1.5, 1.5);
+		}
+
+		if (!positions2.empty() && getRandomChance(rng, 0.2))
+		{
+			auto index = getRandomInt(rng, 0, positions2.size() - 1);
+			weights2[positions2[index].x][positions2[index].y] = getRandomFloat(rng, -1.5, 1.5);
+		}
+
+		if (!positions3.empty() && getRandomChance(rng, 0.2))
+		{
+			auto index = getRandomInt(rng, 0, positions3.size() - 1);
+			weights3[positions3[index].x][positions3[index].y] = getRandomFloat(rng, -1.5, 1.5);
 		}
 	}
+
 	
-	void removeRandomNeuron(std::mt19937 &rng)
+	void removeRandomWeight(std::mt19937 &rng)
 	{
-		std::vector<glm::ivec2> positions;
-		positions.reserve(visionTotal * 3);
-		for (int i = 0; i < 3; i++)
+		std::vector<glm::ivec2> positions1;
+		positions1.reserve(visionTotal * subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
 			for (int j = 0; j < visionTotal; j++)
 			{
-				if (weights[i][j] != 0)
+				if (weights1[i][j] != 0)
 				{
-					positions.push_back({i,j});
+					positions1.push_back({i,j});
 				}
 			}
 
-		if (!positions.empty())
+		std::vector<glm::ivec2> positions2;
+		positions2.reserve(subLayerSize * subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights2[i][j] != 0)
+				{
+					positions2.push_back({i,j});
+				}
+			}
+
+		std::vector<glm::ivec2> positions3;
+		positions3.reserve(3 * subLayerSize);
+		for (int i = 0; i < 3; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights3[i][j] != 0)
+				{
+					positions3.push_back({i,j});
+				}
+			}
+
+		if (!positions1.empty() && getRandomChance(rng, 0.6))
+		{
+			auto index = getRandomInt(rng, 0, positions1.size() - 1);
+			weights1[positions1[index].x][positions1[index].y] = 0;
+		}
+
+		if (!positions2.empty() && getRandomChance(rng, 0.2))
 		{
-			auto index = getRandomInt(rng, 0, positions.size() - 1);
-			weights[positions[index].x][positions[index].y] = 0;
+			auto index = getRandomInt(rng, 0, positions2.size() - 1);
+			weights2[positions2[index].x][positions2[index].y] = 0;
 		}
+
+		if (!positions3.empty() && getRandomChance(rng, 0.2))
+		{
+			auto index = getRandomInt(rng, 0, positions3.size() - 1);
+			weights3[positions3[index].x][positions3[index].y] = 0;
+		}
+
 	}
 
-	void changeRandomNeuron(std::mt19937 &rng)
+	void changeRandomWeight(std::mt19937 &rng)
 	{
-		std::vector<glm::ivec2> positions;
-		positions.reserve(visionTotal * 3);
-		for (int i = 0; i < 3; i++)
+		std::vector<glm::ivec2> positions1;
+		positions1.reserve(visionTotal * subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
 			for (int j = 0; j < visionTotal; j++)
 			{
-				if (weights[i][j] != 0)
+				if (weights1[i][j] != 0)
+				{
+					positions1.push_back({i,j});
+				}
+			}
+
+		std::vector<glm::ivec2> positions2;
+		positions2.reserve(subLayerSize * subLayerSize);
+		for (int i = 0; i < subLayerSize; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights2[i][j] != 0)
+				{
+					positions2.push_back({i,j});
+				}
+			}
+
+		std::vector<glm::ivec2> positions3;
+		positions3.reserve(3 * subLayerSize);
+		for (int i = 0; i < 3; i++)
+			for (int j = 0; j < subLayerSize; j++)
+			{
+				if (weights3[i][j] != 0)
 				{
-					positions.push_back({i,j});
+					positions3.push_back({i,j});
 				}
 			}
 
-		if (!positions.empty())
+		if (!positions1.empty() && getRandomChance(rng, 0.6))
 		{
-			auto index = getRandomInt(rng, 0, positions.size() - 1);
-			weights[positions[index].x][positions[index].y] = getRandomFloat(rng, -1.5, 1.5);
+			auto index = getRandomInt(rng, 0, positions1.size() - 1);
+			weights1[positions1[index].x][positions1[index].y] = getRandomFloat(rng, -1.5, 1.5);
+		}
+
+		if (!positions2.empty() && getRandomChance(rng, 0.2))
+		{
+			auto index = getRandomInt(rng, 0, positions2.size() - 1);
+			weights2[positions2[index].x][positions2[index].y] = getRandomFloat(rng, -1.5, 1.5);
+		}
+
+		if (!positions3.empty() && getRandomChance(rng, 0.2))
+		{
+			auto index = getRandomInt(rng, 0, positions3.size() - 1);
+			weights3[positions3[index].x][positions3[index].y] = getRandomFloat(rng, -1.5, 1.5);
 		}
 	}
 
 	void combine(std::mt19937 &rng, NeuralNetork &other)
 	{
-		std::vector<glm::ivec2> positions;
+		//std::vector<glm::ivec2> positions;
+		//for (int i = 0; i < 3; i++)
+		//	for (int j = 0; j < visionTotal; j++)
+		//	{
+		//		if (weights[i][j] != other.weights[i][j])
+		//		{
+		//			positions.push_back({i,j});
+		//		}
+		//	}
+		//
+		//float chance = getRandomFloat(rng, 0, 1);
+		//
+		//for (auto p : positions)
+		//{
+		//	bool combine = getRandomInt(rng, 0, 5) == 1;
+		//	int i = p.x;
+		//	int j = p.y;
+		//
+		//	if (combine)
+		//	{
+		//		weights[i][j] = (weights[i][j] + other.weights[i][j]) / 2.f;
+		//	}
+		//	else
+		//	{
+		//		bool keeper = getRandomChance(rng, chance);
+		//		if (keeper)
+		//		{
+		//			weights[i][j] = other.weights[i][j];
+		//		}
+		//		else
+		//		{
+		//			//keep
+		//		}
+		//	}
+		//}
+
+
+		//last layer
 		for (int i = 0; i < 3; i++)
-			for (int j = 0; j < visionTotal; j++)
+		{
+			bool keep = getRandomChance(rng, 0.5);
+
+			if (!keep)
 			{
-				if (weights[i][j] != other.weights[i][j])
+				for (int j = 0; j < subLayerSize; j++)
 				{
-					positions.push_back({i,j});
+					weights3[i][j] = other.weights3[i][j];
 				}
 			}
-		
-		float chance = getRandomFloat(rng, 0, 1);
+		}
 
-		for (auto p : positions)
+		//intermediate layer
+		for (int i = 0; i < subLayerSize; i++)
 		{
-			bool combine = getRandomInt(rng, 0, 5) == 1;
-			int i = p.x;
-			int j = p.y;
+			bool keep = getRandomChance(rng, 0.5);
 
-			if (combine)
-			{
-				weights[i][j] = (weights[i][j] + other.weights[i][j]) / 2.f;
-			}
-			else
+			if (!keep)
 			{
-				bool keeper = getRandomChance(rng, chance);
-				if (keeper)
+				for (int j = 0; j < subLayerSize; j++)
 				{
-					weights[i][j] = other.weights[i][j];
+					weights2[i][j] = other.weights2[i][j];
 				}
-				else
+			}
+		}
+
+		//first layer
+		for (int i = 0; i < subLayerSize; i++)
+		{
+			bool keep = getRandomChance(rng, 0.5);
+
+			if (!keep)
+			{
+				for (int j = 0; j < visionTotal; j++)
 				{
-					//keep
+					weights1[i][j] = other.weights1[i][j];
 				}
 			}
 		}
+
+
 	}
 
 };
@@ -468,6 +702,7 @@ struct PlayerSimulation
 {
 	mario::Player p;
 	float maxFit = 0;
+	float maxPosition = 0;
 	float killTimer = 0;
 	int jumpCount = 0;
 };

Pika/gameplay/containers/mario/marioNeuralTrainer.h

@@ -24,7 +24,7 @@ struct MarioNeuralTrainer: public Container
 	static ContainerStaticInfo containerInfo()
 	{
 		ContainerStaticInfo info = {};
-		info.defaultHeapMemorySize = pika::MB(100);
+		info.defaultHeapMemorySize = pika::MB(400);
 
 		info.extensionsSuported = {".mario"};
 
@@ -36,6 +36,7 @@ struct MarioNeuralTrainer: public Container
 	
 	struct SimulationNetwork
 	{
+		bool mutation = 0;
 		mario::PlayerSimulation player;
 		mario::NeuralNetork network;
 	};
@@ -99,11 +100,12 @@ struct MarioNeuralTrainer: public Container
 			i.player = {};
 			i.player.p.position.position = {1,1};
 			i.player.p.lastPos = {1,1};
+			i.mutation = 0;
 			simulations.push_back(i); 
 		}
 
 		//we also add some of the less fit people
-		for (int i = 0; i < 20; i++)
+		for (int i = 0; i < 10; i++)
 		{
 			float a = mario::getRandomFloat(rng, 0, 1);
 			float b = mario::getRandomFloat(rng, 0, 1);
@@ -128,38 +130,52 @@ struct MarioNeuralTrainer: public Container
 			newNetwork.player.p.lastPos = {1,1};
 
 			//combine the 2 individuals
+			
 			if (mario::getRandomChance(rng, 0.25))
 			{
-				int type = mario::getRandomInt(rng, 0, 100);
+				newNetwork.mutation = 1;
+
+				int type = mario::getRandomInt(rng, 0, 120);
 
 				if (type < 10)
 				{
-					newNetwork.network.removeRandomNeuron(rng);
-					newNetwork.network.removeRandomNeuron(rng);
-					newNetwork.network.removeRandomNeuron(rng);
+					newNetwork.network.removeRandomWeight(rng);
+					newNetwork.network.removeRandomWeight(rng);
+					newNetwork.network.removeRandomWeight(rng);
 				}
 				if (type < 25)
 				{
-					newNetwork.network.removeRandomNeuron(rng);
+					newNetwork.network.removeRandomWeight(rng);
 				}
 				else if (type < 50)
 				{
-					newNetwork.network.addRandomNeuron(rng);
+					newNetwork.network.addRandomConnection(rng);
 				}
 				else if (type < 75)
 				{
-					newNetwork.network.addRandomNeuron(rng);
-					newNetwork.network.addRandomNeuron(rng);
+					newNetwork.network.addRandomConnection(rng);
+					newNetwork.network.addRandomConnection(rng);
 				}
 				else if (type < 100)
 				{
-					newNetwork.network.changeRandomNeuron(rng);
+					newNetwork.network.changeRandomWeight(rng);
+				}
+				else if (type <= 120)
+				{
+					newNetwork.network.changeRandomWeight(rng);
+					newNetwork.network.changeRandomWeight(rng);
+					newNetwork.network.changeRandomWeight(rng);
 				}
 
 			}
 			simulations.push_back(newNetwork);
 		}
 
+		for (auto &s : simulations)
+		{
+			s.player.p.position.position.y += mario::getRandomFloat(rng, 0, 5);
+		}
+
 		generation++;
 		deadSimulations.clear();
 	}
@@ -191,9 +207,10 @@ struct MarioNeuralTrainer: public Container
 		for (int i = 0; i < 100; i++)
 		{
 			SimulationNetwork s;
-			s.network.addRandomNeuron(rng);
-			s.network.addRandomNeuron(rng);
-			s.network.addRandomNeuron(rng);
+			s.network.addRandomConnection(rng);
+			s.network.addRandomConnection(rng);
+			s.network.addRandomConnection(rng);
+			s.network.addRandomConnection(rng);
 			s.player.p.position.position = {1,1};
 			s.player.p.lastPos = {1,1};
 			simulations.push_back(s);
@@ -272,7 +289,17 @@ struct MarioNeuralTrainer: public Container
 				newDelta, simulator, simulations[i].network))
 			{
 				deadSimulations.push_back(simulations[i]);
-				simulations.erase(simulations.begin() + i);
+
+				if (simulations.size() == 1)
+				{
+					simulations.clear();
+				}
+				else
+				{
+					simulations[i] = simulations[simulations.size() - 1];
+					simulations.pop_back();
+				}
+			
 				i--;
 				continue;
 			}
@@ -280,13 +307,13 @@ struct MarioNeuralTrainer: public Container
 
 		}
 
-		if (simulations.empty()) 
+		if (simulations.empty())
 		{
 
 			Generation result = {};
 
 			result.fitest = 0;
-			result.leastFit = 999999999999;
+			result.leastFit = 9999;
 			result.averageFit = 0;
 
 			for (auto &g : deadSimulations)
@@ -296,7 +323,7 @@ struct MarioNeuralTrainer: public Container
 					result.fitest = g.player.maxFit;
 				}
 
-				if (g.player.maxFit < result.leastFit)
+				if (g.player.maxFit < result.leastFit && !g.mutation)
 				{
 					result.leastFit = g.player.maxFit;
 				}
@@ -306,6 +333,16 @@ struct MarioNeuralTrainer: public Container
 
 			result.averageFit /= deadSimulations.size();
 
+			if (result.leastFit == 9999)
+			{
+				result.leastFit = 1;
+			}
+
+			if (result.leastFit >= result.averageFit)
+			{
+				result.leastFit = 1;
+			}
+
 			generations.push_back(result);
 
 			recreateGenerations(requestedInfo);

Pika/gameplay/containers/mario/marioNeuralVizualizer.h

@@ -52,9 +52,10 @@ struct MarioNeuralVizualizer: public Container
 
 		std::mt19937 rng(std::random_device{}());
 
-		network.addRandomNeuron(rng);
-		network.addRandomNeuron(rng);
-		network.addRandomNeuron(rng);
+		network.addRandomConnection(rng);
+		network.addRandomConnection(rng);
+		network.addRandomConnection(rng);
+		network.addRandomConnection(rng);
 
 		player.p.position.position = {1,1};
 		player.p.lastPos = {1,1};
@@ -103,7 +104,7 @@ struct MarioNeuralVizualizer: public Container
 		glBindFramebuffer(GL_FRAMEBUFFER, requestedInfo.requestedFBO.fbo);
 		renderer.render();
 
-		ImGui::Begin("Neural trainer");
+		ImGui::Begin("Neural trainer for visualizer");
 		{
 		
 			if (rezFile.run(2))
@@ -113,6 +114,8 @@ struct MarioNeuralVizualizer: public Container
 
 			ImGui::Checkbox("Fixed framerate", &fixedFramerate);
 
+			ImGui::Text("Pos: %d", (int)player.p.position.position.x);
+
 		}
 		ImGui::End();
 

Pika/resources/logs.txt

@@ -1,2 +1,66 @@
-#2024-06-09 13:26:30: Created container: MarioNeuralTrainer
-#2024-06-09 13:35:34: Destroyed continer: MarioNeuralTrainer #1
+#2024-06-10 13:05:12: Created container: MarioNeuralTrainer
+#2024-06-10 13:07:51: Destroyed continer: MarioNeuralTrainer #1
+#2024-06-10 13:09:13[warning]: Couldn't reloaded dll
+#2024-06-10 13:09:14: Reloaded dll
+#2024-06-10 13:09:21: Created container: MarioNeuralTrainer
+#2024-06-10 13:11:16: Destroyed continer: MarioNeuralTrainer #2
+#2024-06-10 13:11:41[warning]: Couldn't reloaded dll
+#2024-06-10 13:11:41: Reloaded dll
+#2024-06-10 13:12:17[warning]: Couldn't reloaded dll
+#2024-06-10 13:12:17: Reloaded dll
+#2024-06-10 13:12:29: Created container: MarioNeuralTrainer
+#2024-06-10 14:16:11: Destroyed continer: MarioNeuralTrainer #3
+#2024-06-10 14:18:09: Created container: MarioNeuralVizualizer
+#2024-06-10 14:18:11: Destroyed continer: MarioNeuralVizualizer #4
+#2024-06-10 14:18:18: Created container: MarioNeuralVizualizer
+#2024-06-10 14:18:45: Destroyed continer: MarioNeuralVizualizer #5
+#2024-06-10 14:18:47: Created container: MarioEditor
+#2024-06-10 14:18:50: Destroyed continer: MarioEditor #6
+#2024-06-10 14:18:52: Created container: MarioEditor
+#2024-06-10 14:19:16: Destroyed continer: MarioEditor #7
+#2024-06-10 14:19:20: Created container: MarioNeuralVizualizer
+#2024-06-10 14:19:59: Destroyed continer: MarioNeuralVizualizer #8
+#2024-06-10 14:20:02: Created container: MarioNeuralVizualizer
+#2024-06-10 14:20:25: Destroyed continer: MarioNeuralVizualizer #9
+#2024-06-10 14:20:28: Created container: MarioNeuralVizualizer
+#2024-06-10 14:21:03: Destroyed continer: MarioNeuralVizualizer #10
+#2024-06-10 14:21:07: Created container: MarioEditor
+#2024-06-10 14:21:51: Destroyed continer: MarioEditor #11
+#2024-06-10 14:21:53: Created container: MarioNeuralVizualizer
+#2024-06-10 14:22:33: Destroyed continer: MarioNeuralVizualizer #12
+#2024-06-10 14:22:38: Created container: MarioEditor
+#2024-06-10 14:22:57: Destroyed continer: MarioEditor #13
+#2024-06-10 14:23:00: Created container: MarioNeuralTrainer
+#2024-06-10 14:23:02: Destroyed continer: MarioNeuralTrainer #14
+#2024-06-10 14:23:03: Created container: MarioNeuralVizualizer
+#2024-06-10 14:23:18: Destroyed continer: MarioNeuralVizualizer #15
+#2024-06-10 14:23:20: Created container: MarioEditor
+#2024-06-10 14:23:33: Destroyed continer: MarioEditor #16
+#2024-06-10 14:23:35: Created container: MarioNeuralVizualizer
+#2024-06-10 14:24:12: Destroyed continer: MarioNeuralVizualizer #17
+#2024-06-10 14:24:15: Created container: MarioEditor
+#2024-06-10 14:25:00: Destroyed continer: MarioEditor #18
+#2024-06-10 14:25:04: Created container: MarioNeuralVizualizer
+#2024-06-10 14:25:17: Destroyed continer: MarioNeuralVizualizer #19
+#2024-06-10 14:25:22: Created container: MarioEditor
+#2024-06-10 14:25:48: Destroyed continer: MarioEditor #20
+#2024-06-10 14:25:50: Created container: MarioNeuralVizualizer
+#2024-06-10 14:26:26: Destroyed continer: MarioNeuralVizualizer #21
+#2024-06-10 14:26:29: Created container: MarioNeuralVizualizer
+#2024-06-10 14:26:52: Destroyed continer: MarioNeuralVizualizer #22
+#2024-06-10 14:26:54: Created container: MarioEditor
+#2024-06-10 14:27:08: Destroyed continer: MarioEditor #23
+#2024-06-10 14:27:12: Created container: MarioNeuralVizualizer
+#2024-06-10 14:27:31: Destroyed continer: MarioNeuralVizualizer #24
+#2024-06-10 14:27:34: Created container: MarioEditor
+#2024-06-10 14:27:49: Destroyed continer: MarioEditor #25
+#2024-06-10 14:27:51: Created container: MarioNeuralVizualizer
+#2024-06-10 14:28:07: Destroyed continer: MarioNeuralVizualizer #26
+#2024-06-10 14:28:44: Created container: MarioEditor
+#2024-06-10 14:29:25: Destroyed continer: MarioEditor #27
+#2024-06-10 14:29:28: Created container: MarioNeuralTrainer
+#2024-06-10 14:34:03[warning]: Couldn't reloaded dll
+#2024-06-10 14:34:03: Reloaded dll
+#2024-06-10 15:21:39: Created container: MarioNeuralVizualizer
+#2024-06-10 15:22:23: Destroyed continer: MarioNeuralVizualizer #29
+#2024-06-10 15:22:26: Destroyed continer: MarioNeuralTrainer #28

Pika/resources/mario/11final2.txt

@@ -0,0 +1,258 @@
+1 1 1
+1 1.00995 16.25
+-6 5.89731 93.4669
+15.201 18.8905 70.4478
+15.0719 29.8178 93.2142
+15.25 65.6492 102.754
+15.1582 76.5638 94.7054
+15.1274 57.5225 70.1478
+15.25 34.2103 142.099
+15.193 83.4809 100.49
+15.25 56.8643 76.4949
+15.25 68.9741 76.2768
+19.354 39.8332 142.25
+15.25 67.9267 142.25
+15.2465 65.2317 93.091
+15.0583 98.07 142.25
+15.25 29.0528 70.5009
+15.25 71.7886 142.25
+15.25 80.4264 100.34
+15.25 99.7597 141.913
+15.1525 86.8654 142.25
+15.25 109.448 142.25
+15.1696 53.5549 142.25
+15.25 72.4812 93.2928
+15.2067 70.1321 93.4342
+15.0901 18.5803 70.6824
+15.1683 81.1532 142.201
+15.1031 93.5252 142.25
+15.1055 55.9776 142.25
+15.25 92.6501 142.111
+15.25 52.4837 142.223
+15.149 107.36 142.245
+15.2406 74.3619 142.161
+15.1523 99.6307 142.25
+15.25 101.129 142.25
+15.2062 84.8008 142.25
+15.25 70.7184 142.25
+15.136 125.908 142.25
+15.0703 66.8025 142.237
+15.0864 38.307 70.5768
+15.2158 130.296 142.203
+15.25 106.567 142.167
+15.214 97.7635 142.25
+15.2116 93.3491 142.117
+15.0603 46.3873 70.4911
+15.0574 60.1431 142.179
+15.0648 65.6236 142.25
+15.1601 87.6066 142.097
+15.1557 94.9527 142.25
+15.11 57.6219 142.161
+15.2075 112.649 142.25
+15.25 103.585 142.156
+15.2372 112.266 142.25
+15.2409 51.1258 70.2285
+15.1348 108.065 142.25
+15.1748 49.1729 70.2383
+15.0885 111.177 142.25
+15.2232 111.623 142.112
+15.1992 95.7349 142.25
+15.25 83.9879 142.25
+15.1544 68.3482 142.093
+15.25 40.8328 70.4023
+15.0894 69.6854 142.25
+15.1766 126.752 142.25
+15.25 99.3298 142.25
+15.2177 62.6892 93.0525
+15.1536 88.8651 142.093
+15.25 60.5111 142.217
+15.1383 68.1532 142.25
+15.1932 56.6004 92.7776
+15.1926 100.177 142.125
+15.1817 94.0767 142.181
+15.0665 47.868 64.9393
+15.1213 67.3748 142.208
+15.1591 104.55 142.13
+15.1507 57.9773 142.25
+15.1701 56.314 70.2667
+15.1328 100.928 142.186
+15.2099 119.856 142.25
+15.101 109.192 142.25
+15.25 87.4448 142.25
+15.25 117.897 142.25
+15.1128 111.479 142.173
+15.25 47.4301 93.1212
+15.1803 56.2922 142.161
+15.1985 104.343 142.25
+15.0693 52.6685 70.5246
+15.2267 65.7271 142.211
+15.25 69.0995 142.142
+15.1242 39.3195 81.3952
+15.0524 127.634 142.093
+15.0637 79.784 142.185
+15.25 89.8411 142.154
+15.16 124.506 142.11
+15.2447 116.413 142.25
+15.0563 115.107 142.25
+15.2339 80.6323 142.25
+15.1976 74.6547 142.171
+15.25 74.0903 93.0002
+15.1364 72.1681 142.195
+15.25 91.7548 142.118
+15.0905 81.4082 142.243
+15.1006 59.956 92.9908
+15.1038 78.949 142.24
+15.1903 43.7029 70.4217
+15.1757 89.2925 142.172
+15.1826 48.4756 70.175
+15.1113 84.0131 142.25
+15.0556 63.1833 142.107
+15.0802 58.7741 142.149
+15.1007 55.9784 70.3504
+15.1099 71.5331 142.073
+15.1008 115.453 142.25
+15.07 74.8017 142.243
+-6 63.7864 142.25
+15.25 101.21 142.25
+10.25 87.0745 173.972
+10.073 47.3095 142.25
+10.0625 123.057 173.985
+10.2237 46.3072 126.163
+-6.22472 54.7564 308.771
+-7.25941 78.3869 232.285
+-7.30461 48.6948 310.876
+-6.35972 64.5236 308.953
+-7.16071 80.7404 236.871
+-7.29098 65.8041 296.114
+-6.2829 95.6556 236.98
+0.745991 59.2458 310.701
+0.649881 94.3719 308.91
+15.1608 112.794 310.256
+15.1167 106.587 309.987
+15.106 106.752 238.739
+15.1087 99.7012 238.823
+15.1549 86.9756 232.549
+15.092 71.2472 307.812
+4.64291 102.009 309.732
+-7.34082 77.473 238.703
+-7.31103 85.5972 239.895
+-7.26547 59.9097 309.631
+1.04548 75.4131 310.496
+1.76328 84.4029 311.453
+12.8911 119.148 269.103
+15.0926 94.9556 294.197
+15.25 120.48 239.459
+15.1703 105.218 238.841
+15.25 117.725 309.795
+15.1252 141.245 292.885
+15.25 149.167 309.565
+15.1324 133.125 309.984
+15.0704 96.2672 238.9
+15.0827 219.221 238.452
+1.70244 98.8368 310.973
+15.25 153.726 309.905
+0.908907 136.612 238.917
+18.3834 197.307 309.839
+15.1963 186.621 309.571
+15.2481 119.523 309.796
+0.632656 131.511 309.708
+15.0728 142.688 308.251
+15.1487 93.9612 309.956
+0.630497 121.994 309.825
+15.0766 80.4852 238.992
+15.25 157.4 309.347
+15.1662 127.533 308.852
+13.9696 122.496 238.763
+14.1069 155.426 238.679
+15.0699 112.105 238.709
+15.1539 142.614 309.408
+15.1234 154.302 309.098
+15.1213 139.567 308.553
+15.25 165.592 307.634
+15.1112 152.402 238.666
+15.25 114.059 308.259
+15.25 143.802 309.61
+0.639971 107.958 309.506
+0.662815 77.5578 309.76
+0.684664 94.6225 239.009
+0.664747 81.8836 240.009
+0.712917 127.253 309.723
+0.645445 138.019 308.754
+0.684406 92.8485 238.952
+0.724636 106.129 238.728
+15.1146 157.394 307.648
+15.0548 165.229 238.829
+2.64256 105.544 309.412
+15.0894 148.333 310.335
+15.1878 139.879 272.156
+15.2251 109.294 309.426
+15.25 93.594 238.785
+15.247 75.4092 239.001
+0.663591 99.9973 238.793
+15.0865 130.873 239.006
+15.25 123.383 309.346
+15.2487 147.554 310.616
+15.1377 88.4867 310.524
+15.25 127.009 308.645
+15.1754 156.261 272.643
+0.627352 183.909 238.845
+15.2291 124.404 239.017
+15.0557 197.761 308.949
+0.887074 153.839 309.748
+0.626751 144.697 293.972
+0.634554 104.09 309.205
+0.693312 110.815 308.729
+0.718283 152.946 309.529
+0.629049 117.39 307.767
+0.725836 84.8248 310.529
+15.25 106.596 308.469
+23.4577 101.353 310.518
+-0.315027 121.818 340.082
+23.7318 142.369 310.661
+0.642677 135.095 308.562
+18.1283 77.0805 309.968
+0.667995 109.164 310.654
+0.74836 114.843 310.84
+0.761147 125.65 309.633
+0.696699 150.305 308.974
+15.08 154.556 309.963
+18.8393 187.652 309.478
+25.0913 160.918 309.125
+23.7063 205.004 308.899
+62.0772 179.715 309.015
+62.4515 209.252 328.614
+53.25 153.303 339.25
+18.551 196.551 309.335
+22.792 117.054 308.992
+62.3664 136.961 308.271
+21.4088 198.751 308.919
+61.2081 173.2 308.689
+62.3723 182.878 308.024
+61.8138 224.872 308.853
+2.79435 170.313 308.909
+17.0225 215.772 309.022
+18.0864 182.26 307.751
+2.85838 213.631 308.191
+176.137 255.611 343.629
+-6.37387 95.9824 308.125
+-6.29148 189.505 308.345
+62.3521 221.986 308.777
+62.5154 69.4178 237.896
+2.65286 91.7214 308.928
+2.6543 100.999 309.53
+13.6566 94.4071 307.703
+12.8799 122.555 308.397
+13.6723 89.5388 308.835
+-6.17879 126.052 309.084
+2.83795 120.34 328.734
+2.67675 202.444 309.467
+2.71292 128.401 308.64
+12.2269 227.18 309.286
+12.5744 154.589 309.772
+0.977415 146.477 339.163
+12.0479 144.676 308.906
+18.3942 127.753 309.4
+17.8219 109.801 309.6
+13.6583 97.8639 340.25
+4.63121 124.97 308.763
+13.113 99.2393 309.686

Pika/resources/mario/13final3.txt

@@ -0,0 +1,206 @@
+-6 0.93 1
+1 1.01837 16.25
+-7 5.51926 142.25
+-7 15.5731 142.198
+-7 22.3413 142.25
+-6 41.8178 142.225
+-7 92.4541 143.119
+-6.32762 65.2607 142.234
+-6 73.1387 142.25
+15.25 109.207 142.25
+-6 66.0348 142.163
+-7 46.9409 142.115
+-7 98.9143 142.247
+-7 66.8713 142.23
+-7 72.936 172.712
+-6 68.9017 142.25
+-7 101.025 142.25
+-7 86.5376 142.24
+15.25 97.0568 142.25
+15.055 63.426 142.25
+15.1236 104.678 213.408
+15.0753 88.0944 171.685
+-7 51.9047 142.25
+15.2152 109.652 142.25
+-80.9007 89.335 142.25
+-100.75 9.61952 70.0827
+-95.8333 46.7004 70.25
+-95.8521 49.9255 75.2058
+-100.934 48.1698 75.25
+-100.757 37.5398 70.25
+-95.9361 52.2058 70.25
+11.25 38.0538 70.25
+11.1299 56.0759 70.25
+11.25 61.3732 72.0643
+11.1609 51.35 70.25
+11.0737 45.2752 70.2421
+11.0529 50.1128 70.1788
+11.2234 53.5343 70.25
+11.1292 47.8133 70.25
+11.1141 56.592 70.25
+11.1176 47.0046 70.25
+11.25 39.24 70.25
+11.0943 52.5134 70.25
+11.0539 44.1253 70.2419
+11.0987 57.172 72.25
+11.0715 43.1225 70.2101
+11.068 45.485 70.25
+11.25 48.6614 70.2059
+11.1939 47.8139 70.25
+11.0689 51.5021 70.1575
+11.0952 47.6442 70.25
+11.1862 56.0921 70.25
+11.25 64.961 70.25
+11.25 53.3155 70.25
+11.1246 42.3332 70.25
+11.1262 49.0376 70.25
+11.161 32.1356 70.25
+11.1258 51.1665 70.2142
+11.2082 48.8226 70.25
+11.0552 46.026 70.1634
+11.164 55.5797 70.25
+11.1988 50.4543 70.25
+11.1717 40.7197 70.25
+11.25 53.0774 70.25
+11.1407 48.6169 70.25
+11.1111 49.2111 70.25
+11.1619 39.0458 70.25
+11.1272 43.1044 70.25
+11.1571 52.7147 70.25
+11.2229 48.0598 70.25
+11.2426 51.0657 70.25
+11.0686 49.7177 70.25
+11.1306 47.0687 72.2183
+11.1324 41.6338 70.25
+11.25 46.813 70.1907
+11.1769 55.8654 70.25
+11.0598 24.0653 70.1452
+11.1533 46.2564 70.1781
+11.0734 46.6965 70.25
+11.062 58.9164 70.25
+11.0793 49.0658 70.25
+11.11 45.8175 70.1991
+11.1981 45.2535 70.25
+11.0753 56.4375 85.6745
+11.2026 44.321 70.25
+11.0759 65.6535 85.8571
+11.2232 37.9387 70.25
+11.25 51.7602 70.25
+11.0755 52.4644 70.25
+11.0563 42.009 70.2107
+11.1821 42.5855 70.1703
+11.2069 46.7493 70.25
+11.2034 32.696 75.25
+11.0546 44.9425 100.988
+11.25 28.9211 80.6197
+-100.822 37.2389 70.25
+11.1014 32.5578 70.25
+-39 43.5033 80.9077
+-39 40.854 101.169
+-100.819 17.2662 70.2378
+11.1728 41.0344 70.1735
+11.25 39.086 70.25
+11.1932 49.2759 111.419
+11.0954 42.8222 75.25
+-39 45.8748 70.25
+-39 36.7886 70.25
+-39 45.0181 70.25
+-39 46.3211 70.2238
+-34 44.4911 75.2446
+-95.811 36.0113 70.25
+-43.3689 27.5641 70.25
+-110.75 55.8536 80.7881
+-24.8629 49.3729 80.8336
+-110.934 52.8551 75.25
+-100.865 29.7434 70.25
+-120.899 16.0349 70.2417
+-95.8968 44.1059 96.4613
+-100.75 45.4629 101.694
+-110.889 33.6978 101.68
+-107.75 36.4744 96.2874
+-110.799 30.0826 96.2543
+-105.929 36.1073 101.404
+-100.9 29.9602 113.982
+-110.851 33.8543 131.959
+-105.83 42.6677 137.357
+-107.75 23.84 104.648
+-115.75 18.6566 104.41
+-110.848 14.5821 109.009
+-115.846 16.1177 109.41
+-110.75 34.9513 111.573
+-100.75 57.0261 137.127
+-110.927 22.7531 136.241
+-115.75 54.2952 137.11
+-120.765 14.2254 141.734
+-120.832 53.1496 131.266
+-110.935 32.3862 137.068
+-110.949 17.4774 149.574
+-110.877 45.4863 111.586
+-100.926 25.3036 142.226
+-100.838 35.3961 154.665
+-115.75 13.9035 149.111
+-100.922 52.9921 154.378
+-95.8005 52.6826 149.483
+-110.75 32.8232 109.363
+-110.75 32.466 142.309
+-105.75 64.6865 109.262
+-100.947 25.287 104.442
+-105.948 55.2733 154.293
+-100.948 45.8765 154.445
+-100.918 37.3492 107.683
+-100.75 36.619 111.115
+-97.7623 40.7841 114.21
+-100.84 64.4317 154.475
+-112.75 32.0748 104.523
+-90.8808 -43.4721 104.383
+-110.861 36.9301 154.191
+-100.829 34.4607 109.483
+-92.9276 41.2109 109.322
+-115.75 59.1121 154.59
+-100.761 63.2064 142.413
+-105.757 38.8673 109.474
+-110.863 35.8856 136.989
+-105.823 60.9319 111.313
+-105.914 58.4272 111.69
+-95.75 50.3066 159.277
+-105.928 28.9297 154.362
+-100.917 55.0227 154.73
+-90.9491 34.4204 111.74
+-100.887 77.4304 159.304
+-95.8688 42.0334 164.331
+-100.919 57.1156 154.343
+-110.765 46.3189 147.367
+-100.75 26.5976 142.493
+-95.9264 26.9607 159.591
+-95.9184 12.7885 111.885
+-90.8284 41.863 111.764
+-100.848 28.6903 159.359
+-100.945 47.4481 111.997
+-100.92 54.4523 159.201
+-95.8967 56.2565 154.53
+-105.829 23.7954 154.558
+-100.83 13.6679 114.498
+-95.9479 52.5136 109.297
+-95.888 31.653 109.082
+-90.75 47.9073 112.427
+-100.792 41.2214 147.287
+-100.939 43.863 159.267
+-90.9155 47.3439 154.234
+-90.75 58.7311 154.254
+-100.775 63.0603 159.789
+-95.7874 54.3981 111.779
+-95.75 61.918 154.37
+11.1432 28.6187 159.275
+-95.909 63.2573 159.251
+-95.75 48.6257 111.755
+-90.75 53.9431 159.315
+-90.75 38.8905 159.243
+-95.9362 59.2374 159.429
+-100.75 47.3251 114.363
+-100.83 48.5408 159.236
+-100.75 46.6687 111.583
+-95.8879 49.6231 157.003
+-95.7626 54.1305 153.969
+-90.75 45.9726 107.246
+-95.75 37.2693 159.261
+-90.75 36.1235 111.885