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
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

//! AlterAttribute — change a creature's attribute (Plotted, Suspected, etc.).
//! Ported from Java's AlterAttributeEffect: toggles various card attributes
//! like Plotted, Harnessed, Solved, Suspected, Saddled, Commander.

use forge_foundation::ZoneType;

use super::EffectContext;
use crate::ability::ability_ir::DefinedRef;
use crate::event::RunParams;
use crate::ids::CardId;
use crate::trigger::TriggerType;

/// Struct form of this effect so it can participate in the
/// `SpellAbilityEffect` trait hierarchy — mirrors Java's
/// `AlterAttributeEffect` class extending `SpellAbilityEffect`.
#[manabrew_engine_macros::spell_effect(AlterAttributeEffect)]
fn resolve(ctx: &mut EffectContext, sa: &crate::spellability::SpellAbility) {
    let activate = sa.ir.alter_attribute_activate;
    let attributes = &sa.ir.alter_attribute_attributes;

    let targets: Vec<CardId> = if let Some(target) = sa.target_chosen.target_card {
        vec![target]
    } else if let Some(source) = sa.source {
        if let Some(def) = sa.defined_ref() {
            if matches!(def, DefinedRef::SelfCard) {
                vec![source]
            } else {
                ctx.game.card(source).remembered_cards.clone()
            }
        } else {
            vec![source]
        }
    } else {
        return;
    };

    for card_id in targets {
        if ctx.game.card(card_id).zone == ZoneType::None {
            continue;
        }

        for attr in attributes {
            match attr.as_str() {
                "Harnessed" => {
                    let val = if activate { "True" } else { "False" };
                    ctx.game.card_mut(card_id).set_s_var("Harnessed", val);
                }
                "Plotted" => {
                    let val = if activate { "True" } else { "False" };
                    ctx.game.card_mut(card_id).set_s_var("Plotted", val);
                }
                "Solve" | "Solved" => {
                    let val = if activate { "True" } else { "False" };
                    ctx.game.card_mut(card_id).set_s_var("Solved", val);
                    if activate {
                        ctx.trigger_handler.run_trigger(
                            TriggerType::CaseSolved,
                            RunParams {
                                card: Some(card_id),
                                player: Some(sa.activating_player),
                                ..Default::default()
                            },
                            false,
                        );
                    }
                }
                "Suspect" | "Suspected" => {
                    if activate {
                        // Suspected creatures have menace and can't block
                        if !ctx.game.card(card_id).keywords.contains_string("Menace") {
                            ctx.game.card_mut(card_id).add_intrinsic_keyword("Menace");
                        }
                        ctx.game.card_mut(card_id).set_s_var("Suspected", "True");
                    } else {
                        ctx.game
                            .card_mut(card_id)
                            .remove_intrinsic_keyword("Menace");
                        ctx.game.card_mut(card_id).remove_s_var("Suspected");
                    }
                }
                "Saddle" | "Saddled" => {
                    let first_time = !ctx.game.card(card_id).has_s_var("SaddledBy");
                    let val = if activate { "True" } else { "False" };
                    ctx.game.card_mut(card_id).set_s_var("Saddled", val);
                    if activate {
                        if let Some(source) = sa.source {
                            ctx.game.card_mut(card_id).add_saddled_by_this_turn(source);
                        }
                        ctx.trigger_handler.run_trigger(
                            TriggerType::BecomesSaddled,
                            RunParams {
                                card: Some(card_id),
                                player: Some(sa.activating_player),
                                first_time: Some(first_time),
                                ..Default::default()
                            },
                            false,
                        );
                    }
                }
                "Commander" => {
                    let val = if activate { "True" } else { "False" };
                    ctx.game.card_mut(card_id).set_s_var("IsCommander", val);
                }
                _ => {}
            }

            if sa.ir.remember_altered {
                if let Some(source) = sa.source {
                    ctx.game.card_mut(source).add_remembered_card(card_id);
                }
            }
        }
    }
}