Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.Designer.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.Designer.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.Designer.cs	(revision 13017)
@@ -112,11 +112,11 @@
       // splitContainer.Panel1
       // 
+      this.splitContainer.Panel1.Controls.Add(this.prefixCode);
       this.splitContainer.Panel1.Controls.Add(this.prefixLabel);
-      this.splitContainer.Panel1.Controls.Add(this.prefixCode);
       // 
       // splitContainer.Panel2
       // 
+      this.splitContainer.Panel2.Controls.Add(this.suffixCode);
       this.splitContainer.Panel2.Controls.Add(this.suffixLabel);
-      this.splitContainer.Panel2.Controls.Add(this.suffixCode);
       this.splitContainer.Size = new System.Drawing.Size(582, 261);
       this.splitContainer.SplitterDistance = 130;
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.cs	(revision 13017)
@@ -26,9 +26,9 @@
 
 namespace HeuristicLab.Problems.GeneticProgramming.Views.Robocode {
-  [View("CodeNode View")]
-  [Content(typeof(CodeNode), IsDefaultView = true)]
+  [View("CodeSymbol View")]
+  [Content(typeof(CodeSymbol), IsDefaultView = true)]
   public partial class CodeNodeView : ItemView {
-    public new CodeNode Content {
-      get { return (CodeNode)base.Content; }
+    public new CodeSymbol Content {
+      get { return (CodeSymbol)base.Content; }
       set { base.Content = value; }
     }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/EnemyCollection.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/EnemyCollection.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/EnemyCollection.cs	(revision 13017)
@@ -51,5 +51,5 @@
 
     public static EnemyCollection ReloadEnemies(string robocodeDir) {
-      EnemyCollection robotList = new EnemyCollection(); ;
+      EnemyCollection robotList = new EnemyCollection();
 
       try {
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Grammar.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Grammar.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Grammar.cs	(revision 13017)
@@ -55,63 +55,63 @@
     private void Initialize() {
       #region Symbols
-      var block = new Block();
-      var stat = new Stat();
-      var ifThenElseStat = new IfThenElseStat();
-      var whileStat = new WhileStat();
+      var block = new SimpleSymbol("Block", "A group of statements", 1, byte.MaxValue);
+      var stat = new SimpleSymbol("Statement", "A statement.", 1, 1);
+      var ifThenElseStat = new SimpleSymbol("IfThenElseStat", "An if statement.", 2, 3);
+      var whileStat = new SimpleSymbol("WhileStat", "A while statement.", 2, 2);
       whileStat.Enabled = false;
 
-      var logicalExpr = new LogicalExpression();
-      var numericalExpr = new NumericalExpression();
-
-      var equal = new Equal();
-      var lessThan = new LessThan();
-      var lessThanOrEqual = new LessThanOrEqual();
-      var greaterThan = new GreaterThan();
-      var greaterThanOrEqual = new GreaterThanOrEqual();
-
-      var conjunction = new Conjunction();
-      var disjunction = new Disjunction();
-      var negation = new Negation();
-
-      var addition = new Addition();
-      var subtraction = new Subtraction();
-      var multiplication = new Multiplication();
-      var division = new Division();
-      var modulus = new Modulus();
+      var boolExpr = new SimpleSymbol("BooleanExpression", "A Boolean expression.", 1, 1);
+      var numericalExpr = new SimpleSymbol("NumericalExpression", "A numerical expression.", 1, 1);
+
+      var equal = new SimpleSymbol("Equal", "Equal comparator.", 2, 2);
+      var lessThan = new SimpleSymbol("LessThan", "LessThan comparator.", 2, 2);
+      var lessThanOrEqual = new SimpleSymbol("LessThanOrEqual", "LessThanOrEqual comparator.", 2, 2);
+      var greaterThan = new SimpleSymbol("GreaterThan", "GreaterThan comparator.", 2, 2);
+      var greaterThanOrEqual = new SimpleSymbol("GreaterThanOrEqual", "GreaterThanOrEqual comparator.", 2, 2);
+
+      var conjunction = new SimpleSymbol("ConditionalAnd", "Conjunction comparator.", 2, byte.MaxValue);
+      var disjunction = new SimpleSymbol("ConditionalOr", "Disjunction comparator.", 2, byte.MaxValue);
+      var negation = new SimpleSymbol("Negation", "A negation.", 1, 1);
+
+      var addition = new SimpleSymbol("Addition", "Addition operator.", 2, byte.MaxValue);
+      var subtraction = new SimpleSymbol("Subtraction", "Subtraction operator.", 2, byte.MaxValue);
+      var multiplication = new SimpleSymbol("Multiplication", "Multiplication operator.", 2, byte.MaxValue);
+      var division = new SimpleSymbol("Division", "Division operator.", 2, byte.MaxValue);
+      var modulus = new SimpleSymbol("Modulus", "Modulus operator.", 2, byte.MaxValue);
 
       var number = new Number();
-      var logicalVal = new LogicalValue();
-
-      var ahead = new Ahead();
-      var back = new Back();
-      var fire = new Fire();
+      var logicalVal = new BooleanValue();
+
+      var ahead = new SimpleSymbol("Ahead", "Immediately moves your robot ahead (forward) by distance measured in pixels.", 1, 1);
+      var back = new SimpleSymbol("Back", "Immediately moves your robot backward by distance measured in pixels.", 1, 1);
+      var fire = new SimpleSymbol("Fire", "Immediately fires a bullet.", 1, 1);
       var shotPower = new ShotPower();
 
-      var getEnergy = new GetEnergy();
-      var getGunHeading = new GetGunHeading();
-      var getHeading = new GetHeading();
-      var getRadarHeading = new GetRadarHeading();
-      var getX = new GetX();
-      var getY = new GetY();
-
-      var turnLeft = new TurnLeft();
-      var turnRight = new TurnRight();
-      var turnGunLeft = new TurnGunLeft();
-      var turnGunRight = new TurnGunRight();
-      var turnRadarLeft = new TurnRadarLeft();
-      var turnRadarRight = new TurnRadarRight();
-
-      var onBulletHit = new OnBulletHit();
-      var onBulletMissed = new OnBulletMissed();
-      var onHitByBullet = new OnHitByBullet();
-      var onHitRobot = new OnHitRobot();
-      var onHitWall = new OnHitWall();
-      var onScannedRobot = new OnScannedRobot();
-
-      var run = new Run();
-      var tank = new Tank();
-
-      var doNothing = new DoNothing();
-      var emptyEvent = new EmptyEvent();
+      var getEnergy = new SimpleSymbol("GetEnergy", "Returns the robot's current energy.", 0, 0);
+      var getHeading = new SimpleSymbol("GetHeading", "Returns the direction that the robot's body is facing, in degrees.", 0, 0);
+      var getGunHeading = new SimpleSymbol("GetGunHeading", "Returns the direction that the robot's gun is facing, in degrees.", 0, 0);
+      var getRadarHeading = new SimpleSymbol("GetRadarHeading", "Returns the direction that the robot's radar is facing, in degrees.", 0, 0);
+      var getX = new SimpleSymbol("GetX", "Returns the X position of the robot. (0,0) is at the bottom left of the battlefield.", 0, 0);
+      var getY = new SimpleSymbol("GetY", "Returns the Y position of the robot. (0,0) is at the bottom left of the battlefield.", 0, 0);
+
+      var turnLeft = new SimpleSymbol("TurnLeft", "Immediately turns the robot's body to the left by degrees.", 1, 1);
+      var turnRight = new SimpleSymbol("TurnRight", "Immediately turns the robot's body to the right by degrees.", 1, 1);
+      var turnGunLeft = new SimpleSymbol("TurnGunLeft", "Immediately turns the robot's gun to the left by degrees.", 1, 1);
+      var turnGunRight = new SimpleSymbol("TurnGunRight", "Immediately turns the robot's gun to the right by degrees.", 1, 1);
+      var turnRadarLeft = new SimpleSymbol("TurnRadarLeft", "Immediately turns the robot's radar to the left by degrees.", 1, 1);
+      var turnRadarRight = new SimpleSymbol("TurnRadarRight", "Immediately turns the robot's radar to the right by degrees.", 1, 1);
+
+      var onBulletHit = new SimpleSymbol("OnBulletHit", "This method is called when one of your bullets hits another robot.", 2, 10);
+      var onBulletMissed = new SimpleSymbol("OnBulletMissed", "This method is called when one of your bullets misses, i.e. hits a wall.", 2, 10);
+      var onHitByBullet = new SimpleSymbol("OnHitByBullet", "This method is called when your robot is hit by a bullet.", 2, 10);
+      var onHitRobot = new SimpleSymbol("OnHitRobot", "This method is called when your robot collides with another robot.", 2, 10);
+      var onHitWall = new SimpleSymbol("OnHitWall", "This method is called when your robot collides with a wall.", 2, 10);
+      var onScannedRobot = new SimpleSymbol("OnScannedRobot", "This method is called when your robot sees another robot, i.e. when the robot's radar scan \"hits\" another robot.", 2, 10);
+
+      var run = new SimpleSymbol("Run", "The main method in every robot.", 1, 10);
+      var tank = new SimpleSymbol("Tank", "The root of a Robocode Tank program.", 2, 7);
+
+      var doNothing = new SimpleSymbol("DoNothing", "Do nothing this turn, meaning that the robot will skip its turn.", 0, 0);
+      var emptyEvent = new SimpleSymbol("EmptyEvent", "This is a placeholder for an empty event.", 0, 0);
       #endregion
 
@@ -127,5 +127,5 @@
       var events = new GroupSymbol(EventsName, new ISymbol[] { run, onScannedRobot, onBulletHit, onBulletMissed, onHitByBullet, onHitRobot, onHitWall });
       var controlStatements = new GroupSymbol(ControlStatementsName, controlSymbols);
-      var expressions = new GroupSymbol(ExpressionsName, new ISymbol[] { logicalExpr, numericalExpr });
+      var expressions = new GroupSymbol(ExpressionsName, new ISymbol[] { boolExpr, numericalExpr });
       var robocodeFunctions = new GroupSymbol(RobocodeFunctionsName, functionSymbols);
       var robocodeActions = new GroupSymbol(RobocodeActionsName, actionSymbols);
@@ -183,5 +183,5 @@
 
       // IfStat
-      AddAllowedChildSymbol(ifThenElseStat, logicalExpr, 0);
+      AddAllowedChildSymbol(ifThenElseStat, boolExpr, 0);
       AddAllowedChildSymbol(ifThenElseStat, stat, 1);
       AddAllowedChildSymbol(ifThenElseStat, emptyEvent, 1);
@@ -192,5 +192,5 @@
 
       // WhileStat
-      AddAllowedChildSymbol(whileStat, logicalExpr, 0);
+      AddAllowedChildSymbol(whileStat, boolExpr, 0);
       AddAllowedChildSymbol(whileStat, stat, 1);
       AddAllowedChildSymbol(whileStat, emptyEvent, 1);
@@ -206,6 +206,6 @@
 
       // Logical Expressions
-      AddAllowedChildSymbol(logicalExpr, logicalVal);
-      AddAllowedChildSymbol(logicalExpr, logicalOperators);
+      AddAllowedChildSymbol(boolExpr, logicalVal);
+      AddAllowedChildSymbol(boolExpr, logicalOperators);
       AddAllowedChildSymbol(logicalOperators, logicalVal);
       AddAllowedChildSymbol(logicalOperators, logicalOperators);
@@ -216,5 +216,5 @@
       AddAllowedChildSymbol(robocodeFunctions, numericalExpr);
       foreach (var a in robocodeActions.Symbols) {
-        if (a is Fire) AddAllowedChildSymbol(a, shotPower);
+        if (a.Name == fire.Name) AddAllowedChildSymbol(a, shotPower);
         else AddAllowedChildSymbol(a, numericalExpr);
       }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/HeuristicLab.Problems.Robocode-3.3.csproj
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/HeuristicLab.Problems.Robocode-3.3.csproj	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/HeuristicLab.Problems.Robocode-3.3.csproj	(revision 13017)
@@ -103,67 +103,29 @@
     <Compile Include="Grammar.cs" />
     <Compile Include="Interpreter.cs" />
-    <Compile Include="RobocodeProblem.cs" />
+    <Compile Include="Problem.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
     <Compile Include="Solution.cs" />
-    <Compile Include="Symbols\Event Methods\Events\EmptyEvent.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\ILogicalComparator.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\INumericalOperator.cs" />
-    <Compile Include="Symbols\Numerical Methods\INumericalMethod.cs" />
-    <Compile Include="Symbols\Stat.cs" />
-    <Compile Include="Symbols\Void Methods\Ahead.cs" />
-    <Compile Include="Symbols\Void Methods\Back.cs" />
-    <Compile Include="Symbols\Block.cs" />
-    <Compile Include="Symbols\Statements\IfThenElseStat.cs" />
-    <Compile Include="Symbols\Statements\WhileStat.cs" />
+    <Compile Include="Symbols\CodeNode.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Symbols\Logical Expressions\BooleanTreeNode.cs" />
-    <Compile Include="Symbols\Logical Expressions\Conjunction.cs" />
-    <Compile Include="Symbols\Logical Expressions\Disjunction.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\Equal.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\GreaterThan.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\GreaterThanOrEqual.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\LessThan.cs" />
-    <Compile Include="Symbols\Logical Expressions\Logical Comparators\LessThanOrEqual.cs" />
-    <Compile Include="Symbols\Logical Expressions\LogicalExpression.cs" />
-    <Compile Include="Symbols\Logical Expressions\LogicalValue.cs" />
-    <Compile Include="Symbols\Logical Expressions\Negation.cs" />
+    <Compile Include="Symbols\Logical Expressions\BooleanValue.cs" />
     <Compile Include="Symbols\Numerical Expressions\NumberTreeNode.cs" />
     <Compile Include="Symbols\Numerical Expressions\Number.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\Addition.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\Division.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\Modulus.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\Multiplication.cs" />
-    <Compile Include="Symbols\Numerical Expressions\Numerical Operators\Subtraction.cs" />
-    <Compile Include="Symbols\Numerical Expressions\NumericalExpression.cs" />
-    <Compile Include="Symbols\CodeNode.cs" />
-    <Compile Include="Symbols\Tank.cs" />
-    <Compile Include="Symbols\Void Methods\DoNothing.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnBulletHit.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnBulletMissed.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnHitByBullet.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnHitRobot.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnHitWall.cs" />
-    <Compile Include="Symbols\Event Methods\Events\OnScannedRobot.cs" />
-    <Compile Include="Symbols\Void Methods\Fire.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetEnergy.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetGunHeading.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetHeading.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetRadarHeading.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetX.cs" />
-    <Compile Include="Symbols\Numerical Methods\GetY.cs" />
-    <Compile Include="Symbols\Program.cs" />
-    <Compile Include="Symbols\Event Methods\Run.cs" />
     <Compile Include="Symbols\Numerical Expressions\ShotPower.cs" />
     <Compile Include="Symbols\Numerical Expressions\ShotPowerTreeNode.cs" />
-    <Compile Include="Symbols\Void Methods\TurnGunLeft.cs" />
-    <Compile Include="Symbols\Void Methods\TurnGunRight.cs" />
-    <Compile Include="Symbols\Void Methods\TurnLeft.cs" />
-    <Compile Include="Symbols\Void Methods\TurnRadarLeft.cs" />
-    <Compile Include="Symbols\Void Methods\TurnRadarRight.cs" />
-    <Compile Include="Symbols\Void Methods\TurnRight.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="BattleRunner.java" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Symbols\Event Methods\Events\" />
+    <Folder Include="Symbols\Logical Expressions\Logical Comparators\" />
+    <Folder Include="Symbols\Numerical Expressions\Numerical Operators\" />
+    <Folder Include="Symbols\Numerical Methods\" />
+    <Folder Include="Symbols\Statements\" />
+    <Folder Include="Symbols\Void Methods\" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs	(revision 13017)
@@ -21,13 +21,17 @@
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.Contracts;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Remoting.Messaging;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
   public static class Interpreter {
+    // TODO performance: it would probably be useful to implement the BattleRunner in such a way that we don't have to restart the java process each time, e.g. using console IO to load & run robots 
     public static double EvaluateTankProgram(ISymbolicExpressionTree tree, string path, EnemyCollection enemies, string robotName = null, bool showUI = false, int nrOfRounds = 3) {
       if (robotName == null)
@@ -148,11 +152,253 @@
     public static string InterpretProgramTree(ISymbolicExpressionTreeNode node, string robotName) {
       var tankNode = node;
-      while (!(tankNode.Symbol is Tank))
+      while (tankNode.Symbol.Name != "Tank")
         tankNode = tankNode.GetSubtree(0);
 
-      string result = ((CodeNode)tankNode.Symbol).Interpret(tankNode, tankNode.Subtrees);
+      string result = Interpret(tankNode);
       result = result.Replace("class output", "class " + robotName);
       return result;
     }
+
+    private static string Interpret(ISymbolicExpressionTreeNode node) {
+      switch (node.Symbol.Name) {
+        case "Block": return InterpretBlock(node);
+        case "Statement": return InterpretStat(node);
+        case "DoNothing": return string.Empty;
+        case "EmptyEvent": return string.Empty;
+
+        case "GetEnergy": return "getEnergy()";
+        case "GetHeading": return "getHeading()";
+        case "GetGunHeading": return "getGunHeading()";
+        case "GetRadarHeading": return "getRadarHeading()";
+        case "GetX": return "getX()";
+        case "GetY": return "getY()";
+
+        case "Addition": return InterpretBinaryOperator(" + ", node);
+        case "Subtraction": return InterpretBinaryOperator(" - ", node);
+        case "Multiplication": return InterpretBinaryOperator(" * ", node);
+        case "Division": return InterpretBinaryOperator(" / ", node);
+        case "Modulus": return InterpretBinaryOperator(" % ", node);
+
+        case "Equal": return InterpretComparison(" == ", node);
+        case "LessThan": return InterpretComparison(" < ", node);
+        case "LessThanOrEqual": return InterpretComparison(" <= ", node);
+        case "GreaterThan": return InterpretComparison("  >", node);
+        case "GreaterThanOrEqual": return InterpretComparison(" >= ", node);
+        case "ConditionalAnd": return InterpretBinaryOperator(" && ", node);
+        case "ConditionalOr": return InterpretBinaryOperator(" || ", node);
+        case "Negation": return InterpretFunc1("!", node);
+
+        case "IfThenElseStat": return InterpretIf(node);
+        case "WhileStat": return InterpretWhile(node);
+        case "BooleanExpression": return InterpretChild(node);
+        case "NumericalExpression": return InterpretChild(node);
+        case "Number": return InterpretNumber(node);
+        case "BooleanValue": return InterpretBoolValue(node);
+
+
+        case "Ahead": return InterpretFunc1("setAhead", node);
+        case "Back": return InterpretFunc1("setBack", node);
+        case "Fire": return InterpretFunc1("setFire", node);
+        case "TurnLeft": return InterpretFunc1("setTurnLeft", node);
+        case "TurnRight": return InterpretFunc1("setTurnRight", node);
+        case "TurnGunLeft": return InterpretFunc1("setTurnGunLeft", node);
+        case "TurnGunRight": return InterpretFunc1("setTurnGunRight", node);
+        case "TurnRadarLeft": return InterpretFunc1("setTurnRadarLeft", node);
+        case "TurnRadarRight": return InterpretFunc1("setTurnRadarRight", node);
+        case "ShotPower": return InterpetShotPower(node);
+
+        case "OnBulletHit": return InterpretOnBulletHit(node);
+        case "OnBulletMissed": return InterpretOnBulletMissed(node);
+        case "OnHitByBullet": return InterpretOnHitByBullet(node);
+        case "OnHitRobot": return InterpretOnHitRobot(node);
+        case "OnHitWall": return InterpretOnHitWall(node);
+        case "OnScannedRobot": return InterpretOnScannedRobot(node);
+
+        case "Run": return InterpretRun(node);
+        case "Tank": return InterpretTank(node);
+        case "CodeSymbol": return InterpretCodeSymbol(node);
+
+        default: throw new ArgumentException(string.Format("Found an unknown symbol {0} in a robocode solution", node.Symbol.Name));
+      }
+    }
+
+    private static string InterpretCodeSymbol(ISymbolicExpressionTreeNode node) {
+      var sy = node.Symbol as CodeSymbol;
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"{0}
+{1}
+{2}", sy.Prefix, code, sy.Suffix);
+    }
+
+    private static string InterpretBoolValue(ISymbolicExpressionTreeNode node) {
+      var boolNode = node as BooleanTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0}", boolNode.Value).ToLower();
+    }
+
+    private static string InterpretNumber(ISymbolicExpressionTreeNode node) {
+      var numberNode = node as NumberTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0}", numberNode.Value);
+    }
+
+    private static string InterpetShotPower(ISymbolicExpressionTreeNode node) {
+      var shotPowerNode = node as ShotPowerTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0:E}", shotPowerNode.Value);
+    }
+
+
+    internal static string InterpretBlock(ISymbolicExpressionTreeNode node) {
+      string result = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format("{{ {0} }}", result + Environment.NewLine);
+    }
+
+    internal static string InterpretStat(ISymbolicExpressionTreeNode node) {
+      // must only have one sub-tree
+      Contract.Assert(node.SubtreeCount == 1);
+      return Interpret(node.GetSubtree(0)) + " ;" + Environment.NewLine;
+    }
+
+    internal static string InterpretIf(ISymbolicExpressionTreeNode node) {
+      ISymbolicExpressionTreeNode condition = null, truePart = null, falsePart = null;
+      string[] parts = new string[3];
+
+      if (node.SubtreeCount < 2 || node.SubtreeCount > 3)
+        throw new Exception("Unexpected number of children. Expected 2 or 3 children.");
+
+      condition = node.GetSubtree(0);
+      truePart = node.GetSubtree(1);
+      if (node.SubtreeCount == 3)
+        falsePart = node.GetSubtree(2);
+
+      parts[0] = Interpret(condition);
+      parts[1] = Interpret(truePart);
+      if (falsePart != null) parts[2] = Interpret(falsePart);
+
+      return string.Format("if ({0}) {{ {1} }} else {{ {2} }}", Interpret(condition), Interpret(truePart),
+        falsePart == null ? string.Empty : Interpret(falsePart));
+    }
+
+    internal static string InterpretWhile(ISymbolicExpressionTreeNode node) {
+      var cond = Interpret(node.GetSubtree(0));
+      var body = Interpret(node.GetSubtree(1));
+      return string.Format("while ({0}) {{ {2} {1} {2} }} {2}", cond, body, Environment.NewLine);
+    }
+
+    public static string InterpretBinaryOperator(string opSy, ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount < 2)
+        throw new ArgumentException(string.Format("Expected at least two children in {0}.", node.Symbol), "node");
+
+      string result = string.Join(opSy, node.Subtrees.Select(Interpret));
+      return "(" + result + ")";
+    }
+
+    public static string InterpretChild(ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount != 1)
+        throw new ArgumentException(string.Format("Expected exactly one child in {0}.", node.Symbol), "node");
+
+      return Interpret(node.GetSubtree(0));
+    }
+
+    public static string InterpretComparison(string compSy, ISymbolicExpressionTreeNode node) {
+      ISymbolicExpressionTreeNode lhs = null, rhs = null;
+      if (node.SubtreeCount != 2)
+        throw new ArgumentException(string.Format("Expected exactly two children in {0}.", node.Symbol), "node");
+
+      lhs = node.GetSubtree(0);
+      rhs = node.GetSubtree(1);
+
+      return Interpret(lhs) + " == " + Interpret(rhs);
+    }
+
+    public static string InterpretFunc1(string functionId, ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount != 1)
+        throw new ArgumentException(string.Format("Expected 1 child in {0}.", node.Symbol.Name), "node");
+
+      return string.Format("{0}({1})", functionId, Interpret(node.GetSubtree(0)));
+    }
+
+    public static string InterpretOnScannedRobot(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onScannedRobot(ScannedRobotEvent e) {{
+  double absoluteBearing = getHeading() + e.getBearing();
+  double bearingFromGun = normalRelativeAngleDegrees(absoluteBearing - getGunHeading());
+  setTurnGunRight(bearingFromGun);
+{0}
+  execute();
+}}", code);
+    }
+
+
+    public static string InterpretOnHitWall(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitWall(HitWallEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnHitRobot(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitRobot(HitRobotEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnHitByBullet(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitByBullet(HitByBulletEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnBulletMissed(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onBulletMissed(BulletMissedEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnBulletHit(ISymbolicExpressionTreeNode node) {
+      var Prefix = "public void onBulletHit(BulletHitEvent e) {";
+      var Suffix =
+@"execute();
+}";
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return Prefix + code + Environment.NewLine + Suffix;
+    }
+
+    public static string InterpretRun(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void run() {{
+  setAdjustGunForRobotTurn(true);
+  turnRadarRightRadians(Double.POSITIVE_INFINITY);
+{0}
+  execute();
+}}", code);
+    }
+
+    public static string InterpretTank(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"package Evaluation;
+import robocode.*;
+import robocode.Robot;
+import robocode.util.*;
+import static robocode.util.Utils.normalRelativeAngleDegrees;
+import java.awt.*;
+
+public class output extends AdvancedRobot {{ 
+{0}
+}}", code);
+    }
   }
 }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Problem.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Problem.cs	(revision 13017)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Problem.cs	(revision 13017)
@@ -0,0 +1,140 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 360)]
+  [Item("Robocode Problem", "Evolution of a robocode program in java using genetic programming.")]
+  public class Problem : SymbolicExpressionTreeProblem {
+    #region Parameter Names
+    private const string RobocodePathParamaterName = "RobocodePath";
+    private const string NrOfRoundsParameterName = "NrOfRounds";
+    private const string EnemiesParameterName = "Enemies";
+    #endregion
+
+    #region Parameters
+    public IFixedValueParameter<DirectoryValue> RobocodePathParameter {
+      get { return (IFixedValueParameter<DirectoryValue>)Parameters[RobocodePathParamaterName]; }
+    }
+    public IFixedValueParameter<IntValue> NrOfRoundsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[NrOfRoundsParameterName]; }
+    }
+    public IValueParameter<EnemyCollection> EnemiesParameter {
+      get { return (IValueParameter<EnemyCollection>)Parameters[EnemiesParameterName]; }
+    }
+
+    public string RobocodePath {
+      get { return RobocodePathParameter.Value.Value; }
+      set { RobocodePathParameter.Value.Value = value; }
+    }
+
+    public int NrOfRounds {
+      get { return NrOfRoundsParameter.Value.Value; }
+      set { NrOfRoundsParameter.Value.Value = value; }
+    }
+
+    public EnemyCollection Enemies {
+      get { return EnemiesParameter.Value; }
+      set { EnemiesParameter.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+
+    public Problem()
+      : base() {
+      DirectoryValue robocodeDir = new DirectoryValue { Value = @"robocode" };
+
+      var robotList = EnemyCollection.ReloadEnemies(robocodeDir.Value);
+      robotList.RobocodePath = robocodeDir.Value;
+
+
+      Parameters.Add(new FixedValueParameter<DirectoryValue>(RobocodePathParamaterName, "Path of the Robocode installation.", robocodeDir));
+      Parameters.Add(new FixedValueParameter<IntValue>(NrOfRoundsParameterName, "Number of rounds a robot has to fight against each opponent.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<EnemyCollection>(EnemiesParameterName, "The enemies that should be battled.", robotList));
+
+      Encoding = new SymbolicExpressionTreeEncoding(new Grammar(), 1000, 10);
+      Encoding.FunctionArguments = 0;
+      Encoding.FunctionDefinitions = 0;
+
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() { RegisterEventHandlers(); }
+
+    public override double Evaluate(ISymbolicExpressionTree tree, IRandom random) {
+      return Interpreter.EvaluateTankProgram(tree, RobocodePath, Enemies, null, false, NrOfRounds);
+    }
+
+    public override void Analyze(ISymbolicExpressionTree[] trees, double[] qualities, ResultCollection results, IRandom random) {
+      // find the tree with the best quality
+      double maxQuality = double.NegativeInfinity;
+      ISymbolicExpressionTree bestTree = null;
+      for (int i = 0; i < qualities.Length; i++) {
+        if (qualities[i] > maxQuality) {
+          maxQuality = qualities[i];
+          bestTree = trees[i];
+        }
+      }
+
+      // create a solution instance
+      var bestSolution = new Solution(bestTree, RobocodePath, NrOfRounds, Enemies);
+
+      // also add the best solution as a result to the result collection
+      // or alternatively update the existing result
+      if (!results.ContainsKey("BestSolution")) {
+        results.Add(new Result("BestSolution", "The best tank program", bestSolution));
+      } else {
+        results["BestSolution"].Value = bestSolution;
+      }
+    }
+
+    public override bool Maximization {
+      get { return true; }
+    }
+
+    private void RegisterEventHandlers() {
+      RobocodePathParameter.Value.StringValue.ValueChanged += RobocodePathParameter_ValueChanged;
+    }
+
+    void RobocodePathParameter_ValueChanged(object sender, System.EventArgs e) {
+      EnemiesParameter.Value.RobocodePath = RobocodePathParameter.Value.Value;
+    }
+  }
+}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/RobocodeProblem.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/RobocodeProblem.cs	(revision 13016)
+++ 	(revision )
@@ -1,158 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 360)]
-  [Item("Robocode Problem", "Evolution of a robocode program in java using genetic programming.")]
-  public class RobocodeProblem : SymbolicExpressionTreeProblem {
-    #region Parameter Names
-    private const string MaxTankProgramLengthParameterName = "MaxProgramLength";
-    private const string MaxTankProgramDepthParameterName = "MaxProgramDepth";
-    private const string RobocodePathParamaterName = "RobocodePath";
-    private const string NrOfRoundsParameterName = "NrOfRounds";
-    private const string EnemiesParameterName = "Enemies";
-    #endregion
-
-    #region Parameters
-    //public IFixedValueParameter<IntValue> MaxTankProgramLengthParameter {
-    //  get { return (IFixedValueParameter<IntValue>)Parameters[MaxTankProgramLengthParameterName]; }
-    //}
-    //public IFixedValueParameter<IntValue> MaxTankProgramDepthParameter {
-    //  get { return (IFixedValueParameter<IntValue>)Parameters[MaxTankProgramDepthParameterName]; }
-    //}
-    public IFixedValueParameter<DirectoryValue> RobocodePathParameter {
-      get { return (IFixedValueParameter<DirectoryValue>)Parameters[RobocodePathParamaterName]; }
-    }
-    public IFixedValueParameter<IntValue> NrOfRoundsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[NrOfRoundsParameterName]; }
-    }
-    public IValueParameter<EnemyCollection> EnemiesParameter {
-      get { return (IValueParameter<EnemyCollection>)Parameters[EnemiesParameterName]; }
-    }
-
-    //public int MaxTankProgramDepth {
-    //  get { return MaxTankProgramDepthParameter.Value.Value; }
-    //  set { MaxTankProgramDepthParameter.Value.Value = value; }
-    //}
-    //
-    //public int MaxTankProgramLength {
-    //  get { return MaxTankProgramLengthParameter.Value.Value; }
-    //  set { MaxTankProgramLengthParameter.Value.Value = value; }
-    //}
-
-    public string RobocodePath {
-      get { return RobocodePathParameter.Value.Value; }
-      set { RobocodePathParameter.Value.Value = value; }
-    }
-
-    public int NrOfRounds {
-      get { return NrOfRoundsParameter.Value.Value; }
-      set { NrOfRoundsParameter.Value.Value = value; }
-    }
-
-    public EnemyCollection Enemies {
-      get { return EnemiesParameter.Value; }
-      set { EnemiesParameter.Value = value; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    protected RobocodeProblem(bool deserializing) : base(deserializing) { }
-    protected RobocodeProblem(RobocodeProblem original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterEventHandlers();
-    }
-
-    public RobocodeProblem()
-      : base() {
-      DirectoryValue robocodeDir = new DirectoryValue { Value = @"C:\robocode" };
-
-      var robotList = EnemyCollection.ReloadEnemies(robocodeDir.Value);
-      robotList.RobocodePath = robocodeDir.Value;
-
-
-      Parameters.Add(new FixedValueParameter<DirectoryValue>(RobocodePathParamaterName, "Path of the Robocode installation.", robocodeDir));
-      Parameters.Add(new FixedValueParameter<IntValue>(NrOfRoundsParameterName, "Number of rounds a robot has to fight against each opponent.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<EnemyCollection>(EnemiesParameterName, "The enemies that should be battled.", robotList));
-
-      Encoding = new SymbolicExpressionTreeEncoding(new Grammar(), 1000, 10);
-      Encoding.FunctionArguments = 0;
-      Encoding.FunctionDefinitions = 0;
-
-      RegisterEventHandlers();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RobocodeProblem(this, cloner);
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() { RegisterEventHandlers(); }
-
-    public override double Evaluate(ISymbolicExpressionTree tree, IRandom random) {
-      return Interpreter.EvaluateTankProgram(tree, RobocodePath, Enemies, null, false, NrOfRounds);
-    }
-
-    public override void Analyze(ISymbolicExpressionTree[] trees, double[] qualities, ResultCollection results, IRandom random) {
-      // find the tree with the best quality
-      double maxQuality = double.NegativeInfinity;
-      ISymbolicExpressionTree bestTree = null;
-      for (int i = 0; i < qualities.Length; i++) {
-        if (qualities[i] > maxQuality) {
-          maxQuality = qualities[i];
-          bestTree = trees[i];
-        }
-      }
-
-      // create a solution instance
-      var bestSolution = new Solution(bestTree, RobocodePath, NrOfRounds, Enemies);
-
-      // also add the best solution as a result to the result collection
-      // or alternatively update the existing result
-      if (!results.ContainsKey("BestSolution")) {
-        results.Add(new Result("BestSolution", "The best tank program", bestSolution));
-      } else {
-        results["BestSolution"].Value = bestSolution;
-      }
-    }
-
-    public override bool Maximization {
-      get { return true; }
-    }
-
-    private void RegisterEventHandlers() {
-      RobocodePathParameter.Value.StringValue.ValueChanged += RobocodePathParameter_ValueChanged;
-    }
-
-    void RobocodePathParameter_ValueChanged(object sender, System.EventArgs e) {
-      EnemiesParameter.Value.RobocodePath = RobocodePathParameter.Value.Value;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Block.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Block.cs	(revision 13016)
+++ 	(revision )
@@ -1,59 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Block : CodeNode {
-    public override int MinimumArity { get { return 1; } }
-    public override int MaximumArity { get { return byte.MaxValue; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Block(bool deserializing) : base(deserializing) { }
-    protected Block(Block original, Cloner cloner) : base(original, cloner) { }
-
-    public Block()
-      : base("Block", "A group of statements.") {
-      Prefix = "{";
-      Suffix = "}";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Block(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
-      string result = children.Aggregate(string.Empty, (current, c) => current + (Environment.NewLine + ((CodeNode)c.Symbol).Interpret(c, c.Subtrees)));
-      return Prefix + result + Environment.NewLine + Suffix;
-    }
-  }
-}
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/CodeNode.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/CodeNode.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/CodeNode.cs	(revision 13017)
@@ -27,22 +27,31 @@
 namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
   [StorableClass]
-  public abstract class CodeNode : Symbol {
-    public abstract string Prefix { get; set; }
-    public abstract string Suffix { get; set; }
+  // a symbol that can represent any user-defined fragment of code
+  public sealed class CodeSymbol : Symbol {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 10; } }
+
+    public string Prefix { get; set; }
+    public string Suffix { get; set; }
+
+    public override bool CanChangeName { get { return false; } } // cannot change, otherwise we cannot detect these symbols in the interpreter
+    public override bool CanChangeDescription { get { return false; } }
 
     [StorableConstructor]
-    protected CodeNode(bool deserializing) : base(deserializing) { }
-    protected CodeNode(CodeNode original, Cloner cloner)
+    private CodeSymbol(bool deserializing) : base(deserializing) { }
+    private CodeSymbol(CodeSymbol original, Cloner cloner)
       : base(original, cloner) {
       Prefix = original.Prefix;
       Suffix = original.Suffix;
     }
-    protected CodeNode(string name, string description)
-      : base(name, description) {
+    public CodeSymbol()
+      : base("CodeSymbol", "The CodeSymbol symbol can represent any user-defined fragment of code.") {
       Prefix = string.Empty;
       Suffix = string.Empty;
     }
 
-    public abstract string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children);
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CodeSymbol(this, cloner);
+    }
   }
 }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanTreeNode.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanTreeNode.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanTreeNode.cs	(revision 13017)
@@ -42,5 +42,5 @@
     }
 
-    public BooleanTreeNode() : base(new LogicalValue()) { }
+    public BooleanTreeNode(BooleanValue boolValueSy) : base(boolValueSy) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanValue.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanValue.cs	(revision 13017)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanValue.cs	(revision 13017)
@@ -0,0 +1,51 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
+  [StorableClass]
+  public class BooleanValue : Symbol {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
+
+    [StorableConstructor]
+    protected BooleanValue(bool deserializing) : base(deserializing) { }
+    protected BooleanValue(BooleanValue original, Cloner cloner) : base(original, cloner) { }
+
+    public BooleanValue() : base("BooleanValue", "A Boolean value.") { }
+
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
+      return new BooleanTreeNode(this);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BooleanValue(this, cloner);
+    }
+
+    public string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return ((BooleanTreeNode)node).Value.ToString().ToLower();
+    }
+  }
+}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Conjunction.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Conjunction.cs	(revision 13016)
+++ 	(revision )
@@ -1,63 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Conjunction : CodeNode {
-    public override int MinimumArity { get { return 2; } }
-    public override int MaximumArity { get { return byte.MaxValue; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Conjunction(bool deserializing) : base(deserializing) { }
-    protected Conjunction(Conjunction original, Cloner cloner) : base(original, cloner) { }
-
-    public Conjunction()
-      : base("Conjunction", "Conjunction comparator.") {
-      Prefix = "(";
-      Suffix = ")";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Conjunction(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      if (children.Count() < 2)
-        throw new ArgumentException("Expected at least two children.", "children");
-
-      string result = string.Join(" && ", children.Select(c => ((CodeNode)c.Symbol).Interpret(c, c.Subtrees)));
-      return Prefix + result + Suffix;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Disjunction.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Disjunction.cs	(revision 13016)
+++ 	(revision )
@@ -1,63 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Disjunction : CodeNode {
-    public override int MinimumArity { get { return 2; } }
-    public override int MaximumArity { get { return byte.MaxValue; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Disjunction(bool deserializing) : base(deserializing) { }
-    protected Disjunction(Disjunction original, Cloner cloner) : base(original, cloner) { }
-
-    public Disjunction()
-      : base("Disjunction", "Disjunction comparator.") {
-      Prefix = "(";
-      Suffix = ")";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Disjunction(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      if (children.Count() < 2)
-        throw new ArgumentException("Expected at least two children.", "children");
-
-      string result = string.Join(" || ", children.Select(c => ((CodeNode)c.Symbol).Interpret(c, c.Subtrees)));
-      return Prefix + result + Suffix;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalExpression.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalExpression.cs	(revision 13016)
+++ 	(revision )
@@ -1,64 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class LogicalExpression : CodeNode {
-    public override int MinimumArity { get { return 1; } }
-    public override int MaximumArity { get { return 1; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected LogicalExpression(bool deserializing) : base(deserializing) { }
-    protected LogicalExpression(LogicalExpression original, Cloner cloner) : base(original, cloner) { }
-
-    public LogicalExpression() : base("LogicalExpression", "A logical expression.") { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new LogicalExpression(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      if (children.Count() != 1)
-        throw new ArgumentException("Expected 1 child in LogicalExpression.", "children");
-
-      var exprTree = children.Single();
-      var symbol = exprTree.Symbol;
-      if (!(symbol is LogicalValue || symbol is Conjunction || symbol is Disjunction || symbol is Negation))
-        throw new InvalidProgramException("Negation was given a child of type " + symbol.GetType() +
-            ". The expected child must be of type LogicalValue or Conjunction or Disjunction or Negation.");
-
-      return Prefix + ((CodeNode)symbol).Interpret(exprTree, exprTree.Subtrees) + Suffix;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalValue.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalValue.cs	(revision 13016)
+++ 	(revision )
@@ -1,57 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Collections.Generic;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class LogicalValue : CodeNode {
-    public override int MinimumArity { get { return 0; } }
-    public override int MaximumArity { get { return 0; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected LogicalValue(bool deserializing) : base(deserializing) { }
-    protected LogicalValue(LogicalValue original, Cloner cloner) : base(original, cloner) { }
-
-    public LogicalValue() : base("LogicalValue", "A logical value.") { }
-
-    public override ISymbolicExpressionTreeNode CreateTreeNode() {
-      return new BooleanTreeNode();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new LogicalValue(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      return Prefix + ((BooleanTreeNode)node).Value.ToString().ToLower() + Suffix;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Negation.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Negation.cs	(revision 13016)
+++ 	(revision )
@@ -1,68 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Negation : CodeNode {
-    public override int MinimumArity { get { return 1; } }
-    public override int MaximumArity { get { return 1; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Negation(bool deserializing) : base(deserializing) { }
-    protected Negation(Negation original, Cloner cloner) : base(original, cloner) { }
-
-    public Negation()
-      : base("Negation", "A negation.") {
-      Prefix = "!(";
-      Suffix = ")";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Negation(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      if (children.Count() != 1)
-        throw new ArgumentException("Expected 1 child in Negation.", "children");
-
-      var exprTree = children.Single();
-      var symbol = exprTree.Symbol;
-      if (!(symbol is LogicalValue || symbol is Conjunction || symbol is Disjunction || symbol is Negation || symbol is ILogicalComparator))
-        throw new InvalidProgramException("Negation was given a child of type " + symbol.GetType() +
-            ". The expected child must be of type LogicalValue or Conjunction or Disjunction or Negation or ILogicalComparator.");
-
-      return Prefix + ((CodeNode)symbol).Interpret(exprTree, exprTree.Subtrees) + Suffix;
-    }
-  }
-}
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Number.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Number.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Number.cs	(revision 13017)
@@ -28,13 +28,7 @@
 namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
   [StorableClass]
-  public class Number : CodeNode {
+  public class Number : Symbol {
     public override int MinimumArity { get { return 0; } }
     public override int MaximumArity { get { return 0; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
 
     [StorableConstructor]
@@ -45,5 +39,5 @@
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
-      return new NumberTreeNode();
+      return new NumberTreeNode(this);
     }
 
@@ -52,5 +46,5 @@
     }
 
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
+    public string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
       return ((NumberTreeNode)node).Value.ToString(CultureInfo.InvariantCulture);
     }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumberTreeNode.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumberTreeNode.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumberTreeNode.cs	(revision 13017)
@@ -42,5 +42,5 @@
     }
 
-    public NumberTreeNode() : base(new Number()) { }
+    public NumberTreeNode(Number numberSy) : base(numberSy) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumericalExpression.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumericalExpression.cs	(revision 13016)
+++ 	(revision )
@@ -1,64 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class NumericalExpression : CodeNode {
-    public override int MinimumArity { get { return 1; } }
-    public override int MaximumArity { get { return 1; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected NumericalExpression(bool deserializing) : base(deserializing) { }
-    protected NumericalExpression(NumericalExpression original, Cloner cloner) : base(original, cloner) { }
-
-    public NumericalExpression() : base("NumericalExpression", "A numerical expression.") { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new NumericalExpression(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      if (children.Count() != 1)
-        throw new ArgumentException("Expected 1 child in NumericalExpression.", "children");
-
-      var exprTree = children.Single();
-      var symbol = exprTree.Symbol;
-      if (!(symbol is Number || symbol is INumericalMethod || symbol is INumericalOperator))
-        throw new InvalidProgramException("NumericalExpression was given a child of type " + symbol.GetType() +
-            ". The expected child must be of type Number or INumericalMethod or INumericalOperator .");
-
-      return Prefix + ((CodeNode)symbol).Interpret(exprTree, exprTree.Subtrees) + Suffix;
-    }
-  }
-}
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPower.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPower.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPower.cs	(revision 13017)
@@ -28,13 +28,7 @@
 namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
   [StorableClass]
-  public class ShotPower : CodeNode {
+  public class ShotPower : Symbol {
     public override int MinimumArity { get { return 0; } }
     public override int MaximumArity { get { return 0; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
 
     [StorableConstructor]
@@ -45,5 +39,5 @@
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
-      return new ShotPowerTreeNode();
+      return new ShotPowerTreeNode(this);
     }
 
@@ -52,5 +46,5 @@
     }
 
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
+    public string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
       return ((ShotPowerTreeNode)node).Value.ToString(CultureInfo.InvariantCulture);
     }
Index: /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPowerTreeNode.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPowerTreeNode.cs	(revision 13016)
+++ /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPowerTreeNode.cs	(revision 13017)
@@ -43,5 +43,5 @@
     }
 
-    public ShotPowerTreeNode() : base(new ShotPower()) { }
+    public ShotPowerTreeNode(ShotPower powerSy) : base(powerSy) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Program.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Program.cs	(revision 13016)
+++ 	(revision )
@@ -1,45 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Program : Symbol {
-    public override int MinimumArity { get { return 2; } }
-    public override int MaximumArity { get { return byte.MaxValue; } }
-
-    [StorableConstructor]
-    protected Program(bool deserializing) : base(deserializing) { }
-    protected Program(Program original, Cloner cloner) : base(original, cloner) { }
-
-    public Program()
-      : base("Program", "A Robocode tank program.") {
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Program(this, cloner);
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Stat.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Stat.cs	(revision 13016)
+++ 	(revision )
@@ -1,58 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Stat : CodeNode {
-    public override int MinimumArity { get { return 1; } }
-    public override int MaximumArity { get { return 1; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Stat(bool deserializing) : base(deserializing) { }
-    protected Stat(Stat original, Cloner cloner) : base(original, cloner) { }
-
-    public Stat()
-      : base("Statement", "A statement.") {
-      Suffix = ";";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Stat(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      return children.Aggregate(string.Empty, (current, c) => current + (Environment.NewLine + ((CodeNode)c.Symbol).Interpret(c, c.Subtrees))) + Suffix;
-    }
-  }
-}
Index: anches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Tank.cs
===================================================================
--- /branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Tank.cs	(revision 13016)
+++ 	(revision )
@@ -1,68 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
-  [StorableClass]
-  public class Tank : CodeNode {
-    public override int MinimumArity { get { return 2; } }
-    public override int MaximumArity { get { return 7; } }
-
-    [Storable]
-    public override string Prefix { get; set; }
-
-    [Storable]
-    public override string Suffix { get; set; }
-
-    [StorableConstructor]
-    protected Tank(bool deserializing) : base(deserializing) { }
-    protected Tank(Tank original, Cloner cloner) : base(original, cloner) { }
-
-    public Tank()
-      : base("Tank", "The root of a Robocode Tank program.") {
-      Prefix =
-@"package Evaluation;
-import robocode.*;
-import robocode.Robot;
-import robocode.util.*;
-import static robocode.util.Utils.normalRelativeAngleDegrees;
-import java.awt.*;
-
-public class output extends AdvancedRobot {";
-      Suffix = "}";
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Tank(this, cloner);
-    }
-
-    public override string Interpret(ISymbolicExpressionTreeNode node, IEnumerable<ISymbolicExpressionTreeNode> children) {
-      string result = children.Aggregate(string.Empty, (current, c) => current + (Environment.NewLine + ((CodeNode)c.Symbol).Interpret(c, c.Subtrees)));
-      return Prefix + result + Environment.NewLine + Suffix;
-    }
-  }
-}
