quicksilver 0.4.0

A simple game framework for 2D games in pure Rust
Documentation 
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::geom::{about_equal, Vector};
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::cmp::{Eq, PartialEq};

#[derive(Clone, Copy, Default, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
///A rectangle with a top-left position and a size
pub struct Rectangle {
    ///The top-left coordinate of the rectangle
    pub pos: Vector,
    ///The width and height of the rectangle
    pub size: Vector,
}

impl Rectangle {
    ///Create a rectangle from a top-left vector and a size vector
    pub fn new(pos: Vector, size: Vector) -> Rectangle {
        Rectangle { pos, size }
    }

    ///Create a rectangle at the origin with the given size
    pub fn new_sized(size: Vector) -> Rectangle {
        Rectangle {
            pos: Vector::ZERO,
            size,
        }
    }

    ///Get the top left coordinate of the Rectangle
    pub fn top_left(&self) -> Vector {
        self.pos
    }

    ///Get the x-coordinate of the Rectangle
    ///(The origin of a Rectangle is at the top left)
    pub fn x(&self) -> f32 {
        self.pos.x
    }

    ///Get the y-coordinate of the Rectangle
    ///(The origin of a Rectangle is at the top left)
    pub fn y(&self) -> f32 {
        self.pos.y
    }

    ///Get the size of the Rectangle
    pub fn size(&self) -> Vector {
        self.size
    }

    ///Get the height of the Rectangle
    pub fn height(&self) -> f32 {
        self.size.y
    }

    ///Get the width of the Rectangle
    pub fn width(&self) -> f32 {
        self.size.x
    }
}

impl PartialEq for Rectangle {
    fn eq(&self, other: &Rectangle) -> bool {
        about_equal(self.x(), other.pos.x)
            && about_equal(self.y(), other.pos.y)
            && about_equal(self.width(), other.size.x)
            && about_equal(self.height(), other.size.y)
    }
}

impl Eq for Rectangle {}

#[cfg(test)]
mod tests {
    use crate::geom::*;

    #[test]
    fn overlap() {
        let a = &Rectangle::new_sized(Vector::new(32.0, 32.0));
        let b = &Rectangle::new(Vector::new(16.0, 16.0), Vector::new(32.0, 32.0));
        let c = &Rectangle::new(Vector::new(50.0, 50.0), Vector::new(5.0, 5.0));
        assert!(a.overlaps_rectangle(b));
        assert!(!a.overlaps_rectangle(c));
    }

    #[test]
    fn contains() {
        let rect = Rectangle::new_sized(Vector::new(32.0, 32.0));
        let vec1 = Vector::new(5.0, 5.0);
        let vec2 = Vector::new(33.0, 1.0);
        assert!(rect.contains(vec1));
        assert!(!rect.contains(vec2));
    }

    #[test]
    fn constraint() {
        let constraint = &Rectangle::new_sized(Vector::new(10.0, 10.0));
        let a = Rectangle::new(Vector::new(-1.0, 3.0), Vector::new(5.0, 5.0));
        let b = Rectangle::new(Vector::new(4.0, 4.0), Vector::new(8.0, 3.0));
        let a = a.constrain(constraint);
        assert_eq!(a.top_left(), Vector::new(0.0, 3.0));
        let b = b.constrain(constraint);
        assert_eq!(b.top_left(), Vector::new(2.0, 4.0));
    }

    #[test]
    fn translate() {
        let a = Rectangle::new(Vector::new(10.0, 10.0), Vector::new(5.0, 5.0));
        let v = Vector::new(1.0, -1.0);
        let translated = a.translate(v);
        assert_eq!(a.top_left() + v, translated.top_left());
    }
}