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

use std::collections::BTreeSet;

use common::world::Block;
use rustc_hash::FxHashSet;

#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
pub struct TickTarget {
    pub x: i32,
    pub y: i32,
    pub z: i32,
    pub block: Block,
}

/// Port of the `scheduledTickTreeSet`/`scheduledTickSet` pair: due ticks ordered by
/// time, then by creation order, with at most one pending tick per block and position.
#[derive(Default)]
pub struct TickList {
    queue: BTreeSet<(i64, u64, TickTarget)>,
    pending: FxHashSet<TickTarget>,
    next_id: u64,
}

impl TickList {
    pub fn schedule(&mut self, target: TickTarget, time: i64) {
        let id = self.next_id;
        self.next_id += 1;
        if self.pending.insert(target) {
            self.queue.insert((time, id, target));
        }
    }

    /// Removes and returns the earliest tick if it is due at `time`.
    pub fn pop_due(&mut self, time: i64) -> Option<TickTarget> {
        let first = self.queue.first().filter(|entry| entry.0 <= time)?;
        let target = first.2;
        self.queue.pop_first();
        self.pending.remove(&target);
        Some(target)
    }

    /// Moves every pending tick by `delta` ticks.
    pub fn shift(&mut self, delta: i64) {
        self.queue = std::mem::take(&mut self.queue)
            .into_iter()
            .map(|(time, id, target)| (time + delta, id, target))
            .collect();
    }

    pub fn len(&self) -> usize {
        self.queue.len()
    }
}