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

use crate::attribute::Attribute;
use crate::misc::{Source, Zone};
use crate::usize_wrapper::{CardID, PlayerID};
use std::collections::{BTreeMap, BTreeSet};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct Card<CardType, AttName>
where
    AttName: Ord,
{
    id: CardID,
    owner: Option<PlayerID>,
    pub src: String,
    pub zone: Zone,
    pub card_type: CardType,
    pub created_by: Source,
    attributes: BTreeMap<AttName, Attribute>,
}

impl<CardType, AttName> Card<CardType, AttName>
where
    AttName: Default + Ord,
{
    pub fn new(
        id: CardID,
        card_type: CardType,
        owner: Option<PlayerID>,
    ) -> Card<CardType, AttName> {
        Card {
            id,
            owner: owner,
            src: "Default".to_string(),
            zone: Zone::Nowhere,
            card_type,
            created_by: Source::Game,
            attributes: Default::default(),
        }
    }

    pub fn id(&self) -> CardID {
        self.id
    }

    pub fn owner(&self) -> Option<PlayerID> {
        self.owner
    }

    pub fn int(&self, att: AttName) -> Option<isize> {
        self.attributes.get(&att)?.int()
    }

    pub fn text(&self, att: AttName) -> Option<&str> {
        self.attributes.get(&att)?.text()
    }

    pub fn flag(&self, att: AttName) -> Option<bool> {
        self.attributes.get(&att)?.flag()
    }

    pub fn set(&self, att: AttName) -> Option<&BTreeSet<Attribute>> {
        self.attributes.get(&att)?.set()
    }

    pub fn att(&mut self, name: AttName, att: Attribute) {
        self.attributes.insert(name, att);
    }
}