Changeset 13017 for branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs

Timestamp:

10/16/15 10:36:09 (9 years ago)

Author:

gkronber

Message:

#2069 refactored grammar, symbols, and interpreter

File:

• branches/Robocode.TrunkInt/HeuristicLab.Problems.Robocode/3.3/Interpreter.cs (modified) (2 diffs)

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

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.Contracts;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Remoting.Messaging;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.GeneticProgramming.Robocode {
   public static class Interpreter {
+    // TODO performance: it would probably be useful to implement the BattleRunner in such a way that we don't have to restart the java process each time, e.g. using console IO to load & run robots 
     public static double EvaluateTankProgram(ISymbolicExpressionTree tree, string path, EnemyCollection enemies, string robotName = null, bool showUI = false, int nrOfRounds = 3) {
       if (robotName == null)
@@ -148 +152 @@
     public static string InterpretProgramTree(ISymbolicExpressionTreeNode node, string robotName) {
       var tankNode = node;
-      while (!(tankNode.Symbol is Tank))
+      while (tankNode.Symbol.Name != "Tank")
         tankNode = tankNode.GetSubtree(0);
 
-      string result = ((CodeNode)tankNode.Symbol).Interpret(tankNode, tankNode.Subtrees);
+      string result = Interpret(tankNode);
       result = result.Replace("class output", "class " + robotName);
       return result;
     }
+
+    private static string Interpret(ISymbolicExpressionTreeNode node) {
+      switch (node.Symbol.Name) {
+        case "Block": return InterpretBlock(node);
+        case "Statement": return InterpretStat(node);
+        case "DoNothing": return string.Empty;
+        case "EmptyEvent": return string.Empty;
+
+        case "GetEnergy": return "getEnergy()";
+        case "GetHeading": return "getHeading()";
+        case "GetGunHeading": return "getGunHeading()";
+        case "GetRadarHeading": return "getRadarHeading()";
+        case "GetX": return "getX()";
+        case "GetY": return "getY()";
+
+        case "Addition": return InterpretBinaryOperator(" + ", node);
+        case "Subtraction": return InterpretBinaryOperator(" - ", node);
+        case "Multiplication": return InterpretBinaryOperator(" * ", node);
+        case "Division": return InterpretBinaryOperator(" / ", node);
+        case "Modulus": return InterpretBinaryOperator(" % ", node);
+
+        case "Equal": return InterpretComparison(" == ", node);
+        case "LessThan": return InterpretComparison(" < ", node);
+        case "LessThanOrEqual": return InterpretComparison(" <= ", node);
+        case "GreaterThan": return InterpretComparison("  >", node);
+        case "GreaterThanOrEqual": return InterpretComparison(" >= ", node);
+        case "ConditionalAnd": return InterpretBinaryOperator(" && ", node);
+        case "ConditionalOr": return InterpretBinaryOperator(" || ", node);
+        case "Negation": return InterpretFunc1("!", node);
+
+        case "IfThenElseStat": return InterpretIf(node);
+        case "WhileStat": return InterpretWhile(node);
+        case "BooleanExpression": return InterpretChild(node);
+        case "NumericalExpression": return InterpretChild(node);
+        case "Number": return InterpretNumber(node);
+        case "BooleanValue": return InterpretBoolValue(node);
+
+
+        case "Ahead": return InterpretFunc1("setAhead", node);
+        case "Back": return InterpretFunc1("setBack", node);
+        case "Fire": return InterpretFunc1("setFire", node);
+        case "TurnLeft": return InterpretFunc1("setTurnLeft", node);
+        case "TurnRight": return InterpretFunc1("setTurnRight", node);
+        case "TurnGunLeft": return InterpretFunc1("setTurnGunLeft", node);
+        case "TurnGunRight": return InterpretFunc1("setTurnGunRight", node);
+        case "TurnRadarLeft": return InterpretFunc1("setTurnRadarLeft", node);
+        case "TurnRadarRight": return InterpretFunc1("setTurnRadarRight", node);
+        case "ShotPower": return InterpetShotPower(node);
+
+        case "OnBulletHit": return InterpretOnBulletHit(node);
+        case "OnBulletMissed": return InterpretOnBulletMissed(node);
+        case "OnHitByBullet": return InterpretOnHitByBullet(node);
+        case "OnHitRobot": return InterpretOnHitRobot(node);
+        case "OnHitWall": return InterpretOnHitWall(node);
+        case "OnScannedRobot": return InterpretOnScannedRobot(node);
+
+        case "Run": return InterpretRun(node);
+        case "Tank": return InterpretTank(node);
+        case "CodeSymbol": return InterpretCodeSymbol(node);
+
+        default: throw new ArgumentException(string.Format("Found an unknown symbol {0} in a robocode solution", node.Symbol.Name));
+      }
+    }
+
+    private static string InterpretCodeSymbol(ISymbolicExpressionTreeNode node) {
+      var sy = node.Symbol as CodeSymbol;
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"{0}
+{1}
+{2}", sy.Prefix, code, sy.Suffix);
+    }
+
+    private static string InterpretBoolValue(ISymbolicExpressionTreeNode node) {
+      var boolNode = node as BooleanTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0}", boolNode.Value).ToLower();
+    }
+
+    private static string InterpretNumber(ISymbolicExpressionTreeNode node) {
+      var numberNode = node as NumberTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0}", numberNode.Value);
+    }
+
+    private static string InterpetShotPower(ISymbolicExpressionTreeNode node) {
+      var shotPowerNode = node as ShotPowerTreeNode;
+      return string.Format(NumberFormatInfo.InvariantInfo, "{0:E}", shotPowerNode.Value);
+    }
+
+
+    internal static string InterpretBlock(ISymbolicExpressionTreeNode node) {
+      string result = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format("{{ {0} }}", result + Environment.NewLine);
+    }
+
+    internal static string InterpretStat(ISymbolicExpressionTreeNode node) {
+      // must only have one sub-tree
+      Contract.Assert(node.SubtreeCount == 1);
+      return Interpret(node.GetSubtree(0)) + " ;" + Environment.NewLine;
+    }
+
+    internal static string InterpretIf(ISymbolicExpressionTreeNode node) {
+      ISymbolicExpressionTreeNode condition = null, truePart = null, falsePart = null;
+      string[] parts = new string[3];
+
+      if (node.SubtreeCount < 2 || node.SubtreeCount > 3)
+        throw new Exception("Unexpected number of children. Expected 2 or 3 children.");
+
+      condition = node.GetSubtree(0);
+      truePart = node.GetSubtree(1);
+      if (node.SubtreeCount == 3)
+        falsePart = node.GetSubtree(2);
+
+      parts[0] = Interpret(condition);
+      parts[1] = Interpret(truePart);
+      if (falsePart != null) parts[2] = Interpret(falsePart);
+
+      return string.Format("if ({0}) {{ {1} }} else {{ {2} }}", Interpret(condition), Interpret(truePart),
+        falsePart == null ? string.Empty : Interpret(falsePart));
+    }
+
+    internal static string InterpretWhile(ISymbolicExpressionTreeNode node) {
+      var cond = Interpret(node.GetSubtree(0));
+      var body = Interpret(node.GetSubtree(1));
+      return string.Format("while ({0}) {{ {2} {1} {2} }} {2}", cond, body, Environment.NewLine);
+    }
+
+    public static string InterpretBinaryOperator(string opSy, ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount < 2)
+        throw new ArgumentException(string.Format("Expected at least two children in {0}.", node.Symbol), "node");
+
+      string result = string.Join(opSy, node.Subtrees.Select(Interpret));
+      return "(" + result + ")";
+    }
+
+    public static string InterpretChild(ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount != 1)
+        throw new ArgumentException(string.Format("Expected exactly one child in {0}.", node.Symbol), "node");
+
+      return Interpret(node.GetSubtree(0));
+    }
+
+    public static string InterpretComparison(string compSy, ISymbolicExpressionTreeNode node) {
+      ISymbolicExpressionTreeNode lhs = null, rhs = null;
+      if (node.SubtreeCount != 2)
+        throw new ArgumentException(string.Format("Expected exactly two children in {0}.", node.Symbol), "node");
+
+      lhs = node.GetSubtree(0);
+      rhs = node.GetSubtree(1);
+
+      return Interpret(lhs) + " == " + Interpret(rhs);
+    }
+
+    public static string InterpretFunc1(string functionId, ISymbolicExpressionTreeNode node) {
+      if (node.SubtreeCount != 1)
+        throw new ArgumentException(string.Format("Expected 1 child in {0}.", node.Symbol.Name), "node");
+
+      return string.Format("{0}({1})", functionId, Interpret(node.GetSubtree(0)));
+    }
+
+    public static string InterpretOnScannedRobot(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onScannedRobot(ScannedRobotEvent e) {{
+  double absoluteBearing = getHeading() + e.getBearing();
+  double bearingFromGun = normalRelativeAngleDegrees(absoluteBearing - getGunHeading());
+  setTurnGunRight(bearingFromGun);
+{0}
+  execute();
+}}", code);
+    }
+
+
+    public static string InterpretOnHitWall(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitWall(HitWallEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnHitRobot(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitRobot(HitRobotEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnHitByBullet(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onHitByBullet(HitByBulletEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnBulletMissed(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void onBulletMissed(BulletMissedEvent e) {{
+{0}
+execute();
+}}", code);
+    }
+
+    public static string InterpretOnBulletHit(ISymbolicExpressionTreeNode node) {
+      var Prefix = "public void onBulletHit(BulletHitEvent e) {";
+      var Suffix =
+@"execute();
+}";
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return Prefix + code + Environment.NewLine + Suffix;
+    }
+
+    public static string InterpretRun(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"public void run() {{
+  setAdjustGunForRobotTurn(true);
+  turnRadarRightRadians(Double.POSITIVE_INFINITY);
+{0}
+  execute();
+}}", code);
+    }
+
+    public static string InterpretTank(ISymbolicExpressionTreeNode node) {
+      string code = string.Join(Environment.NewLine, node.Subtrees.Select(Interpret));
+      return string.Format(
+@"package Evaluation;
+import robocode.*;
+import robocode.Robot;
+import robocode.util.*;
+import static robocode.util.Utils.normalRelativeAngleDegrees;
+import java.awt.*;
+
+public class output extends AdvancedRobot {{ 
+{0}
+}}", code);
+    }
   }
 }