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
|
use crate::{client::Client, helper::from_timestamp};
use chrono::NaiveDateTime;
use karlcommon::{ClientboundPacket, ServerboundPacket, Task};
use log::warn;
use std::{
collections::{HashMap, VecDeque},
ops::Range,
};
pub struct Globals {
pub client: Client,
pub tasks: HashMap<u64, Task>,
pub awaiting_instance_requests: VecDeque<(u64, Range<NaiveDateTime>)>,
pub instance_cache:
HashMap<(u64, Range<NaiveDateTime>), Option<Vec<Range<Option<NaiveDateTime>>>>>,
}
impl Globals {
pub fn new(client: Client) -> Self {
Globals {
client,
tasks: Default::default(),
instance_cache: Default::default(),
awaiting_instance_requests: Default::default(),
}
}
pub fn update_network(&mut self) {
while let Ok(p) = self.client.receiver.try_recv() {
match p {
ClientboundPacket::TaskList(t) => {
self.tasks = HashMap::from_iter(t.into_iter().map(|e| (e.id, e)));
}
ClientboundPacket::Sync => {
self.client.busy = false;
}
ClientboundPacket::InstanceList(is) => {
if let Some(i) = self.awaiting_instance_requests.pop_front() {
self.instance_cache.insert(
i,
Some(
is.iter()
.map(|r| r.start.map(from_timestamp)..r.end.map(from_timestamp))
.collect(),
),
);
} else {
warn!("got unknown instance list packet")
}
}
ClientboundPacket::InvalidateState => {
self.instance_cache.clear();
self.tasks.clear();
self.client.send_sync(ServerboundPacket::ListTasks);
}
_ => {}
}
}
}
pub fn get_instances_range(
&mut self,
task: u64,
start: NaiveDateTime,
end: NaiveDateTime,
) -> &Option<Vec<Range<Option<NaiveDateTime>>>> {
// looks silly but the borrow checker likes it more
let has = self.instance_cache.contains_key(&(task, start..end));
if has {
if let Some(c) = self.instance_cache.get(&(task, start..end)) {
return c;
}
return &None;
}
self.awaiting_instance_requests
.push_back((task, start..end));
self.instance_cache.insert((task, start..end), None);
self.client.send_sync(ServerboundPacket::ListInstances {
task,
range: Some(start.timestamp())..Some(end.timestamp()),
limit: 4069,
});
&None
}
}
|
