package neural;

import java.util.Arrays;
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
import org.encog.engine.network.activation.ActivationSigmoid;
import org.encog.ml.data.basic.BasicMLData;
import org.encog.neural.data.basic.BasicNeuralDataSet;
import org.encog.neural.networks.BasicNetwork;
import org.encog.neural.networks.layers.BasicLayer;
import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
import robocode.BattleResults;
import robocode.control.*;
import robocode.control.events.*;

public class BattlefieldParameterEvaluator {
	// Minimum allowable battlefield size is 400
	final static int MAXBATTLEFIELDSIZE = 4000;
	// Minimum allowable gun cooling rate is 0.1
	final static double MAXGUNCOOLINGRATE = 10;
	final static int NUMBATTLEFIELDSIZES = 601;
	final static int NUMCOOLINGRATES = 501;
	final static int NUMSAMPLES = 1000;
	// Number of inputs for the multilayer perceptron (size of the input vectors)
	final static int NUM_NN_INPUTS = 2;
	// Number of hidden neurons of the neural network
	final static int NUM_NN_HIDDEN_UNITS = 50;
	// Number of epochs for training
	final static int NUM_TRAINING_EPOCHS = 100000;
	static int NdxBattle;
	static double[] FinalScore1;
	static double[] FinalScore2;

	public static void main(String[] args) {
double []BattlefieldSize=new double[NUMSAMPLES];
double []GunCoolingRate=new double[NUMSAMPLES];
FinalScore1=new double[NUMSAMPLES];
FinalScore2=new double[NUMSAMPLES];
Random rng=new Random(15L);
// Disable log messages from Robocode
RobocodeEngine.setLogMessagesEnabled(false);
// Create the RobocodeEngine
// Run from C:/Robocode
RobocodeEngine engine = new RobocodeEngine(new java.io.File("C:/Robocode"));
// Add our own battle listener to the RobocodeEngine
engine.addBattleListener(new BattleObserver());
// Show the Robocode battle view
engine.setVisible(false);
// Setup the battle specification
// Setup battle parameters
int numberOfRounds = 1;
long inactivityTime = 100;
int sentryBorderSize = 50;
boolean hideEnemyNames = false;
// Get the robots and set up their initial states
RobotSpecification[] competingRobots = 
engine.getLocalRepository("sample.RamFire,sample.TrackFire");
RobotSetup[] robotSetups = new RobotSetup[2];
for(NdxBattle=0;NdxBattle<NUMSAMPLES;NdxBattle++)
{
// Choose the battlefield size and gun cooling rate   
BattlefieldSize[NdxBattle]=
MAXBATTLEFIELDSIZE*(0.1+0.9*rng.nextDouble());
GunCoolingRate[NdxBattle]=MAXGUNCOOLINGRATE*(0.1+0.9*rng.nextDouble());
// Create the battlefield
BattlefieldSpecification battlefield = 
new BattlefieldSpecification((int)BattlefieldSize[NdxBattle],
(int)BattlefieldSize[NdxBattle]);
// Set the robot positions
robotSetups[0]=new RobotSetup(BattlefieldSize[NdxBattle]/2.0,
BattlefieldSize[NdxBattle]/3.0,0.0);
robotSetups[1]=new RobotSetup(BattlefieldSize[NdxBattle]/2.0,
2.0*BattlefieldSize[NdxBattle]/3.0,0.0);
// Prepare the battle specification
BattleSpecification battleSpec = 
new BattleSpecification(battlefield,
numberOfRounds,
inactivityTime,
GunCoolingRate[NdxBattle],
sentryBorderSize,
hideEnemyNames,
competingRobots,
robotSetups);
// Run our specified battle and let it run till it is over
engine.runBattle(battleSpec, true);
}
// Cleanup our RobocodeEngine
engine.close();
System.out.println(Arrays.toString(BattlefieldSize));
System.out.println(Arrays.toString(GunCoolingRate));
System.out.println(Arrays.toString(FinalScore1));
System.out.println(Arrays.toString(FinalScore2));
// Create the training dataset for the neural network
double [][]RawInputs=new double[NUMSAMPLES][NUM_NN_INPUTS];
double [][]RawOutputs=new double[NUMSAMPLES][1];
for(int NdxSample=0;NdxSample<NUMSAMPLES;NdxSample++)
{
// IMPORTANT: normalize the inputs and the outputs to
// the interval [0,1]    
RawInputs[NdxSample][0]=BattlefieldSize[NdxSample]/MAXBATTLEFIELDSIZE;
RawInputs[NdxSample][1]=GunCoolingRate[NdxSample]/MAXGUNCOOLINGRATE;
RawOutputs[NdxSample][0]=FinalScore1[NdxSample]/250;
}
BasicNeuralDataSet MyDataSet=new BasicNeuralDataSet(RawInputs,RawOutputs);
// Create and train the neural network   
//... TO DO ...
System.out.println("Training network...");
//... TO DO ...
System.out.println("Training completed.");
System.out.println("Testing network...");
// Generate test samples to build an output image
int []OutputRGBint=new int[NUMBATTLEFIELDSIZES*NUMCOOLINGRATES];
Color MyColor;
double MyValue=0;
double [][]MyTestData=new double
[NUMBATTLEFIELDSIZES*NUMCOOLINGRATES][NUM_NN_INPUTS];
for(int NdxBattleSize=0;NdxBattleSize<NUMBATTLEFIELDSIZES;NdxBattleSize++)
{
	for(int NdxCooling=0;NdxCooling<NUMCOOLINGRATES;NdxCooling++)
{
MyTestData[NdxCooling+NdxBattleSize*NUMCOOLINGRATES][0]=
0.1+0.9*((double)NdxBattleSize)/NUMBATTLEFIELDSIZES;
MyTestData[NdxCooling+NdxBattleSize*NUMCOOLINGRATES][1]=
0.1+0.9*((double)NdxCooling)/NUMCOOLINGRATES;
}
}
// Simulate the neural network with the test samples and fill a matrix
for(int NdxBattleSize=0;NdxBattleSize<NUMBATTLEFIELDSIZES;NdxBattleSize++)
{ 
	for(int NdxCooling=0;NdxCooling<NUMCOOLINGRATES;NdxCooling++)
{
// INSERT SOMETHING HERE
double MyTestData[NdxCooling+NdxBattleSize*NUMCOOLINGRATES];
MyValue=ClipColor(MyResult);
MyColor=new Color((float)MyValue,
(float)MyValue,
(float)MyValue);
OutputRGBint[NdxCooling+NdxBattleSize*NUMCOOLINGRATES]=
MyColor.getRGB();
}
}
System.out.println("Testing completed.");
// Plot the training samples
for(int NdxSample=0;;)
{
MyValue=ClipColor(FinalScore1[NdxSample]/250);
MyColor=new Color((float)MyValue,(float)MyValue,(float)MyValue);
int MyPixelIndex=(int)(Math.round(NUMCOOLINGRATES*((GunCoolingRate[NdxSample]/MAXGUNCOOLINGRATE)‐0.1)/0.9)+Math.round(NUMBATTLEFIELDSIZES*((BattlefieldSize[NdxSample]/MAXBATTLEFIELDSIZE)-0.1)/0.9)*NUMCOOLINGRATES);
if ((MyPixelIndex>=0) && 
(MyPixelIndex<NUMCOOLINGRATES*NUMBATTLEFIELDSIZES))
{
OutputRGBint[MyPixelIndex]=MyColor.getRGB();
}
}
BufferedImage img=new BufferedImage
(NUMCOOLINGRATES,NUMBATTLEFIELDSIZES,BufferedImage.TYPE_INT_RGB);
img.setRGB(0, 0, NUMCOOLINGRATES, NUMBATTLEFIELDSIZES,
OutputRGBint, 0, NUMCOOLINGRATES);
File f=new File("hello.png");
try {
ImageIO.write(img,"png",f);
} catch (IOException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
}
System.out.println("Image generated.");
// Make sure that the Java VM is shut down properly
System.exit(0);
}

