A card game engine for TCGs, primarily Magic: The Gathering but with support for others
Restructuring the module a bit
+114
-89
-89
src/game.rs
-89
src/game.rs
···
1
-
use std::collections::HashMap;
2
-
use uuid::Uuid;
3
-
4
-
pub struct PlayerId(Uuid);
5
-
pub struct CardId(Uuid);
6
-
pub struct ZoneId(Uuid);
7
-
pub struct CardDefId(Uuid);
8
-
9
-
pub enum Phase {
10
-
Beginning(PlayerId),
11
-
PreCombatMain(PlayerId),
12
-
Combat(PlayerId),
13
-
PostCombatMain(PlayerId),
14
-
End(PlayerId)
15
-
}
16
-
17
-
pub struct GameState {
18
-
players: HashMap<PlayerId, Player>,
19
-
cards: HashMap<CardId, CardInstance>,
20
-
zones: HashMap<ZoneId, Zone>
21
-
}
22
-
23
-
pub struct CardInstance {
24
-
id: CardId,
25
-
definition_id: CardDefId,
26
-
owner: PlayerId,
27
-
zone: ZoneId,
28
-
tapped: bool
29
-
}
30
-
31
-
pub struct CardDefinition {
32
-
id: CardDefId,
33
-
name: String,
34
-
cost: u32,
35
-
// abilities: Vec<Ability>
36
-
// TODO: Implement abilities later
37
-
}
38
-
39
-
pub struct Zone {
40
-
id: ZoneId,
41
-
owner: PlayerId,
42
-
cards: Vec<CardId>,
43
-
zone_type: ZoneType,
44
-
visibility: ZoneVisibility
45
-
}
46
-
47
-
pub enum ZoneType {
48
-
Hand,
49
-
Library,
50
-
Graveyard,
51
-
Battlefield,
52
-
Exile,
53
-
Stack
54
-
}
55
-
56
-
pub enum ZoneVisibility {
57
-
Public,
58
-
HiddenToOpponent,
59
-
HiddenToAll
60
-
}
61
-
62
-
pub struct Player {
63
-
id: PlayerId,
64
-
life: i32,
65
-
// Zones owned by this player
66
-
hand: ZoneId,
67
-
library: ZoneId,
68
-
graveyard: ZoneId,
69
-
battlefield: ZoneId,
70
-
exile: ZoneId,
71
-
// Gameplay state
72
-
mana_pool: ManaPool,
73
-
// Status effects
74
-
poison_counters: u32,
75
-
energy_counters: u32,
76
-
rad_counters: u32,
77
-
ticket_counters: u32,
78
-
experience_counters: u32,
79
-
commander_damage: HashMap<PlayerId, u32>
80
-
}
81
-
82
-
pub struct ManaPool {
83
-
red: u32,
84
-
blue: u32,
85
-
green: u32,
86
-
white: u32,
87
-
black: u32,
88
-
colorless: u32
89
-
}
+40
src/game/card.rs
+40
src/game/card.rs
···
1
+
use uuid::Uuid;
2
+
use crate::game::{player::PlayerId, zone::ZoneId};
3
+
4
+
pub struct CardId(Uuid);
5
+
pub struct CardDefId(Uuid);
6
+
7
+
pub struct CardInstance {
8
+
id: CardId,
9
+
definition_id: CardDefId,
10
+
owner: PlayerId,
11
+
zone: ZoneId,
12
+
tapped: bool
13
+
}
14
+
15
+
pub struct CardDefinition {
16
+
id: CardDefId,
17
+
name: String,
18
+
cost: u32,
19
+
// abilities: Vec<Ability>
20
+
// TODO: Implement abilities later
21
+
}
22
+
23
+
impl CardDefinition {
24
+
pub fn new(name: String, cost: u32) -> Self {
25
+
Self {
26
+
id: CardDefId(Uuid::new_v4()),
27
+
name,
28
+
cost
29
+
}
30
+
}
31
+
}
32
+
33
+
pub struct ManaPool {
34
+
red: u32,
35
+
blue: u32,
36
+
green: u32,
37
+
white: u32,
38
+
black: u32,
39
+
colorless: u32
40
+
}
+25
src/game/player.rs
+25
src/game/player.rs
···
1
+
use uuid::Uuid;
2
+
use std::collections::HashMap;
3
+
use crate::game::{zone::ZoneId, card::ManaPool};
4
+
5
+
pub struct PlayerId(Uuid);
6
+
7
+
pub struct Player {
8
+
id: PlayerId,
9
+
life: i32,
10
+
// Zones owned by this player
11
+
hand: ZoneId,
12
+
library: ZoneId,
13
+
graveyard: ZoneId,
14
+
battlefield: ZoneId,
15
+
exile: ZoneId,
16
+
// Gameplay state
17
+
mana_pool: ManaPool,
18
+
// Status effects
19
+
poison_counters: u32,
20
+
energy_counters: u32,
21
+
rad_counters: u32,
22
+
ticket_counters: u32,
23
+
experience_counters: u32,
24
+
special_damage: HashMap<PlayerId, u32>
25
+
}
+18
src/game/state.rs
+18
src/game/state.rs
···
1
+
use crate::game::{player::{PlayerId, Player}, card::{CardId, CardInstance}, zone::{ZoneId, Zone}};
2
+
use std::collections::HashMap;
3
+
4
+
pub struct TurnOrder(Vec<PlayerId>);
5
+
6
+
pub enum Phase {
7
+
Beginning(PlayerId),
8
+
PreCombatMain(PlayerId),
9
+
Combat(PlayerId),
10
+
PostCombatMain(PlayerId),
11
+
End(PlayerId)
12
+
}
13
+
14
+
pub struct GameState {
15
+
players: HashMap<PlayerId, Player>,
16
+
cards: HashMap<CardId, CardInstance>,
17
+
zones: HashMap<ZoneId, Zone>
18
+
}
+27
src/game/zone.rs
+27
src/game/zone.rs
···
1
+
use uuid::Uuid;
2
+
use crate::game::{player::PlayerId, card::CardId};
3
+
4
+
pub struct ZoneId(Uuid);
5
+
6
+
pub struct Zone {
7
+
id: ZoneId,
8
+
owner: PlayerId,
9
+
cards: Vec<CardId>,
10
+
zone_type: ZoneType,
11
+
visibility: ZoneVisibility
12
+
}
13
+
14
+
pub enum ZoneType {
15
+
Hand,
16
+
Library,
17
+
Graveyard,
18
+
Battlefield,
19
+
Exile,
20
+
Stack
21
+
}
22
+
23
+
pub enum ZoneVisibility {
24
+
Public,
25
+
HiddenToOpponent,
26
+
HiddenToAll
27
+
}