source: branches/Robocode/HeuristicLab.Problems.Robocode/Grammar.cs @ 10216

using System.Collections.Generic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.Robocode {
  [StorableClass]
  [Item("Robocode Grammar", "The grammar for the Robocode GP problem.")]
  public class Grammar : SymbolicExpressionGrammar {
    [StorableConstructor]
    private Grammar(bool deserializing) : base(deserializing) { }
    private Grammar(Grammar original, Cloner cloner)
      : base(original, cloner) {
    }

    public Grammar()
      : base("Robocode Grammar", "The grammar for the Robocode GP problem.") {
      Initialize();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new Grammar(this, cloner);
    }

    // initialize set of allowed symbols and define 
    // the allowed combinations of symbols
    private void Initialize() {
      #region Symbols
      var block = new Block();

      var ifStmt = new IfStatement();
      var elseStmt = new ElseStatement();
      var whileLoop = new WhileLoop();

      var numExpr = new NumericalExpression();
      var number = new Number();
      var numOp = new NumericalOperation();
      var add = new Addition();
      var sub = new Subtraction();
      var mult = new Multiplication();
      var div = new Division();
      var mod = new Modulus();

      var logicExpr = new LogicalExpression();
      var logicComp = new LogicalComparison();
      var numComp = new NumericalComparison();
      var logicVal = new LogicalValue();
      var not = new Negation();
      var and = new Conjunction();
      var or = new Disjunction();
      var eq = new Equal();
      var lt = new LessThan();
      var gt = new GreaterThan();
      var lteq = new LessThanOrEqual();
      var gteq = new GreaterThanOrEqual();

      var ahead = new Ahead();
      var back = new Back();
      var constant = new Constant();
      var doNothing = new DoNothing();
      var fire = new Fire();
      var shotPower = new ShotPower();

      var getEnergy = new GetEnergy();
      var getGunHeading = new GetGunHeading();
      var getHeading = new GetHeading();
      var getRadarHeading = new GetRadarHeading();
      var getX = new GetX();
      var getY = new GetY();

      //var setAdjustGunForRobotTurn = new SetAdjustGunForRobotTurn();
      //var setAdjustRadarForGunTurn = new SetAdjustRadarForGunTurn();
      //var setAdjustRadarForRobotTurn = new SetAdjustRadarForRobotTurn();
      //var independent = new Independent();

      var turnLeft = new TurnLeft();
      var turnRight = new TurnRight();
      var turnGunLeft = new TurnGunLeft();
      var turnGunRight = new TurnGunRight();
      var turnRadarLeft = new TurnRadarLeft();
      var turnRadarRight = new TurnRadarRight();

      var onBulletHit = new OnBulletHit();
      var onBulletMissed = new OnBulletMissed();
      var onHitByBullet = new OnHitByBullet();
      var onHitRobot = new OnHitRobot();
      var onHitWall = new OnHitWall();
      var onScannedRobot = new OnScannedRobot();
      var emptyEvent = new EmptyEvent();

      var run = new Run();
      var tank = new Tank();
      var program = new Program();
      #endregion

      #region Symbol Collections
      var numericalExpressions = new List<ISymbol>()
            {
                number, numOp, getEnergy, getGunHeading, getHeading, getRadarHeading, getX, getY
            };

      var numericalOperators = new List<ISymbol>()
            {
                add, sub, mult, div, mod
            };

      var logicalExpressions = new List<ISymbol>()
            {
                logicVal, logicComp, numComp, not
            };

      var logicalComparators = new List<ISymbol>()
            {
                and, or
            };

      var numericalComparators = new List<ISymbol>()
            {
                lt, gt, lteq, gteq, eq
            };

      var terminalSymbols = new List<ISymbol>()
            {
                doNothing, //getEnergy, getGunHeading, getHeading, getRadarHeading, getX, getY
            };

      var functionSymbols = new List<ISymbol>()
            {
                ahead, back, fire,
                //setAdjustGunForRobotTurn, setAdjustRadarForGunTurn, setAdjustRadarForRobotTurn, 
                turnGunLeft, turnGunRight, turnLeft, turnRadarLeft, turnRadarRight, turnRight
            };

      var constantSymbols = new List<ISymbol>()
            {
                shotPower, /*independent,*/ constant
            };

      var eventSymbols = new List<ISymbol>()
            {
                run, onBulletHit, onBulletMissed, onHitByBullet, 
                onHitRobot, onHitWall, onScannedRobot, block, emptyEvent
            };
      #endregion

      #region Adding Symbols
      // add all symbols to the grammar

      AddSymbol(ifStmt);
      AddSymbol(elseStmt);
      AddSymbol(whileLoop);

      AddSymbol(numExpr);
      foreach (var s in numericalExpressions)
        AddSymbol(s);
      foreach (var s in numericalOperators)
        AddSymbol(s);

      AddSymbol(logicExpr);
      foreach (var s in logicalExpressions)
        AddSymbol(s);
      foreach (var s in logicalComparators)
        AddSymbol(s);
      foreach (var s in numericalComparators)
        AddSymbol(s);

      foreach (var s in terminalSymbols)
        AddSymbol(s);
      foreach (var s in functionSymbols)
        AddSymbol(s);
      foreach (var s in constantSymbols)
        AddSymbol(s);
      foreach (var s in eventSymbols)
        AddSymbol(s);
      AddSymbol(tank);
      #endregion

      #region Defining Grammar
      // define grammar rules

      // Branches
      AddAllowedChildSymbol(ifStmt, logicExpr, 0);
      AddAllowedChildSymbol(ifStmt, block, 1);
      AddAllowedChildSymbol(ifStmt, elseStmt, 2);
      AddAllowedChildSymbol(ifStmt, doNothing, 2);
      AddAllowedChildSymbol(elseStmt, block);
      AddAllowedChildSymbol(whileLoop, logicExpr, 0);
      AddAllowedChildSymbol(whileLoop, block, 1);

      // Numerical Expressions
      foreach (var s in numericalExpressions) {
        AddAllowedChildSymbol(numExpr, s);
        AddAllowedChildSymbol(numOp, s, 1);
        AddAllowedChildSymbol(numOp, s, 2);
      }
      foreach (var s in numericalOperators)
        AddAllowedChildSymbol(numOp, s, 0);

      // Logical Expressions
      foreach (var s in logicalExpressions) {
        AddAllowedChildSymbol(logicExpr, s);
        AddAllowedChildSymbol(not, s);
        AddAllowedChildSymbol(logicComp, s, 1);
        AddAllowedChildSymbol(logicComp, s, 2);
      }
      foreach (var s in logicalComparators)
        AddAllowedChildSymbol(logicComp, s, 0);
      foreach (var s in numericalExpressions) {
        AddAllowedChildSymbol(numComp, s, 1);
        AddAllowedChildSymbol(numComp, s, 2);
      }
      foreach (var s in numericalComparators)
        AddAllowedChildSymbol(numComp, s, 0);


      // All Void Statements can appear in run or in an event handler or inside a block
      foreach (var e in eventSymbols) {
        AddAllowedChildSymbol(e, ifStmt);
        AddAllowedChildSymbol(e, whileLoop);
        AddAllowedChildSymbol(e, doNothing);
        foreach (var f in functionSymbols)
          AddAllowedChildSymbol(e, f);
      }

      // Add the appropriate parameters as children of their respective functions
      foreach (var f in functionSymbols) {
        if (f is SetAdjustGunForRobotTurn ||
            f is SetAdjustRadarForGunTurn ||
            f is SetAdjustRadarForRobotTurn)
          AddAllowedChildSymbol(f, logicExpr);
        else if (f is Fire)
          AddAllowedChildSymbol(f, shotPower);
        else
          AddAllowedChildSymbol(f, numExpr);

      }

      // Add all Event Methods to Tank. Run and OnScannedEvent are not optional,
      // so EmptyEvent cannot take their places

      AddAllowedChildSymbol(tank, run, 0);
      AddAllowedChildSymbol(tank, onScannedRobot, 1);
      AddAllowedChildSymbol(tank, onBulletMissed, 2);
      AddAllowedChildSymbol(tank, onHitByBullet, 3);
      AddAllowedChildSymbol(tank, onHitRobot, 4);
      AddAllowedChildSymbol(tank, onHitWall, 5);
      AddAllowedChildSymbol(tank, onBulletHit, 6);
      for (int i = 2; i < tank.MaximumArity; i++)
        AddAllowedChildSymbol(tank, emptyEvent, i);

      AddAllowedChildSymbol(StartSymbol, tank, 0);
      #endregion
    }
  }
}