Пример #1
0
 private static double GetAdjacencyBonus(Field field, Unit unit, ExecutionOptions options)
 {
     double downBonus = options.AdjacencyDownRatio;
     double sideBonus = options.AdjacencySideRatio;
     double result = 0;
     foreach (var m in unit.Members)
     {
         if (m.Y < field.Height - 1)
         {
             if (field[m.Translate(MoveDirection.SouthEast)])
             {
                 result += downBonus;
             }
             else
             {
                 result -= downBonus;
             }
             if (field[m.Translate(MoveDirection.SouthWest)])
             {
                 result += downBonus;
             }
             else
             {
                 result -= downBonus;
             }
         }
         if (m.X < field.Width - 1 && field[m.Translate(MoveDirection.East)])
             result += sideBonus;
         if (m.X > 0 && field[m.Translate(MoveDirection.West)])
             result += sideBonus;
     }
     return result;
 }
Пример #2
0
        private static IEnumerable<ExecutionResult> Calculate(
			Snapshot baseSnapshot,
			MoveDirection? move,
			ExecutionOptions options,
			int depth,
			double minEstimate)
        {
            var snapshot = move.HasValue
                ? Game.MakeMove(baseSnapshot, move.Value)
                : baseSnapshot;
            if (snapshot == null) // illegal move
                yield break;
            var estimate = SnapshotEvaluate(snapshot, options);

            bool nextUnit = snapshot.UnitIndex > baseSnapshot.UnitIndex;
            // stop recursion
            if (snapshot.Finished || depth <= 0 || estimate < minEstimate || nextUnit) // TODO: some diff
            {
                yield return new ExecutionResult
                {
                    Commands = new [] { move.Value },
                    Estimate = estimate,
                    Snapshot = snapshot
                };
                yield break;
            }

            var candidateMoves = (MoveDirection[])Enum.GetValues(typeof (MoveDirection));

            var childResults = candidateMoves
                .SelectMany(m => Calculate(snapshot, m, options, depth - 1, estimate))
                .OrderByDescending(r => r.Estimate)
                .Take((int)Math.Ceiling(options.MaxWidth));
            foreach (var result in childResults)
            {
                var commands = move.HasValue
                    ? result.Commands.Prepend(move.Value).ToArray()
                    : result.Commands;

                yield return new ExecutionResult
                {
                    Commands = commands,
                    Estimate = result.Estimate + CommandEncoding.GetWordsPower(commands) * options.PowerWordsBonus,
                    Snapshot = result.Snapshot
                };
            }
        }
Пример #3
0
 private static void Mutate(ExecutionOptions options, double percent)
 {
     var propsDict = typeof(ExecutionOptions).GetProperties().ToDictionary(p => p.Name);
     foreach (var variable in Variables)
     {
         var property = propsDict[variable.Key];
         double oldValue = (double)property.GetValue(options);
         double newValue = variable.Value.Mutate(oldValue, percent);
         property.SetValue(options, newValue);
     }
 }
Пример #4
0
 private static ExecutionOptions Generate()
 {
     var result = new ExecutionOptions
     {
         MinEstimation = Double.MinValue
     };
     var props = typeof(ExecutionOptions)
         .GetProperties()
         .ToDictionary(p => p.Name);
     foreach (var variable in Variables)
     {
         var property = props[variable.Key];
         double value = variable.Value.GetRandomValue();
         property.SetValue(result, value);
     }
     return result;
 }
Пример #5
0
        private static ExecutionOptions Crossover(
			ExecutionOptions first, ExecutionOptions second)
        {
            var result = new ExecutionOptions { MinEstimation = Double.MinValue };
            var props = typeof(ExecutionOptions)
                .GetProperties()
                .ToDictionary(p => p.Name);
            foreach (var variable in Variables)
            {
                var property = props[variable.Key];
                double value = Random.Next(2) == 0
                    ? (double) property.GetValue(first)
                    : (double) property.GetValue(second);
                //double firstValue = (double)property.GetValue(first);
                //double secondValue = (double)property.GetValue(second);
                //double mean = (firstValue + secondValue) / 2;
                property.SetValue(result, value);
            }
            return result;
        }
Пример #6
0
 private static ExecutionResult Calculate(Snapshot snapshot, ExecutionOptions options)
 {
     var request = new ExecutionRequest
     {
         Snapshot = snapshot,
         Options = options
     };
     var solver = new IterativeSearchSolver(1200); //new TraverseSolver();
     return solver.Solve(request).First();
 }
Пример #7
0
 private static double SnapshotEvaluate(Snapshot snapshot, ExecutionOptions options)
 {
     if (snapshot.UnitHistory.Count <= 1) // new unit, so field has changed
     {
         snapshot.FieldEstimate = GetFieldEstimate(snapshot.Field, options);
     }
     return snapshot.Score
         + snapshot.FieldEstimate
         + GetUnitPositionBonus(snapshot.Field, snapshot.CurrentUnit, options);
 }
Пример #8
0
        private static double GetUnitPositionBonus(
			Field field, Unit unit, ExecutionOptions options)
        {
            int minX = unit.GetMinX();
            int maxX = unit.GetMaxX();
            int minY = unit.GetMinY();
            int maxY = unit.GetMaxY();
            int depth = field.Height - minY;

            int width = maxX - maxY;

            int marginBottom = field.Height - maxY;

            int center = (maxX + minX) / 2;

            var attractor = GetBottomOpenPosition(field);

            double attractorDistance = Math.Abs(attractor.X - unit.Pivot.X); // attractor.DistanceTo(unit.Pivot);

            double depthPenalty = 0;
            foreach (var member in unit.Members)
            {
                depthPenalty += field.Height - 1 - member.Y;
            }

            int edgeBonus = 0;
            foreach (var position in unit.Members)
            {
                if (position.X == 0 || position.X == field.Width - 1)
                    edgeBonus += 1;
            }

            double adjacencyBonus = GetAdjacencyBonus(field, unit, options);

            return edgeBonus * options.EdgeRatio
                + adjacencyBonus
                - depthPenalty * options.DepthPenaltyRatio
                - attractorDistance * options.AttractorRatio;
        }
Пример #9
0
 private static double GetFieldEstimate(Field field, ExecutionOptions options)
 {
     return CornerCellsBonus(field) * options.CornerCellsBonus
         - GetHiddenHoles(field) * options.HiddenHolesPenalty;
 }