nil-core 0.5.5

Multiplayer strategy game
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

// Copyright (C) Call of Nil contributors
// SPDX-License-Identifier: AGPL-3.0-only

#[cfg(test)]
mod tests;

use crate::city::City;
use crate::error::{Error, Result};
use crate::military::Military;
use crate::player::{Player, PlayerId, PlayerManager, PlayerStatus};
use crate::report::ReportId;
use crate::resources::maintenance::Maintenance;
use crate::world::World;

impl World {
  #[inline]
  pub fn player_manager(&self) -> &PlayerManager {
    &self.player_manager
  }

  #[inline]
  pub fn player(&self, id: &PlayerId) -> Result<&Player> {
    self.player_manager.player(id)
  }

  #[inline]
  pub(crate) fn player_mut(&mut self, id: &PlayerId) -> Result<&mut Player> {
    self.player_manager.player_mut(id)
  }

  pub fn players(&self) -> impl Iterator<Item = &Player> {
    self.player_manager.players()
  }

  #[inline]
  pub fn get_player_maintenance(&self, player: &PlayerId) -> Result<Maintenance> {
    self.get_maintenance(player)
  }

  pub fn get_player_military(&self, player: &PlayerId) -> Result<Military> {
    let coords = self.continent.coords_of(player);
    self.military.intersection(coords)
  }

  pub fn get_player_reports(&self, player: &PlayerId) -> Vec<ReportId> {
    self
      .report_manager
      .reports_of(player)
      .collect()
  }

  #[inline]
  pub fn has_player(&self, id: &PlayerId) -> bool {
    self.player_manager.has(id)
  }

  pub fn has_any_active_player(&self) -> bool {
    self
      .player_manager
      .players()
      .any(Player::is_active)
  }

  pub fn set_player_status(&mut self, id: &PlayerId, status: PlayerStatus) -> Result<()> {
    *self
      .player_manager
      .player_mut(id)?
      .status_mut() = status;

    self.emit_player_updated(id.clone())?;

    Ok(())
  }

  pub fn spawn_player(&mut self, mut player: Player) -> Result<()> {
    let id = player.id();
    if self.has_player(&id) {
      Err(Error::PlayerAlreadySpawned(id))
    } else {
      let (coord, field) = self.find_spawn_point()?;
      *field = City::builder(coord)
        .name(&*id)
        .owner(&id)
        .build()
        .into();

      *player.status_mut() = PlayerStatus::Active;
      self.player_manager.manage(player)?;

      self.emit_public_city_updated(coord)?;

      Ok(())
    }
  }
}