戦い11 - Behind Coleus

昨日はカレーを作った。

昨日の夜2年ほど使ったブルートゥースキーボードの電池が切れた。
マウスは2か月に1回電池切れるのに結構長いと思った。

今日は、カードのプレイを実装していこうと思う。

手札からプレイするカードを選択する→1枚を返せばいいだけだからこの前と一緒でイージー選択したカードがタクティクスだったら、そちらに移動選択したカードがファイターだったら、そちらに移動
明日は久しぶりに休みです - Behind Coleus

取り敢えずこれを実行する為に、
イベントを作った。

また、

pub fn transition_battle_or_play(
    mut next_state: ResMut<NextState<PlayState>>,
    mut select_attacker_event_writer: EventWriter<SelectAttacker>,
    mut select_hand_event_writer: EventWriter<SelectHand>,

    mut state_move_event_reader: EventReader<StateMove>,
) {
    for event in state_move_event_reader.read() {
        let choice = check_the_will_of_battle_or_play();

        match choice {
            1 => {
                println!("バトルに移行します");
                select_attacker_event_writer.send(SelectAttacker);
            }

            2 => {
                println!("カードプレイに移行します");
                select_hand_event_writer.send(SelectHand);
            }
            0 => {
                println!("メインフェーズ終了しました");
                next_state.set(PlayState::TurnEnd);
            }

            _ => {}
        }
    }
}

ここから、移動したいので、SelectHandイベントリーダーを使う。

あと、必要なリソースは、こちらのＳゾーン、手札、がある。

結構カードのタイプの分別が難しいような気がして、一つの関数におさめるのはやめた。

一度、Check_played_card_typeみたいな関数を通して、タイプを判別すればいいと思う。

pub fn select_a_hand(
    mut select_hand_event_reader: EventReader<SelectHand>,
    player1_hand: ResMut<Player1Hand>,
    player1_szone: ResMut<Player1SZone>,
    mut check_played_card_type_event_writer: EventWriter<CheckPlayedCardType>, 
    query: Query<(Entity, &Card, &SpinCondition), With<Player1>>,
) {
    for event in select_hand_event_reader.read() {
        let total_energy: u32 = player1_szone
            .cards
            .iter()
            .filter_map(|entity| {
                if let Ok*1 = query.get(*entity) {
                    if let SpinCondition::ReSpin = spincondition {
                        Some(card.energy) // リスピン中のカードのエナジーを取得
                    } else {
                        None
                    }
                } else {
                    None
                }
            })
            .sum();

        // 合計エナジーを表示
        println!(
            "現在のSゾーンのリスピン状態のカードの合計エナジー: {}",
            total_energy
        );

        // 手札のカードの情報を番号付きで表示
        println!("手札のカード:");
        for (index, &entity) in player1_hand.cards.iter().enumerate() {
            if let Ok*2 = query.get(entity) {
                println!("{}: {} [エナジー: {}]", index + 1, card.name, card.energy);
            }
        }

        // ユーザーからの入力を受け取る
        let mut input = String::new();
        io::stdin()
            .read_line(&mut input)
            .expect("Failed to read line");

        if let Ok(selected_index) = input.trim().parse::<usize>() {
            if selected_index > 0 && selected_index <= player1_hand.cards.len() {
                let selected_entity = player1_hand.cards[selected_index - 1];

                // 選択されたカードのエナジーが合計エナジー以下であることを確認
                if let Ok*3 = query.get(selected_entity) {
                    if card.energy <= total_energy {
                        println!("{} を選択しました。", card.name);
                        // 選択されたカードに対する処理を続ける
                        // play_fighter_event_writer.send(...);
                        check_played_card_type_event_writer.send(CheckPlayedCardType { played_card_id: selected_entity });
                    } else {
                        println!(
                            "選択したカードのエナジーが合計エナジーを超えています。再度選択してください。"
                        );
                    }
                }
            } else {
                println!("無効な選択です。");
            }
        } else {
            println!("有効な番号を入力してください。");
        }
    }
}

