manabrew-engine 0.6.0

Magic: The Gathering rules engine — a Rust port of Forge
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::game::GameState;
use crate::ids::{CardId, PlayerId};
use crate::player::player_predicates;
use forge_foundation::ZoneType;

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PlayerCollection(pub Vec<PlayerId>);

impl IntoIterator for PlayerCollection {
    type Item = PlayerId;
    type IntoIter = std::vec::IntoIter<PlayerId>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

impl<'a> IntoIterator for &'a PlayerCollection {
    type Item = &'a PlayerId;
    type IntoIter = std::slice::Iter<'a, PlayerId>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter()
    }
}

impl PlayerCollection {
    pub fn new(players: Vec<PlayerId>) -> Self {
        Self(players)
    }

    pub fn alive(game: &GameState) -> Self {
        Self(game.alive_players())
    }

    pub fn opponents_of(game: &GameState, player: PlayerId) -> Self {
        Self(
            game.player_order
                .iter()
                .copied()
                .filter(|&pid| player_predicates::is_opponent_of(game, player, pid))
                .collect(),
        )
    }

    pub fn teammates_of(game: &GameState, player: PlayerId) -> Self {
        Self(
            game.player_order
                .iter()
                .copied()
                .filter(|&pid| player_predicates::same_team(game, player, pid))
                .collect(),
        )
    }

    pub fn contains(&self, player: PlayerId) -> bool {
        self.0.contains(&player)
    }

    pub fn cards_in(&self, game: &GameState, zone: ZoneType) -> Vec<CardId> {
        self.0
            .iter()
            .flat_map(|&pid| game.cards_in_zone(zone, pid).iter().copied())
            .collect()
    }

    pub fn cards_in_zones(
        &self,
        game: &GameState,
        zones: impl IntoIterator<Item = ZoneType>,
    ) -> Vec<CardId> {
        zones
            .into_iter()
            .flat_map(|zone| self.cards_in(game, zone))
            .collect()
    }

    pub fn creatures_in_play(&self, game: &GameState) -> Vec<CardId> {
        self.cards_in(game, ZoneType::Battlefield)
            .into_iter()
            .filter(|&cid| game.card(cid).is_creature())
            .collect()
    }

    pub fn filter<F>(&self, predicate: F) -> Self
    where
        F: Fn(PlayerId) -> bool,
    {
        Self(
            self.0
                .iter()
                .copied()
                .filter(|&pid| predicate(pid))
                .collect(),
        )
    }

    pub fn min<F>(&self, score: F) -> Option<PlayerId>
    where
        F: Fn(PlayerId) -> i32,
    {
        self.0.iter().copied().min_by_key(|&pid| score(pid))
    }

    pub fn max<F>(&self, score: F) -> Option<PlayerId>
    where
        F: Fn(PlayerId) -> i32,
    {
        self.0.iter().copied().max_by_key(|&pid| score(pid))
    }

    pub fn sum<F>(&self, score: F) -> i32
    where
        F: Fn(PlayerId) -> i32,
    {
        self.0.iter().copied().map(score).sum()
    }
}