source: branches/Robocode/HeuristicLab.Problems.Robocode/Problem.cs @ 9598

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
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;
            }
        }
    }
}