Removed bitfield comment
[entelect-challenge-tower-defence.git] / src / engine / geometry.rs
1 use engine::constants::*;
2
3 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
4 pub struct Point {
5     pub x: u8,
6     pub y: u8
7 }
8
9 impl Point {
10     pub fn new(x: u8, y: u8) -> Point {
11         Point { x, y }
12     }
13     pub fn move_left(&self) -> Option<Point> {
14         self.x.checked_sub(1).map(|x| Point {
15             x,
16             ..*self
17         })
18     }
19     pub fn move_right(&self, size: &Point) -> Option<Point> {
20         if self.x + 1 >= size.x {
21             None
22         } else {
23             Some(Point {
24                 x: self.x + 1,
25                 ..*self
26             })
27         }
28     }
29
30     pub fn wrapping_move_left(&mut self) {
31         self.x = self.x.wrapping_sub(1);
32     }
33     pub fn wrapping_move_right(&mut self) {
34         self.x = self.x.wrapping_add(1);
35     }
36
37     pub fn flip_x(&self) -> Point {
38         let flipped_x = if self.x >= SINGLE_MAP_WIDTH {
39             FULL_MAP_WIDTH - self.x - 1
40         } else {
41             self.x
42         };
43         Point::new(flipped_x, self.y)
44     }
45 }
46
47 impl Point {
48     /**
49      * # Bitfields
50      * 
51      * 0,0 is the top left point.
52      * >> (towards 0) moves bits towards the player that owns that side
53      * << (towards max) moves bits towards the opponent
54      * This involves mirroring the x dimension for the opponent's side
55      */
56
57
58     pub fn to_bitfield(&self) -> (u64, u64) {
59         (self.to_left_bitfield(), self.to_right_bitfield())
60     }
61     
62     pub fn to_left_bitfield(&self) -> u64 {
63         if self.x >= SINGLE_MAP_WIDTH {
64             0
65         } else {
66             let index = self.y * SINGLE_MAP_WIDTH + self.x;
67             1 << index
68         }
69     }
70
71     pub fn to_right_bitfield(&self) -> u64 {
72         if self.x < SINGLE_MAP_WIDTH {
73             0
74         } else {
75             let index = self.y * SINGLE_MAP_WIDTH + FULL_MAP_WIDTH - self.x - 1;
76             1 << index
77         }
78     }
79
80     pub fn to_either_bitfield(&self) -> u64 {
81         self.to_left_bitfield() | self.to_right_bitfield()
82     }
83 }
84
85 use std::cmp::Ord;
86 use std::cmp::Ordering;
87
88 impl PartialOrd for Point {
89     fn partial_cmp(&self, other: &Point) -> Option<Ordering> {
90         Some(self.cmp(other))
91     }
92 }
93 impl Ord for Point {
94     fn cmp(&self, other: &Point) -> Ordering {
95         let a = self.flip_x();
96         let b = other.flip_x();
97         a.y.cmp(&b.y).then(a.x.cmp(&b.x))
98     }
99 }