Example #1
0
        public int?Distance(Point p1)
        {
            int distance;

            if (_cache.TryGetValue(p1, out distance))
            {
                // it is already within cache
                return(distance);
            }
            if (_map.IsDirectPath(_p0, p1))
            {
                // air path
                distance = _p0.Distance(p1);
                Add(p1, distance);
                return(distance);
            }
            for (var curDistance = _lastCompletedLevel + 1; !_cache.ContainsKey(p1); curDistance++, _lastCompletedLevel++)
            {
                // it is completed
                var previousLevel = _cache.Where(p => p.Value == curDistance - 1).Select(p => p.Key).ToHashSet();
                var nextLevel     = previousLevel.SelectMany(p => _map.Directions(p).Select(d => p.Go(d)))
                                    .Distinct()
                                    .Where(p => !_cache.ContainsKey(p))
                                    .ToHashSet();

                if (!nextLevel.Any())
                {
                    // no way to go further
                    return(null);
                }

                foreach (var p in nextLevel)
                {
                    Add(p, curDistance);
                }
            }
            return(_cache[p1]);
        }
Example #2
0
        // destination with hint in which direction to go
        public Tuple <Point, Direction> GetDestination(Man man)
        {
            var enemies = MenOfRace(Enemy(man.Race)).ToArray();

            {
                var enimiesDistance = enemies.ToDictionary(e => e, e => e.Position.Distance(man.Position)).ToArray();
                var minDistanceAsIs = enimiesDistance.Min(p => p.Value);
                Assert.True(minDistanceAsIs > 0, "never enemies on the same position");
                if (minDistanceAsIs == 1)
                {
                    // we are in position to attack an enemy, no need to move
                    return(null);
                }
            }

            // positions in range versus enemies
            var inRange = enemies
                          .SelectMany(e => _map.Directions(e.Position).Select(e.Position.Go))
                          .ToHashSet()
                          .ToDictionary(p => p, p => p.Distance(man.Position))
                          .ToArray()
            ;                     // different enemies can have same in range positions

            // it could happen that all enemies (ie the only one) are rounded from all sides
            // in this way no way to go
            if (!inRange.Any())
            {
                return(null);
            }

            // simplest strategy: select path with minimal distance
            var minDistance = inRange.Min(p => p.Value);

            if (minDistance == 0)
            {
                return(null);                              // no way to go
            }
            // more difficult task
            var optimizer = new Optimizer(_map, man.Position);

            var partialResult      = new Dictionary <Point, int>();
            int?curMinimalDistance = null;

            foreach (var inRangePoint in inRange.OrderBy(p => p.Value))
            {
                // we try from  by air shortest distance
                if (curMinimalDistance.HasValue)
                {
                    if (curMinimalDistance.Value < inRangePoint.Value)
                    {
                        // the distance already found is less then shortest candidate by air
                        // we may terminate
                        break;
                    }
                }

                var distance = optimizer.Distance(inRangePoint.Key);
                if (distance.HasValue)
                {
                    partialResult.Add(inRangePoint.Key, distance.Value);
                    curMinimalDistance = curMinimalDistance.HasValue
                                                ? Math.Min(curMinimalDistance.Value, distance.Value) : distance.Value;
                }
            }

            if (!curMinimalDistance.HasValue)
            {
                // no way to connect two points
                return(null);
            }

            var destinationList     = partialResult.Where(p => p.Value == curMinimalDistance.Value).Select(p => p.Key);
            var selectedDestination = destinationList.OrderBy(p => p.ReadingOrder).First();

            var optimizer1 = new Optimizer(_map, selectedDestination);
            var options    = _map.Directions(man.Position)
                             .ToDictionary(d => d, d => man.Position.Go(d))
                             .OrderBy(p => p.Value.ReadingOrder)
                             .ToArray();

            foreach (var o in options)
            {
                var distance = optimizer1.Distance(o.Value);                 // decreased distance due to the step ahead to the target
                if (distance.HasValue)
                {
                    if ((curMinimalDistance.Value - 1) == distance.Value)
                    {
                        // this is the correct direction and expected distance
                        return(Tuple.Create(selectedDestination, o.Key));
                    }
                }
            }
            throw new Exception("unexpected processing of options");
        }