tbg 0.1.3

A library for implementing turn based games logic
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

use crate::cardinal::Point;
use crate::usize_wrapper::{CardID, DeckID, GridID, PlayerID};
#[derive(Serialize, Deserialize, Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub enum Zone {
    Grid(GridID, Point, Point),
    Deck(DeckID),
    Nowhere,
}

impl Zone {
    pub fn is_board(&self) -> bool {
        match self {
            Zone::Grid(_, _, _) => true,
            _ => false,
        }
    }

    pub fn is_deck(&self) -> bool {
        match self {
            Zone::Deck(_) => true,
            _ => false,
        }
    }

    pub fn is_nowhere(&self) -> bool {
        match self {
            Zone::Nowhere => true,
            _ => false,
        }
    }
}

#[derive(Serialize, Deserialize, Copy, Clone, PartialEq, Eq, Debug)]
pub enum Source {
    Game,
    Player(PlayerID),
    Card(CardID),
    Deck(DeckID),
    Grid(GridID),
    GridPoint(GridID, Point),
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
pub struct Phase<PhaseType>
where
    PhaseType: PartialEq + Eq,
{
    player: PlayerID,
    phase_type: PhaseType,
    time_limit: usize,
    time_current: usize,
}

impl<PhaseType> Phase<PhaseType>
where
    PhaseType: PartialEq + Eq,
{
    pub fn new(phase_type: PhaseType, time_limit: usize, player: PlayerID) -> Phase<PhaseType> {
        Phase {
            player,
            phase_type,
            time_limit,
            time_current: 0,
        }
    }

    pub fn player(&self) -> PlayerID {
        self.player
    }

    pub fn phase_type(&self) -> &PhaseType {
        &self.phase_type
    }

    pub fn is(&self, pt: PhaseType) -> bool {
        self.phase_type == pt
    }
}
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Default)]
pub struct LayeredEffect<Effect, EffectLayer> {
    pub layer: EffectLayer,
    pub effect: Effect,
    pub player: Option<PlayerID>,
    pub card: Option<CardID>,
}