entropy-game 0.2.3

Game with enrtopy in memory.
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 ordered_float::NotNan;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

use crate::node::NodeID;

#[derive(
    Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize, ToSchema,
)]
pub struct GID(pub u64);
impl GID {
    pub fn get_then_increase(&mut self) -> GID {
        let rtn = self.clone();
        self.0 += 1;
        rtn
    }
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, ToSchema)]
pub struct Guest {
    pub id: GID,
    pub node: NodeID,
    pub energy: u64,
    pub walk_cost: u64,
    temperature: u8,
    #[schema(value_type = f32)]
    engine_efficiency: NotNan<f32>,
}

impl Guest {
    /// used by World::Spawn
    pub(crate) fn new(id: GID, node: NodeID) -> Guest {
        Guest {
            id,
            node,
            temperature: 128,
            energy: 100u64,
            engine_efficiency: NotNan::new(0.8).unwrap(),
            walk_cost: 1u64,
        }
    }

    pub(crate) fn is_energy_enough(&self, cost: u64) -> bool {
        self.energy >= cost
    }

    pub(crate) fn carnot_efficiency(&self, cell: &u8) -> f32 {
        let s = unsafe { NotNan::new_unchecked(self.temperature as f32) };
        let o = unsafe { NotNan::new_unchecked(*cell as f32) };
        let (h, c) = if s > o { (*s, *o) } else { (*o, *s) };
        1f32 - c / h
    }

    pub(crate) fn total_efficiency(&self, cell: &u8) -> f32 {
        *self.engine_efficiency * self.carnot_efficiency(cell)
    }

    /// Return the energy generated by the guest.
    /// The guest will generate energy based on its temperature.
    /// If the guest is hotter than the cell, it will consume the cell's energy and increase its own temperature.
    /// If the guest is colder than the cell, it will produce energy and decrease its own temperature.
    /// The guest will also lose some of its energy for the efficiency cost.
    pub(crate) fn generate_energy(&mut self, cell: &mut u8) -> u8 {
        // Calculate the delta energy first, for borrow check
        let delta = self.temperature.abs_diff(*cell);
        let delta = (self.total_efficiency(cell) * delta as f32).floor() as u8;

        // no overflow will happen, the efficiency proves that, so no need to check

        // Determine which temperature is hotter and colder.
        // and go change
        if self.temperature > *cell {
            self.temperature -= delta;
            *cell += delta;
        } else if self.temperature < *cell {
            self.temperature += delta;
            *cell -= delta;
        } else {
            ()
        };

        self.energy += delta as u64;
        delta
    }
}