	/*
	 * Clip a color value (double precision) to lie in the valid range [0,1]
	 */
	public static double ClipColor(double Value) {
		if (Value < 0.0) {
			Value = 0.0;
		}
		if (Value > 1.0) {
			Value = 1.0;
		}
		return Value;
	}

	//
	// Our private battle listener for handling the battle event we are interested in.
	//
	static class BattleObserver extends BattleAdaptor {
		// Called when the battle is completed successfully with battle results
		public void onBattleCompleted(BattleCompletedEvent e) {
			System.out.println("‐‐ Battle has completed ‐‐");
			// Get the indexed battle results
			BattleResults[] results = e.getIndexedResults();
			// Print out the indexed results with the robot names
			System.out.println("Battle results:");
			for (BattleResults result : results) {
				System.out.println(" " + result.getTeamLeaderName() + ": " + result.getScore());
			}
			// Store the scores of the robots
			BattlefieldParameterEvaluator.FinalScore1[NdxBattle] = results[0].getScore();
			BattlefieldParameterEvaluator.FinalScore2[NdxBattle] = results[1].getScore();
		}

		// Called when the game sends out an information message during the battle
		public void onBattleMessage(BattleMessageEvent e) {
			// System.out.println("Msg> " + e.getMessage());
		}

		// Called when the game sends out an error message during the battle
		public void onBattleError(BattleErrorEvent e) {
			System.out.println("Err> " + e.getError());
		}
	}
}