もうこれでいいんじゃない？
エネジーっていうのがくどいからなおした。

0を押すと戻らしたいので、イベントライターで、無効な選択ですのところに、プレイか、バトルかを選ぶのをつけた。

やっぱり、エナジーの表示はする必要が無いと考えた。何故なら、タクティクスで重要なのは必要エナジーだからだ。ただ、表示位してもいいと思った。

pub fn check_played_card_type(
    mut check_played_card_type_event_reader: EventReader<CheckPlayedCardType>,
    mut play_fighter_event_writer: EventWriter<PlayFighter>,
    mut play_tactics_evemt_writer: EventWriter<PlayTactics>,
    query: Query<(Entity, Option<&Fighter>, Option<&Tactics>)>,
) {
    for event in check_played_card_type_event_reader.read(){
        if let Ok*4 = query.get(event.played_card_id) {
            if fighter_option.is_some() {
                println!("{:?} はファイターです。", event.played_card_id);
                play_fighter_event_writer.send(PlayFighter { played_card_id: event.played_card_id });
                // ファイターに対する処理をここに追加
            } else if tactics_option.is_some() {
                println!("{:?} はタクティクスです。", event.played_card_id);
                play_tactics_evemt_writer.send(PlayTactics { played_card_id: event.played_card_id });
                // タクティクスに対する処理をここに追加
            } else {
                println!("{:?} はファイターでもタクティクスでもありません。", event.played_card_id);
            }
        } else {
            println!("{:?} は無効なエンティティです。", event.played_card_id);
        }
    }
}

この関数をつけて、条件分岐を起こした。

このあと、0エナジーのファイターには、スピンさせるカードを選ぶコードが必要ないことに気付いて、以下のように場合分けした。また、エナジーは表示した。

pub fn check_played_card_type(
    mut check_played_card_type_event_reader: EventReader<CheckPlayedCardType>,
    mut play_fighter_spin_szone_event_writer: EventWriter<PlayFighterSpinSzone>,
    mut play_zero_energy_fighter_event_writer: EventWriter<PlayZeroEnergyFighterFromHand>,
    mut play_tactics_spin_szone_event_writer: EventWriter<PlayTacticsSpinSzone>,
    query: Query<(Entity, &Card, Option<&Fighter>, Option<&Tactics>)>,
) {
    for event in check_played_card_type_event_reader.read() {
        if let Ok*5 = query.get(event.played_card_id) {
            if let Some(fighter) = fighter_option {
                println!(
                    "{} はファイターでエナジーは{}です。",
                    card.name, card.energy
                );
                if card.energy == 0 {
                    play_zero_energy_fighter_event_writer.send(PlayZeroEnergyFighterFromHand {
                        played_card_id: event.played_card_id,
                    });
                } else {
                    play_fighter_spin_szone_event_writer.send(PlayFighterSpinSzone {
                        played_card_id: event.played_card_id,
                    });
                }

                // ファイターに対する処理をここに追加
            } else if let Some(tactics) = tactics_option {
                println!(
                    "{} はタクティクスで必要エナジーは{}です。",
                    card.name, tactics.required_energy
                );
                play_tactics_spin_szone_event_writer.send(PlayTacticsSpinSzone {
                    played_card_id: event.played_card_id,
                });
                // タクティクスに対する処理をここに追加
            } else {
                println!(
                    "{:?} はファイターでもタクティクスでもありません。",
                    event.played_card_id
                );
            }
        } else {
            println!("{:?} は無効なエンティティです。", event.played_card_id);
        }
    }
}

簡単なプレイファイターからやっていく。

