Exemplo n.º 1
0
 /// <summary>
 /// Destination for a movement. Ignores all robots on the map but does take into account walls, conveyor belts and gears. Returns
 /// the final location of the move.
 /// </summary>
 /// <param name="map">The game map.</param>
 /// <param name="startLocation">Where the unit starts.</param>
 /// <param name="cards">The cards to apply.</param>
 /// <returns>The final location of the move.</returns>
 public static MovePoint CardDestination(GameMap map, BoardLocation startLocation, IEnumerable<Card> cards)
 {
     List<MovePoint> points = CardPath(map, startLocation, cards);
     if ((points == null) || (points.Count == 0))
         return null;
     return points[points.Count - 1];
 }
Exemplo n.º 2
0
 /// <summary>
 /// Calculates what damage a unit will receive from lasers at a given location.
 /// </summary>
 /// <param name="map">The game map.</param>
 /// <param name="location">Where the unit is located.</param>
 /// <returns>The amount of damage. Will be 0 or 1.</returns>
 public static int CalcLaserDamage(GameMap map, BoardLocation location)
 {
     int damage = 0;
     damage += _CalcLaserDamage(map, location.MapPosition, 0, -1, MapSquare.DIRECTION.SOUTH, MapSquare.SIDE.NORTH, MapSquare.SIDE.SOUTH);
     damage += _CalcLaserDamage(map, location.MapPosition, 0, 1, MapSquare.DIRECTION.NORTH, MapSquare.SIDE.SOUTH, MapSquare.SIDE.NORTH);
     damage += _CalcLaserDamage(map, location.MapPosition, -1, 0, MapSquare.DIRECTION.EAST, MapSquare.SIDE.WEST, MapSquare.SIDE.EAST);
     damage += _CalcLaserDamage(map, location.MapPosition, 1, 0, MapSquare.DIRECTION.WEST, MapSquare.SIDE.EAST, MapSquare.SIDE.WEST);
     return damage;
 }
Exemplo n.º 3
0
        /// <summary>
        /// Destination for a movement. Ignores all robots on the map but does take into account walls, conveyor belts and gears. Returns
        /// every step of the move.
        /// </summary>
        /// <param name="map">The game map.</param>
        /// <param name="startLocation">Where the unit starts.</param>
        /// <param name="cards">The cards to apply.</param>
        /// <returns>Every step of the move.</returns>
        public static List<MovePoint> CardPath(GameMap map, BoardLocation startLocation, IEnumerable<Card> cards)
        {
            // if we can't move, we end up where we started
            List<MovePoint> points = new List<MovePoint> {new MovePoint(startLocation)};

            foreach (Card cardOn in cards)
            {
                // move robot
                MovePoint endLocation = Move(map, startLocation, cardOn.Move);
                if (endLocation.Dead)
                {
                    points.Add(endLocation);
                    return points;
                }
                if (! endLocation.Location.Equals(startLocation))
                {
                    startLocation = endLocation.Location;
                    points.Add(new MovePoint(startLocation));
                }

                // conveyor belt - may cause a 1/4 turn.
                MapSquare sq = map.GetSquare(startLocation.MapPosition);
                for (int speed=1; (sq.Conveyor != null) && (speed <= sq.Conveyor.Speed); speed++)
                {
                    endLocation = Move(map, startLocation.MapPosition, sq.Conveyor.Direction);
                    BoardLocation locMove = new BoardLocation(endLocation.Location.MapPosition, startLocation.Direction);
                    sq = map.GetSquare(endLocation.Location.MapPosition);
                    if (sq.Conveyor != null)
                    {
                        MapSquare.DIRECTION dirEnter = MoveDirection(startLocation.MapPosition, endLocation.Location.MapPosition);
                        locMove = locMove.Rotate((int)sq.Conveyor.Direction - (int)dirEnter);
                    }
                    startLocation = locMove;
                    points.Add(new MovePoint(startLocation));
                }

                // gears
                if (sq.Type == MapSquare.TYPE.ROTATE_CLOCKWISE)
                {
                    startLocation = startLocation.Rotate(1);
                    points.Add(new MovePoint(startLocation));
                }
                if (sq.Type == MapSquare.TYPE.ROTATE_COUNTERCLOCKWISE)
                {
                    startLocation = startLocation.Rotate(-1);
                    points.Add(new MovePoint(startLocation));
                }

                // damage
                int damage = CalcLaserDamage(map, startLocation);
                if (damage != 0)
                    points[points.Count - 1].Damage = damage;
            }

            return points;
        }
Exemplo n.º 4
0
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="src">Initialize with the values in this struct.</param>
 public BoardLocation(BoardLocation src)
 {
     _mapPosition = src.MapPosition;
     _direction = src.Direction;
 }
