Changeset 9790

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/CodeNodeView.cs

-                      r9781
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Windows.Forms;
 using HeuristicLab.Core.Views;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/Plugin.cs.frame

r9787	r9790
29	29	namespace HeuristicLab.Problems.Robocode.Views
30	30	{
31		[Plugin("HeuristicLab.Problems.Robocode.Views", "The Robocode problem for genetic programming.", "3.3.7.$WCREV$")]
	31	[Plugin("HeuristicLab.Problems.Robocode.Views", "The Robocode problem for genetic programming.", "3.3.8.$WCREV$")]
32	32	[PluginFile("HeuristicLab.Problems.Robocode.Views-3.3.dll", PluginFileType.Assembly)]
33	33	[PluginDependency("HeuristicLab.Data", "3.3")]

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/SolutionCodeView.cs

-                      r9781
+                      r9790
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Diagnostics;
+using System.IO;
 using System.Windows.Forms;
 using HeuristicLab.Core.Views;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
 using HeuristicLab.MainForm;
-using System.Diagnostics;
-using System.IO;
+namespace HeuristicLab.Problems.Robocode
+{
+    [View("Robocode Tank Code View")]
+    [Content(typeof(Solution), IsDefaultView = true)]
+    public partial class SolutionCodeView : NamedItemView
+    {
+        private string Path { get; set; }
+namespace HeuristicLab.Problems.Robocode {
+  [View("Robocode Tank Code View")]
+  [Content(typeof(Solution), IsDefaultView = true)]
+  public partial class SolutionCodeView : NamedItemView {
+    private string Path { get; set; }
+        public new Solution Content
+        {
+            get { return (Solution)base.Content; }
+            set { base.Content = value; }
+        }
+    public new Solution Content {
+      get { return (Solution)base.Content; }
+      set { base.Content = value; }
+    }
         public SolutionCodeView() : base()
+        {
             InitializeComponent();
             this.Path = "F:/robocode/";
             this.programCode.Text = "";
+        }
+    public SolutionCodeView()
+      : base() {
+      InitializeComponent();
+      this.Path = "F:/robocode/";
+      this.programCode.Text = "";
+    }
+        protected override void OnContentChanged()
+        {
+            base.OnContentChanged();
+            if (Content == null)
+            {
+                this.programCode.Text = "";
+            }
+            else
+            {
+                this.Path = Content.Path;
+                string code = Interpreter.InterpretProgramTree(Content.Tree.Root);
+                code = code.Replace("class output extends", "class BestSolution extends");
+                this.programCode.Text = code;
+                File.AppendAllText(Path + "/robots/Evaluation/PreviousBestSolution.java", "\r\n/**********************************************/\r\n" + code);
+                File.WriteAllText(Path + "/robots/Evaluation/BestSolution.java", code, System.Text.Encoding.Default);
+            }
+        }
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        this.programCode.Text = "";
+      } else {
+        this.Path = Content.Path;
+        string code = Interpreter.InterpretProgramTree(Content.Tree.Root);
+        code = code.Replace("class output extends", "class BestSolution extends");
+        this.programCode.Text = code;
+        File.AppendAllText(Path + "/robots/Evaluation/PreviousBestSolution.java", "\r\n/**********************************************/\r\n" + code);
+        File.WriteAllText(Path + "/robots/Evaluation/BestSolution.java", code, System.Text.Encoding.Default);
+      }
+    }
+        private void btnRunInRobocode_Click(object sender, EventArgs e)
+        {
+            string formattedPath = Path.Replace("/", "\\");
+            ProcessStartInfo javaCompileInfo = new ProcessStartInfo();
+            javaCompileInfo.FileName = "cmd.exe";
+            javaCompileInfo.Arguments = "/C javac -cp " + formattedPath + "\\libs\\robocode.jar " + formattedPath + "\\robots\\Evaluation\\BestSolution.java";
+            javaCompileInfo.RedirectStandardOutput = true;
+            javaCompileInfo.RedirectStandardError = true;
+            javaCompileInfo.UseShellExecute = false;
+            javaCompileInfo.CreateNoWindow = true;
+    private void btnRunInRobocode_Click(object sender, EventArgs e) {
+      string formattedPath = Path.Replace("/", "\\");
+      ProcessStartInfo javaCompileInfo = new ProcessStartInfo();
+      javaCompileInfo.FileName = "cmd.exe";
+      javaCompileInfo.Arguments = "/C javac -cp " + formattedPath + "\\libs\\robocode.jar " + formattedPath + "\\robots\\Evaluation\\BestSolution.java";
+      javaCompileInfo.RedirectStandardOutput = true;
+      javaCompileInfo.RedirectStandardError = true;
+      javaCompileInfo.UseShellExecute = false;
+      javaCompileInfo.CreateNoWindow = true;
             Process javaCompile = new Process();
             javaCompile.StartInfo = javaCompileInfo;
             javaCompile.Start();
             javaCompile.WaitForExit();
+      Process javaCompile = new Process();
+      javaCompile.StartInfo = javaCompileInfo;
+      javaCompile.Start();
+      javaCompile.WaitForExit();
             ProcessStartInfo evaluateCodeInfo = new ProcessStartInfo();
             evaluateCodeInfo.FileName = "cmd.exe";
             //javaCompileInfo.Arguments = "/C javac -cp C:\\robocode\\libs\\robocode.jar \"" + path + "\\Spaced Up\\output.java\"";
             evaluateCodeInfo.Arguments = "/C java -classpath " + formattedPath + "\\libs;" + formattedPath + "\\libs\\robocode.core-1.8.1.0.jar;" + formattedPath + "\\libs\\robocode.jar;" + formattedPath + "\\libs\\picocontainer-2.14.2.jar BattleRunner Evaluation.BestSolution*";
             //Console.WriteLine(javaCompileInfo.Arguments);
             evaluateCodeInfo.RedirectStandardOutput = true;
             evaluateCodeInfo.RedirectStandardError = true;
             evaluateCodeInfo.UseShellExecute = false;
+      ProcessStartInfo evaluateCodeInfo = new ProcessStartInfo();
+      evaluateCodeInfo.FileName = "cmd.exe";
+      //javaCompileInfo.Arguments = "/C javac -cp C:\\robocode\\libs\\robocode.jar \"" + path + "\\Spaced Up\\output.java\"";
+      evaluateCodeInfo.Arguments = "/C java -classpath " + formattedPath + "\\libs;" + formattedPath + "\\libs\\robocode.core-1.8.1.0.jar;" + formattedPath + "\\libs\\robocode.jar;" + formattedPath + "\\libs\\picocontainer-2.14.2.jar BattleRunner Evaluation.BestSolution*";
+      //Console.WriteLine(javaCompileInfo.Arguments);
+      evaluateCodeInfo.RedirectStandardOutput = true;
+      evaluateCodeInfo.RedirectStandardError = true;
+      evaluateCodeInfo.UseShellExecute = false;
+            Process evaluateCode = new Process();
+            evaluateCode.StartInfo = evaluateCodeInfo;
+            evaluateCode.Start();
+            evaluateCode.WaitForExit();
+        }
+      Process evaluateCode = new Process();
+      evaluateCode.StartInfo = evaluateCodeInfo;
+      evaluateCode.Start();
+      evaluateCode.WaitForExit();
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/SolutionProgramView.Designer.cs

-                      r9781
+                      r9790
 #region License Information
 /* HeuristicLab
  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
  * This file is part of HeuristicLab.
 …
 using System.Windows.Forms;
-using HeuristicLab.Core.Views;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
-using HeuristicLab.MainForm;
 namespace HeuristicLab.Problems.Robocode {

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode.Views/3.3/SolutionProgramView.cs

r9781	r9790
1	1	#region License Information
2	2	/* HeuristicLab
3		* Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
	3	* Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4	4	*
5	5	* This file is part of HeuristicLab.

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/BestSolutionAnalyzer.cs

-                      r9781
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    [Item("Best Tank program Analyzer",
+          "Analyzer that stores the best tank program.")]
+    public class BestSolutionAnalyzer : SingleSuccessorOperator,
+      ISymbolicExpressionTreeAnalyzer
+    {
+        #region parameter names
+        private const string QualityParameterName = "Quality";
+        private const string SymbolicExpressionTreeParameterName =
+          "TankProgram";
+        private const string MovesParameterName = "Moves";
+        private const string ShotsParameterName = "Shots";
+        private const string BestSolutionParameterName = "Best solution";
+        private const string ResultsParameterName = "Results";
+        private const string RobocodePathParamaterName = "Path";
+        private const string CoevolutionParameterName = "Coevolution";
+        #endregion
+        #region parameters
+        public IScopeTreeLookupParameter<DoubleValue> QualityParameter
+        {
+            get
+            {
+                return (IScopeTreeLookupParameter<DoubleValue>)
+                          Parameters[QualityParameterName];
+            }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  [Item("Best Tank program Analyzer",
+        "Analyzer that stores the best tank program.")]
+  public class BestSolutionAnalyzer : SingleSuccessorOperator,
+    ISymbolicExpressionTreeAnalyzer {
+    #region parameter names
+    private const string QualityParameterName = "Quality";
+    private const string SymbolicExpressionTreeParameterName =
+      "TankProgram";
+    private const string MovesParameterName = "Moves";
+    private const string ShotsParameterName = "Shots";
+    private const string BestSolutionParameterName = "Best solution";
+    private const string ResultsParameterName = "Results";
+    private const string RobocodePathParamaterName = "Path";
+    private const string CoevolutionParameterName = "Coevolution";
+    #endregion
+    #region parameters
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get {
+        return (IScopeTreeLookupParameter<DoubleValue>)
+                  Parameters[QualityParameterName];
+      }
+    }
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get {
+        return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)
+                  Parameters[SymbolicExpressionTreeParameterName];
+      }
+    }
+    //public ILookupParameter<IntValue> MovesParameter
+    //{
+    //    get
+    //    {
+    //        return (ILookupParameter<IntValue>)
+    //                  Parameters[MovesParameterName];
+    //    }
+    //}
+    //public ILookupParameter<IntValue> ShotsParameter
+    //{
+    //    get
+    //    {
+    //        return (ILookupParameter<IntValue>)
+    //                  Parameters[ShotsParameterName];
+    //    }
+    //}
+    public ILookupParameter<Solution> BestSolutionParameter {
+      get {
+        return (ILookupParameter<Solution>)
+                  Parameters[BestSolutionParameterName];
+      }
+    }
+    public ILookupParameter<ResultCollection> ResultParameter {
+      get {
+        return (ILookupParameter<ResultCollection>)
+                  Parameters[ResultsParameterName];
+      }
+    }
+    public ILookupParameter<StringValue> RobocodePathParameter {
+      get {
+        return (ILookupParameter<StringValue>)
+            Parameters[RobocodePathParamaterName];
+      }
+    }
+    public ILookupParameter<BoolValue> CoevolutionParameter {
+      get {
+        return (ILookupParameter<BoolValue>)
+            Parameters[CoevolutionParameterName];
+      }
+    }
+    #endregion
+    [StorableConstructor]
+    protected BestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
+    protected BestSolutionAnalyzer(BestSolutionAnalyzer original,
+                                   Cloner cloner)
+      : base(original, cloner) {
+    }
+    public BestSolutionAnalyzer() {
+      Parameters.Add(
+        new ScopeTreeLookupParameter<DoubleValue>(
+          QualityParameterName,
+          "The solution quality of the tank program."));
+      Parameters.Add(
+        new ScopeTreeLookupParameter<ISymbolicExpressionTree>(
+          SymbolicExpressionTreeParameterName,
+          "The tank program to evaluate represented " +
+          "as symbolic expression tree."));
+      Parameters.Add(
+        new LookupParameter<Solution>(
+          BestSolutionParameterName, "The best tank program."));
+      //Parameters.Add(
+      //  new LookupParameter<IntValue>(
+      //    MovesParameterName, "The number of moves made."));
+      //Parameters.Add(
+      //  new LookupParameter<IntValue>(
+      //    ShotsParameterName, "The shots made."));
+      Parameters.Add(
+        new LookupParameter<ResultCollection>(
+          ResultsParameterName, "The result collection of the algorithm."));
+      Parameters.Add(
+        new LookupParameter<StringValue>(
+          RobocodePathParamaterName,
+          "Path of the Robocode installation."));
+      Parameters.Add(
+          new LookupParameter<BoolValue>(
+              CoevolutionParameterName,
+              "Use Coevolution"));
+    }
+    public override IOperation Apply() {
+      // get an array of all trees
+      // and an array of all qualities
+      var trees = SymbolicExpressionTreeParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      // 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].Value > maxQuality) {
+          maxQuality = qualities[i].Value;
+          bestTree = trees[i];
+        }
+        public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter
+        {
+            get
+            {
+                return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)
+                          Parameters[SymbolicExpressionTreeParameterName];
+            }
+      }
+      var coevolution = CoevolutionParameter.ActualValue.Value;
+      double actualQuality = 0;
+      if (coevolution)
+        actualQuality = Interpreter.EvaluateTankProgram(bestTree, null, RobocodePathParameter.ActualValue.Value);
+      // create a solution instance
+      //int shots = ShotsParameter.ActualValue.Value;
+      //int moves = MovesParameter.ActualValue.Value;
+      var bestSolution = new Solution(bestTree, RobocodePathParameter.ActualValue.Value);//, moves, shots);
+      // store the new solution in the best solution parameter
+      BestSolutionParameter.ActualValue = bestSolution;
+      // also add the best solution as a result to the result collection
+      // or alternatively update the existing result
+      var resultCollection = ResultParameter.ActualValue;
+      if (!resultCollection.ContainsKey(BestSolutionParameterName)) {
+        resultCollection.Add(
+          new Result(BestSolutionParameterName,
+                     "The best tank program", bestSolution));
+        //if(coevolution)
+        //    resultCollection.Add(
+        //        new Result("Actual Quality",
+        //            "The actual quality of the best program", new DoubleValue(actualQuality)));
+      } else {
+        resultCollection[BestSolutionParameterName].Value = bestSolution;
+      }
+      if (coevolution) {
+        if (!resultCollection.ContainsKey("Actual Quality")) {
+          resultCollection.Add(
+              new Result("Actual Quality",
+                  "The actual quality of the best program", new DoubleValue(actualQuality)));
+        } else {
+          resultCollection["Actual Quality"].Value = new DoubleValue(actualQuality);
+        }
+        //public ILookupParameter<IntValue> MovesParameter
+        //{
+        //    get
+        //    {
+        //        return (ILookupParameter<IntValue>)
+        //                  Parameters[MovesParameterName];
+        //    }
+        //}
+        //public ILookupParameter<IntValue> ShotsParameter
+        //{
+        //    get
+        //    {
+        //        return (ILookupParameter<IntValue>)
+        //                  Parameters[ShotsParameterName];
+        //    }
+        //}
+        public ILookupParameter<Solution> BestSolutionParameter
+        {
+            get
+            {
+                return (ILookupParameter<Solution>)
+                          Parameters[BestSolutionParameterName];
+            }
+        }
+        public ILookupParameter<ResultCollection> ResultParameter
+        {
+            get
+            {
+                return (ILookupParameter<ResultCollection>)
+                          Parameters[ResultsParameterName];
+            }
+        }
+        public ILookupParameter<StringValue> RobocodePathParameter
+        {
+            get
+            {
+                return (ILookupParameter<StringValue>)
+                    Parameters[RobocodePathParamaterName];
+            }
+        }
+        public ILookupParameter<BoolValue> CoevolutionParameter
+        {
+            get
+            {
+                return (ILookupParameter<BoolValue>)
+                    Parameters[CoevolutionParameterName];
+            }
+        }
+        #endregion
+        [StorableConstructor]
+        protected BestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
+        protected BestSolutionAnalyzer(BestSolutionAnalyzer original,
+                                       Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+        public BestSolutionAnalyzer()
+        {
+            Parameters.Add(
+              new ScopeTreeLookupParameter<DoubleValue>(
+                QualityParameterName,
+                "The solution quality of the tank program."));
+            Parameters.Add(
+              new ScopeTreeLookupParameter<ISymbolicExpressionTree>(
+                SymbolicExpressionTreeParameterName,
+                "The tank program to evaluate represented " +
+                "as symbolic expression tree."));
+            Parameters.Add(
+              new LookupParameter<Solution>(
+                BestSolutionParameterName, "The best tank program."));
+            //Parameters.Add(
+            //  new LookupParameter<IntValue>(
+            //    MovesParameterName, "The number of moves made."));
+            //Parameters.Add(
+            //  new LookupParameter<IntValue>(
+            //    ShotsParameterName, "The shots made."));
+            Parameters.Add(
+              new LookupParameter<ResultCollection>(
+                ResultsParameterName, "The result collection of the algorithm."));
+            Parameters.Add(
+              new LookupParameter<StringValue>(
+                RobocodePathParamaterName,
+                "Path of the Robocode installation."));
+            Parameters.Add(
+                new LookupParameter<BoolValue>(
+                    CoevolutionParameterName,
+                    "Use Coevolution"));
+        }
+        public override IOperation Apply()
+        {
+            // get an array of all trees
+            // and an array of all qualities
+            var trees = SymbolicExpressionTreeParameter.ActualValue;
+            var qualities = QualityParameter.ActualValue;
+            // 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].Value > maxQuality)
+                {
+                    maxQuality = qualities[i].Value;
+                    bestTree = trees[i];
+                }
+            }
+            var coevolution = CoevolutionParameter.ActualValue.Value;
+            double actualQuality = 0;
+            if (coevolution)
+                actualQuality = Interpreter.EvaluateTankProgram(bestTree, null, RobocodePathParameter.ActualValue.Value);
+            // create a solution instance
+            //int shots = ShotsParameter.ActualValue.Value;
+            //int moves = MovesParameter.ActualValue.Value;
+            var bestSolution = new Solution(bestTree, RobocodePathParameter.ActualValue.Value);//, moves, shots);
+            // store the new solution in the best solution parameter
+            BestSolutionParameter.ActualValue = bestSolution;
+            // also add the best solution as a result to the result collection
+            // or alternatively update the existing result
+            var resultCollection = ResultParameter.ActualValue;
+            if (!resultCollection.ContainsKey(BestSolutionParameterName))
+            {
+              resultCollection.Add(
+                new Result(BestSolutionParameterName,
+                           "The best tank program", bestSolution));
+              //if(coevolution)
+              //    resultCollection.Add(
+              //        new Result("Actual Quality",
+              //            "The actual quality of the best program", new DoubleValue(actualQuality)));
+            }
+            else
+            {
+                resultCollection[BestSolutionParameterName].Value = bestSolution;
+            }
+            if (coevolution)
+            {
+                if (!resultCollection.ContainsKey("Actual Quality"))
+                {
+                    resultCollection.Add(
+                        new Result("Actual Quality",
+                            "The actual quality of the best program", new DoubleValue(actualQuality)));
+                }
+                else
+                {
+                    resultCollection["Actual Quality"].Value = new DoubleValue(actualQuality);
+                }
+            }
+            // important return base.Apply() to make sure the
+            // next operator is queued for execution
+            return base.Apply();
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new BestSolutionAnalyzer(this, cloner);
+        }
+        // override this property to indicate that this analyzer
+        // should be enabled by default in the algorithm
+        public bool EnabledByDefault
+        {
+            get { return true; }
+        }
+    }
+      }
+      // important return base.Apply() to make sure the
+      // next operator is queued for execution
+      return base.Apply();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestSolutionAnalyzer(this, cloner);
+    }
+    // override this property to indicate that this analyzer
+    // should be enabled by default in the algorithm
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Crossover/RobocodeCrossover.cs

-                      r9565
+                      r9790
 #region License Information
 /* HeuristicLab
  * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
  * This file is part of HeuristicLab.
 …
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 namespace HeuristicLab.Problems.Robocode {

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Crossover/RobocodeMethodCrossover.cs

-                      r9565
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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 System.Linq;
 …
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+namespace HeuristicLab.Problems.Robocode
+{
+    /// <summary>
+    /// Takes two parent individuals P0 and P1 each. Selects a random node N0 of P0 and a random node N1 of P1.
+    /// And replaces the branch with root0 N0 in P0 with N1 from P1 if the tree-size limits are not violated.
+    /// When recombination with N0 and N1 would create a tree that is too large or invalid the operator randomly selects new N0 and N1
+    /// until a valid configuration is found.
+    /// </summary>
+    [Item("RobocodeMethodCrossover", "An operator which performs crossover of randomly chosen statements with a method.")]
+    [StorableClass]
+    public class RobocodeMethodCrossover : SymbolicExpressionTreeCrossover//, ISymbolicExpressionTreeSizeConstraintOperator
+namespace HeuristicLab.Problems.Robocode {
+  /// <summary>
+  /// Takes two parent individuals P0 and P1 each. Selects a random node N0 of P0 and a random node N1 of P1.
+  /// And replaces the branch with root0 N0 in P0 with N1 from P1 if the tree-size limits are not violated.
+  /// When recombination with N0 and N1 would create a tree that is too large or invalid the operator randomly selects new N0 and N1
+  /// until a valid configuration is found.
+  /// </summary>
+  [Item("RobocodeMethodCrossover", "An operator which performs crossover of randomly chosen statements with a method.")]
+  [StorableClass]
+  public class RobocodeMethodCrossover : SymbolicExpressionTreeCrossover//, ISymbolicExpressionTreeSizeConstraintOperator
+  {
+    #region Parameter Names
+    private const string HomologousCrossoverPrameterName = "HomologousCrossover";
+    private const string MaximumCrossoverMethodsParameterName = "MaximumCrossoverMethods";
+    #endregion
+    #region Parameter Properties
+    public IValueLookupParameter<BoolValue> HomologousCrossoverParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters[HomologousCrossoverPrameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumCrossoverMethodsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumCrossoverMethodsParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public BoolValue HomologousCrossover {
+      get { return HomologousCrossoverParameter.ActualValue; }
+    }
+    public IntValue MaximumCrossoverMethods {
+      get { return MaximumCrossoverMethodsParameter.ActualValue; }
+    }
+    #endregion
+    [StorableConstructor]
+    protected RobocodeMethodCrossover(bool deserializing) : base(deserializing) { }
+    protected RobocodeMethodCrossover(RobocodeMethodCrossover original, Cloner cloner) :
+      base(original, cloner) { }
+    public RobocodeMethodCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>(HomologousCrossoverPrameterName,
+          "Specifies if the number of statements exchanged between the two parents is the same.", new BoolValue(false)));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumCrossoverMethodsParameterName,
+          "The maximal methods to apply crossover on (0 or a number higher than the count of " +
+          "methods means applying crossover to them all).", new IntValue(0)));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RobocodeMethodCrossover(this, cloner);
+    }
+    public override ISymbolicExpressionTree Crossover(IRandom random,
+      ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1) {
+      return Cross(random, parent0, parent1, HomologousCrossover.Value,
+        MaximumCrossoverMethods.Value);
+    }
+    public static ISymbolicExpressionTree Cross(IRandom random,
+      ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
+      bool homologous, int maximumCrossoverMethods) {
+      // select a random crossover point in the first parent
+      List<CutPoint> crossoverPoints0;
+      SelectCrossoverPoint(random, parent0, maximumCrossoverMethods, out crossoverPoints0);
+      foreach (CutPoint c in crossoverPoints0) {
+        List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
+        parent1.Root.ForEachNodePostfix((n) => {
+          if (n.Symbol.GetType() == c.Child.Symbol.GetType())
+            allowedBranches.Add(n);
+        });
+        if (allowedBranches.Count == 0) {
+          break;
+        } else {
+          ISymbolicExpressionTreeNode branch = allowedBranches.FirstOrDefault();
+          int startBranchParent0 = (c.Child.SubtreeCount <= 2) ? 0 : random.Next(0, c.Child.SubtreeCount - 2);
+          int endBranchParent0 = (c.Child.SubtreeCount <= 2) ? 1 : random.Next(startBranchParent0 + 1, c.Child.SubtreeCount - 1);
+          int Parent0Branches = endBranchParent0 - startBranchParent0;
+          for (int i = 0; i < Parent0Branches; i++) {
+            c.Child.RemoveSubtree(startBranchParent0);
+          }
+          if (homologous) {
+            for (int j = startBranchParent0; j <= endBranchParent0; j++) {
+              c.Child.AddSubtree(branch.GetSubtree(j));
+            }
+          } else {
+            int startBranchParent1 = (branch.SubtreeCount <= 2) ? 0 : random.Next(0, branch.SubtreeCount - 2);
+            int endBranchParent1 = (branch.SubtreeCount <= 2) ? 1 : random.Next(startBranchParent1 + 1, branch.SubtreeCount - 1);
+            int Parent1Branches = endBranchParent1 - startBranchParent1;
+            for (int j = startBranchParent1; j <= endBranchParent1 && c.Child.SubtreeCount < c.Child.Symbol.MaximumArity; j++) {
+              c.Child.AddSubtree(branch.GetSubtree(j));
+            }
+          }
+        }
+      }
+      return parent0;
+    }
+    private static void SelectCrossoverPoint(IRandom random, ISymbolicExpressionTree parent0,
+        int maximumCrossoverMethods, out List<CutPoint> crossoverPoints) {
+      List<CutPoint> MethodPoints = new List<CutPoint>();
+      parent0.Root.ForEachNodePostfix((n) => {
+        if (n.SubtreeCount > 0 && n != parent0.Root) {
+          foreach (var child in n.Subtrees) {
+            if (child.Symbol is Run ||
+                child.Symbol is OnBulletHit ||
+                child.Symbol is OnBulletMissed ||
+                child.Symbol is OnHitByBullet ||
+                child.Symbol is OnHitRobot ||
+                child.Symbol is OnHitWall ||
+                child.Symbol is OnScannedRobot)
+              MethodPoints.Add(new CutPoint(n, child));
+          }
+        }
+      });
+      if (maximumCrossoverMethods == 0)
+        crossoverPoints = MethodPoints;
+      else {
+        crossoverPoints = new List<CutPoint>();
+        for (int i = 0; i < maximumCrossoverMethods; i++) {
+          CutPoint c = MethodPoints.SelectRandom(random);
+          crossoverPoints.Add(c);
+          MethodPoints.Remove(c);
+          if (MethodPoints.Count == 0) break;
+        }
+      }
+    }
+    /*private static ISymbolicExpressionTreeNode SelectRandomBranch(IRandom random, IEnumerable<ISymbolicExpressionTreeNode> branches, double internalNodeProbability)
+    {
+        #region Parameter Names
+        private const string HomologousCrossoverPrameterName = "HomologousCrossover";
+        private const string MaximumCrossoverMethodsParameterName = "MaximumCrossoverMethods";
+        #endregion
+        #region Parameter Properties
+        public IValueLookupParameter<BoolValue> HomologousCrossoverParameter
+        if (internalNodeProbability < 0.0 || internalNodeProbability > 1.0) throw new ArgumentException("internalNodeProbability");
+        List<ISymbolicExpressionTreeNode> allowedInternalBranches;
+        List<ISymbolicExpressionTreeNode> allowedLeafBranches;
+        if (random.NextDouble() < internalNodeProbability)
+        {
+            get { return (IValueLookupParameter<BoolValue>)Parameters[HomologousCrossoverPrameterName]; }
+        }
+        public IValueLookupParameter<IntValue> MaximumCrossoverMethodsParameter
+            // select internal node if possible
+            allowedInternalBranches = (from branch in branches
+                                       where branch != null && branch.SubtreeCount > 0
+                                       select branch).ToList();
+            if (allowedInternalBranches.Count > 0)
+            {
+                return allowedInternalBranches.SelectRandom(random);
+            }
+            else
+            {
+                // no internal nodes allowed => select leaf nodes
+                allowedLeafBranches = (from branch in branches
+                                       where branch == null || branch.SubtreeCount == 0
+                                       select branch).ToList();
+                return allowedLeafBranches.SelectRandom(random);
+            }
+        }
+        else
+        {
+            get { return (IValueLookupParameter<IntValue>)Parameters[MaximumCrossoverMethodsParameterName]; }
+        }
+        #endregion
+        #region Properties
+        public BoolValue HomologousCrossover
+        {
+            get { return HomologousCrossoverParameter.ActualValue; }
+        }
+        public IntValue MaximumCrossoverMethods
+        {
+            get { return MaximumCrossoverMethodsParameter.ActualValue; }
+        }
+        #endregion
+        [StorableConstructor]
+        protected RobocodeMethodCrossover(bool deserializing) : base(deserializing) { }
+        protected RobocodeMethodCrossover(RobocodeMethodCrossover original, Cloner cloner) :
+            base(original, cloner) { }
+        public RobocodeMethodCrossover()
+            : base()
+        {
+            Parameters.Add(new ValueLookupParameter<BoolValue>(HomologousCrossoverPrameterName,
+                "Specifies if the number of statements exchanged between the two parents is the same.", new BoolValue(false)));
+            Parameters.Add(new ValueLookupParameter<IntValue>(MaximumCrossoverMethodsParameterName,
+                "The maximal methods to apply crossover on (0 or a number higher than the count of " +
+                "methods means applying crossover to them all).", new IntValue(0)));
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new RobocodeMethodCrossover(this, cloner);
+        }
+        public override ISymbolicExpressionTree Crossover(IRandom random,
+          ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1)
+        {
+            return Cross(random, parent0, parent1, HomologousCrossover.Value,
+              MaximumCrossoverMethods.Value);
+        }
+        public static ISymbolicExpressionTree Cross(IRandom random,
+          ISymbolicExpressionTree parent0, ISymbolicExpressionTree parent1,
+          bool homologous, int maximumCrossoverMethods)
+        {
+            // select a random crossover point in the first parent
+            List<CutPoint> crossoverPoints0;
+            SelectCrossoverPoint(random, parent0, maximumCrossoverMethods, out crossoverPoints0);
+            foreach (CutPoint c in crossoverPoints0)
+            {
+                List<ISymbolicExpressionTreeNode> allowedBranches = new List<ISymbolicExpressionTreeNode>();
+                parent1.Root.ForEachNodePostfix((n) =>
+                {
+                    if (n.Symbol.GetType() == c.Child.Symbol.GetType())
+                        allowedBranches.Add(n);
+                });
+                if (allowedBranches.Count == 0)
+                {
+                    break;
+                }
+                else
+                {
+                    ISymbolicExpressionTreeNode branch = allowedBranches.FirstOrDefault();
+                    int startBranchParent0 = (c.Child.SubtreeCount <= 2)? 0 : random.Next(0, c.Child.SubtreeCount - 2);
+                    int endBranchParent0 = (c.Child.SubtreeCount <= 2) ? 1 : random.Next(startBranchParent0 + 1, c.Child.SubtreeCount - 1);
+                    int Parent0Branches = endBranchParent0 - startBranchParent0;
+                    for (int i = 0; i < Parent0Branches; i++)
+                    {
+                        c.Child.RemoveSubtree(startBranchParent0);
+                    }
+                    if (homologous)
+                    {
+                        for (int j = startBranchParent0; j <= endBranchParent0; j++)
+                        {
+                            c.Child.AddSubtree(branch.GetSubtree(j));
+                        }
+                    }
+                    else
+                    {
+                        int startBranchParent1 = (branch.SubtreeCount <= 2) ? 0 : random.Next(0, branch.SubtreeCount - 2);
+                        int endBranchParent1 = (branch.SubtreeCount <= 2) ? 1 : random.Next(startBranchParent1 + 1, branch.SubtreeCount - 1);
+                        int Parent1Branches = endBranchParent1 - startBranchParent1;
+                        for (int j = startBranchParent1; j <= endBranchParent1 && c.Child.SubtreeCount < c.Child.Symbol.MaximumArity; j++)
+                        {
+                            c.Child.AddSubtree(branch.GetSubtree(j));
+                        }
+                    }
+                }
+            }
+            return parent0;
+        }
+        private static void SelectCrossoverPoint(IRandom random, ISymbolicExpressionTree parent0,
+            int maximumCrossoverMethods, out List<CutPoint> crossoverPoints)
+        {
+            List<CutPoint> MethodPoints = new List<CutPoint>();
+            parent0.Root.ForEachNodePostfix((n) =>
+            {
+                if (n.SubtreeCount > 0 && n != parent0.Root)
+                {
+                    foreach (var child in n.Subtrees)
+                    {
+                        if (child.Symbol is Run ||
+                            child.Symbol is OnBulletHit ||
+                            child.Symbol is OnBulletMissed ||
+                            child.Symbol is OnHitByBullet ||
+                            child.Symbol is OnHitRobot ||
+                            child.Symbol is OnHitWall ||
+                            child.Symbol is OnScannedRobot)
+                            MethodPoints.Add(new CutPoint(n, child));
+                    }
+                }
+            });
+            if (maximumCrossoverMethods == 0)
+                crossoverPoints = MethodPoints;
+            // select leaf node if possible
+            allowedLeafBranches = (from branch in branches
+                                   where branch == null || branch.SubtreeCount == 0
+                                   select branch).ToList();
+            if (allowedLeafBranches.Count > 0)
+            {
+                return allowedLeafBranches.SelectRandom(random);
+            }
             else
+            {
-                crossoverPoints = new List<CutPoint>();
-                for (int i = 0; i < maximumCrossoverMethods; i++)
+                {
-                    CutPoint c = MethodPoints.SelectRandom(random);
-                    crossoverPoints.Add(c);
-                    MethodPoints.Remove(c);
-                    if (MethodPoints.Count == 0) break;
+                }
+            }
+        }
-        /*private static ISymbolicExpressionTreeNode SelectRandomBranch(IRandom random, IEnumerable<ISymbolicExpressionTreeNode> branches, double internalNodeProbability)
+        {
-            if (internalNodeProbability < 0.0 || internalNodeProbability > 1.0) throw new ArgumentException("internalNodeProbability");
-            List<ISymbolicExpressionTreeNode> allowedInternalBranches;
-            List<ISymbolicExpressionTreeNode> allowedLeafBranches;
-            if (random.NextDouble() < internalNodeProbability)
+            {
-                // select internal node if possible
                 allowedInternalBranches = (from branch in branches
                                            where branch != null && branch.SubtreeCount > 0
                                            select branch).ToList();
+                if (allowedInternalBranches.Count > 0)
+                {
+                    return allowedInternalBranches.SelectRandom(random);
+                }
+                else
+                {
+                    // no internal nodes allowed => select leaf nodes
+                    allowedLeafBranches = (from branch in branches
+                                           where branch == null || branch.SubtreeCount == 0
+                                           select branch).ToList();
+                    return allowedLeafBranches.SelectRandom(random);
+                }
+            }
+            else
+            {
+                // select leaf node if possible
+                allowedLeafBranches = (from branch in branches
+                                       where branch == null || branch.SubtreeCount == 0
+                                       select branch).ToList();
+                if (allowedLeafBranches.Count > 0)
+                {
+                    return allowedLeafBranches.SelectRandom(random);
+                }
+                else
+                {
+                    allowedInternalBranches = (from branch in branches
+                                               where branch != null && branch.SubtreeCount > 0
+                                               select branch).ToList();
+                    return allowedInternalBranches.SelectRandom(random);
+                }
+            }
+        }*/
+    }
+                return allowedInternalBranches.SelectRandom(random);
+            }
+        }
+    }*/
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Evaluator.cs

