manabrew-engine 0.4.1

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

//! Remove counters from source as a cost. Mirrors Java's `CostRemoveCounter`.

use crate::card::CounterType;
use crate::game::GameState;
use crate::ids::{CardId, PlayerId};

pub fn pay_as_decided(
    game: &mut GameState,
    source: CardId,
    amount: i32,
    counter_type: &CounterType,
) -> bool {
    game.card_mut(source).remove_counter(counter_type, amount);
    true
}

/// Refund by adding counters back.
pub fn refund(game: &mut GameState, source: CardId, amount: i32, counter_type: &CounterType) {
    game.card_mut(source).add_counter(counter_type, amount);
}

pub fn can_pay(game: &GameState, source: CardId, part: &super::CostPart) -> bool {
    let super::CostPart::SubCounter {
        amount,
        counter_type,
        type_filter,
    } = part
    else {
        return false;
    };
    let controller = game.card(source).controller;
    can_pay_for_player(
        game,
        source,
        controller,
        amount.resolve(game, source, controller),
        counter_type,
        type_filter,
    )
}

pub fn can_pay_for_player(
    game: &GameState,
    source: CardId,
    player: PlayerId,
    amount: i32,
    counter_type: &CounterType,
    type_filter: &str,
) -> bool {
    if !type_filter.eq_ignore_ascii_case("CARDNAME")
        && !type_filter.eq_ignore_ascii_case("NICKNAME")
    {
        return super::get_sub_counter_targets(game, player, source, type_filter)
            .into_iter()
            .any(|cid| game.card(cid).counter_count(counter_type) >= amount);
    }
    let card = game.card(source);
    if card.zone != forge_foundation::ZoneType::Battlefield || card.phased_out {
        return false;
    }
    card.counter_count(counter_type) >= amount
}