Exemplo n.º 5
0
 /// <summary>
 /// Create from passed in XML..
 /// </summary>
 /// <param name="element">Initialize with the values in this object.</param>
 protected CombatUnit(XElement element)
 {
     Location = new BoardLocation(element);
 }
Exemplo n.º 6
0
 /// <summary>
 /// Create the object. No damage.
 /// </summary>
 /// <param name="location">The location of the move result.</param>
 /// <param name="dead">true if the move caused death.</param>
 public MovePoint(BoardLocation location, bool dead)
 {
     Location = location;
     Dead = dead;
 }
Exemplo n.º 7
0
 /// <summary>
 /// Create the object. Not dead.
 /// </summary>
 /// <param name="location">The location of the move result.</param>
 /// <param name="damage">The damage level from this move.</param>
 public MovePoint(BoardLocation location, int damage)
 {
     Location = location;
     Damage = damage;
 }
Exemplo n.º 8
0
 /// <summary>
 /// Create the object. No damage and not dead.
 /// </summary>
 /// <param name="location">The location of the move result.</param>
 public MovePoint(BoardLocation location)
 {
     Location = location;
     Damage = 0;
     Dead = false;
 }
Exemplo n.º 9
0
        /// <summary>
        /// Move a unit one square in the requested direction. Ignores all robots on the map but does take into account walls, conveyor belts and gears.
        /// </summary>
        /// <param name="map">The game map.</param>
        /// <param name="position">The map square to start the move from.</param>
        /// <param name="direction">The direction to move.</param>
        /// <returns>The final location of the move.</returns>
        public static MovePoint Move(GameMap map, Point position, MapSquare.DIRECTION direction)
        {
            // watch for wall in this direction
            MapSquare.SIDE sideExit = sideMoveOut[(int) direction];
            MapSquare.SIDE sideEnter = sideMoveIn[(int) direction];
            BoardLocation location = new BoardLocation(position, direction);

            // can we exit this square?
            MapSquare sq = map.GetSquare(position);
            if ((sq.Walls & sideExit) != 0)
                return new MovePoint(location);
            BoardLocation moveTo = location.Move(1);

            // did we go off the board?
            if ((moveTo.MapPosition.X < 0) || (map.Width <= moveTo.MapPosition.X) ||
                (moveTo.MapPosition.Y < 0) || (map.Height <= moveTo.MapPosition.Y))
                return new MovePoint(location, true);

            // did we go into a pit?
            if (map.GetSquare(moveTo.MapPosition).Type == MapSquare.TYPE.PIT)
                return new MovePoint(moveTo, true);

            // can we enter the new square?
            sq = map.GetSquare(moveTo.MapPosition);
            if ((sq.Walls & sideEnter) != 0)
                return new MovePoint(location);

            return new MovePoint(moveTo);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Move a unit one card move. Ignores all robots on the map but does take into account walls, conveyor belts and gears.
        /// </summary>
        /// <param name="map">The game map.</param>
        /// <param name="startLocation">Where the unit starts.</param>
        /// <param name="move">The move to apply.</param>
        /// <returns>The final location of the move.</returns>
        public static MovePoint Move(GameMap map, BoardLocation startLocation, Card.ROBOT_MOVE move)
        {
            int steps = 0;
            switch (move)
            {
                case Card.ROBOT_MOVE.BACKWARD_ONE:
                    steps = -1;
                    break;
                case Card.ROBOT_MOVE.FORWARD_ONE:
                    steps = 1;
                    break;
                case Card.ROBOT_MOVE.FORWARD_TWO:
                    steps = 2;
                    break;
                case Card.ROBOT_MOVE.FORWARD_THREE:
                    steps = 3;
                    break;
                case Card.ROBOT_MOVE.ROTATE_LEFT:
                    return new MovePoint(startLocation.Rotate(-1));
                case Card.ROBOT_MOVE.ROTATE_RIGHT:
                    return new MovePoint(startLocation.Rotate(1));
                case Card.ROBOT_MOVE.ROTATE_UTURN:
                    return new MovePoint(startLocation.Rotate(2));
            }

            MapSquare.DIRECTION dir = steps >= 0 ? startLocation.Direction : startLocation.Rotate(2).Direction;
            Point position = startLocation.MapPosition;
            while (steps != 0)
            {
                MovePoint mp = Move(map, position, dir);
                if (mp.Dead)
                    return new MovePoint(new BoardLocation(mp.Location.MapPosition, startLocation.Direction), true);
                position = mp.Location.MapPosition;
                int singleStep = Math.Max(-1, Math.Min(1, steps));
                steps -= singleStep;
            }
            return new MovePoint(new BoardLocation(position, startLocation.Direction));
        }