fn trigger_responses(
    &mut self,
    triggers: &Vec<game_engine::types::EventTrigger>,
    targets: &Vec<String>,
    game_dict: &game_engine::types::GameDictionary,
  ) -> HashMap<String, shared_types::ResponseData> {
    let mut responses: HashMap<String, shared_types::ResponseData> = HashMap::new();
    // check what the possible actions of anyone in the lobby are when a card is played or effect is activated
    // ex.. A targets B for Bang!, B has 2 missed cards and C can also choose to play a helping card to save B

    for (player_id, player_data) in self.player_data.iter() {
      let is_target = targets.contains(player_id);
      // Search Character abilities that may activate
      if let Some(character_data) = game_dict.character_dict.get(&player_data.character) {
        // if the player is one of the targets
        if triggers
          .iter()
          .any(|trigger| character_data.triggers.contains(trigger))
        {
          if is_target {
            if character_data.effect_optional {
              // let response_data: &mut shared_types::ResponseData = responses
              //   .entry(player_id.clone())
              //   .or_insert(shared_types::ResponseData {
              //     cards: Vec::new(),
              //     characters: Vec::new(),
              //   });
              // response_data.characters.push(character_data.)
            } else {
              // character_data.effect activate
            }
          } else {
            // player not target code
          }
        }
      }
      // Search Character Hand & Field for possible Card responses
      for card in player_data.card_iter() {
        if let Some(card_data) = game_dict.card_dict.get(&card.name) {
          if is_target {
            if triggers
              .iter()
              .any(|trigger| card_data.triggers.contains(trigger))
            {
              let response_data: &mut shared_types::ResponseData = responses
                .entry(player_id.clone())
                .or_insert(shared_types::ResponseData {
                  cards: Vec::new(),
                  characters: Vec::new(),
                });
              response_data.cards.push(card.name.clone());
            }
          } else {
            // player not target code
            // another player could play a card to assist or counter a player's move
          }
        }
      }
    }

    // send messages to players who have the option to use an ability,
    // execute those that activate by default

    // update all players on the activations that took place, then
    // send a message to all players and wait for their responses...

    return responses;
  }
/// This could be a card response or a character ability response.

This could be a card response or a character ability response.
This could be a card response or a character ability response .
fn trigger_responses(
    &mut self,
    triggers: &Vec<game_engine::types::EventTrigger>,
    targets: &Vec<String>,
    game_dict: &game_engine::types::GameDictionary,
  ) -> HashMap<String, shared_types::ResponseData> {
    let mut responses: HashMap<String, shared_types::ResponseData> = HashMap::new();
    // check what the possible actions of anyone in the lobby are when a card is played or effect is activated
    // ex.. A targets B for Bang!, B has 2 missed cards and C can also choose to play a helping card to save B
    for (player_id, player_data) in self.player_data.iter() {
      let is_target = targets.contains(player_id);
      // Search Character abilities that may activate
      if let Some(character_data) = game_dict.character_dict.get(&player_data.character) {
        // if the player is one of the targets
        if triggers
          .iter()
          .any(|trigger| character_data.triggers.contains(trigger))
        {
          if is_target {
            if character_data.effect_optional {
              // let response_data: &mut shared_types::ResponseData = responses
              //   .entry(player_id.clone())
              //   .or_insert(shared_types::ResponseData {
              //     cards: Vec::new(),
              //     characters: Vec::new(),
              //   });
              // response_data.characters.push(character_data.)
            } else {
              // character_data.effect activate
            }
          } else {
            // player not target code
          }
        }
      }
      // Search Character Hand & Field for possible Card responses
      for card in player_data.card_iter() {
        if let Some(card_data) = game_dict.card_dict.get(&card.name) {
          if is_target {
            if triggers
              .iter()
              .any(|trigger| card_data.triggers.contains(trigger))
            {
              let response_data: &mut shared_types::ResponseData = responses
                .entry(player_id.clone())
                .or_insert(shared_types::ResponseData {
                  cards: Vec::new(),
                  characters: Vec::new(),
                });
              response_data.cards.push(card.name.clone());
            }
          } else {
            // player not target code
            // another player could play a card to assist or counter a player's move
          }
        }
      }
    }
    // send messages to players who have the option to use an ability,
    // execute those that activate by default
    // update all players on the activations that took place, then
    // send a message to all players and wait for their responses...
    return responses;
  }
fn trigger_responses ( & mut self , triggers : & Vec < game_engine :: types :: EventTrigger > , targets : & Vec < String > , game_dict : & game_engine :: types :: GameDictionary , ) -> HashMap < String , shared_types :: ResponseData > { let mut responses : HashMap < String , shared_types :: ResponseData > = HashMap :: new ( ) ; // check what the possible actions of anyone in the lobby are when a card is played or effect is activated
 // ex.. A targets B for Bang!, B has 2 missed cards and C can also choose to play a helping card to save B
 for ( player_id , player_data ) in self . player_data . iter ( ) { let is_target = targets . contains ( player_id ) ; // Search Character abilities that may activate
 if let Some ( character_data ) = game_dict . character_dict . get ( & player_data . character ) { // if the player is one of the targets
 if triggers . iter ( ) . any ( | trigger | character_data . triggers . contains ( trigger ) ) { if is_target { if character_data . effect_optional { // let response_data: &mut shared_types::ResponseData = responses
 //   .entry(player_id.clone())
 //   .or_insert(shared_types::ResponseData {
 //     cards: Vec::new(),
 //     characters: Vec::new(),
 //   });
 // response_data.characters.push(character_data.)
 } else { // character_data.effect activate
 } } else { // player not target code
 } } } // Search Character Hand & Field for possible Card responses
 for card in player_data . card_iter ( ) { if let Some ( card_data ) = game_dict . card_dict . get ( & card . name ) { if is_target { if triggers . iter ( ) . any ( | trigger | card_data . triggers . contains ( trigger ) ) { let response_data : & mut shared_types :: ResponseData = responses . entry ( player_id . clone ( ) ) . or_insert ( shared_types :: ResponseData { cards : Vec :: new ( ) , characters : Vec :: new ( ) , } ) ; response_data . cards . push ( card . name . clone ( ) ) ; } } else { // player not target code
 // another player could play a card to assist or counter a player's move
 } } } } // send messages to players who have the option to use an ability,
 // execute those that activate by default
 // update all players on the activations that took place, then
 // send a message to all players and wait for their responses...
 return responses ; }
This could be a card response or a character ability response.
This could be a card response or a character ability response .
&mut self
triggers
&Vec<game_engine::types::EventTrigger>
targets
&Vec<String>
game_dict
&game_engine::types::GameDictionary
&mut self
triggers
&Vec<game_engine::types::EventTrigger>
targets
&Vec<String>
game_dict
&game_engine::types::GameDictionary