-                      r9781
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Threading;
+using System.Xml;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 …
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
-using System;
-using System.IO;
-using System.Threading;
-using System.Xml;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    [Item("Robocode Evaluator", "Evaluator for the Robocode GP problem.")]
+    public class Evaluator : SingleSuccessorOperator,
+      ISingleObjectiveEvaluator
+    {
+        #region parameter names
+        private const string QualityParameterName = "Quality";
+        private const string TankProgramParameterName = "TankProgram";
+        private const string RobocodePathParamaterName = "Path";
+        private const string CoevolutionParameterName = "Coevolution";
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  [Item("Robocode Evaluator", "Evaluator for the Robocode GP problem.")]
+  public class Evaluator : SingleSuccessorOperator,
+    ISingleObjectiveEvaluator {
+    #region parameter names
+    private const string QualityParameterName = "Quality";
+    private const string TankProgramParameterName = "TankProgram";
+    private const string RobocodePathParamaterName = "Path";
+    private const string CoevolutionParameterName = "Coevolution";
+        private static string solutionTemplatePath = "";
+        public static string SolutionTemplate
+        {
+            get { return solutionTemplatePath; }
+            set
+            {
+                solutionTemplatePath = value;
+            }
+    private static string solutionTemplatePath = "";
+    public static string SolutionTemplate {
+      get { return solutionTemplatePath; }
+      set {
+        solutionTemplatePath = value;
+      }
+    }
+    public static SemaphoreSlim semaphore = new SemaphoreSlim(10);
+    #endregion
+    #region parameters
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get {
+        return (ILookupParameter<DoubleValue>)
+                 Parameters[QualityParameterName];
+      }
+    }
+    public ILookupParameter<ISymbolicExpressionTree> TankProgramParameter {
+      get {
+        return (ILookupParameter<ISymbolicExpressionTree>)
+                 Parameters[TankProgramParameterName];
+      }
+    }
+    public ILookupParameter<StringValue> RobocodePathParameter {
+      get {
+        return (ILookupParameter<StringValue>)
+            Parameters[RobocodePathParamaterName];
+      }
+    }
+    public ILookupParameter<BoolValue> CoevolutionParameter {
+      get {
+        return (ILookupParameter<BoolValue>)
+            Parameters[CoevolutionParameterName];
+      }
+    }
+    #endregion
+    [StorableConstructor]
+    protected Evaluator(bool deserializing) : base(deserializing) { }
+    protected Evaluator(Evaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    // default constructor for the evaluator
+    public Evaluator() {
+      Parameters.Add(
+        new LookupParameter<DoubleValue>(
+          QualityParameterName,
+          "The solution quality of the Robocode tank program."));
+      Parameters.Add(
+        new LookupParameter<ISymbolicExpressionTree>(
+          TankProgramParameterName,
+          "The Robocode tank program to evaluate represented as a " +
+          "symbolic expression tree."));
+      Parameters.Add(
+        new LookupParameter<StringValue>(
+          RobocodePathParamaterName,
+          "Path of the Robocode installation."));
+      Parameters.Add(
+          new LookupParameter<BoolValue>(
+              CoevolutionParameterName,
+              "Use Coevolution"));
+      SolutionTemplate = "../tank.xml";
+    }
+    // override the apply method to change the behaviour of the operator
+    // here we take trees as inputs and calculate qualities
+    // (fitness evaluation)
+    public override IOperation Apply() {
+      semaphore.Wait();
+      ISymbolicExpressionTree tree = TankProgramParameter.ActualValue;
+      //XmlDocument doc = new XmlDocument();
+      //doc.Load("../tank.xml");
+      XmlNode node = null;
+      string path = RobocodePathParameter.ActualValue.Value;
+      if (CoevolutionParameter.ActualValue.Value) {
+        var trees = ExecutionContext.Parent.Scope.SubScopes;//SymbolicExpressionTreeParameter.ActualValue;
+        if (trees.Count == 2) {
+          trees = trees[0].SubScopes;
+          //treeCount = trees[0].SubScopes.Count;
+          //int selTreeCount = trees[1].SubScopes.Count;
+        }
+        public static SemaphoreSlim semaphore = new SemaphoreSlim(10);
+        #endregion
+        #region parameters
+        public ILookupParameter<DoubleValue> QualityParameter
+        {
+            get
+            {
+                return (ILookupParameter<DoubleValue>)
+                         Parameters[QualityParameterName];
+            }
+        }
+        public ILookupParameter<ISymbolicExpressionTree> TankProgramParameter
+        {
+            get
+            {
+                return (ILookupParameter<ISymbolicExpressionTree>)
+                         Parameters[TankProgramParameterName];
+            }
+        }
+        public ILookupParameter<StringValue> RobocodePathParameter
+        {
+            get
+            {
+                return (ILookupParameter<StringValue>)
+                    Parameters[RobocodePathParamaterName];
+            }
+        }
+        public ILookupParameter<BoolValue> CoevolutionParameter
+        {
+            get
+            {
+                return (ILookupParameter<BoolValue>)
+                    Parameters[CoevolutionParameterName];
+            }
+        }
+        #endregion
+        [StorableConstructor]
+        protected Evaluator(bool deserializing) : base(deserializing) { }
+        protected Evaluator(Evaluator original, Cloner cloner)
+            : base(original, cloner)
+        {
+        Random random = new Random();
+        ScopeList chosenScopes = new ScopeList(5);
+        for (int i = 0; i < 5; i++) {
+          var newScope = trees.ToArray()[random.Next(0, trees.Count - 1)];
+          chosenScopes.Add(newScope);
+        }
+        // default constructor for the evaluator
+        public Evaluator()
+        {
+            Parameters.Add(
+              new LookupParameter<DoubleValue>(
+                QualityParameterName,
+                "The solution quality of the Robocode tank program."));
+            Parameters.Add(
+              new LookupParameter<ISymbolicExpressionTree>(
+                TankProgramParameterName,
+                "The Robocode tank program to evaluate represented as a " +
+                "symbolic expression tree."));
+            Parameters.Add(
+              new LookupParameter<StringValue>(
+                RobocodePathParamaterName,
+                "Path of the Robocode installation."));
+            Parameters.Add(
+                new LookupParameter<BoolValue>(
+                    CoevolutionParameterName,
+                    "Use Coevolution"));
+        //if (evaluations % 99 == 0)
+        //    evaluations = evaluations;
+            SolutionTemplate = "../tank.xml";
+        }
+        QualityParameter.ActualValue = new DoubleValue(Interpreter.EvaluateTankProgram(tree, chosenScopes, node, path));
+      } else
+        QualityParameter.ActualValue = new DoubleValue(Interpreter.EvaluateTankProgram(tree, node, path));
+        // override the apply method to change the behaviour of the operator
+        // here we take trees as inputs and calculate qualities
+        // (fitness evaluation)
+        public override IOperation Apply()
+        {
+            semaphore.Wait();
+            ISymbolicExpressionTree tree = TankProgramParameter.ActualValue;
+            //XmlDocument doc = new XmlDocument();
+            //doc.Load("../tank.xml");
+            XmlNode node = null;
+            string path = RobocodePathParameter.ActualValue.Value;
+      semaphore.Release();
+            if (CoevolutionParameter.ActualValue.Value)
+            {
+                var trees = ExecutionContext.Parent.Scope.SubScopes;//SymbolicExpressionTreeParameter.ActualValue;
+                if (trees.Count == 2)
+                {
+                    trees = trees[0].SubScopes;
+                    //treeCount = trees[0].SubScopes.Count;
+                    //int selTreeCount = trees[1].SubScopes.Count;
+                }
+      // important: return base.Apply() to make sure that the
+      // next operator is queued for execution
+      return base.Apply();
+    }
+                Random random = new Random();
+                ScopeList chosenScopes = new ScopeList(5);
+                for (int i = 0; i < 5; i++)
+                {
+                    var newScope = trees.ToArray()[random.Next(0, trees.Count - 1)];
+                    chosenScopes.Add(newScope);
+                }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Evaluator(this, cloner);
+    }
+                //if (evaluations % 99 == 0)
+                //    evaluations = evaluations;
+                QualityParameter.ActualValue = new DoubleValue(Interpreter.EvaluateTankProgram(tree, chosenScopes, node, path));
+            }
+            else
+                QualityParameter.ActualValue = new DoubleValue(Interpreter.EvaluateTankProgram(tree, node, path));
+            semaphore.Release();
+            // important: return base.Apply() to make sure that the
+            // next operator is queued for execution
+            return base.Apply();
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new Evaluator(this, cloner);
+        }
+        public bool EnabledByDefault
+        {
+            get { return true; }
+        }
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/External Evaluator/BattleRunner.java

-                      r9567
+                      r9790
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/>.
+ */
 import robocode.control.*;
 import robocode.control.events.*;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Grammar.cs

-                      r9781
+                      r9790
+using System.Collections.Generic;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Core;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs

-                      r9781
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Diagnostics;
 using System.IO;
 …
         q.Append("Error: " + evaluateCode.StandardError.ReadToEnd() + "\r\n");
         cmdOutput += q.ToString();
+      }catch {
+      }
+      catch {
         return -1000.0;
+      }

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Plugin.cs.frame

r9787	r9790
29	29	namespace HeuristicLab.Problems.Robocode
30	30	{
31		[Plugin("HeuristicLab.Problems.Robocode", "The Robocode problem for genetic programming.", "3.3.7.$WCREV$")]
	31	[Plugin("HeuristicLab.Problems.Robocode", "The Robocode problem for genetic programming.", "3.3.8.$WCREV$")]
32	32	[PluginFile("HeuristicLab.Problems.Robocode-3.3.dll", PluginFileType.Assembly)]
33	33	[PluginDependency("HeuristicLab.Data", "3.3")]

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Problem.cs

-                      r9781
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Linq;
 using HeuristicLab.Common;
 …
 using HeuristicLab.PluginInfrastructure;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    [Creatable("Problems")]
+    [Item("Robocode Problem",
+          "The Robocode problem for genetic programming.")]
+    public class Problem : SingleObjectiveHeuristicOptimizationProblem<Evaluator,
+      ISymbolicExpressionTreeCreator>
+    {
+        #region parameter names
+        private const string TankProgramParameterName = "TankProgram";
+        private const string MaxTankProgramLengthParameterName =
+          "MaxProgramLength";
+        private const string MaxTankProgramDepthParameterName =
+          "MaxProgramDepth";
+        private const string TankGrammarParameterName = "Grammar";
+        private const string RobocodePathParamaterName = "Path";
+        private const string CoevolutionParameterName = "Coevolution";
+        #endregion
+        #region parameters
+        public IFixedValueParameter<IntValue> MaxTankProgramLengthParameter
+        {
+            get
+            {
+                return (IFixedValueParameter<IntValue>)
+                  Parameters[MaxTankProgramLengthParameterName];
+            }
+        }
+        public IFixedValueParameter<IntValue> MaxTankProgramDepthParameter
+        {
+            get
+            {
+                return (IFixedValueParameter<IntValue>)
+                  Parameters[MaxTankProgramDepthParameterName];
+            }
+        }
+        public IValueParameter<Grammar> GrammarParameter
+        {
+            get
+            {
+                return (IValueParameter<Grammar>)
+                  Parameters[TankGrammarParameterName];
+            }
+        }
+        public IFixedValueParameter<StringValue> RobocodePathParameter
+        {
+            get
+            {
+                return (IFixedValueParameter<StringValue>)
+                    Parameters[RobocodePathParamaterName];
+            }
+        }
+        public IFixedValueParameter<BoolValue> CoevolutionParameter
+        {
+            get
+            {
+                return (IFixedValueParameter<BoolValue>)
+                    Parameters[CoevolutionParameterName];
+            }
+        }
+        #endregion
+        [StorableConstructor]
+        protected Problem(bool deserializing)
+            : base(deserializing)
+        {
+        }
+        protected Problem(Problem original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+        // default constructor for the problem
+        // also creates the fitness evaluation operator (Evaluator),
+        // and the tree creation operator (RampedHalfAndHalfTreeCreator)
+        public Problem()
+            : base(new Evaluator(), new RampedHalfAndHalfTreeCreator())
+        {
+           Parameters.Add(
+              new FixedValueParameter<IntValue>(
+                MaxTankProgramDepthParameterName,
+                "Maximal depth of the Robocode tank program.",
+                new IntValue(6)));
+            Parameters.Add(
+              new FixedValueParameter<IntValue>(
+                MaxTankProgramLengthParameterName,
+                "Maximal length of the tank program.",
+                new IntValue(1000)));
+            Parameters.Add(
+              new ValueParameter<Grammar>(
+                TankGrammarParameterName,
+                "Grammar for the tank program.",
+                new Grammar()));
+            Parameters.Add(new FixedValueParameter<StringValue>(
+                RobocodePathParamaterName,
+                "Path of the Robocode installation.",
+                new StringValue("F:/robocode2")));
+            Parameters.Add(new FixedValueParameter<BoolValue>(
+                CoevolutionParameterName,
+                "Use Coevolution", new BoolValue(false)));
+            Maximization.Value = true;
+            InitializeOperators();
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new Problem(this, cloner);
+        }
+        private void InitializeOperators()
+        {
+            Operators.AddRange(
+              ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
+            Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
+            Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
+            Operators.Add(new BestSolutionAnalyzer());
+            ParameterizeOperators();
+            ParameterizeAnalyzers();
+        }
+        protected override void OnEvaluatorChanged()
+        {
+            base.OnEvaluatorChanged();
+            Evaluator.TankProgramParameter.ActualName =
+              TankProgramParameterName;
+            ParameterizeAnalyzers();
+            ParameterizeOperators();
+        }
+        protected override void OnSolutionCreatorChanged()
+        {
+            base.OnSolutionCreatorChanged();
+            SolutionCreator.SymbolicExpressionTreeParameter.ActualName =
+              TankProgramParameterName;
+            ParameterizeAnalyzers();
+            ParameterizeOperators();
+        }
+        private void ParameterizeAnalyzers()
+        {
+            var analyzers = Operators.OfType<IAnalyzer>();
+            foreach (var o in analyzers.OfType<ISymbolicExpressionTreeAnalyzer>())
+            {
+                o.SymbolicExpressionTreeParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+            }
+            foreach (var o in analyzers.OfType<BestSolutionAnalyzer>())
+            {
+                o.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+            }
+        }
+        private void ParameterizeOperators()
+        {
+            var operators = Parameters
+              .OfType<IValueParameter>()
+              .Select(p => p.Value)
+              .OfType<IOperator>()
+              .Union(Operators);
+            foreach (var o in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>())
+            {
+                o.SymbolicExpressionTreeGrammarParameter.ActualName =
+                  TankGrammarParameterName;
+            }
+            foreach (var o in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>())
+            {
+                o.MaximumSymbolicExpressionTreeDepthParameter.ActualName =
+                  MaxTankProgramDepthParameterName;
+                o.MaximumSymbolicExpressionTreeLengthParameter.ActualName =
+                  MaxTankProgramLengthParameterName;
+            }
+            foreach (var op in operators.OfType<Evaluator>())
+            {
+                op.TankProgramParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+            }
+            foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>())
+            {
+                op.ParentsParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+                op.ChildParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+            }
+            foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>())
+            {
+                op.SymbolicExpressionTreeParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+            }
+            foreach (var op in operators.OfType<ISymbolicExpressionTreeCreator>())
+            {
+                op.SymbolicExpressionTreeParameter.ActualName =
+                  SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+            }
+        }
+    }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  [Creatable("Problems")]
+  [Item("Robocode Problem",
+        "The Robocode problem for genetic programming.")]
+  public class Problem : SingleObjectiveHeuristicOptimizationProblem<Evaluator,
+    ISymbolicExpressionTreeCreator> {
+    #region parameter names
+    private const string TankProgramParameterName = "TankProgram";
+    private const string MaxTankProgramLengthParameterName =
+      "MaxProgramLength";
+    private const string MaxTankProgramDepthParameterName =
+      "MaxProgramDepth";
+    private const string TankGrammarParameterName = "Grammar";
+    private const string RobocodePathParamaterName = "Path";
+    private const string CoevolutionParameterName = "Coevolution";
+    #endregion
+    #region parameters
+    public IFixedValueParameter<IntValue> MaxTankProgramLengthParameter {
+      get {
+        return (IFixedValueParameter<IntValue>)
+          Parameters[MaxTankProgramLengthParameterName];
+      }
+    }
+    public IFixedValueParameter<IntValue> MaxTankProgramDepthParameter {
+      get {
+        return (IFixedValueParameter<IntValue>)
+          Parameters[MaxTankProgramDepthParameterName];
+      }
+    }
+    public IValueParameter<Grammar> GrammarParameter {
+      get {
+        return (IValueParameter<Grammar>)
+          Parameters[TankGrammarParameterName];
+      }
+    }
+    public IFixedValueParameter<StringValue> RobocodePathParameter {
+      get {
+        return (IFixedValueParameter<StringValue>)
+            Parameters[RobocodePathParamaterName];
+      }
+    }
+    public IFixedValueParameter<BoolValue> CoevolutionParameter {
+      get {
+        return (IFixedValueParameter<BoolValue>)
+            Parameters[CoevolutionParameterName];
+      }
+    }
+    #endregion
+    [StorableConstructor]
+    protected Problem(bool deserializing)
+      : base(deserializing) {
+    }
+    protected Problem(Problem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    // default constructor for the problem
+    // also creates the fitness evaluation operator (Evaluator),
+    // and the tree creation operator (RampedHalfAndHalfTreeCreator)
+    public Problem()
+      : base(new Evaluator(), new RampedHalfAndHalfTreeCreator()) {
+      Parameters.Add(
+         new FixedValueParameter<IntValue>(
+           MaxTankProgramDepthParameterName,
+           "Maximal depth of the Robocode tank program.",
+           new IntValue(6)));
+      Parameters.Add(
+        new FixedValueParameter<IntValue>(
+          MaxTankProgramLengthParameterName,
+          "Maximal length of the tank program.",
+          new IntValue(1000)));
+      Parameters.Add(
+        new ValueParameter<Grammar>(
+          TankGrammarParameterName,
+          "Grammar for the tank program.",
+          new Grammar()));
+      Parameters.Add(new FixedValueParameter<StringValue>(
+          RobocodePathParamaterName,
+          "Path of the Robocode installation.",
+          new StringValue("F:/robocode2")));
+      Parameters.Add(new FixedValueParameter<BoolValue>(
+          CoevolutionParameterName,
+          "Use Coevolution", new BoolValue(false)));
+      Maximization.Value = true;
+      InitializeOperators();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+    private void InitializeOperators() {
+      Operators.AddRange(
+        ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
+      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
+      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
+      Operators.Add(new BestSolutionAnalyzer());
+      ParameterizeOperators();
+      ParameterizeAnalyzers();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      Evaluator.TankProgramParameter.ActualName =
+        TankProgramParameterName;
+      ParameterizeAnalyzers();
+      ParameterizeOperators();
+    }
+    protected override void OnSolutionCreatorChanged() {
+      base.OnSolutionCreatorChanged();
+      SolutionCreator.SymbolicExpressionTreeParameter.ActualName =
+        TankProgramParameterName;
+      ParameterizeAnalyzers();
+      ParameterizeOperators();
+    }
+    private void ParameterizeAnalyzers() {
+      var analyzers = Operators.OfType<IAnalyzer>();
+      foreach (var o in analyzers.OfType<ISymbolicExpressionTreeAnalyzer>()) {
+        o.SymbolicExpressionTreeParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var o in analyzers.OfType<BestSolutionAnalyzer>()) {
+        o.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
+    }
+    private void ParameterizeOperators() {
+      var operators = Parameters
+        .OfType<IValueParameter>()
+        .Select(p => p.Value)
+        .OfType<IOperator>()
+        .Union(Operators);
+      foreach (var o in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>()) {
+        o.SymbolicExpressionTreeGrammarParameter.ActualName =
+          TankGrammarParameterName;
+      }
+      foreach (var o in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
+        o.MaximumSymbolicExpressionTreeDepthParameter.ActualName =
+          MaxTankProgramDepthParameterName;
+        o.MaximumSymbolicExpressionTreeLengthParameter.ActualName =
+          MaxTankProgramLengthParameterName;
+      }
+      foreach (var op in operators.OfType<Evaluator>()) {
+        op.TankProgramParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
+        op.ParentsParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        op.ChildParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
+        op.SymbolicExpressionTreeParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<ISymbolicExpressionTreeCreator>()) {
+        op.SymbolicExpressionTreeParameter.ActualName =
+          SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Solution.cs

-                      r9781
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Encodings.SymbolicExpressionTreeEncoding;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/Constant.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class Constant : Symbol
+    {
+        public override int MinimumArity { get { return 0; } }
+        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Constant : Symbol {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
+        [StorableConstructor]
+        private Constant(bool deserializing) : base(deserializing) { }
+        private Constant(Constant original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private Constant(bool deserializing) : base(deserializing) { }
+    private Constant(Constant original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public Constant()
+            : base("Constant", "A random fixed integer.")
+        {
+        }
+    public Constant()
+      : base("Constant", "A random fixed integer.") {
+    }
+        public override ISymbolicExpressionTreeNode CreateTreeNode()
+        {
+            return new ConstantTreeNode();
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new Constant(this, cloner);
+        }
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
+      return new ConstantTreeNode();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Constant(this, cloner);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/ConstantTreeNode.cs

-                      r9565
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    public class ConstantTreeNode : SymbolicExpressionTreeTerminalNode
+    {
+        private int value;
+        [Storable]
+        public int Value
+        {
+            get { return value; }
+            private set { this.value = value; }
+        }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class ConstantTreeNode : SymbolicExpressionTreeTerminalNode {
+    private int value;
+    [Storable]
+    public int Value {
+      get { return value; }
+      private set { this.value = value; }
+    }
+        [StorableConstructor]
+        private ConstantTreeNode(bool deserializing) : base(deserializing) { }
+        private ConstantTreeNode(ConstantTreeNode original, Cloner cloner)
+            : base(original, cloner)
+        {
+            this.value = original.value;
+        }
+    [StorableConstructor]
+    private ConstantTreeNode(bool deserializing) : base(deserializing) { }
+    private ConstantTreeNode(ConstantTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      this.value = original.value;
+    }
+        public ConstantTreeNode()
+            : base(new Constant())
+        {
+        }
+    public ConstantTreeNode()
+      : base(new Constant()) {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ConstantTreeNode(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConstantTreeNode(this, cloner);
+    }
+        public override bool HasLocalParameters
+        {
+            get { return true; }
+        }
+    public override bool HasLocalParameters {
+      get { return true; }
+    }
+        public override void ResetLocalParameters(IRandom random)
+        {
+            value = random.Next(-360, 360);
+        }
+    public override void ResetLocalParameters(IRandom random) {
+      value = random.Next(-360, 360);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/Independent.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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
-namespace HeuristicLab.Problems.Robocode
+{
-    /*[StorableClass]
-    public class Independent : Symbol
+    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+        [StorableConstructor]
         private Independent(bool deserializing) : base(deserializing) { }
         private Independent(Independent original, Cloner cloner)
             : base(original, cloner)
+        {
+        }
+namespace HeuristicLab.Problems.Robocode {
+  /*[StorableClass]
+  public class Independent : Symbol
+  {
+      public override int MinimumArity { get { return 0; } }
+      public override int MaximumArity { get { return 0; } }
+        public Independent()
+            : base("Independent", "A random fixed integer.")
+        {
+        }
+      [StorableConstructor]
+      private Independent(bool deserializing) : base(deserializing) { }
+      private Independent(Independent original, Cloner cloner)
+          : base(original, cloner)
+      {
+      }
+        public override ISymbolicExpressionTreeNode CreateTreeNode()
+        {
+            return new BooleanTreeNode();
+        }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new Independent(this, cloner);
+        }
+    }*/
+      public Independent()
+          : base("Independent", "A random fixed integer.")
+      {
+      }
+      public override ISymbolicExpressionTreeNode CreateTreeNode()
+      {
+          return new BooleanTreeNode();
+      }
+      public override IDeepCloneable Clone(Cloner cloner)
+      {
+          return new Independent(this, cloner);
+      }
+  }*/
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/SetAdjustGunForRobotTurn.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class SetAdjustGunForRobotTurn : Symbol
+    {
+        public override int MinimumArity { get { return 1; } }
+        public override int MaximumArity { get { return 1; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class SetAdjustGunForRobotTurn : Symbol {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 1; } }
+        [StorableConstructor]
+        private SetAdjustGunForRobotTurn(bool deserializing) : base(deserializing) { }
+        private SetAdjustGunForRobotTurn(SetAdjustGunForRobotTurn original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private SetAdjustGunForRobotTurn(bool deserializing) : base(deserializing) { }
+    private SetAdjustGunForRobotTurn(SetAdjustGunForRobotTurn original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public SetAdjustGunForRobotTurn()
+            : base("SetAdjustGunForRobotTurn", "Sets the gun to turn independent from the robot's turn.")
+        {
+        }
+    public SetAdjustGunForRobotTurn()
+      : base("SetAdjustGunForRobotTurn", "Sets the gun to turn independent from the robot's turn.") {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SetAdjustGunForRobotTurn(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SetAdjustGunForRobotTurn(this, cloner);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/SetAdjustRadarForGunTurn.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class SetAdjustRadarForGunTurn : Symbol
+    {
+        public override int MinimumArity { get { return 1; } }
+        public override int MaximumArity { get { return 1; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class SetAdjustRadarForGunTurn : Symbol {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 1; } }
+        [StorableConstructor]
+        private SetAdjustRadarForGunTurn(bool deserializing) : base(deserializing) { }
+        private SetAdjustRadarForGunTurn(SetAdjustRadarForGunTurn original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private SetAdjustRadarForGunTurn(bool deserializing) : base(deserializing) { }
+    private SetAdjustRadarForGunTurn(SetAdjustRadarForGunTurn original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public SetAdjustRadarForGunTurn()
+            : base("SetAdjustRadarForGunTurn", "Sets the radar to turn independent from the gun's turn.")
+        {
+        }
+    public SetAdjustRadarForGunTurn()
+      : base("SetAdjustRadarForGunTurn", "Sets the radar to turn independent from the gun's turn.") {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SetAdjustRadarForGunTurn(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SetAdjustRadarForGunTurn(this, cloner);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Abandoned/SetAdjustRadarForRobotTurn.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class SetAdjustRadarForRobotTurn : Symbol
+    {
+        public override int MinimumArity { get { return 1; } }
+        public override int MaximumArity { get { return 1; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class SetAdjustRadarForRobotTurn : Symbol {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 1; } }
+        [StorableConstructor]
+        private SetAdjustRadarForRobotTurn(bool deserializing) : base(deserializing) { }
+        private SetAdjustRadarForRobotTurn(SetAdjustRadarForRobotTurn original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private SetAdjustRadarForRobotTurn(bool deserializing) : base(deserializing) { }
+    private SetAdjustRadarForRobotTurn(SetAdjustRadarForRobotTurn original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public SetAdjustRadarForRobotTurn()
+            : base("SetAdjustRadarForRobotTurn", "Sets the radar to turn independent from the robot's turn.")
+        {
+        }
+    public SetAdjustRadarForRobotTurn()
+      : base("SetAdjustRadarForRobotTurn", "Sets the radar to turn independent from the robot's turn.") {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SetAdjustRadarForRobotTurn(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SetAdjustRadarForRobotTurn(this, cloner);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Block.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Branches/ElseStatement.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Branches/IfStatement.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Branches/WhileLoop.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/CodeNode.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/EmptyEvent.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnBulletHit.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnBulletMissed.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnHitByBullet.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnHitRobot.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnHitWall.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Events/OnScannedRobot.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Event Methods/Run.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/BooleanTreeNode.cs

-                      r9565
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    public class BooleanTreeNode : SymbolicExpressionTreeTerminalNode
+    {
+        private bool value;
+        [Storable]
+        public bool Value
+        {
+            get { return value; }
+            private set { this.value = value; }
+        }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class BooleanTreeNode : SymbolicExpressionTreeTerminalNode {
+    private bool value;
+    [Storable]
+    public bool Value {
+      get { return value; }
+      private set { this.value = value; }
+    }
+        [StorableConstructor]
+        private BooleanTreeNode(bool deserializing) : base(deserializing) { }
+        private BooleanTreeNode(BooleanTreeNode original, Cloner cloner)
+            : base(original, cloner)
+        {
+            this.value = original.value;
+        }
+    [StorableConstructor]
+    private BooleanTreeNode(bool deserializing) : base(deserializing) { }
+    private BooleanTreeNode(BooleanTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      this.value = original.value;
+    }
+        public BooleanTreeNode()
+            : base(new LogicalValue())
+        {
+        }
+    public BooleanTreeNode()
+      : base(new LogicalValue()) {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new BooleanTreeNode(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BooleanTreeNode(this, cloner);
+    }
+        public override bool HasLocalParameters
+        {
+            get { return true; }
+        }
+    public override bool HasLocalParameters {
+      get { return true; }
+    }
+        public override void ResetLocalParameters(IRandom random)
+        {
+            value = (bool)(random.Next(0, 1) == 1);
+        }
+    public override void ResetLocalParameters(IRandom random) {
+      value = (bool)(random.Next(0, 1) == 1);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/Conjunction.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/Disjunction.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/Equal.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/GreaterThan.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/GreaterThanOrEqual.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/LessThan.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Logical Comparators/LessThanOrEqual.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalComparison.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalExpression.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/LogicalValue.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/Negation.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Logical Expressions/NumericalComparison.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Number.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumberTreeNode.cs

-                      r9565
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    public class NumberTreeNode : SymbolicExpressionTreeTerminalNode
+    {
+        private int value;
+        [Storable]
+        public int Value
+        {
+            get { return value; }
+            private set { this.value = value; }
+        }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class NumberTreeNode : SymbolicExpressionTreeTerminalNode {
+    private int value;
+    [Storable]
+    public int Value {
+      get { return value; }
+      private set { this.value = value; }
+    }
+        [StorableConstructor]
+        private NumberTreeNode(bool deserializing) : base(deserializing) { }
+        private NumberTreeNode(NumberTreeNode original, Cloner cloner)
+            : base(original, cloner)
+        {
+            this.value = original.value;
+        }
+    [StorableConstructor]
+    private NumberTreeNode(bool deserializing) : base(deserializing) { }
+    private NumberTreeNode(NumberTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      this.value = original.value;
+    }
+        public NumberTreeNode()
+            : base(new Number())
+        {
+        }
+    public NumberTreeNode()
+      : base(new Number()) {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new NumberTreeNode(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NumberTreeNode(this, cloner);
+    }
+        public override bool HasLocalParameters
+        {
+            get { return true; }
+        }
+    public override bool HasLocalParameters {
+      get { return true; }
+    }
+        public override void ResetLocalParameters(IRandom random)
+        {
+            value = random.Next(-360, 360);
+        }
+    public override void ResetLocalParameters(IRandom random) {
+      value = random.Next(-360, 360);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Numerical Operators/Addition.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Numerical Operators/Division.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Numerical Operators/Modulus.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Numerical Operators/Multiplication.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/Numerical Operators/Subtraction.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumericalExpression.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/NumericalOperation.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPower.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class ShotPower : CodeNode
+    {
+        public override int MinimumArity { get { return 0; } }
+        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class ShotPower : 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 Prefix { get; set; }
         [Storable]
         public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
+        [StorableConstructor]
+        private ShotPower(bool deserializing) : base(deserializing) { }
+        private ShotPower(ShotPower original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private ShotPower(bool deserializing) : base(deserializing) { }
+    private ShotPower(ShotPower original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public ShotPower()
+            : base("ShotPower", "The power of a shot between 0.1 and 3.")
+        {
+        }
+    public ShotPower()
+      : base("ShotPower", "The power of a shot between 0.1 and 3.") {
+    }
+        public override ISymbolicExpressionTreeNode CreateTreeNode()
+        {
+            return new ShotPowerTreeNode();
+        }
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
+      return new ShotPowerTreeNode();
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ShotPower(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ShotPower(this, cloner);
+    }
+        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
+        {
+            return " " + ((ShotPowerTreeNode)node).Value + " ";
+        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return " " + ((ShotPowerTreeNode)node).Value + " ";
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Expressions/ShotPowerTreeNode.cs

-                      r9565
+                      r9790
+using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Problems.Robocode
+{
+    [StorableClass]
+    public class ShotPowerTreeNode : SymbolicExpressionTreeTerminalNode
+    {
+        private double value;
+        [Storable]
+        public double Value
+        {
+            get { return value; }
+            private set { this.value = value; }
+        }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class ShotPowerTreeNode : SymbolicExpressionTreeTerminalNode {
+    private double value;
+    [Storable]
+    public double Value {
+      get { return value; }
+      private set { this.value = value; }
+    }
+        [StorableConstructor]
+        private ShotPowerTreeNode(bool deserializing) : base(deserializing) { }
+        private ShotPowerTreeNode(ShotPowerTreeNode original, Cloner cloner)
+            : base(original, cloner)
+        {
+            this.value = original.value;
+        }
+    [StorableConstructor]
+    private ShotPowerTreeNode(bool deserializing) : base(deserializing) { }
+    private ShotPowerTreeNode(ShotPowerTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      this.value = original.value;
+    }
+        public ShotPowerTreeNode()
+            : base(new ShotPower())
+        {
+        }
+    public ShotPowerTreeNode()
+      : base(new ShotPower()) {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ShotPowerTreeNode(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ShotPowerTreeNode(this, cloner);
+    }
+        public override bool HasLocalParameters
+        {
+            get { return true; }
+        }
+    public override bool HasLocalParameters {
+      get { return true; }
+    }
+        public override void ResetLocalParameters(IRandom random)
+        {
+            value = (double)random.Next(1, 3);
+        }
+    public override void ResetLocalParameters(IRandom random) {
+      value = (double)random.Next(1, 3);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetEnergy.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetGunHeading.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetHeading.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetRadarHeading.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetX.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/GetY.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Numerical Methods/INumericalMethod.cs

-                      r9565
+                      r9790
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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
+namespace HeuristicLab.Problems.Robocode
+{
+    public interface INumericalMethod
+    {
+    }
+namespace HeuristicLab.Problems.Robocode {
+  public interface INumericalMethod {
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Program.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class Program : Symbol
+    {
+        public override int MinimumArity { get { return 2; } }
+        public override int MaximumArity { get { return byte.MaxValue; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Program : Symbol {
+    public override int MinimumArity { get { return 2; } }
+    public override int MaximumArity { get { return byte.MaxValue; } }
+        [StorableConstructor]
+        private Program(bool deserializing) : base(deserializing) { }
+        private Program(Program original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private Program(bool deserializing) : base(deserializing) { }
+    private Program(Program original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public Program()
+            : base("Program", "A Robocode tank program.")
+        {
+        }
+    public Program()
+      : base("Program", "A Robocode tank program.") {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new Program(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Program(this, cloner);
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Tank.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/Ahead.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/Back.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/DoNothing.cs

-                      r9565
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Robocode
+{
+    [StorableClass]
+    public class DoNothing : CodeNode
+    {
+        public override int MinimumArity { get { return 0; } }
+        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class DoNothing : 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 Prefix { get; set; }
         [Storable]
         public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
+        [StorableConstructor]
+        private DoNothing(bool deserializing) : base(deserializing) { }
+        private DoNothing(DoNothing original, Cloner cloner)
+            : base(original, cloner)
+        {
+        }
+    [StorableConstructor]
+    private DoNothing(bool deserializing) : base(deserializing) { }
+    private DoNothing(DoNothing original, Cloner cloner)
+      : base(original, cloner) {
+    }
+        public DoNothing()
+            : base("DoNothing", "Do nothing this turn, meaning that the robot will skip it's turn.")
+        {
+        }
+    public DoNothing()
+      : base("DoNothing", "Do nothing this turn, meaning that the robot will skip it's turn.") {
+    }
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new DoNothing(this, cloner);
+        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoNothing(this, cloner);
+    }
+        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
+        {
+            return "";
+        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return "";
+    }
+  }
+}

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/Fire.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnGunLeft.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnGunRight.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnLeft.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnRadarLeft.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnRadarRight.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Symbols/Void Methods/TurnRight.cs

-                      r9630
+                      r9790
+using HeuristicLab.Common;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;

Context Navigation

Legend:

Download in other formats: