ryot 0.2.2

MMORPG library based on the concepts of open tibia written in rust and bevy.
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

use crate::position::TilePosition;
use glam::Vec2;
use rstest::rstest;
use std::collections::HashSet;

#[rstest]
#[case((0, 0), (0., -32.))]
#[case((1, 0), (32., -32.))]
#[case((0, 1), (0., 0.))]
#[case((1, 1), (32., 0.))]
#[case((-3, 0), (-96., -32.))]
#[case((0, -3), (0., -128.))]
#[case((-3, -3), (-96., -128.))]
#[case((12300, -5433), (393600., -173888.))]
fn test_position_to_screen_vec2(#[case] input: (i32, i32), #[case] expected: (f32, f32)) {
    let position = TilePosition::new(input.0, input.1, 0);
    let screen_vec2 = Vec2::from(position);
    assert_eq!(screen_vec2, Vec2::new(expected.0, expected.1));
}

#[rstest]
#[case((0., 0.), (0, 1))]
#[case((1., 0.), (1, 1))]
#[case((0., 1.), (0, 1))]
#[case((1., 1.), (1, 1))]
#[case((-26., 0.), (0, 1))]
#[case((0., -26.), (0, 0))]
#[case((-26., -26.), (0, 0))]
#[case((26., 0.), (1, 1))]
#[case((-32., -32.), (-1, 0))]
#[case((-31.999, -31.999), (0, 0))]
#[case((32., 0.), (1, 1))]
#[case((100000., 200000.), (3125, 6251))]
fn test_position_from_screen_vec2(#[case] input: (f32, f32), #[case] expected: (i32, i32)) {
    let position = TilePosition::from(Vec2::new(input.0, input.1));
    assert_eq!(position, TilePosition::new(expected.0, expected.1, 0));
}

#[rstest]
#[case((0, 0), true)]
#[case((i32::MIN, i32::MIN), false)]
#[case((i32::MAX, i32::MAX), false)]
#[case((i32::MIN, 0), false)]
#[case((0, i32::MIN), false)]
#[case((i16::MAX as i32, 0), true)]
#[case((0, i16::MAX as i32), true)]
fn test_validate(#[case] input: (i32, i32), #[case] expected: bool) {
    let position = TilePosition::new(input.0, input.1, 0);
    assert_eq!(position.is_valid(), expected);
}

#[rstest]
#[case((0, 0))]
#[case((1, 0))]
#[case((0, 1))]
#[case((1, 1))]
#[case((-3, 0))]
#[case((0, -3))]
#[case((-3, -3))]
#[case((12300, -5433))]
fn test_reversible(#[case] input: (i32, i32)) {
    let position = TilePosition::new(input.0, input.1, 0);
    let screen = Vec2::from(position);
    let position2 = TilePosition::from(screen);
    assert_eq!(
        position, position2,
        "position: {:?}, screen: {:?}",
        position, screen
    );
}

#[rstest]
#[case(
    TilePosition::new(0, 0, 0),
    TilePosition::new(0, 1, 0),
    &HashSet::from([TilePosition::new(0, 0, 0), TilePosition::new(0, 1, 0), TilePosition::new(0, 2, 0)]),
    true
)]
#[case(
    TilePosition::new(0, 0, 0),
    TilePosition::new(0, 1, 0),
    &HashSet::from([TilePosition::new(0, 1, 0), TilePosition::new(0, 2, 0)]),
    false
)]
#[case(
    TilePosition::new(0, 0, 0),
    TilePosition::new(0, 1, 0),
    &HashSet::from([TilePosition::new(0, 0, 0), TilePosition::new(0, 2, 0)]),
    false
)]
fn test_is_directly_connected(
    #[case] from: TilePosition,
    #[case] to: TilePosition,
    #[case] positions: &HashSet<TilePosition>,
    #[case] expected: bool,
) {
    assert_eq!(from.is_directly_connected(to, positions), expected);
}