nil-core 0.5.3

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

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

use crate::continent::ContinentKey;
use crate::error::Result;
use crate::infrastructure::storage::{
  OverallStorageCapacity,
  OverallStorageCapacityWeight,
  StorageCapacityWeight,
};
use crate::ruler::Ruler;
use crate::world::World;

impl World {
  pub fn get_storage_capacity<R>(&self, ruler: R) -> Result<OverallStorageCapacity>
  where
    R: Into<Ruler>,
  {
    let stats = &self.stats.infrastructure;
    self
      .continent
      .cities_of(ruler)
      .try_fold(OverallStorageCapacity::default(), |mut acc, city| {
        acc += city.storage_capacity(stats)?;
        Ok(acc)
      })
  }

  pub fn get_storage_capacity_weight<K>(&self, key: K) -> Result<OverallStorageCapacityWeight>
  where
    K: ContinentKey,
  {
    let stats = &self.stats.infrastructure;
    let city = key
      .into_coord(self.continent.size())
      .and_then(|coord| self.city(coord))?;

    let capacity = city.storage_capacity(stats)?;
    let total = self.get_storage_capacity(city.owner().clone())?;

    let mut weight = OverallStorageCapacityWeight::new(city.coord());

    macro_rules! set_weight {
      ($($storage:ident),+ $(,)?) => {
        $(
          if *total.$storage > 0u32 {
            let value = f64::from(capacity.$storage) / f64::from(total.$storage);
            weight.$storage = StorageCapacityWeight::from(value);
            debug_assert!(value.is_normal());
          }
        )+
      };
    }

    set_weight!(silo, warehouse);

    Ok(weight)
  }
}