Struct PlayerController 

pub struct PlayerController<'a, A: PlayerAgent + ?Sized> {
    pub game: &'a GameState,
    pub player: PlayerId,
    pub agent: &'a mut A,
    pub full_controls: BTreeSet<FullControlFlag>,
}

Fields

game: &'a GameState

player: PlayerId

agent: &'a mut A

full_controls: BTreeSet<FullControlFlag>

Implementations

impl<'a, A: PlayerAgent + ?Sized> PlayerController<'a, A>

pub fn new(game: &'a GameState, player: PlayerId, agent: &'a mut A) -> Self

pub fn snapshot_state(&mut self, mana_pools: &[ManaPool])

pub fn available_priority_actions( &self, playable: &[PlayOption], tappable_lands: &[CardId], untappable_lands: &[CardId], activatable: &[(CardId, usize)], ) -> Vec<PlayerAction>

pub fn add_full_control(&mut self, flag: FullControlFlag)

pub fn remove_full_control(&mut self, flag: FullControlFlag)

pub fn has_full_control(&self, flag: FullControlFlag) -> bool

pub fn notify(&mut self, event: GameNotification)

pub fn reveal_cards( &mut self, cards: &[CardId], zone: ZoneType, owner: PlayerId, message_prefix: Option<&str>, )

pub fn temp_show_cards(&mut self, cards: &[CardId])

pub fn end_temp_show_cards(&mut self)

pub fn reveal_delayed(&mut self, delayed: &DelayedReveal)

pub fn choose_attackers( &mut self, available: &[CardId], possible_defenders: &[DefenderId], ) -> Vec<(CardId, DefenderId)>

pub fn choose_blockers( &mut self, attackers: &[CardId], available_blockers: &[CardId], max_blockers: Option<usize>, ) -> Vec<(CardId, CardId)>

pub fn choose_blocker_for( &mut self, attackers: &[CardId], blocker: CardId, ) -> Option<CardId>

pub fn exert_attackers(&mut self, attackers: &[CardId]) -> Vec<CardId>

pub fn enlist_attackers(&mut self, attackers: &[CardId]) -> Vec<CardId>

pub fn choose_damage_assignment_order( &mut self, attacker: CardId, blockers: &[CardId], ) -> Vec<CardId>

pub fn assign_combat_damage( &mut self, attacker: CardId, blockers_in_order: &[CardId], defender: Option<DefenderId>, damage_to_assign: i32, ) -> Vec<(Option<CardId>, i32)>

pub fn choose_target_player( &mut self, valid: &[PlayerId], sa: Option<&SpellAbility>, ) -> Option<PlayerId>

pub fn choose_target_card( &mut self, valid: &[CardId], sa: Option<&SpellAbility>, ) -> Option<CardId>

pub fn choose_target_any( &mut self, valid_players: &[PlayerId], valid_cards: &[CardId], sa: Option<&SpellAbility>, ) -> TargetChoice

pub fn choose_entities_for_effect( &mut self, candidates: &[GameEntity], min: usize, max: usize, ) -> Vec<GameEntity>

pub fn choose_single_entity_for_effect( &mut self, candidates: &[GameEntity], ) -> Option<GameEntity>

pub fn choose_cards_for_effect( &mut self, valid: &[CardId], min: usize, max: usize, ) -> Vec<CardId>

pub fn choose_cards_for_zone_change( &mut self, valid: &[CardId], min: usize, max: usize, select_prompt: &str, ) -> Vec<CardId>

pub fn choose_single_card_for_zone_change( &mut self, valid: &[CardId], select_prompt: &str, is_optional: bool, ) -> Option<CardId>

pub fn choose_type( &mut self, type_category: &str, valid_types: &[String], ) -> Option<String>

pub fn choose_some_type( &mut self, type_category: &str, valid_types: &[String], ) -> Option<String>

pub fn choose_number_from_list( &mut self, choices: &[i32], message: &str, source_card_id: Option<CardId>, ) -> Option<i32>

pub fn choose_binary( &mut self, question: &str, kind: BinaryChoiceKind, default_choice: Option<bool>, source: Option<CardId>, api: Option<ApiType>, ) -> bool

pub fn confirm_action( &mut self, mode: Option<&str>, message: &str, options: &[String], source: Option<CardId>, api: Option<ApiType>, ) -> bool