pub fn play_fighter_spin_szone(
    mut player1_szone: ResMut<Player1SZone>,
    mut play_fighter_spin_szone_event_reader: EventReader<PlayFighterSpinSzone>,
    query: Query<(Entity, &Card, &SpinCondition), With<Player1>>,
    mut commands: Commands,
    mut state_move_event_writer: EventWriter<StateMove>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    mut play_fighter_from_hand_event_writer: EventWriter<PlayFighterFromHand>,
) {
    for event in play_fighter_spin_szone_event_reader.read() {
        let mut available_cards = Vec::new();
        let mut spin_targets: Vec<Entity> = Vec::new();
        let mut sum_of_energy = 0;

        // played_cardのエナジーを取得
        let energy: u32 = if let Ok*6 = query.get(event.played_card_id) {
            card.energy
        } else {
            // played_cardが無効な場合の処理
            println!("無効なplayed_cardです。");
            continue; // 次のイベントに進む
        };

        // Sゾーンのカードをリストアップ
        for &entity in &player1_szone.cards {
            if let Ok*7 = query.get(entity) {
                if let SpinCondition::ReSpin = spincondition {
                    available_cards.push(entity);
                    println!(
                        "{}: {} (Sゾーン)[{}]",
                        available_cards.len(),
                        card.name,
                        card.energy
                    );
                }
            }
        }

        // played_cardのエナジーが0の場合の処理
        if energy == 0 {
            println!("played_cardのエナジーが0です。");
            // エナジーが0の場合の独自のロジックをここに追加
            continue; // または、特定の処理を実行
        }

        // 選択ループ
        while sum_of_energy < energy {
            println!(
                "スピンさせるカードを選択してください (1-{}) 0:やりなおす",
                available_cards.len()
            );

            let mut input = String::new();
            io::stdin()
                .read_line(&mut input)
                .expect("Failed to read line");

            if let Ok(selected_index) = input.trim().parse::<usize>() {
                if selected_index == 0 {
                    state_move_event_writer.send(StateMove);
                }
                if selected_index > 0 && selected_index <= available_cards.len() {
                    let selected_entity = available_cards[selected_index - 1];

                    // すでに選択されたカードか確認
                    if spin_targets.contains(&selected_entity) {
                        println!("このカードはすでに選択されています。");
                        continue; // 再選択を促す
                    }

                    if let Ok*8 = query.get(selected_entity) {
                        // スピンさせるカードのリストを作る
                        spin_targets.push(selected_entity);
                        sum_of_energy += card.energy;
                        println!(
                            "{} をスピンさせる対象として追加しました (現在の合計エナジー: {})",
                            card.name, sum_of_energy
                        );
                    }
                } else {
                    println!("無効な選択です。");
                }
            } else {
                println!("有効な番号を入力してください。");
            }
        }

        println!(
            "合計エナジーが達成されました。スピン対象: {:?}",
            spin_targets
        );
        for target in &spin_targets {
            if let Ok*9 = query.get(*target) {
                println!("- {} [エナジー: {}]", card.name, card.energy);
            }
        }

        let choice = check_the_will_of_spinning_cards();
        match choice {
            1 => {
                //エレメントについての言及は全くしていないことに注意！！

                println!("スピンさせました。");
                for target in &spin_targets {
                    commands.entity(*target).insert(SpinCondition::Spin);
                }
                play_fighter_from_hand_event_writer.send(PlayFighterFromHand {
                    played_card_id: event.played_card_id,
                    spin_cards_list: spin_targets,
                });
            }

            2 => {
                println!("やり直します");
                select_hand_event_writer.send(SelectHand);
            }
            _ => {}
        }

        // 今後の処理をここに追加（例: スピン実行など）
    }
}

pub fn check_the_will_of_spinning_cards() -> i32 {
    loop {
        println!("[1]:決定する [2]:やりなおす ");
        let mut input = String::new();
        io::stdin()
            .read_line(&mut input)
            .expect("Failed to read line");

        // 入力を整数に変換し、結果を返す
        match input.trim().parse::<i32>() {
            Ok(choice) if choice == 1 || choice == 2 => return choice,
            _ => println!("無効な選択です。もう一度入力してください。"),
        }
    }
}

この関数は長いが、何をしているかというと、スピン対象のリストが条件を満たすまで、入力を繰り返させる関数である。
また、それが完了した際に、入力を受け付けて、やり直すか選ぶという関数である。

