1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Utilities for doing math on [`Position`]s which are present in the
//! JavaScript API.
use crate::constants::Direction;

use super::Position;

impl Position {
    /// Gets linear direction to the specified position.
    ///
    /// Note that this chooses between `Top`/`Bottom`/`Left`/`Right` and
    /// `TopLeft`/`TopRight`/`BottomLeft`/`BottomRight` by the magnitude in both
    /// directions. For instance, [`Direction::Top`] can be returned even
    /// if the target has a slightly different `x` coordinate.
    pub fn get_direction_to(self, target: Position) -> Option<Direction> {
        // Logic copied from https://github.com/screeps/engine/blob/020ba168a1fde9a8072f9f1c329d5c0be8b440d7/src/utils.js#L73-L107
        let (dx, dy) = target - self;
        if dx.abs() > dy.abs() * 2 {
            if dx > 0 {
                Some(Direction::Right)
            } else {
                Some(Direction::Left)
            }
        } else if dy.abs() > dx.abs() * 2 {
            if dy > 0 {
                Some(Direction::Bottom)
            } else {
                Some(Direction::Top)
            }
        } else if dx > 0 && dy > 0 {
            Some(Direction::BottomRight)
        } else if dx > 0 && dy < 0 {
            Some(Direction::TopRight)
        } else if dx < 0 && dy > 0 {
            Some(Direction::BottomLeft)
        } else if dx < 0 && dy < 0 {
            Some(Direction::TopLeft)
        } else {
            None
        }
    }

    /// Gets linear range to the specified position.
    ///
    /// This operates on positions as "world positions", and will return an
    /// accurate range for positions in different rooms. Note that the
    /// corresponding JavaScript method, `RoomPosition.getRangeTo` returns
    /// `Infinity` if given positions in different rooms.
    #[inline]
    pub fn get_range_to(self, target: Position) -> u32 {
        let (dx, dy) = self - target;
        dx.abs().max(dy.abs()) as u32
    }

    /// Checks whether this position is in the given range of another position.
    ///
    /// This operates on positions as "world positions", and may return true for
    /// positions in different rooms which are still within the given range.
    /// Note that the corresponding JavaScript method, `RoomPosition.inRangeTo`,
    /// will always return `false` for positions from different rooms.
    #[inline]
    pub fn in_range_to(self, target: Position, range: u32) -> bool {
        self.get_range_to(target) <= range
    }

    /// Checks whether this position is the same as the specified position.
    ///
    /// Note that this is equivalent to `this_pos == target.pos()`.
    #[inline]
    pub fn is_equal_to(self, target: Position) -> bool {
        self == target
    }

    /// True if this position is in the same room as the target, and the range
    /// is at most 1.
    #[inline]
    pub fn is_near_to(self, target: Position) -> bool {
        self.room_name() == target.room_name()
            && (u8::from(self.x()) as i32 - u8::from(target.x()) as i32).abs() <= 1
            && (u8::from(self.y()) as i32 - u8::from(target.y()) as i32).abs() <= 1
    }
}

#[cfg(test)]
mod test {
    use crate::{local::RoomCoordinate, Direction, Position, RoomName};

    #[test]
    fn test_direction_to() {
        let one = unsafe { RoomCoordinate::unchecked_new(1) };
        let two = unsafe { RoomCoordinate::unchecked_new(2) };
        let a = Position::new(one, one, RoomName::from_coords(1, 1).unwrap());
        let b = Position::new(two, two, RoomName::from_coords(1, 1).unwrap());
        assert_eq!(a.get_direction_to(b), Some(Direction::BottomRight));
    }
}