diff --git a/src/Graphwar/ComputerPlayer.java b/src/Graphwar/ComputerPlayer.java
index 97e8d1d..3619dc5 100644
--- a/src/Graphwar/ComputerPlayer.java
+++ b/src/Graphwar/ComputerPlayer.java
@@ -1,5 +1,5 @@
 //  Copyright (C) 2011 Lucas Catabriga Rocha <catabriga90@gmail.com>
-//    
+//
 //  This file is part of Graphwar.
 //
 //  Graphwar is free software: you can redistribute it and/or modify
@@ -25,7 +25,7 @@
 
 
 public class ComputerPlayer extends Player implements Runnable
-{		
+{
 	private int numGenerations;
 	private int numFunctions;
 	private EvolvableFunction[] bestFunction;
@@ -33,13 +33,13 @@ public class ComputerPlayer extends Player implements Runnable
 	private boolean over9000;
 	//private boolean sayFunc;
 	private boolean myTurn;
-	
+
 	private class EvolvableFunction implements Comparator<EvolvableFunction>
 	{
 		public PolishNotationFunction function;
 		public double angle;
 		public double points;
-		
+
 		EvolvableFunction()
 		{
 			function = new PolishNotationFunction();
@@ -47,62 +47,43 @@ private class EvolvableFunction implements Comparator<EvolvableFunction>
 			points = 0;
 		}
 
-		public int compare(EvolvableFunction arg0, EvolvableFunction arg1) 
+		public int compare(EvolvableFunction arg0, EvolvableFunction arg1)
 		{
 			if(arg0.points < arg1.points)
-			{
 				return 1;
-			}
 			if(arg0.points > arg1.points)
-			{
 				return -1;
-			}
-			else
-			{
-				return 0;	
-			}			
+			return 0;
 		}
-		
+
 	}
-	
-	
+
+
 	private double bestAngle;
 	private String function;
-	
-	
+
+
 	private boolean processingFunction;
-	
+
 	private Graphwar graphwar;
-	
+
 	private static Random random = new Random();
-		
+
 	public ComputerPlayer(String name, int playerID, int team, boolean localPlayer, int numSoldiers, boolean ready, int level, Graphwar graphwar)
 	{
 		super(name, playerID, team, localPlayer, numSoldiers, ready);
-		
+
 		this.graphwar = graphwar;
-		
+
 		this.numGenerations = level;
-		if(level > 9000)
-		{
-			over9000 = true;
-		}
-		else
-		{
-			over9000 = false;
-		}
+
+		over9000 = level > 9000;
 		this.numFunctions = Constants.NUM_FUNCTIONS_AI;
-		
+
 		bestFunction = new EvolvableFunction[Constants.MAX_SOLDIERS_PER_PLAYER];
-		for(int i=0; i<Constants.MAX_SOLDIERS_PER_PLAYER; i++)
-		{
-			bestFunction[i] = new EvolvableFunction();
-			bestFunction[i].function.makeRandomFunction(Constants.NORMAL_FUNC);
-			bestFunction[i].angle = Math.PI*random.nextDouble()-Math.PI/2;
-		}
-		
+
 		functions = new EvolvableFunction[Constants.MAX_SOLDIERS_PER_PLAYER][numFunctions];
-		
+
 		for(int i=0; i<Constants.MAX_SOLDIERS_PER_PLAYER; i++)
 		{
 			for(int j=0; j<numFunctions; j++)
@@ -112,353 +93,272 @@ public ComputerPlayer(String name, int playerID, int team, boolean localPlayer,
 				functions[i][j].angle = Math.PI*random.nextDouble()-Math.PI/2;
 			}
 		}
-		
+
 		function = "0";
 		bestAngle = 0;
-		
+
 		//sayFunc = false;
 		myTurn = false;
-		
+
 	}
-	
+
 	public double getAngle()
 	{
 		return bestAngle;
 	}
-		
+
     public void thinkFunction()
-    {    	
-    	if(over9000)
-    	{
-    		myTurn = true;
-    	}
-    	
-    	if(processingFunction == false)
-    	{
-    		processingFunction = true;
-    	
-    		new Thread(this).start();
-    	}
+    {
+		myTurn = over9000;
+
+		if(!processingFunction)
+		{
+			processingFunction = true;
+			new Thread(this).start();
+		}
     }
-    
+
     public void stopThinkFunction()
     {
-    	myTurn = false;
-    	processingFunction = false;
+		myTurn = false;
+		processingFunction = false;
     }
-    
+
    // public void setSayFunc(boolean sayFunc)
    // {
   //  	this.sayFunc = sayFunc;
   //  }
-    
-    private double evaluateFunction(PolishNotationFunction ft, double angle)
+
+    private double evaluateFunction(PolishNotationFunction ft, double angle, int gameMode)
     {
-    	Function func = new Function(ft);
-    	
-    	Player[] players = graphwar.getGameData().getPlayers().toArray(new Player[0]);
-    	int numPlayers = players.length;
-    	
-    	boolean inverted;
-    	
-    	if(this.team==Constants.TEAM1)
-		{
-    		inverted = false;
-		}
-		else
-		{
-			inverted = true;	
-		}
-    	
-		switch(graphwar.getGameData().getGameMode())
+		Function func = new Function(ft);
+
+		Player[] players = graphwar.getGameData().getPlayers().toArray(new Player[0]);
+		int numPlayers = players.length;
+
+		func.processRange(
+			graphwar.getGameData().getObstacle(),
+			players,
+			numPlayers,
+			graphwar.getGameData().getCurrentTurnIndex(),
+			this.team==Constants.TEAM2,
+			gameMode,
+			angle
+		);
+
+
+		double minDistSquared = 1000000;
+
+		double totalPoints = 0;
+
+
+		for(int i=0; i<numPlayers; i++)
 		{
-			case Constants.NORMAL_FUNC:
-				func.processFunctionRange(graphwar.getGameData().getObstacle(), players, numPlayers, graphwar.getGameData().getCurrentTurnIndex(), inverted);	
-			break;
-			case Constants.FST_ODE:
-				func.processRK4Range(graphwar.getGameData().getObstacle(), players, numPlayers, graphwar.getGameData().getCurrentTurnIndex(), inverted);
-			break;
-			case Constants.SND_ODE:
-				func.processRK42Range(graphwar.getGameData().getObstacle(), players, numPlayers, graphwar.getGameData().getCurrentTurnIndex(), angle, inverted);
-			break;
-		}
-    	
-    	double minDistSquared = 1000000;
-    	
-    	double totalPoints = 0;  	
-    	
-    	
-    	for(int i=0; i<numPlayers; i++)
-    	{
-    		soldiers:
-    		for(int j=0; j<players[i].getNumSoldiers(); j++)
-    		{
-    			if(players[i].soldiers[j].isAlive())
-    			{
-	    			for(int k=0; k<func.getNumPlayersHit(); k++)
+			soldiers:
+			for(int j=0; j<players[i].getNumSoldiers(); j++)
+			{
+				if(!players[i].soldiers[j].isAlive())
+					continue;
+				for(int k=0; k<func.getNumPlayersHit(); k++)
+				{
+					if(func.getPlayerHit(k) == i && func.getSoldierHit(k) == j)
 					{
-						if(func.getPlayerHit(k) == i && func.getSoldierHit(k) == j)
-						{
-							if(players[i].getTeam() != this.team)
-			    			{
-								totalPoints += 2000000;
-			    			}
-							else
-							{
-								totalPoints -= 2000000;
-							}
-							
-							continue soldiers;
-						}
+						totalPoints += (players[i].getTeam() == this.team)?-2000000:2000000;
+						continue soldiers;
 					}
-	    			
-	    			if(players[i].getTeam() != this.team)
-	    			{    				
-		    			double soldierMinDist = Double.MAX_VALUE;
-		    			
-		    			for(int k=0; k<func.getNumSteps(); k++)
-		    			{
-		    				double distX;
-							double distY = (-Constants.PLANE_LENGTH*func.getY(k)/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2) - players[i].getSoldiers()[j].getY();
-							
-							if(this.team==Constants.TEAM2)
-							{
-								distX = Constants.PLANE_LENGTH - (Constants.PLANE_LENGTH*func.getX(k)/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2) - players[i].getSoldiers()[j].getX();
-							
-								if(distX < 0)
-									continue;
-							}
-							else
-							{
-								distX = (Constants.PLANE_LENGTH*func.getX(k)/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2) - players[i].getSoldiers()[j].getX();
-							
-								if(distX > 0)
-									continue;
-							}
-							
-							double tempDistSquared = Math.pow(distX,2) + Math.pow(distY,2);
-							
-							if(tempDistSquared < soldierMinDist)
-							{
-								soldierMinDist = tempDistSquared;
-							}
-		    			}
-		    			
-		    			if(soldierMinDist < minDistSquared)
-		    			{
-		    				minDistSquared = soldierMinDist;
-		    			}
-	    			}
-    			}
-    		}
-    	}
-    	
-    	totalPoints += 1000000-minDistSquared;
-    	
-    	return totalPoints;
+				}
+
+				if(players[i].getTeam() == this.team)
+					continue;
+
+				double soldierMinDist = Double.MAX_VALUE;
+
+				for(int k=0; k<func.getNumSteps(); k++)
+				{
+					double distX = (Constants.PLANE_LENGTH*func.getX(k)/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2);
+					double distY = (-Constants.PLANE_LENGTH*func.getY(k)/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2);
+
+					boolean isTeam2 = this.team == Constants.TEAM2;
+
+					distX = ((isTeam2)?(Constants.PLANE_LENGTH - distX):distX) - players[i].getSoldiers()[j].getX();
+					distY = distY - players[i].getSoldiers()[j].getY();
+					if ((isTeam2 && distX < 0) || (!isTeam2 && distX > 0))
+						continue;
+
+					double tempDistSquared = Math.pow(distX,2) + Math.pow(distY,2);
+
+					if(tempDistSquared < soldierMinDist)
+						soldierMinDist = tempDistSquared;
+
+				}
+
+				if(soldierMinDist < minDistSquared)
+					minDistSquared = soldierMinDist;
+			}
+		}
+
+		totalPoints += 1000000-minDistSquared;
+
+		return totalPoints;
     }
 
     private int getFunctionToReproduce(EvolvableFunction[] functions, double totalPoints)
     {
-    	double randomPoints = totalPoints*random.nextDouble();
-    	
-    	for(int i=0; i<functions.length; i++)
-    	{
-    		if(totalPoints > randomPoints)
-    		{
-    			totalPoints -= functions[i].points;
-    		}
-    		else
-    		{
-    			return i;
-    		}
-    	}
-    	
-    	return 0;
+		double randomPoints = totalPoints*random.nextDouble();
+
+		for(int i=0; i<functions.length; i++)
+		{
+			if(totalPoints <= randomPoints)
+				return i;
+			totalPoints -= functions[i].points;
+
+		}
+
+		return 0;
     }
-    
+
     private double getTotalPoints(EvolvableFunction[] functions)
     {
-    	double totalPoints = 0;
-    	
-    	for(int i=0; i<functions.length; i++)
-    	{
-    		totalPoints += functions[i].points;
-    	}
-    	
-    	return totalPoints;
+		double totalPoints = 0;
+
+		for(int i=0; i<functions.length; i++)
+		{
+			totalPoints += functions[i].points;
+		}
+
+		return totalPoints;
     }
-    
-	public void run() 
-	{		
+
+	private double mutateAngle(double angle, int gameMode)
+	{
+		if(gameMode!=Constants.SND_ODE)
+			return angle;
+		if (random.nextBoolean())
+			return angle;
+		if (random.nextBoolean())
+			return Math.PI*random.nextDouble()-Math.PI/2;
+		return angle + angle*(random.nextDouble()-0.5)/5;
+	}
+
+	public void run()
+	{
 		int gameMode = graphwar.getGameData().getGameMode();
-		
+
 		EvolvableFunction[] functions = this.functions[this.getCurrentTurnSoldierIndex()];
-		
+
 		double totalPoints = 0;
-		
+
 		generationLoop:
 		for(int k=0; processingFunction && graphwar.getGameData().getGameState()==Constants.GAME && ((k<numGenerations && (graphwar.getGameData().getRemainingTime()) > 5000) || (over9000)); k++)
 		{
-			
-			if(graphwar.getGameData().getCurrentTurnPlayer() == this)
-			{
-				functions = this.functions[this.currentTurnSoldier];
-			}
-			else
+
+			functions = this.functions[this.currentTurnSoldier];
+			if (graphwar.getGameData().getCurrentTurnPlayer() != this)
 			{
 				int nextTurnSoldier = this.getCurrentTurnSoldierIndex();
-				
-				if(nextTurnSoldier == -1)
-				{
+				if (nextTurnSoldier == -1)
 					return;
-				}
-				else
-				{
-					functions = this.functions[nextTurnSoldier];
-				}
+				functions = this.functions[nextTurnSoldier];
 			}
-	    	
-	    	EvolvableFunction[] newFunctions = new EvolvableFunction[numFunctions];
-	    	
-	    	totalPoints = getTotalPoints(functions);
-	    	
-	    	for(int i=0; i<Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI; i++)
-	    	{
+
+			EvolvableFunction[] newFunctions = new EvolvableFunction[numFunctions];
+
+			totalPoints = getTotalPoints(functions);
+
+			for(int i=0; i<Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI; i++)
+			{
 	    		//newFunctions[i] = functions[getFunctionToReproduce(functions, totalPoints)];
-	    		newFunctions[i] = functions[i];
-	    	}
-	    	
-	    	for(int i=Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI; i<Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI+Constants.NUM_FUNCTION_MUTATED_AI; i++)
-	    	{
-	    		newFunctions[i] = new EvolvableFunction();
-	    		
-	    		int funcToMutate = getFunctionToReproduce(functions, totalPoints);	    		
+				newFunctions[i] = functions[i];
+			}
+
+			for(int i=Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI; i<Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI+Constants.NUM_FUNCTION_MUTATED_AI; i++)
+			{
+				newFunctions[i] = new EvolvableFunction();
+
+				int funcToMutate = getFunctionToReproduce(functions, totalPoints);
 	    		//int funcToMutate = 0;
-	    		newFunctions[i].function = new PolishNotationFunction(functions[funcToMutate].function, gameMode);
-	    		newFunctions[i].angle = functions[funcToMutate].angle;
-	    		
-	    		if(gameMode==Constants.SND_ODE)
-    			{
-	    			if(random.nextBoolean())
-    				{
-	    				if(random.nextBoolean())
-	    				{
-	    					functions[i].angle = Math.PI*random.nextDouble()-Math.PI/2;
-	    				}
-	    				else
-	    				{
-	    					functions[i].angle = functions[i].angle + functions[i].angle*(random.nextDouble()-0.5)/5;
-	    				}
-    				}
-    			}
-	    	}
-	    	
-	    	for(int i=Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI+Constants.NUM_FUNCTION_MUTATED_AI; i<numFunctions; i++)
-	    	{
-	    		newFunctions[i] = new EvolvableFunction();
-	    		
-	    		int cross1 = getFunctionToReproduce(functions, totalPoints);	    
-	    		int cross2 = getFunctionToReproduce(functions, totalPoints);	    
-	    		//int cross1 = 0;	    
+				newFunctions[i].function = new PolishNotationFunction(functions[funcToMutate].function, gameMode);
+
+				newFunctions[i].angle = functions[funcToMutate].angle;
+				newFunctions[i].angle = mutateAngle(newFunctions[i].angle, gameMode);
+
+			}
+
+			for(int i=Constants.NUM_FUNCTIONS_UNCHANGED_TURN_AI+Constants.NUM_FUNCTION_MUTATED_AI; i<numFunctions; i++)
+			{
+				newFunctions[i] = new EvolvableFunction();
+
+				int cross1 = getFunctionToReproduce(functions, totalPoints);
+				int cross2 = getFunctionToReproduce(functions, totalPoints);
+	    		//int cross1 = 0;
 	    		//int cross2 = 1;
-	    		newFunctions[i].function = new PolishNotationFunction(functions[cross1].function, functions[cross2].function, gameMode);
-	    		
-	    		if(random.nextBoolean())
-	    		{
-	    			newFunctions[i].angle = functions[cross1].angle;
-	    		}
-	    		else
-	    		{
-	    			newFunctions[i].angle = functions[cross2].angle;
-	    		}
-	    		
-	    		if(gameMode==Constants.SND_ODE)
-    			{
-	    			if(random.nextBoolean())
-    				{
-	    				if(random.nextBoolean())
-	    				{
-	    					functions[i].angle = Math.PI*random.nextDouble()-Math.PI/2;
-	    				}
-	    				else
-	    				{
-	    					functions[i].angle = functions[i].angle + functions[i].angle*(random.nextDouble()-0.5)/5;
-	    				}
-    				}
-    			}
-	    	}
-	    	
-	    	EvolvableFunction[] oldFunctions = this.functions[this.currentTurnSoldier];
-	    	this.functions[this.currentTurnSoldier] = newFunctions;
-	    	functions = newFunctions;
-	    	
-	    	for(int i=0; i<numFunctions; i++)
-	    	{   
-	    		double points = evaluateFunction(functions[i].function,functions[i].angle);	    
-	    		functions[i].points = points;
-	    		
+				newFunctions[i].function = new PolishNotationFunction(functions[cross1].function, functions[cross2].function, gameMode);
+
+				newFunctions[i].angle = functions[random.nextBoolean()?cross1:cross2].angle;
+				newFunctions[i].angle = mutateAngle(newFunctions[i].angle, gameMode);
+
+			}
+
+			EvolvableFunction[] oldFunctions = this.functions[this.currentTurnSoldier];
+			this.functions[this.currentTurnSoldier] = newFunctions;
+			functions = newFunctions;
+
+			for(int i=0; i<numFunctions; i++)
+			{
+				double points = evaluateFunction(functions[i].function,functions[i].angle, gameMode);
+				functions[i].points = points;
+
 	    		//System.out.print("|");
-	    		
-	    		if((graphwar.getGameData().getRemainingTime()) < 3000 && !over9000)
-	    		{
-	    			functions = oldFunctions;
-	    			this.functions[this.currentTurnSoldier] = oldFunctions;
-	    			break generationLoop;
-	    		}
-	    	}
-	    	
+				if ((graphwar.getGameData().getRemainingTime()) >= 3000 || over9000)
+					continue;
+				functions = oldFunctions;
+				this.functions[this.currentTurnSoldier] = oldFunctions;
+				break generationLoop;
+			}
+
 	    	//System.out.println();
-	    	
-	    	Arrays.sort(functions, functions[0]);
-	    	
-	    		    	
-	    	if(over9000)
-	    	{
-	    		if(myTurn && (graphwar.getGameData().getRemainingTime()) < 5000)
-	    		{
-	    			bestFunction[this.currentTurnSoldier] =  functions[0];	    			
-	    			sendFunction();
-	    			
-	    			myTurn = false;
-	    		}
-	    	}
-	    		 	
-	    			 
+
+			Arrays.sort(functions, functions[0]);
+
+
+			if(!over9000 || !myTurn || (graphwar.getGameData().getRemainingTime()) >= 5000)
+				continue;
+
+			bestFunction[this.currentTurnSoldier] =  functions[0];
+			sendFunction();
+
+			myTurn = false;
 		}
-		
-		//bestFunction[this.currentSoldierTurn] =  functions[getFunctionToReproduce(functions, totalPoints)];	    	
-	    if(processingFunction)
-	    {
-			if(over9000 == false)
-			{
-				bestFunction[this.currentTurnSoldier] =  functions[0];			
-				sendFunction();				
-			}
-	    }
-		
+
+		//bestFunction[this.currentSoldierTurn] =  functions[getFunctionToReproduce(functions, totalPoints)];
+		if(processingFunction && !over9000)
+		{
+			bestFunction[this.currentTurnSoldier] =  functions[0];
+			sendFunction();
+		}
+
 		processingFunction = false;
-		
+
 		//gameInfo.sendChatMessage(gameInfo.getCurrentTurn(), function + " " +  functions[0].points);
 	}
-	
+
 	private void sendFunction()
-	{		
+	{
 		function = bestFunction[this.currentTurnSoldier].function.simplifyFunction().getStringFunction();
 		bestAngle = bestFunction[this.currentTurnSoldier].angle;
-		
+
 		//System.out.println(this.getName()+":");
 		//System.out.println(bestFunction[this.currentTurnSoldier].function.getStringFunction());
 		//System.out.println(function);
-		
+
 		graphwar.getGameData().setAngle(bestAngle);
 		graphwar.getGameData().sendFunction(function);
-		
+
 		//if(sayFunc)
 		//{
 		//	graphwar.getGameData().sendChatMessage(this, function);
 		//}
-		
+
 	}
 
 }
diff --git a/src/Graphwar/Function.java b/src/Graphwar/Function.java
index 30bddaf..0c06f8c 100644
--- a/src/Graphwar/Function.java
+++ b/src/Graphwar/Function.java
@@ -1,5 +1,5 @@
 //  Copyright (C) 2011 Lucas Catabriga Rocha <catabriga90@gmail.com>
-//    
+//
 //  This file is part of Graphwar.
 //
 //  Graphwar is free software: you can redistribute it and/or modify
@@ -23,295 +23,146 @@ public class Function
 	private String strFunc;
 	private PolishNotationFunction polishFunc;
 	private double offSet;
-	
+
 	private double fireAngle;
 	private double[] valuesX;
 	private double[] valuesY;
 	private double[] valuesDY;
 	private int numSteps;
-	
+
 	private int[] playersHit;
 	private int[] soldiersHit;
 	private int[] soldierHitPosition;
 	private int numPlayersHit;
-	
+
 	private double lastX;
 	private double lastY;
-	
-	Function(String str) throws MalformedFunction
-	{		
-		strFunc = str;
-		
-		polishFunc = new PolishNotationFunction(strFunc);
-		
+
+	private void init()
+	{
 		offSet = 0;
-		
+
 		fireAngle = 0;
 		valuesX = null;
 		valuesY = null;
 		valuesDY = null;
 		numSteps = 0;
-		
+
 		playersHit = null;
 		soldiersHit = null;
+		soldierHitPosition = null;
 		numPlayersHit = 0;
-		
+
 		lastX = 0;
 		lastY = 0;
-		
 	}
-	
+
+	Function(String str) throws MalformedFunction
+	{
+		strFunc = str;
+		polishFunc = new PolishNotationFunction(strFunc);
+
+		init();
+
+	}
+
 	Function(PolishNotationFunction polishNotationFunction)
 	{
 		strFunc = "";
-		
 		polishFunc = polishNotationFunction;
-		
-		offSet = 0;
-		
-		fireAngle = 0;
-		valuesX = null;
-		valuesY = null;
-		valuesDY = null;
-		numSteps = 0;
-		
-		playersHit = null;
-		soldiersHit = null;
-		soldierHitPosition = null;
-		numPlayersHit = 0;
-		
-		lastX = 0;
-		lastY = 0;		
-		
+
+		init();
+
 	}
-	
+
 	public int getNumPlayersHit()
 	{
 		return numPlayersHit;
 	}
-	
+
 	public int getPlayerHit(int index)
 	{
 		return playersHit[index];
 	}
-	
+
 	public int getSoldierHit(int index)
 	{
 		return soldiersHit[index];
 	}
-	
+
 	public int getSoldierHitPosition(int index)
 	{
 		return soldierHitPosition[index];
 	}
-	
+
 	public double getFireAngle()
 	{
 		return fireAngle;
-	}	
-	
+	}
+
 	public double getX(int index)
 	{
 		return valuesX[index];
 	}
-	
+
 	public double getY(int index)
 	{
 		return valuesY[index];
 	}
-	
+
 	public int getNumSteps()
 	{
 		return numSteps;
 	}
-	
+
 	public String getStringFunc()
 	{
 		return strFunc;
 	}
-	
+
 	private double getStartAngle(double x, double radius)
 	{
 		double angle = 0;
-		
+
 		double startAngleTangent = (polishFunc.evaluateFunction(x+Constants.STEP_SIZE,0,0) - polishFunc.evaluateFunction(x,0,0))/Constants.STEP_SIZE;
 		angle = Math.atan(startAngleTangent);
-	
+
 		double finalX;
 		double error = 10000;
 		for(int i=0; error > Constants.ANGLE_ERROR && i<Constants.MAX_ANGLE_LOOPS; i++)
 		{
 			finalX = x + radius*Math.cos(angle);
 			startAngleTangent = (polishFunc.evaluateFunction(finalX+Constants.STEP_SIZE,0,0) - polishFunc.evaluateFunction(finalX,0,0))/Constants.STEP_SIZE;
-			
+
 			double newAngle = Math.atan(startAngleTangent);
-			
+
 			error = Math.abs(newAngle - angle);
-				
+
 			//System.out.println(angle+" "+newAngle);
 			//System.out.println(x+" "+finalX+" "+radius+"\n");
-			
+
 			angle = newAngle;
-			
-			
-		}		
-		
+
+
+		}
+
 		return angle;
 	}
-	
-	private boolean playerAlreadyHit(int player, int soldier)
+
+	private double getRK4(double x, double y, double step)
 	{
-		for(int i=0; i<numPlayersHit; i++)
-		{
-			if(playersHit[i] == player && soldiersHit[i]==soldier)
-				return true;
-		}
-		
-		return false;
-	}
-	
-	public void processFunctionRange(Obstacle obstacle, Player players[], int numPlayers, int currentTurn, boolean inverted)
-	{		
-		playersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		soldiersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		soldierHitPosition = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		numPlayersHit = 0;
-		
-		valuesX = new double[Constants.FUNC_MAX_STEPS];
-		valuesY = new double[Constants.FUNC_MAX_STEPS];
-		
-		Soldier currentTurnSoldier = players[currentTurn].getCurrentTurnSoldier();
-						
-		valuesX[0] = currentTurnSoldier.getX();
-		valuesY[0] = currentTurnSoldier.getY();
-		
-		if(inverted)
-		{
-			valuesX[0] = Constants.PLANE_LENGTH - valuesX[0];
-		}
-								
-		valuesX[0] = (Constants.PLANE_GAME_LENGTH*(valuesX[0] - Constants.PLANE_LENGTH/2))/Constants.PLANE_LENGTH;
-		valuesY[0] = (Constants.PLANE_GAME_LENGTH*(-valuesY[0] + Constants.PLANE_HEIGHT/2))/Constants.PLANE_LENGTH;
-		
-		double gameCoordinateRadius = ((double)(Constants.PLANE_GAME_LENGTH*Constants.SOLDIER_RADIUS))/Constants.PLANE_LENGTH;
-				
-		fireAngle = getStartAngle(valuesX[0], gameCoordinateRadius);
-				
-		if(Double.isNaN(fireAngle)==false && Double.isInfinite(fireAngle)==false )
-		{
-			valuesX[0] = valuesX[0] + gameCoordinateRadius*Math.cos(fireAngle);	
-			valuesY[0] = valuesY[0] + gameCoordinateRadius*Math.sin(fireAngle);
-		}
-				
-		offSet = -polishFunc.evaluateFunction(valuesX[0],0,0) + valuesY[0];
-			
-		double stepSize = Constants.STEP_SIZE;
-		double tempStepSize = Constants.STEP_SIZE;
-				
-		numSteps = Constants.FUNC_MAX_STEPS;		
-		for(int i=1; i<Constants.FUNC_MAX_STEPS; i++)
-		{	
-			tempStepSize = stepSize;
-			
-			valuesX[i] = valuesX[i-1] + tempStepSize;
-			valuesY[i] = polishFunc.evaluateFunction(valuesX[i],0,0)+offSet;
-			
-			boolean endFunc = false;
-			
-			for(int j=0; Math.pow(valuesX[i]-valuesX[i-1], 2)+Math.pow(valuesY[i]-valuesY[i-1], 2) > Constants.FUNC_MAX_STEP_DISTANCE_SQUARED;j++)
-			{			
-				if(valuesX[i]-valuesX[i-1]>Constants.FUNC_MIN_X_STEP_DISTANCE)
-				{
-					tempStepSize = tempStepSize/2;
-					
-					valuesX[i] = valuesX[i-1] + tempStepSize;	
-					valuesY[i] = polishFunc.evaluateFunction(valuesX[i],0,0)+offSet;
-				}
-				else
-				{
-					endFunc = true;
-					break;
-				}
-			}
-			
-			if(endFunc)
-			{
-				numSteps = i;
-				break;
-			}
-				
-			double x = Constants.PLANE_LENGTH*valuesX[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;
-			double y = -Constants.PLANE_LENGTH*valuesY[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
-		
-			
-			if(inverted)
-			{
-				x = Constants.PLANE_LENGTH - x;
-			}
-			
-			for(int j=0; j<numPlayers; j++)
-			{
-				for(int k=0; k<players[j].getNumSoldiers(); k++)
-				{
-					if(j==currentTurn)
-					{
-						if(k == players[j].getCurrentTurnSoldierIndex())
-						{
-							continue;
-						}							
-					}
-					
-					if(players[j].getSoldiers()[k].isAlive())
-					{
-										
-						double distX = players[j].getSoldiers()[k].getX() - x;
-						double distY = players[j].getSoldiers()[k].getY() - y;
-						
-						double distSquared = (Math.pow(distX, 2)+Math.pow(distY, 2));
-											
-						if(distSquared < Constants.SOLDIER_RADIUS*Constants.SOLDIER_RADIUS)
-						{
-							if(playerAlreadyHit(j,k)==false)
-							{
-								playersHit[numPlayersHit] = j;
-								soldiersHit[numPlayersHit] = k;
-								soldierHitPosition[numPlayersHit] = i;
-								numPlayersHit++;
-							}
-						}
-					}
-				}
-			}	
-		
-		
-			if(obstacle.collidePoint((int)x, (int)y))
-			{
-				numSteps = i;
-				break;
-			}
-			
-			if(Double.isNaN(y) || Double.isInfinite(y))
-			{
-				numSteps = i;
-				break;
-			}
-				
-		}
-		
-		lastX = Constants.PLANE_LENGTH*valuesX[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;
-		lastY = -Constants.PLANE_LENGTH*valuesY[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
-	
-		//for(int i=0; i<valuesX.length; i++)
-		//{			
-			//valuesX[i] = 80*valuesX[i]+400;
-			//valuesY[i] = 232-80*valuesY[i]+offSet;					
-		//}
+		double k1 = polishFunc.evaluateFunction( x, y, 0);
+		double k2 = polishFunc.evaluateFunction( x + 0.5*step, y + 0.5*step*k1, 0);
+		double k3 = polishFunc.evaluateFunction( x + 0.5*step, y + 0.5*step*k2, 0);
+		double k4 = polishFunc.evaluateFunction( x + step, y + step*k3, 0);
+
+		return y + (step/6)*(k1 + 2*k2 + 2*k3 + k4);
 	}
-	
+
 	private double getRK4StartAngle(double x, double y, double radius)
 	{
 		double angle = 0;
-		double startAngleTangent;		
+		double startAngleTangent;
 		double finalX;
 		double finalY;
 		double error = 10000;
@@ -319,370 +170,218 @@ private double getRK4StartAngle(double x, double y, double radius)
 		{
 			finalX = x + radius*Math.cos(angle);
 			finalY = y + radius*Math.sin(angle);
-			
+
 			double tempStepSize = Constants.STEP_SIZE;
-			
-			double k1 = polishFunc.evaluateFunction( finalX, finalY, 0);
-			double k2 = polishFunc.evaluateFunction( finalX + 0.5*tempStepSize, finalY + 0.5*tempStepSize*k1, 0);
-			double k3 = polishFunc.evaluateFunction( finalX + 0.5*tempStepSize, finalY + 0.5*tempStepSize*k2, 0);
-			double k4 = polishFunc.evaluateFunction( finalX + tempStepSize, finalY + tempStepSize*k3, 0);
-				
-			double nextY = finalY + (tempStepSize/6)*(k1 + 2*k2 + 2*k3 + k4);
+
+			double nextY = getRK4(finalX, finalY, tempStepSize);
 			double nextX = finalX + tempStepSize;
-						
+
 			startAngleTangent = (nextY-finalY)/(nextX-finalX);
-			
+
 			double newAngle = Math.atan(startAngleTangent);
-			
+
 			error = Math.abs(newAngle - angle);
-				
+
 			angle = newAngle;
-		}		
-		
+		}
+
 		return angle;
 	}
-	
-	public void processRK4Range(Obstacle obstacle, Player players[], int numPlayers, int currentTurn, boolean inverted)
-	{	
-		playersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		soldiersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		soldierHitPosition = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
-		numPlayersHit = 0;
-		
-		valuesX = new double[Constants.FUNC_MAX_STEPS];
-		valuesY = new double[Constants.FUNC_MAX_STEPS];
-		
-		double stepSize = Constants.STEP_SIZE;
-		
-		Soldier currentTurnSoldier = players[currentTurn].getCurrentTurnSoldier();
-		
-		valuesX[0] = currentTurnSoldier.getX();
-		valuesY[0] = currentTurnSoldier.getY();
-		
-		if(inverted)
+
+	private double[] getRK42(double x, double y, double dy, double step)
+	{
+		double x1 = x;
+		double y1 = y;
+		double y2 = dy;
+
+		double k11 = y2;
+		double k12 = polishFunc.evaluateFunction( x1, y1, y2);
+
+		x1 = x + step/2;
+		y1 = y + (step/2)*k11;
+		y2 = dy + (step/2)*k12;
+
+		double k21 = y2;
+		double k22 = polishFunc.evaluateFunction( x1, y1, y2);
+
+		y1 = y + (step/2)*k21;
+		y2 = dy + (step/2)*k22;
+
+		double k31 = y2;
+		double k32 = polishFunc.evaluateFunction( x1, y1, y2);
+
+		x1 = x + step;
+		y1 = y + (step)*k31;
+		y2 = dy + (step)*k32;
+
+		double k41 = y2;
+		double k42 = polishFunc.evaluateFunction( x1, y1, y2);
+
+
+		y1 = y + (step/6)*(k11 + 2*k21 + 2*k31 + k41);
+		y2 = dy + (step/6)*(k12 + 2*k22 + 2*k32 + k42);
+
+
+		return new double[]{y1, y2};
+	}
+
+	private void setNextValues(double[] valuesX, double[] valuesY, double[] valuesDY, double step, int index, int gameMode)
+	{
+		valuesX[index] = valuesX[index-1] + step;
+		valuesY[index] = valuesY[index-1];
+		valuesDY[index] = valuesDY[index-1];
+		if (gameMode == Constants.NORMAL_FUNC)
+			valuesY[index] = polishFunc.evaluateFunction(valuesX[index],0,0) + offSet;
+		if (gameMode == Constants.FST_ODE)
+			valuesY[index] = getRK4(valuesX[index-1], valuesY[index-1], step);
+		if (gameMode == Constants.SND_ODE)
 		{
-			valuesX[0] = Constants.PLANE_LENGTH - valuesX[0];
+			double[] vecY = getRK42(valuesX[index-1], valuesY[index-1], valuesDY[index-1], step);
+			valuesY[index] = vecY[0];
+			valuesDY[index] = vecY[1];
 		}
-								
-		valuesX[0] = (Constants.PLANE_GAME_LENGTH*(valuesX[0] - Constants.PLANE_LENGTH/2))/Constants.PLANE_LENGTH;
-		valuesY[0] = (Constants.PLANE_GAME_LENGTH*(-valuesY[0] + Constants.PLANE_HEIGHT/2))/Constants.PLANE_LENGTH;
-		
-		double gameCoordinateRadius = ((double)(Constants.PLANE_GAME_LENGTH*Constants.SOLDIER_RADIUS))/Constants.PLANE_LENGTH;
-		
-		fireAngle = getRK4StartAngle(valuesX[0], valuesY[0], gameCoordinateRadius);
-				
-		valuesX[0] = valuesX[0] + gameCoordinateRadius*Math.cos(fireAngle);	
-		valuesY[0] = valuesY[0] + gameCoordinateRadius*Math.sin(fireAngle);		
-		
-		
-		numSteps = Constants.FUNC_MAX_STEPS;
-		for(int i=1; i<Constants.FUNC_MAX_STEPS; i++)
+	}
+
+	private boolean playerAlreadyHit(int player, int soldier)
+	{
+		for(int i=0; i<numPlayersHit; i++)
 		{
-			double tempStepSize = stepSize;
-			
-			double k1 = polishFunc.evaluateFunction( valuesX[i-1], valuesY[i-1], 0);
-			double k2 = polishFunc.evaluateFunction( valuesX[i-1] + 0.5*tempStepSize, valuesY[i-1] + 0.5*tempStepSize*k1, 0);
-			double k3 = polishFunc.evaluateFunction( valuesX[i-1] + 0.5*tempStepSize, valuesY[i-1] + 0.5*tempStepSize*k2, 0);
-			double k4 = polishFunc.evaluateFunction( valuesX[i-1] + tempStepSize, valuesY[i-1] + tempStepSize*k3, 0);
-				
-			valuesY[i] = valuesY[i-1] + (tempStepSize/6)*(k1 + 2*k2 + 2*k3 + k4);
-			valuesX[i] = valuesX[i-1] + tempStepSize;
-			
-			boolean endFunc = false;
-			
-			for(int j=0; Math.pow(valuesX[i]-valuesX[i-1], 2)+Math.pow(valuesY[i]-valuesY[i-1], 2) > Constants.FUNC_MAX_STEP_DISTANCE_SQUARED && valuesX[i]-valuesX[i-1]>Constants.FUNC_MIN_X_STEP_DISTANCE;j++)
-			{
-				if(valuesX[i]-valuesX[i-1]>Constants.FUNC_MIN_X_STEP_DISTANCE)
-				{
-					tempStepSize = tempStepSize/2;
-					
-					k1 = polishFunc.evaluateFunction( valuesX[i-1], valuesY[i-1], 0);
-					k2 = polishFunc.evaluateFunction( valuesX[i-1] + 0.5*tempStepSize, valuesY[i-1] + 0.5*tempStepSize*k1, 0);
-					k3 = polishFunc.evaluateFunction( valuesX[i-1] + 0.5*tempStepSize, valuesY[i-1] + 0.5*tempStepSize*k2, 0);
-					k4 = polishFunc.evaluateFunction( valuesX[i-1] + tempStepSize, valuesY[i-1] + tempStepSize*k3, 0);
-						
-					valuesY[i] = valuesY[i-1] + (tempStepSize/6)*(k1 + 2*k2 + 2*k3 + k4);
-					valuesX[i] = valuesX[i-1] + tempStepSize;	
-				}
-				else
-				{
-					endFunc = true;
-					break;
-				}
-			}
-			
-			if(endFunc)
-			{
-				numSteps = i;
-				break;
-			}
-			
-			double x = Constants.PLANE_LENGTH*valuesX[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;
-			double y = -Constants.PLANE_LENGTH*valuesY[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
-		
-			
-			if(inverted)
-			{
-				x = Constants.PLANE_LENGTH - x;
-			}
-			
-			for(int j=0; j<numPlayers; j++)
-			{
-				for(int k=0; k<players[j].getNumSoldiers(); k++)
-				{
-					if(j==currentTurn)
-					{
-						if(k == players[j].getCurrentTurnSoldierIndex())
-						{
-							continue;
-						}							
-					}
-					
-					if(players[j].getSoldiers()[k].isAlive())
-					{
-										
-						double distX = players[j].getSoldiers()[k].getX() - x;
-						double distY = players[j].getSoldiers()[k].getY() - y;
-						
-						double distSquared = (Math.pow(distX, 2)+Math.pow(distY, 2));
-											
-						if(distSquared < Constants.SOLDIER_RADIUS*Constants.SOLDIER_RADIUS)
-						{
-							if(playerAlreadyHit(j,k)==false)
-							{
-								playersHit[numPlayersHit] = j;
-								soldiersHit[numPlayersHit] = k;
-								soldierHitPosition[numPlayersHit] = i;
-								numPlayersHit++;
-							}
-						}
-					}
-				}
-			}			
-			
-			if(obstacle.collidePoint((int)x, (int)y))
-			{
-				numSteps = i;
-				break;
-			}
-			
-			if(Double.isNaN(y) || Double.isInfinite(y))
-			{
-				numSteps = i;
-				break;
-			}
-						
+			if(playersHit[i] == player && soldiersHit[i]==soldier)
+				return true;
 		}
-			
-		lastX = Constants.PLANE_LENGTH*valuesX[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;;
-		lastY = -Constants.PLANE_LENGTH*valuesY[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
-		
+
+		return false;
 	}
-	
-	public void processRK42Range(Obstacle obstacle, Player players[], int numPlayers, int currentTurn, double angle ,boolean inverted)
-	{	
+
+	public void processRange(Obstacle obstacle, Player players[], int numPlayers, int currentTurn, boolean inverted, int gameMode, double angle)
+	{
 		playersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
 		soldiersHit = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
 		soldierHitPosition = new int[numPlayers*Constants.MAX_SOLDIERS_PER_PLAYER];
 		numPlayersHit = 0;
-		
-		
+
 		valuesX = new double[Constants.FUNC_MAX_STEPS];
 		valuesY = new double[Constants.FUNC_MAX_STEPS];
 		valuesDY = new double[Constants.FUNC_MAX_STEPS];
-		
+
 		double stepSize = Constants.STEP_SIZE;
-		
+
 		Soldier currentTurnSoldier = players[currentTurn].getCurrentTurnSoldier();
-		
+
 		valuesX[0] = currentTurnSoldier.getX();
-				
-		if(inverted)
+		valuesY[0] = currentTurnSoldier.getY();
+
+		valuesX[0] = (inverted)?(Constants.PLANE_LENGTH - valuesX[0]):valuesX[0];
+
+		if (gameMode == Constants.SND_ODE)
 		{
-			valuesX[0] = Constants.PLANE_LENGTH - valuesX[0];
+			valuesX[0] = valuesX[0] + Constants.SOLDIER_RADIUS*Math.cos(angle);
+			valuesY[0] = valuesY[0] - Constants.SOLDIER_RADIUS*Math.sin(angle);
 		}
-		
-		valuesX[0] = valuesX[0] + Constants.SOLDIER_RADIUS*Math.cos(angle);
-		
-		
-		valuesY[0] = currentTurnSoldier.getY();
-		valuesY[0] = valuesY[0] - Constants.SOLDIER_RADIUS*Math.sin(angle);
-		
-		
+
+
 		valuesX[0] = (Constants.PLANE_GAME_LENGTH*(valuesX[0] - Constants.PLANE_LENGTH/2))/Constants.PLANE_LENGTH;
 		valuesY[0] = (Constants.PLANE_GAME_LENGTH*(-valuesY[0] + Constants.PLANE_HEIGHT/2))/Constants.PLANE_LENGTH;
 		valuesDY[0] = Math.tan(angle);
-			
-		fireAngle = angle;
-		
-		numSteps = Constants.FUNC_MAX_STEPS;
-		for(int i=1; i<Constants.FUNC_MAX_STEPS; i++)
+
+		double gameCoordinateRadius = ((double)(Constants.PLANE_GAME_LENGTH*Constants.SOLDIER_RADIUS))/Constants.PLANE_LENGTH;
+
+		fireAngle = Double.NaN;
+
+		if (gameMode == Constants.NORMAL_FUNC)
+			fireAngle = getStartAngle(valuesX[0], gameCoordinateRadius);
+		if (gameMode == Constants.FST_ODE)
+			fireAngle = getRK4StartAngle(valuesX[0], valuesY[0], gameCoordinateRadius);
+		if (gameMode == Constants.SND_ODE)
+			fireAngle = angle;
+
+		if (gameMode != Constants.SND_ODE && !Double.isNaN(fireAngle) && !Double.isInfinite(fireAngle))
 		{
+			valuesX[0] = valuesX[0] + gameCoordinateRadius*Math.cos(fireAngle);
+			valuesY[0] = valuesY[0] + gameCoordinateRadius*Math.sin(fireAngle);
+		}
+
+		offSet = -polishFunc.evaluateFunction(valuesX[0],0,0) + valuesY[0];
+
+		numSteps = Constants.FUNC_MAX_STEPS;
+		for (int i = 1; i < Constants.FUNC_MAX_STEPS; i++)
+		{ // Compute the function
 			double tempStepSize = stepSize;
-						
-			
-			double x1 = valuesX[i-1];
-			double y1 = valuesY[i-1];
-			double y2 = valuesDY[i-1];
-			
-			double k11 = y2;
-			double k12 = polishFunc.evaluateFunction( x1, y1, y2);
-			
-			x1 = valuesX[i-1] + tempStepSize/2;
-			y1 = valuesY[i-1] + (tempStepSize/2)*k11;
-			y2 = valuesDY[i-1] + (tempStepSize/2)*k12;
-			
-			double k21 = y2;
-			double k22 = polishFunc.evaluateFunction( x1, y1, y2);
-			
-			y1 = valuesY[i-1] + (tempStepSize/2)*k21;
-			y2 = valuesDY[i-1] + (tempStepSize/2)*k22;
-			
-			double k31 = y2;
-			double k32 = polishFunc.evaluateFunction( x1, y1, y2);
-			
-			x1 = valuesX[i-1] + tempStepSize;
-			y1 = valuesY[i-1] + (tempStepSize)*k31;
-			y2 = valuesDY[i-1] + (tempStepSize)*k32;
-			
-			double k41 = y2;
-			double k42 = polishFunc.evaluateFunction( x1, y1, y2);
-			
-			
-			valuesX[i] = valuesX[i-1] + tempStepSize;
-			valuesY[i] = valuesY[i-1] + (tempStepSize/6)*(k11 + 2*k21 + 2*k31 + k41);
-			valuesDY[i] = valuesDY[i-1] + (tempStepSize/6)*(k12 + 2*k22 + 2*k32 + k42);
-			
+
+			setNextValues(valuesX, valuesY, valuesDY, tempStepSize, i, gameMode);
+
 			boolean endFunc = false;
-			
-			for(int j=0; Math.pow(valuesX[i]-valuesX[i-1], 2)+Math.pow(valuesY[i]-valuesY[i-1], 2) > Constants.FUNC_MAX_STEP_DISTANCE_SQUARED && valuesX[i]-valuesX[i-1]>Constants.FUNC_MIN_X_STEP_DISTANCE;j++)
-			{
-				if(valuesX[i]-valuesX[i-1]>Constants.FUNC_MIN_X_STEP_DISTANCE)
-				{
-			
-					tempStepSize = tempStepSize/2;				
-					
-					x1 = valuesX[i-1];
-					y1 = valuesY[i-1];
-					y2 = valuesDY[i-1];
-					
-					k11 = y2;
-					k12 = polishFunc.evaluateFunction( x1, y1, y2);
-					
-					x1 = valuesX[i-1] + tempStepSize/2;
-					y1 = valuesY[i-1] + (tempStepSize/2)*k11;
-					y2 = valuesDY[i-1] + (tempStepSize/2)*k12;
-					
-					k21 = y2;
-					k22 = polishFunc.evaluateFunction( x1, y1, y2);
-					
-					y1 = valuesY[i-1] + (tempStepSize/2)*k21;
-					y2 = valuesDY[i-1] + (tempStepSize/2)*k22;
-					
-					k31 = y2;
-					k32 = polishFunc.evaluateFunction( x1, y1, y2);
-					
-					x1 = valuesX[i-1] + tempStepSize;
-					y1 = valuesY[i-1] + (tempStepSize)*k31;
-					y2 = valuesDY[i-1] + (tempStepSize)*k32;
-					
-					k41 = y2;
-					k42 = polishFunc.evaluateFunction( x1, y1, y2);
-					
-					
-					valuesX[i] = valuesX[i-1] + tempStepSize;
-					valuesY[i] = valuesY[i-1] + (tempStepSize/6)*(k11 + 2*k21 + 2*k31 + k41);
-					valuesDY[i] = valuesDY[i-1] + (tempStepSize/6)*(k12 + 2*k22 + 2*k32 + k42);
-				}
-				else
+
+			for(int j = 0; Math.pow(valuesX[i]-valuesX[i-1], 2) + Math.pow(valuesY[i]-valuesY[i-1], 2) > Constants.FUNC_MAX_STEP_DISTANCE_SQUARED; j++)
+			{ // If the step is too big, halve it
+				if (valuesX[i] - valuesX[i-1] <= Constants.FUNC_MIN_X_STEP_DISTANCE)
 				{
-					endFunc = true;
+					if (gameMode == Constants.NORMAL_FUNC)
+						endFunc = true;
 					break;
 				}
-				
+				tempStepSize = tempStepSize/2;
+
+				setNextValues(valuesX, valuesY, valuesDY, tempStepSize, i, gameMode);
 			}
-			
 			if(endFunc)
 			{
 				numSteps = i;
 				break;
 			}
-			
-			
+
 			double x = Constants.PLANE_LENGTH*valuesX[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;
 			double y = -Constants.PLANE_LENGTH*valuesY[i]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
-		
-			
-			if(inverted)
-			{
-				x = Constants.PLANE_LENGTH - x;
-			}
-			
-			for(int j=0; j<numPlayers; j++)
-			{
-				for(int k=0; k<players[j].getNumSoldiers(); k++)
+
+			x = (inverted)?(Constants.PLANE_LENGTH - x):x;
+
+			for(int j = 0; j < numPlayers; j++)
+			{ // Check if any of the players are hit
+				Player player = players[j];
+				for(int k = 0; k < player.getNumSoldiers(); k++)
 				{
-					if(j==currentTurn)
-					{
-						if(k == players[j].getCurrentTurnSoldierIndex())
-						{
-							continue;
-						}							
-					}
-					
-					if(players[j].getSoldiers()[k].isAlive())
-					{
-										
-						double distX = players[j].getSoldiers()[k].getX() - x;
-						double distY = players[j].getSoldiers()[k].getY() - y;
-						
-						double distSquared = (Math.pow(distX, 2)+Math.pow(distY, 2));
-											
-						if(distSquared < Constants.SOLDIER_RADIUS*Constants.SOLDIER_RADIUS)
-						{
-							if(playerAlreadyHit(j,k)==false)
-							{
-								playersHit[numPlayersHit] = j;
-								soldiersHit[numPlayersHit] = k;
-								soldierHitPosition[numPlayersHit] = i;
-								numPlayersHit++;
-							}
-						}
-					}
+					if(j == currentTurn && k == player.getCurrentTurnSoldierIndex()) // The launcher
+						continue;
+					if (!player.getSoldiers()[k].isAlive()) // The soldier is dead
+						continue;
+
+					double distX = players[j].getSoldiers()[k].getX() - x;
+					double distY = players[j].getSoldiers()[k].getY() - y;
+					double distSquared = (Math.pow(distX, 2)+Math.pow(distY, 2));
+
+					if(distSquared >= Constants.SOLDIER_RADIUS*Constants.SOLDIER_RADIUS) // The soldier is too far
+						continue;
+					if(Double.isNaN(distSquared)) // The illegal case
+						continue;
+					if(playerAlreadyHit(j,k)) // The player has already been hit
+						continue;
+
+					playersHit[numPlayersHit] = j;
+					soldiersHit[numPlayersHit] = k;
+					soldierHitPosition[numPlayersHit] = i;
+					numPlayersHit++;
 				}
 			}
-						
-			
-			if(obstacle.collidePoint((int)x, (int)y))
-			{
-				numSteps = i;
-				break;
-			}
-			
-			if(Double.isNaN(y) || Double.isInfinite(y))
+
+			if(obstacle.collidePoint((int)x, (int)y) || Double.isNaN(y) || Double.isInfinite(y))
 			{
 				numSteps = i;
 				break;
 			}
-			
-			
 		}
-		
-		lastX = Constants.PLANE_LENGTH*valuesX[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;;
-		lastY = -Constants.PLANE_LENGTH*valuesY[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
 
-				
+		lastX = Constants.PLANE_LENGTH*valuesX[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_LENGTH/2;
+		lastY = -Constants.PLANE_LENGTH*valuesY[numSteps-1]/Constants.PLANE_GAME_LENGTH + Constants.PLANE_HEIGHT/2;
 	}
-	
+
 	public double getLastX()
 	{
 		return lastX;
 	}
-	
+
 	public double getLastY()
 	{
 		return lastY;
 	}
 
-	
 }
diff --git a/src/Graphwar/GameData.java b/src/Graphwar/GameData.java
index 9b59423..201b4c7 100644
--- a/src/Graphwar/GameData.java
+++ b/src/Graphwar/GameData.java
@@ -1061,44 +1061,22 @@ else if(numDrawSteps > soldier.getKillPosition())
 	}
 	
 	private void processFunction(Player player, String functionString) throws MalformedFunction
-	{				
+	{
 		function = new Function(functionString);
-								
+
 		player.getCurrentTurnSoldier().setFunction(functionString);
 								
 		//If player is in team 2 the function must go in the other direction
 		//and the obstacles are inverted
-		if(player.getTeam()==Constants.TEAM1)
-		{			
-			switch(gameMode)
-			{
-				case Constants.NORMAL_FUNC:
-					function.processFunctionRange(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, false);	
-				break;
-				case Constants.FST_ODE:
-					function.processRK4Range(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, false);
-				break;
-				case Constants.SND_ODE:
-					function.processRK42Range(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, player.getCurrentTurnSoldier().getAngle(),false);
-				break;
-			}			
-		}
-		else
-		{
-			switch(gameMode)
-			{
-				case Constants.NORMAL_FUNC:
-					function.processFunctionRange(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, true);	
-				break;
-				case Constants.FST_ODE:
-					function.processRK4Range(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, true);
-				break;
-				case Constants.SND_ODE:
-					function.processRK42Range(obstacle, players.toArray(new Player[0]), players.size(), currentTurn, player.getCurrentTurnSoldier().getAngle(),true);
-				break;
-			}			
-		}
-		
+		function.processRange(
+			obstacle,
+			players.toArray(new Player[0]),
+			players.size(), currentTurn,
+			player.getTeam()==Constants.TEAM2,
+			gameMode,
+			player.getCurrentTurnSoldier().getAngle()
+		);
+
 		soldiersHit = new ArrayList<Soldier>();
 		int numPlayersHit = function.getNumPlayersHit();
 		for(int i=0; i<numPlayersHit; i++)