取り敢えず一直線にはコストを選べるようになってる。

デバッグしてたら、

撤退する時、お互いのカードが混ざっていることに気付いたので、クエリにWith<Player1>をつけて直しました。

これで、撤退とＳゾーンの更新を確認しました

ただ、やり直しはできなかったので、直す。　ただ、大きな問題ではないから無視してもよさそうではある。

とりあえず、0コストのファイターの選択をした。

pub fn play_zero_energy_fighter(
    mut play_zero_energy_fighter_event_reader: EventReader<PlayZeroEnergyFighterFromHand>,
    mut commands: Commands,
    mut play_fighter_finish_event_writer: EventWriter<PlayFighterFinish>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    query: Query<(Entity, &Card, &Fighter), With<Player1>>
) {
    for event in play_zero_energy_fighter_event_reader.read(){
        if let Ok*10 = query.get(event.played_card_id) {
            println!("{}を手札から召喚しますか？", card.name);
        
        let choice = check_the_will_of_spinning_cards();
        match choice {
            1 => {
                //エレメントについての言及は全くしていないことに注意！！
                commands.entity(event.played_card_id).insert(Location::FZone);
                // Fighter コンポーネントを新しい summoned_sick で更新
            commands.entity(event.played_card_id).insert(Fighter {
                summoned_sick: true,
                ..*fighter
            }); // power はそのまま
                println!("{}を手札から召喚しました", card.name);
                println!("{:?}は召喚酔いをしています", event.played_card_id);
                play_fighter_finish_event_writer.send(PlayFighterFinish { played_card_id: event.played_card_id });                
            }

            2 => {
                println!("やり直します");
                select_hand_event_writer.send(SelectHand);
            }
            _ => {}
        }
    }
        
    }
}

0エナジーの時の処理
召喚酔いをさせるのを忘れないようにした。

 

pub fn play_fighter_from_hand(
    mut play_fighter_from_hand_event_reader: EventReader<PlayFighterFromHand>,
    mut commands: Commands,
    mut play_fighter_finish_event_writer: EventWriter<PlayFighterFinish>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    query: Query<(Entity, &Card, &Fighter), With<Player1>>
) {
    for event in play_fighter_from_hand_event_reader.read(){
        if let Ok*11 = query.get(event.played_card_id) {
            println!("{}を手札から召喚しますか？", card.name);
        
        let choice = check_the_will_of_spinning_cards();
        match choice {
            1 => {
                //エレメントについての言及は全くしていないことに注意！！
                commands.entity(event.played_card_id).insert(Location::FZone);
                // Fighter コンポーネントを新しい summoned_sick で更新
            commands.entity(event.played_card_id).insert(Fighter {
                summoned_sick: true,
                ..*fighter
            }); // power はそのまま
                println!("{}を手札から召喚しました", card.name);
                println!("{:?}は召喚酔いをしています", event.played_card_id);
                play_fighter_finish_event_writer.send(PlayFighterFinish { played_card_id: event.played_card_id });                
            }

            2 => {
                println!("やり直します");
                select_hand_event_writer.send(SelectHand);
            }
            _ => {}
        }
    }
        
    }
}

ほとんど一緒。

よく考えたら、既にスピンはさせちゃってるんだから、戻る時は、スピンを戻さないとだめだわ。

pub fn play_fighter_from_hand(
    mut play_fighter_from_hand_event_reader: EventReader<PlayFighterFromHand>,
    mut commands: Commands,
    mut play_fighter_finish_event_writer: EventWriter<PlayFighterFinish>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    query: Query<(Entity, &Card, &Fighter), With<Player1>>
) {
    for event in play_fighter_from_hand_event_reader.read(){
        if let Ok*12 = query.get(event.played_card_id) {
            println!("{}を手札から召喚しますか？", card.name);
        
        let choice = check_the_will_of_spinning_cards();
        match choice {
            1 => {
                //エレメントについての言及は全くしていないことに注意！！
                commands.entity(event.played_card_id).insert(Location::FZone);
                // Fighter コンポーネントを新しい summoned_sick で更新
            commands.entity(event.played_card_id).insert(Fighter {
                summoned_sick: true,
                ..*fighter
            }); // power はそのまま
                println!("{}を手札から召喚しました", card.name);
                println!("{:?}は召喚酔いをしています", event.played_card_id);
                play_fighter_finish_event_writer.send(PlayFighterFinish { played_card_id: event.played_card_id });                
            }

            2 => {
                println!("やり直します");
                for target in &event.spin_cards_list {
                    commands.entity(*target).insert(SpinCondition::Spin);
                }
                println!("スピンしたカードを元に戻しました。");
                select_hand_event_writer.send(SelectHand);
            }
            _ => {}
        }
    }
        
    }
}

