alex/beta-minecraft-rust

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

use crate::interaction::Screen;
use crate::menu::contains;
use common::inventory::ContainerKind;

pub fn container_rect(size: [f32; 2], kind: ContainerKind) -> [f32; 4] {
    let height = match kind {
        ContainerKind::Chest { slots } => (slots / 9 * 18 + 114) as f32,
        _ => 166.0,
    };
    [
        ((size[0] - 176.0) / 2.0).floor(),
        ((size[1] - height) / 2.0).floor(),
        176.0,
        height,
    ]
}

pub fn slot_position(kind: ContainerKind, index: usize) -> [f32; 2] {
    let base = kind.inventory_start();
    if index >= base {
        let index = index - base;
        let y = match kind {
            ContainerKind::Chest { slots } => (slots / 9 * 18 + 32) as f32,
            _ => 84.0,
        };
        return [
            8.0 + (index % 9) as f32 * 18.0,
            y + if index < 27 {
                (index / 9) as f32 * 18.0
            } else {
                58.0
            },
        ];
    }
    match kind {
        ContainerKind::Inventory => match index {
            0 => [144.0, 36.0],
            1..=4 => [
                88.0 + ((index - 1) % 2) as f32 * 18.0,
                26.0 + ((index - 1) / 2) as f32 * 18.0,
            ],
            _ => [8.0, 8.0 + (index - 5) as f32 * 18.0],
        },
        ContainerKind::Workbench if index == 0 => [124.0, 35.0],
        ContainerKind::Workbench => [
            30.0 + ((index - 1) % 3) as f32 * 18.0,
            17.0 + ((index - 1) / 3) as f32 * 18.0,
        ],
        ContainerKind::Chest { .. } => [
            8.0 + (index % 9) as f32 * 18.0,
            18.0 + (index / 9) as f32 * 18.0,
        ],
        ContainerKind::Furnace => [[56.0, 17.0], [56.0, 53.0], [116.0, 35.0]][index],
        ContainerKind::Dispenser => [
            62.0 + (index % 3) as f32 * 18.0,
            17.0 + (index / 3) as f32 * 18.0,
        ],
    }
}

pub fn slot_at(size: [f32; 2], kind: ContainerKind, cursor: [f32; 2]) -> Option<i16> {
    let rect = container_rect(size, kind);
    let slot = (0..kind.slot_count()).find(|&index| {
        let [x, y] = slot_position(kind, index);
        contains([rect[0] + x - 1.0, rect[1] + y - 1.0, 18.0, 18.0], cursor)
    });
    slot.map(|index| index as i16)
        .or((!contains(rect, cursor)).then_some(-999))
}

pub fn button_rect(size: [f32; 2], screen: Screen, index: usize) -> [f32; 4] {
    let offset = if screen == Screen::Death {
        72.0 + index as f32 * 24.0
    } else {
        8.0 + index as f32 * 96.0
    };
    [size[0] / 2.0 - 100.0, size[1] / 4.0 + offset, 200.0, 20.0]
}

pub fn button_at(size: [f32; 2], screen: Screen, cursor: [f32; 2]) -> Option<usize> {
    (0..2).find(|&index| contains(button_rect(size, screen, index), cursor))
}