pub fn confirm_payment( &mut self, cost_kind: &str, message: &str, source: Option<CardId>, api: Option<ApiType>, ) -> bool

pub fn pay_cost_to_prevent_effect( &mut self, cost_kind: &str, message: &str, source: Option<CardId>, api: Option<ApiType>, can_pay: bool, targets: &[GameEntity], effect_text: &str, ) -> bool

pub fn confirm_bid_action( &mut self, mode: Option<&str>, message: &str, bid: i32, winner: Option<PlayerId>, ) -> bool

pub fn confirm_replacement_effect( &mut self, description: &str, source: Option<CardId>, ) -> bool

pub fn confirm_static_application( &mut self, message: &str, logic: Option<&str>, source: Option<CardId>, ) -> bool

pub fn choose_optional_trigger( &mut self, description: &str, source: Option<CardId>, api: Option<ApiType>, ) -> bool

pub fn choose_target_spell( &mut self, valid_entries: &[u32], source: Option<CardId>, ) -> Option<u32>

pub fn choose_mode( &mut self, descriptions: &[String], min: usize, max: usize, source_card_id: Option<CardId>, ) -> Vec<usize>

pub fn pay_mana_cost( &mut self, card_id: CardId, card_name: &str, mana_cost: &str, mana_cost_display: &str, mana_cost_checkpoint: &str, can_confirm_from_pool: bool, allow_reserved_source_reuse: bool, reserved_sacrifices: &[CardId], mana_ability_options: &[ManaAbilityOption], tappable_lands: &[CardId], untappable_lands: &[CardId], mana_pool: &ManaPool, ) -> ManaCostAction

pub fn pay_combat_cost( &mut self, attacker: CardId, cost: i32, description: &str, mana_ability_options: &[ManaAbilityOption], tappable_lands: &[CardId], untappable_lands: &[CardId], mana_pool_total: i32, ) -> CombatCostAction

pub fn decide_cost_part( &mut self, source: CardId, cost_part: &CostPart, ) -> Option<PaymentDecision>

pub fn order_cost_parts(&mut self, parts: Vec<CostPart>) -> Vec<CostPart>

pub fn choose_color(&mut self, valid_colors: &[String]) -> Option<String>

pub fn choose_card_name(&mut self, valid_names: &[String]) -> Option<String>

pub fn choose_scry( &mut self, source: Option<CardId>, cards: &[CardId], ) -> Vec<Vec<CardId>>

pub fn choose_surveil( &mut self, source: Option<CardId>, cards: &[CardId], ) -> Vec<Vec<CardId>>

pub fn choose_reorder_library(&mut self, cards: &[CardId]) -> Vec<CardId>

pub fn choose_discard(&mut self, hand: &[CardId], num: usize) -> Vec<CardId>

pub fn choose_random_discard( &mut self, hand: &[CardId], num: usize, ) -> Vec<CardId>

pub fn choose_delve( &mut self, valid: &[CardId], max: usize, source: Option<CardId>, ) -> Vec<CardId>

pub fn choose_improvise( &mut self, untapped_artifacts: &[CardId], remaining_cost: &ManaCost, source: Option<CardId>, ) -> Vec<CardId>

pub fn choose_convoke( &mut self, untapped_creatures: &[CardId], remaining_cost: &ManaCost, source: Option<CardId>, ) -> Vec<CardId>

pub fn specify_mana_combo( &mut self, available_colors: &[String], amount: usize, source: Option<CardId>, express_choice: Option<u16>, ) -> Vec<String>

pub fn choose_roll_swap_value( &mut self, current_result: i32, power: i32, toughness: i32, source: Option<CardId>, ) -> Option<RollSwapChoice>

pub fn reveal( &mut self, cards: &[CardId], zone: ZoneType, owner: PlayerId, message_prefix: Option<&str>, )

pub fn notify_of_value(&mut self, label: &str, value: &str)

pub fn choose_single_replacement_effect( &mut self, descriptions: &[String], ) -> usize

pub fn choose_land_or_spell(&mut self) -> Option<bool>

pub fn choose_sector(&mut self, sectors: &[String]) -> Option<String>

pub fn add_keyword_cost(&mut self, prompt: &str) -> bool

pub fn cheat_shuffle(&mut self)

pub fn reset_inputs(&mut self)

pub fn can_play_unlimited_lands(&self) -> bool