また、そのままデータの更新システムに行くのではなく、
一旦空のイベントを挟むことで、後に効果処理を出来るようにしておく作戦がある。

pub fn play_fighter_finish(
    mut play_fighter_finish_event_reader: EventReader<PlayFighterFinish>,
    mut check_event_writer: EventWriter<CheckCard>,
) {
    for event in play_fighter_finish_event_reader.read() {
        check_event_writer.send(CheckCard);
    }
}

それがこれ、【召喚時】効果とかは、PlayFighterFinishが終われば起動するようにする。

タクティクスは、エナジーの調整が発生しうるかで場合分けしなければならない。

その場合分けは、エナジーの合計が10を超えるかどうかで考えた。

エナジーの調整のイベントには、プレイするカードと、スピンしたカードに加え、何エナジー調整しないといけないかという情報を記録させた。

pub fn play_tactics_spin_szone(
    player1_szone: ResMut<Player1SZone>,
    mut play_tactics_spin_szone_event_reader: EventReader<PlayTacticsSpinSzone>,
    query: Query<(Entity, &Card, &SpinCondition, &Tactics), With<Player1>>,
    query2: Query<(Entity, &Card, &SpinCondition), With<Player1>>,
    mut commands: Commands,
    mut state_move_event_writer: EventWriter<StateMove>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    mut play_tactics_from_hand_event_writer: EventWriter<PlayTacticsFromHand>,
    mut energy_adjustment_event_writer: EventWriter<EnergyAdjustment>,
) {
    for event in play_tactics_spin_szone_event_reader.read() {
        let mut available_cards = Vec::new();
        let mut spin_targets: Vec<Entity> = Vec::new();
        let mut sum_of_energy = 0;

        // played_cardのエナジーを取得
        let energy: u32 = if let Ok*13 = query.get(event.played_card_id) {
            tactics.required_energy
        } else {
            // played_cardが無効な場合の処理
            println!("無効なplayed_cardです。");
            continue; // 次のイベントに進む
        };

        // Sゾーンのカードをリストアップ
        for &entity in &player1_szone.cards {
            if let Ok*14 = query2.get(entity) {
                if let SpinCondition::ReSpin = spincondition {
                    available_cards.push(entity);
                    println!(
                        "{}: {} (Sゾーン)[{}]",
                        available_cards.len(),
                        card.name,
                        card.energy
                    );
                }
            }
        }

        // played_cardのエナジーが0の場合の処理
        if energy == 0 {
            println!("played_cardのエナジーが0です。");
            // エナジーが0の場合の独自のロジックをここに追加
            continue; // または、特定の処理を実行
        }

        // 選択ループ
        while sum_of_energy < energy {
            println!(
                "スピンさせるカードを選択してください (1-{}) 0:やりなおす",
                available_cards.len()
            );

            let mut input = String::new();
            io::stdin()
                .read_line(&mut input)
                .expect("Failed to read line");

            if let Ok(selected_index) = input.trim().parse::<usize>() {
                if selected_index > 0 && selected_index <= available_cards.len() {
                    let selected_entity = available_cards[selected_index - 1];

                    // すでに選択されたカードか確認
                    if spin_targets.contains(&selected_entity) {
                        println!("このカードはすでに選択されています。");
                        continue; // 再選択を促す
                    }

                    if let Ok*15 = query2.get(selected_entity) {
                        // スピンさせるカードのリストを作る
                        spin_targets.push(selected_entity);
                        sum_of_energy += card.energy;
                        println!(
                            "{} をスピンさせる対象として追加しました (現在の合計エナジー: {})",
                            card.name, sum_of_energy
                        );
                    }
                } else {
                    println!("無効な選択です。");
                    state_move_event_writer.send(StateMove);
                }
            } else {
                println!("有効な番号を入力してください。");
            }
        }

        println!(
            "合計エナジーが達成されました。スピン対象: {:?}",
            spin_targets
        );

        if let Ok*16 = query2.get(event.played_card_id) {
            sum_of_energy += card.energy;
        }
        if sum_of_energy > 10 {
            println!(
                "プレイするタクティクスも含めたエナジーは{}です。",
                sum_of_energy
            );
            println!("エナジーの調整が発生します。");
            for target in &spin_targets {
                if let Ok*17 = query2.get(*target) {
                    println!("- {} [エナジー: {}]", card.name, card.energy);
                }
            }
            let choice = check_the_will_of_spinning_cards();
            match choice {
                1 => {
                    //エレメントについての言及は全くしていないことに注意！！

                    println!("スピンさせました。");
                    for target in &spin_targets {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    energy_adjustment_event_writer.send(EnergyAdjustment {
                        played_card_id: event.played_card_id,
                        spin_cards_list: spin_targets,
                        penalty_energy: sum_of_energy - 10,
                    });
                }

                2 => {
                    println!("やり直します");
                    select_hand_event_writer.send(SelectHand);
                }
                _ => {}
            }
        } else {
            for target in &spin_targets {
                if let Ok*18 = query2.get(*target) {
                    println!("- {} [エナジー: {}]", card.name, card.energy);
                }
            }

            let choice = check_the_will_of_spinning_cards();
            match choice {
                1 => {
                    //エレメントについての言及は全くしていないことに注意！！

                    println!("スピンさせました。");
                    for target in &spin_targets {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    play_tactics_from_hand_event_writer.send(PlayTacticsFromHand {
                        played_card_id: event.played_card_id,
                        spin_cards_list: spin_targets,
                    });
                }

                2 => {
                    println!("やり直します");
                    select_hand_event_writer.send(SelectHand);
                }
                _ => {}
            }
        }

        // 今後の処理をここに追加（例: スピン実行など）
    }
}

違いは、必要エナジーをループの条件にしたことです。

そして、エナジーの調整イベントには、ペナルティに必要なエナジーも記録した。

エナジーの調整はちょっと難しいので、普通にプレイできるときの、デバグをする。

pub fn play_tactics_from_hand(
    mut play_tactics_from_hand_event_reader: EventReader<PlayTacticsFromHand>,
    mut commands: Commands,
    mut play_tactics_finish_event_writer: EventWriter<PlayTacticsFinish>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    query: Query<(Entity, &Card), With<Player1>>,
) {
    for event in play_tactics_from_hand_event_reader.read() {
        if let Ok*19 = query.get(event.played_card_id) {
            println!("{}を手札から発動しますか？", card.name);
            let choice = check_the_will_of_spinning_cards();
            match choice {
                1 => {
                    //エレメントについての言及は全くしていないことに注意！！
                    commands
                        .entity(event.played_card_id)
                        .insert(Location::SZone);
                    println!("{}を手札から発動しました", card.name);
                    play_tactics_finish_event_writer.send(PlayTacticsFinish {
                        played_card_id: event.played_card_id,
                    });
                }

                2 => {
                    println!("やり直します");
                    for target in &event.spin_cards_list {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    println!("スピンしたカードを元に戻しました。");
                    select_hand_event_writer.send(SelectHand);
                }
                _ => {}
            }
        }
    }
}

pub fn play_tactics_finish(
    mut play_tactics_finish_event_reader: EventReader<PlayTacticsFinish>,
    mut check_event_writer: EventWriter<CheckCard>,
) {
    for event in play_tactics_finish_event_reader.read() {
        check_event_writer.send(CheckCard);
    }
}

普通のプレイは、ほとんどplay fighterと一緒だが、召喚酔いが無いのと、手札から、Ｓゾーンに移動することが違う。

タクティクスは調整が無い状態で一直線ならプレイできた。　エナジーの調整になるかはチェックする。

エナジーの調整はできてないですねー。　
なんでだー？

と思ったけど、このsum of energyっていうのは、タクティクスをプレイするために使ったカードのエナジーの合計だから、Ｓゾーンのエナジーの合計と違うねん。
だから、直さないといけないね。

pub fn play_tactics_spin_szone(
    player1_szone: ResMut<Player1SZone>,
    mut play_tactics_spin_szone_event_reader: EventReader<PlayTacticsSpinSzone>,
    query: Query<(Entity, &Card, &SpinCondition, &Tactics), With<Player1>>,
    query2: Query<(Entity, &Card, &SpinCondition), With<Player1>>,
    mut commands: Commands,
    mut state_move_event_writer: EventWriter<StateMove>,
    mut select_hand_event_writer: EventWriter<SelectHand>,
    mut play_tactics_from_hand_event_writer: EventWriter<PlayTacticsFromHand>,
    mut energy_adjustment_event_writer: EventWriter<EnergyAdjustment>,
) {
    for event in play_tactics_spin_szone_event_reader.read() {
        let mut available_cards = Vec::new();
        let mut spin_targets: Vec<Entity> = Vec::new();
        let mut used_energy_for_tactics = 0;
        //Sゾーンのカードのエナジーの合計をスピンコンディション関係なく取得。
        let mut total_energy_in_szone: u32 = player1_szone
        .cards
        .iter()
        .filter_map(|entity| {
            if let Ok*20 = query2.get(*entity) {
               
                    Some(card.energy) // リスピン中のカードのエナジーを取得
                } else {
                    None
                }
        })
        .sum();


        // played_cardのエナジーを取得
        let energy: u32 = if let Ok*21 = query.get(event.played_card_id) {
            tactics.required_energy
        } else {
            // played_cardが無効な場合の処理
            println!("無効なplayed_cardです。");
            continue; // 次のイベントに進む
        };

        // Sゾーンのカードをリストアップ
        for &entity in &player1_szone.cards {
            if let Ok*22 = query2.get(entity) {
                if let SpinCondition::ReSpin = spincondition {
                    available_cards.push(entity);
                    println!(
                        "{}: {} (Sゾーン)[{}]",
                        available_cards.len(),
                        card.name,
                        card.energy
                    );
                }
            }
        }

        // played_cardのエナジーが0の場合の処理
        if energy == 0 {
            println!("played_cardのエナジーが0です。");
            // エナジーが0の場合の独自のロジックをここに追加
            continue; // または、特定の処理を実行
        }
        
        // 選択ループ
        while used_energy_for_tactics < energy {
            println!(
                "スピンさせるカードを選択してください (1-{}) 0:やりなおす",
                available_cards.len()
            );

            let mut input = String::new();
            io::stdin()
                .read_line(&mut input)
                .expect("Failed to read line");

            if let Ok(selected_index) = input.trim().parse::<usize>() {
                if selected_index > 0 && selected_index <= available_cards.len() {
                    let selected_entity = available_cards[selected_index - 1];

                    // すでに選択されたカードか確認
                    if spin_targets.contains(&selected_entity) {
                        println!("このカードはすでに選択されています。");
                        continue; // 再選択を促す
                    }

                    if let Ok*23 = query2.get(selected_entity) {
                        // スピンさせるカードのリストを作る
                        spin_targets.push(selected_entity);
                        used_energy_for_tactics += card.energy;
                        println!(
                            "{} をスピンさせる対象として追加しました (現在の合計使用エナジー: {})",
                            card.name, used_energy_for_tactics
                        );
                    }
                } else {
                    println!("無効な選択です。");
                    state_move_event_writer.send(StateMove);
                }
            } else {
                println!("有効な番号を入力してください。");
            }
        }

        println!(
            "合計エナジーが達成されました。スピン対象: {:?}",
            spin_targets
        );

        if let Ok*24 = query2.get(event.played_card_id) {
            total_energy_in_szone += card.energy;
            println!(
                "プレイするタクティクスも含めたエナジーは{}です。",
                total_energy_in_szone
            );
        }
        if total_energy_in_szone > 10 {
            
            println!("エナジーの調整が発生します。");
            for target in &spin_targets {
                if let Ok*25 = query2.get(*target) {
                    println!("- {} [エナジー: {}]", card.name, card.energy);
                }
            }
            let choice = check_the_will_of_spinning_cards();
            match choice {
                1 => {
                    //エレメントについての言及は全くしていないことに注意！！

                    println!("スピンさせました。");
                    for target in &spin_targets {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    energy_adjustment_event_writer.send(EnergyAdjustment {
                        played_card_id: event.played_card_id,
                        spin_cards_list: spin_targets,
                        penalty_energy: total_energy_in_szone - 10,
                    });
                }

                2 => {
                    println!("やり直します");
                    select_hand_event_writer.send(SelectHand);
                }
                _ => {}
            }
        } else {
            for target in &spin_targets {
                if let Ok*26 = query2.get(*target) {
                    println!("- {} [エナジー: {}]", card.name, card.energy);
                }
            }

            let choice = check_the_will_of_spinning_cards();
            match choice {
                1 => {
                    //エレメントについての言及は全くしていないことに注意！！

                    println!("スピンさせました。");
                    for target in &spin_targets {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    play_tactics_from_hand_event_writer.send(PlayTacticsFromHand {
                        played_card_id: event.played_card_id,
                        spin_cards_list: spin_targets,
                    });
                }

                2 => {
                    println!("やり直します");
                    select_hand_event_writer.send(SelectHand);
                }
                _ => {}
            }
        }

        // 今後の処理をここに追加（例: スピン実行など）
    }
}

わかりにくかった、sum_of_energyを、used_energy_for_tacticsという変数にかえ、
最初に、total_energy_in_szoneという数の計算を置いた。

これできてそうだ。エナジーの調整が発生することは、書いてある。
ただ、スピンさせるカードの情報とかの位置は微妙だな。UIは後でいじりまーす。
やり直しの実装について

これだと、一回スピンさせちゃったから、情報が更新されてなくて、ダメかも。
一度、CheckCardに戻ったほうがいいかも。
都は一旦思ったが、全然違った。

2 => {
                    println!("やり直します");
                    for target in &event.spin_cards_list {
                        commands.entity(*target).insert(SpinCondition::Spin);
                    }
                    println!("スピンしたカードを元に戻しました。");
                    select_hand_event_writer.send(SelectHand);
                }

やり直すとか言って、じつは、Spinさせていた事件が発覚。

なおしたら、できつぁ。

次、エナジーの調整のシステムを作っていく。
なお、調整しないといけないエナジーのは与えられた定数である。
・まず、もし、調整しないといけないエナジー以上のエナジーのカードがSゾーンにあれば、それらを表示して選択させる。この場合は1枚だけ選ぶことになる。
・なければ、Ｓゾーンのカード全てを表示し、カード1枚をSゾーンから選ばせる。
そして、その選んだカードのエナジーの合計を記録する。
・選んだカードの合計エナジーが調整しないといけないエナジーを上回るまで、繰り返す。なお、調整しないといけないエナジー以上のエナジーのカードがＳゾーンにあれば、それらだけを表示させるようにする。
・同じカードは選べない。

↑数学的には、1枚がダメだったら、2枚でいけるすべての組み合わせを表示し、2枚がダメだったら、3枚で行けるすべての組み合わせを表示しないといけない。4枚がダメだったら、4枚で行けるすべての組み合わせ...とやっていかないといけない。

ただ、それは面倒なので、このような繰り返しの方がいいかなと思う。