e
})?;
(||{
- self.c.g.updates.insert(player, Default::default());
+ let pu_bc = PlayerUpdates::new_begin(&self.c.g.gs);
+ self.c.g.updates.insert(player, pu_bc.new());
})(); // <- No ?, ensures that IEFE is infallible (barring panics)
(player, logentry)
}
}
#[throws(StartupError)]
- pub fn load(name: InstanceName) -> InstanceRef {
+ fn load(name: InstanceName) -> InstanceRef {
{
let mut st = GLOBAL.save_area_lock.lock().unwrap();
let st = &mut *st;
Err(e)
})?;
let mut updates : SecondarySlotMap<_,_> = Default::default();
+ let pu_bc = PlayerUpdates::new_begin(&gs);
for player in gs.players.keys() {
- updates.insert(player, Default::default());
+ updates.insert(player, pu_bc.new());
}
let name = Arc::new(name);
access_load.tokens_players.retain(
let to_send = match log.into_iter().rev()
.find(|(_,update)| update.gen <= gen) {
- None => log.front_index(),
+ None => UpdateId::min_value(),
Some((mut i,_)) => { i.try_increment(); i },
};
// ---------- prepared updates, queued in memory ----------
-impl Default for PlayerUpdates {
- fn default() -> PlayerUpdates { PlayerUpdates {
- log : StableIndexVecDeque::with_capacity(50),
- cv : Default::default(),
- } }
+
+pub struct PlayerUpdatesBuildContext {
+ pub(self) u1: Arc<PreparedUpdate>,
+}
+
+impl PlayerUpdatesBuildContext {
+ pub fn new(&self) -> PlayerUpdates {
+ let mut log = StableIndexVecDeque::with_capacity(50);
+ log.push_back(self.u1.clone());
+ let cv = Default::default();
+ PlayerUpdates { log, cv }
+ }
}
impl PlayerUpdates {
+ pub fn new_begin(gs: &GameState) -> PlayerUpdatesBuildContext {
+ let u1 = Arc::new(PreparedUpdate {
+ gen : gs.gen,
+ when: Instant::now(),
+ us: vec![],
+ });
+ PlayerUpdatesBuildContext { u1 }
+ }
+
pub fn push<U: Into<Arc<PreparedUpdate>>>(&mut self, update: U) {
self.log.push_back(update.into());
self.cv.notify_all();