647 lines
32 KiB
Rust
647 lines
32 KiB
Rust
use std::cell::Cell;
|
|
use std::collections::VecDeque;
|
|
|
|
use futures::channel::mpsc::UnboundedSender;
|
|
use gloo_storage::Storage as _;
|
|
use leptos::prelude::*;
|
|
use trictrac_store::{
|
|
Board as StoreBoard, CheckerMove, Color, Dice as StoreDice, Jan, MoveError, MoveRules,
|
|
};
|
|
|
|
use super::board::{bar_matched_dice_used, Board};
|
|
use super::die::Die;
|
|
use crate::app::{GameUiState, NetCommand, PauseReason};
|
|
use crate::game::trictrac::types::{PlayerAction, PreGameRollState, SerStage, SerTurnStage};
|
|
use crate::i18n::*;
|
|
use crate::portal::lobby::{qr_svg, room_url};
|
|
|
|
use super::score_panel::MergedScorePanel;
|
|
use super::scoring::ScoringPanel;
|
|
|
|
#[component]
|
|
pub fn GameScreen(state: GameUiState) -> impl IntoView {
|
|
let i18n = use_i18n();
|
|
|
|
let vs = state.view_state.clone();
|
|
let vs_board = vs.board;
|
|
let vs_dice = vs.dice;
|
|
let player_id = state.player_id;
|
|
let is_my_turn = vs.active_mp_player == Some(player_id);
|
|
let is_move_stage = is_my_turn
|
|
&& matches!(
|
|
vs.turn_stage,
|
|
SerTurnStage::Move | SerTurnStage::HoldOrGoChoice
|
|
);
|
|
let waiting_for_confirm = state.waiting_for_confirm;
|
|
let pause_reason = state.pause_reason.clone();
|
|
let suppress_dice_anim = state.suppress_dice_anim;
|
|
|
|
// ── Hovered jan moves (shown as arrows on the board) ──────────────────────
|
|
let hovered_jan_moves: RwSignal<Vec<(CheckerMove, CheckerMove)>> = RwSignal::new(vec![]);
|
|
provide_context(hovered_jan_moves);
|
|
|
|
// ── Staged move state ──────────────────────────────────────────────────────
|
|
let selected_origin: RwSignal<Option<u8>> = RwSignal::new(None);
|
|
let staged_moves: RwSignal<Vec<(u8, u8)>> = RwSignal::new(Vec::new());
|
|
|
|
let cmd_tx = use_context::<UnboundedSender<NetCommand>>()
|
|
.expect("UnboundedSender<NetCommand> not found in context");
|
|
let pending =
|
|
use_context::<RwSignal<VecDeque<GameUiState>>>().expect("pending not found in context");
|
|
let cmd_tx_effect = cmd_tx.clone();
|
|
let prev_staged_len = Cell::new(0usize);
|
|
|
|
// ── Free-play mode ─────────────────────────────────────────────────────────
|
|
fn load_free_mode() -> bool {
|
|
gloo_storage::LocalStorage::get::<bool>("trictrac_free_mode").unwrap_or(false)
|
|
}
|
|
fn save_free_mode(val: bool) {
|
|
gloo_storage::LocalStorage::set("trictrac_free_mode", val).ok();
|
|
}
|
|
let free_mode: RwSignal<bool> = RwSignal::new(load_free_mode());
|
|
let move_error: RwSignal<Option<Option<MoveError>>> = RwSignal::new(None);
|
|
|
|
Effect::new(move |_| {
|
|
let moves = staged_moves.get();
|
|
let n = moves.len();
|
|
if n > prev_staged_len.get() {
|
|
crate::game::sound::play_checker_move();
|
|
}
|
|
prev_staged_len.set(n);
|
|
if n == 2 {
|
|
let to_cm = |&(from, to): &(u8, u8)| {
|
|
CheckerMove::new(from as usize, to as usize).unwrap_or_default()
|
|
};
|
|
let m1 = to_cm(&moves[0]);
|
|
let m2 = to_cm(&moves[1]);
|
|
|
|
if free_mode.get_untracked() {
|
|
let (vm1, vm2) = if player_id == 0 {
|
|
(m1, m2)
|
|
} else {
|
|
(m1.mirror(), m2.mirror())
|
|
};
|
|
let mut store_board = StoreBoard::new();
|
|
store_board.set_positions(&Color::White, vs_board);
|
|
let store_dice = StoreDice { values: vs_dice };
|
|
let color = if player_id == 0 {
|
|
Color::White
|
|
} else {
|
|
Color::Black
|
|
};
|
|
let rules = MoveRules::new(&color, &store_board, store_dice);
|
|
if rules.moves_follow_rules(&(vm1, vm2)) {
|
|
cmd_tx_effect
|
|
.unbounded_send(NetCommand::Action(PlayerAction::Move(m1, m2)))
|
|
.ok();
|
|
staged_moves.set(vec![]);
|
|
selected_origin.set(None);
|
|
prev_staged_len.set(0);
|
|
} else {
|
|
let specific_err = rules.moves_allowed(&(vm1, vm2)).err();
|
|
move_error.set(Some(specific_err));
|
|
// Keep staged_moves intact so pieces stay in place until Retry is clicked.
|
|
}
|
|
} else {
|
|
cmd_tx_effect
|
|
.unbounded_send(NetCommand::Action(PlayerAction::Move(m1, m2)))
|
|
.ok();
|
|
staged_moves.set(vec![]);
|
|
selected_origin.set(None);
|
|
prev_staged_len.set(0);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ── Auto-roll effect ─────────────────────────────────────────────────────
|
|
let show_roll =
|
|
is_my_turn && vs.turn_stage == SerTurnStage::RollDice && vs.stage != SerStage::PreGameRoll;
|
|
if show_roll && !waiting_for_confirm {
|
|
let cmd_tx_auto = cmd_tx.clone();
|
|
Effect::new(move |_| {
|
|
cmd_tx_auto
|
|
.unbounded_send(NetCommand::Action(PlayerAction::Roll))
|
|
.ok();
|
|
});
|
|
}
|
|
|
|
let dice = vs.dice;
|
|
let show_dice = dice != (0, 0);
|
|
|
|
// ── Button senders ─────────────────────────────────────────────────────────
|
|
let cmd_tx_go = cmd_tx.clone();
|
|
let cmd_tx_end_quit = cmd_tx.clone();
|
|
let cmd_tx_end_replay = cmd_tx.clone();
|
|
let show_hold_go = is_my_turn
|
|
&& vs.turn_stage == SerTurnStage::HoldOrGoChoice
|
|
&& state.my_scored_event.is_none();
|
|
|
|
// ── Valid move sequences for this turn ─────────────────────────────────────
|
|
let valid_sequences: Vec<(CheckerMove, CheckerMove)> = if is_move_stage && dice != (0, 0) {
|
|
let mut store_board = StoreBoard::new();
|
|
store_board.set_positions(&Color::White, vs.board);
|
|
let store_dice = StoreDice { values: dice };
|
|
let color = if player_id == 0 {
|
|
Color::White
|
|
} else {
|
|
Color::Black
|
|
};
|
|
let rules = MoveRules::new(&color, &store_board, store_dice);
|
|
let raw = rules.get_possible_moves_sequences(true, vec![]);
|
|
if player_id == 0 {
|
|
raw
|
|
} else {
|
|
raw.into_iter()
|
|
.map(|(m1, m2)| (m1.mirror(), m2.mirror()))
|
|
.collect()
|
|
}
|
|
} else {
|
|
vec![]
|
|
};
|
|
let valid_seqs_empty = valid_sequences.clone();
|
|
|
|
// ── Scores ─────────────────────────────────────────────────────────────────
|
|
let my_score = vs.scores[player_id as usize].clone();
|
|
let opp_score = vs.scores[1 - player_id as usize].clone();
|
|
|
|
// ── Ceremony state ──────────────────────────────────────────────────────────
|
|
let is_ceremony = vs.stage == SerStage::PreGameRoll;
|
|
let pre_game_roll_data: Option<PreGameRollState> = vs.pre_game_roll.clone();
|
|
let my_name_ceremony = my_score.name.clone();
|
|
let opp_name_ceremony = opp_score.name.clone();
|
|
let cmd_tx_ceremony = cmd_tx.clone();
|
|
|
|
// ── Scoring notifications ──────────────────────────────────────────────────
|
|
let my_scored_event = state.my_scored_event.clone();
|
|
let opp_scored_event = state.opp_scored_event.clone();
|
|
|
|
let my_pts_earned: u8 = my_scored_event.as_ref().map_or(0, |e| {
|
|
if e.holes_gained == 0 {
|
|
e.points_earned
|
|
} else {
|
|
0
|
|
}
|
|
});
|
|
let opp_pts_earned: u8 = opp_scored_event.as_ref().map_or(0, |e| {
|
|
if e.holes_gained == 0 {
|
|
e.points_earned
|
|
} else {
|
|
0
|
|
}
|
|
});
|
|
let my_holes_gained_score: u8 = my_scored_event.as_ref().map_or(0, |e| e.holes_gained);
|
|
let opp_holes_gained_score: u8 = opp_scored_event.as_ref().map_or(0, |e| e.holes_gained);
|
|
let my_bredouille_flash: bool = my_scored_event
|
|
.as_ref()
|
|
.map_or(false, |e| e.bredouille && e.holes_gained > 0);
|
|
|
|
let is_double_dice = dice.0 == dice.1 && dice.0 != 0;
|
|
|
|
let last_moves = state.last_moves;
|
|
|
|
let hit_fields: Vec<u8> = {
|
|
let is_hit_jan = |jan: &Jan| {
|
|
matches!(
|
|
jan,
|
|
Jan::TrueHitSmallJan
|
|
| Jan::TrueHitBigJan
|
|
| Jan::TrueHitOpponentCorner
|
|
| Jan::FalseHitSmallJan
|
|
| Jan::FalseHitBigJan
|
|
)
|
|
};
|
|
let mut fields: Vec<u8> = vec![];
|
|
for event_opt in [&my_scored_event, &opp_scored_event] {
|
|
if let Some(event) = event_opt {
|
|
for entry in &event.jans {
|
|
if is_hit_jan(&entry.jan) {
|
|
for (m1, m2) in &entry.moves {
|
|
for m in [m1, m2] {
|
|
let to = m.get_to() as u8;
|
|
if to != 0 && !fields.contains(&to) {
|
|
fields.push(to);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fields
|
|
};
|
|
|
|
// ── Sound effects ──────────────────────────────────────────────────────────
|
|
let active_is_move_stage = matches!(
|
|
vs.turn_stage,
|
|
SerTurnStage::Move | SerTurnStage::HoldOrGoChoice
|
|
);
|
|
if show_dice && last_moves.is_none() && active_is_move_stage && !suppress_dice_anim {
|
|
crate::game::sound::play_dice_roll();
|
|
}
|
|
if last_moves.is_some() {
|
|
crate::game::sound::play_checker_move();
|
|
}
|
|
if let Some(ref ev) = my_scored_event {
|
|
if ev.holes_gained > 0 {
|
|
crate::game::sound::play_hole_scored();
|
|
}
|
|
}
|
|
if let Some(ref ev) = opp_scored_event {
|
|
if ev.holes_gained > 0 {
|
|
crate::game::sound::play_opp_hole_scored();
|
|
}
|
|
}
|
|
|
|
// ── Capture for closures ───────────────────────────────────────────────────
|
|
let stage = vs.stage.clone();
|
|
let turn_stage = vs.turn_stage.clone();
|
|
let turn_stage_for_panel = turn_stage.clone();
|
|
let turn_stage_for_sub = turn_stage.clone();
|
|
let room_id = state.room_id.clone();
|
|
let is_bot_game = state.is_bot_game;
|
|
|
|
// ── Active player indicator ────────────────────────────────────────────────
|
|
let active_player_is_me: Option<bool> = if stage == SerStage::InGame {
|
|
Some(is_my_turn)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// ── Game-over info ─────────────────────────────────────────────────────────
|
|
let stage_is_ended = stage == SerStage::Ended;
|
|
let winner_is_me = my_score.holes >= 12;
|
|
let my_name_end = my_score.name.clone();
|
|
let my_holes_end = my_score.holes;
|
|
let opp_name_end = opp_score.name.clone();
|
|
let opp_holes_end = opp_score.holes;
|
|
|
|
let share_url_copied = RwSignal::new(false);
|
|
let share_url = if !is_bot_game {
|
|
room_url(&room_id)
|
|
} else {
|
|
String::new()
|
|
};
|
|
let share_svg = if !is_bot_game {
|
|
qr_svg(&share_url)
|
|
} else {
|
|
String::new()
|
|
};
|
|
|
|
view! {
|
|
<div class="game-container">
|
|
|
|
// ── Share popover (while waiting for opponent) ───────────────────
|
|
{(!is_bot_game && stage == SerStage::PreGame).then(|| {
|
|
let url_label = share_url.clone();
|
|
let url_copy = share_url.clone();
|
|
let svg = share_svg.clone();
|
|
view! {
|
|
<div class="share-popover">
|
|
<p class="share-popover-label">{t!(i18n, share_link)}</p>
|
|
<div class="share-url-row">
|
|
<span class="share-url-text">{url_label}</span>
|
|
<button class="share-copy-btn" on:click=move |_| {
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
let u = url_copy.clone();
|
|
wasm_bindgen_futures::spawn_local(async move {
|
|
if let Some(cb) = web_sys::window()
|
|
.map(|w| w.navigator().clipboard())
|
|
{
|
|
let _ = wasm_bindgen_futures::JsFuture::from(
|
|
cb.write_text(&u),
|
|
).await;
|
|
share_url_copied.set(true);
|
|
gloo_timers::future::TimeoutFuture::new(2000).await;
|
|
share_url_copied.set(false);
|
|
}
|
|
});
|
|
}
|
|
}>
|
|
{move || if share_url_copied.get() {
|
|
t_string!(i18n, link_copied)
|
|
} else {
|
|
t_string!(i18n, copy_link)
|
|
}}
|
|
</button>
|
|
</div>
|
|
<p class="share-popover-label">{t!(i18n, scan_qr)}</p>
|
|
<div class="qr-container" inner_html=svg />
|
|
</div>
|
|
}
|
|
})}
|
|
|
|
// ── Player strip (full-width, in-flow) ───────────────────────────
|
|
<MergedScorePanel
|
|
my_score=my_score
|
|
opp_score=opp_score
|
|
my_points_earned=my_pts_earned
|
|
opp_points_earned=opp_pts_earned
|
|
my_holes_gained=my_holes_gained_score
|
|
opp_holes_gained=opp_holes_gained_score
|
|
my_bredouille=my_bredouille_flash
|
|
active_player_is_me=active_player_is_me
|
|
/>
|
|
|
|
// ── Board + controls (sidebar on wide, footer on narrow) ─────────
|
|
<div class="main-body">
|
|
<Board
|
|
view_state=vs
|
|
player_id=player_id
|
|
selected_origin=selected_origin
|
|
staged_moves=staged_moves
|
|
valid_sequences=valid_sequences
|
|
bar_dice=show_dice.then_some(dice)
|
|
bar_is_move=is_move_stage
|
|
is_my_turn=is_my_turn
|
|
bar_is_double=is_double_dice
|
|
last_moves=last_moves
|
|
hit_fields=hit_fields
|
|
suppress_dice_anim=suppress_dice_anim
|
|
free_mode=free_mode
|
|
/>
|
|
|
|
// ── Controls: dice card + status/actions card ────────────────
|
|
<div class="controls">
|
|
{show_dice.then(|| view! {
|
|
<div class="ctrl-dice">
|
|
<div class="ctrl-dice-row">
|
|
{move || {
|
|
let staged = staged_moves.get();
|
|
let (u0, u1) = if suppress_dice_anim {
|
|
(true, true)
|
|
} else if is_move_stage {
|
|
bar_matched_dice_used(&staged, dice)
|
|
} else {
|
|
(false, false)
|
|
};
|
|
view! {
|
|
<Die value=dice.0 used=u0 is_double=is_double_dice />
|
|
<Die value=dice.1 used=u1 is_double=is_double_dice />
|
|
}
|
|
}}
|
|
</div>
|
|
<label class="free-mode-toggle">
|
|
<input
|
|
type="checkbox"
|
|
prop:checked=move || free_mode.get()
|
|
on:change=move |ev| {
|
|
let v = event_target_checked(&ev);
|
|
save_free_mode(v);
|
|
free_mode.set(v);
|
|
move_error.set(None);
|
|
}
|
|
/>
|
|
{t!(i18n, free_mode_label)}
|
|
<span class="free-mode-help"
|
|
title=move || t_string!(i18n, free_mode_tooltip).to_owned()>
|
|
"?"
|
|
</span>
|
|
</label>
|
|
</div>
|
|
})}
|
|
|
|
<div class="ctrl-status">
|
|
<div class="game-status">
|
|
{move || {
|
|
if let Some(ref reason) = pause_reason {
|
|
return String::from(match reason {
|
|
PauseReason::AfterOpponentRoll => t_string!(i18n, after_opponent_roll),
|
|
PauseReason::AfterOpponentGo => t_string!(i18n, after_opponent_go),
|
|
PauseReason::AfterOpponentMove => t_string!(i18n, after_opponent_move),
|
|
PauseReason::AfterOpponentPreGameRoll => t_string!(i18n, after_opponent_pre_game_roll),
|
|
});
|
|
}
|
|
let n = staged_moves.get().len();
|
|
if is_move_stage {
|
|
t_string!(i18n, select_move, n = n + 1)
|
|
} else {
|
|
String::from(match (&stage, is_my_turn, &turn_stage) {
|
|
(SerStage::Ended, _, _) => t_string!(i18n, game_over),
|
|
(SerStage::PreGame, _, _) | (SerStage::PreGameRoll, _, _) => t_string!(i18n, waiting_for_opponent),
|
|
(SerStage::InGame, true, SerTurnStage::RollDice) => t_string!(i18n, your_turn_roll),
|
|
(SerStage::InGame, true, SerTurnStage::HoldOrGoChoice) => t_string!(i18n, hold_or_go),
|
|
(SerStage::InGame, true, _) => t_string!(i18n, your_turn),
|
|
(SerStage::InGame, false, _) => t_string!(i18n, opponent_turn),
|
|
})
|
|
}
|
|
}}
|
|
</div>
|
|
{move || {
|
|
let hint: String = if waiting_for_confirm {
|
|
t_string!(i18n, hint_continue).to_owned()
|
|
} else if is_move_stage {
|
|
t_string!(i18n, hint_move).to_owned()
|
|
} else if is_my_turn && turn_stage_for_sub == SerTurnStage::HoldOrGoChoice {
|
|
t_string!(i18n, hint_hold_or_go).to_owned()
|
|
} else {
|
|
String::new()
|
|
};
|
|
(!hint.is_empty()).then(|| view! { <p class="game-sub-prompt">{hint}</p> })
|
|
}}
|
|
// ── Free-mode error banner ─────────────────────────────
|
|
{move || {
|
|
move_error.get().map(|opt_err| {
|
|
let msg: String = match opt_err {
|
|
None => t_string!(i18n, err_invalid_move).to_owned(),
|
|
Some(MoveError::OpponentCorner) => t_string!(i18n, err_opponent_corner).to_owned(),
|
|
Some(MoveError::CornerNeedsTwoCheckers) => t_string!(i18n, err_corner_needs_two).to_owned(),
|
|
Some(MoveError::CornerByEffectPossible) => t_string!(i18n, err_corner_by_effect).to_owned(),
|
|
Some(MoveError::ExitNeedsAllCheckersOnLastQuarter) => t_string!(i18n, err_exit_needs_all_in_last_jan).to_owned(),
|
|
Some(MoveError::ExitByEffectPossible) => t_string!(i18n, err_exit_by_effect).to_owned(),
|
|
Some(MoveError::ExitNotFarthest) => t_string!(i18n, err_exit_not_farthest).to_owned(),
|
|
Some(MoveError::OpponentCanFillQuarter) => t_string!(i18n, err_opponent_can_fill_quarter).to_owned(),
|
|
Some(MoveError::MustFillQuarter) => t_string!(i18n, err_must_fill_quarter).to_owned(),
|
|
Some(MoveError::MustPlayAllDice) => t_string!(i18n, err_must_play_all_dice).to_owned(),
|
|
Some(MoveError::MustPlayStrongerDie) => t_string!(i18n, err_must_play_stronger_die).to_owned(),
|
|
};
|
|
view! {
|
|
<div class="free-mode-error">
|
|
<span class="free-mode-error-msg">{msg}</span>
|
|
<button
|
|
class="btn btn-secondary"
|
|
on:click=move |_| {
|
|
staged_moves.set(vec![]);
|
|
selected_origin.set(None);
|
|
move_error.set(None);
|
|
}
|
|
>{t!(i18n, reset_move)}</button>
|
|
</div>
|
|
}
|
|
})
|
|
}}
|
|
<div class="board-actions">
|
|
{waiting_for_confirm.then(|| view! {
|
|
<button class="btn btn-primary" on:click=move |_| {
|
|
pending.update(|q| { q.pop_front(); });
|
|
}>{t!(i18n, continue_btn)}</button>
|
|
})}
|
|
{show_hold_go.then(|| view! {
|
|
<button class="btn btn-primary" on:click=move |_| {
|
|
cmd_tx_go.unbounded_send(NetCommand::Action(PlayerAction::Go)).ok();
|
|
}>{t!(i18n, go)}</button>
|
|
})}
|
|
{move || {
|
|
let staged = staged_moves.get();
|
|
let show = is_move_stage && staged.len() < 2 && (
|
|
valid_seqs_empty.is_empty() || match staged.len() {
|
|
0 => valid_seqs_empty.iter().any(|(m1, _)| m1.get_from() == 0),
|
|
1 => {
|
|
let (f0, t0) = staged[0];
|
|
valid_seqs_empty.iter()
|
|
.filter(|(m1, _)| {
|
|
m1.get_from() as u8 == f0
|
|
&& m1.get_to() as u8 == t0
|
|
})
|
|
.any(|(_, m2)| m2.get_from() == 0)
|
|
}
|
|
_ => false,
|
|
}
|
|
);
|
|
show.then(|| view! {
|
|
<button
|
|
class="btn btn-secondary"
|
|
on:click=move |_| {
|
|
selected_origin.set(None);
|
|
staged_moves.update(|v| v.push((0, 0)));
|
|
}
|
|
>{t!(i18n, empty_move)}</button>
|
|
})
|
|
}}
|
|
{move || {
|
|
(is_move_stage && staged_moves.get().len() == 1).then(|| view! {
|
|
<button
|
|
class="btn btn-secondary"
|
|
on:click=move |_| {
|
|
staged_moves.set(vec![]);
|
|
selected_origin.set(None);
|
|
}
|
|
>{t!(i18n, cancel_move)}</button>
|
|
})
|
|
}}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
// ── Scoring notification panels ───────────────────────────────────
|
|
<div class="scoring-row">
|
|
<div class="scoring-panels-container">
|
|
{my_scored_event.map(|event| view! {
|
|
<ScoringPanel event=event turn_stage=turn_stage_for_panel />
|
|
})}
|
|
{opp_scored_event.map(|event| view! {
|
|
<ScoringPanel event=event turn_stage=SerTurnStage::RollDice is_opponent=true />
|
|
})}
|
|
</div>
|
|
</div>
|
|
|
|
// ── Pre-game ceremony overlay ─────────────────────────────────────
|
|
{is_ceremony.then(|| {
|
|
let pgr = pre_game_roll_data.unwrap_or(PreGameRollState {
|
|
host_die: None,
|
|
guest_die: None,
|
|
tie_count: 0,
|
|
});
|
|
if pgr.host_die != None {
|
|
crate::game::sound::play_dice_roll();
|
|
}
|
|
|
|
let my_die = if player_id == 0 { pgr.host_die } else { pgr.guest_die };
|
|
let opp_die = if player_id == 0 { pgr.guest_die } else { pgr.host_die };
|
|
let can_roll = my_die.is_none() && !waiting_for_confirm;
|
|
let show_tie = pgr.tie_count > 0;
|
|
let toss_result: Option<bool> = match (my_die, opp_die) {
|
|
(Some(m), Some(o)) if m != o => Some(m > o),
|
|
_ => None,
|
|
};
|
|
let opp_name_toss = opp_name_ceremony.clone();
|
|
view! {
|
|
<div class="ceremony-overlay">
|
|
<div class="ceremony-box">
|
|
<h2>{t!(i18n, pre_game_roll_title)}</h2>
|
|
{show_tie.then(|| view! {
|
|
<p class="ceremony-tie">{t!(i18n, pre_game_roll_tie)}</p>
|
|
})}
|
|
<div class="ceremony-dice">
|
|
<div class="ceremony-die-slot">
|
|
<span class="ceremony-die-label">{my_name_ceremony}{t!(i18n, you_suffix)}</span>
|
|
<Die value=my_die.unwrap_or(0) used=false />
|
|
</div>
|
|
<div class="ceremony-die-slot">
|
|
<span class="ceremony-die-label">{opp_name_ceremony}</span>
|
|
<Die value=opp_die.unwrap_or(0) used=false />
|
|
</div>
|
|
</div>
|
|
{toss_result.map(|i_win| {
|
|
let text = move || if i_win {
|
|
t_string!(i18n, toss_you_first).to_owned()
|
|
} else {
|
|
t_string!(i18n, toss_opp_first, name = opp_name_toss.as_str()).to_owned()
|
|
};
|
|
view! { <p class="ceremony-result">{text}</p> }
|
|
})}
|
|
{waiting_for_confirm.then(|| {
|
|
let pending_c = pending;
|
|
view! {
|
|
<button class="btn btn-primary" on:click=move |_| {
|
|
pending_c.update(|q| { q.pop_front(); });
|
|
}>{t!(i18n, continue_btn)}</button>
|
|
}
|
|
})}
|
|
{can_roll.then(|| {
|
|
let cmd_tx_c = cmd_tx_ceremony.clone();
|
|
view! {
|
|
<button class="btn btn-primary" on:click=move |_| {
|
|
cmd_tx_c.unbounded_send(NetCommand::Action(PlayerAction::PreGameRoll)).ok();
|
|
}>{t!(i18n, pre_game_roll_btn)}</button>
|
|
}
|
|
})}
|
|
</div>
|
|
</div>
|
|
}
|
|
})}
|
|
|
|
// ── Game-over overlay ─────────────────────────────────────────────
|
|
{stage_is_ended.then(|| {
|
|
if winner_is_me {
|
|
crate::game::sound::play_victory();
|
|
} else {
|
|
crate::game::sound::play_defeat();
|
|
}
|
|
let opp_name_end_clone = opp_name_end.clone();
|
|
let winner_text = move || if winner_is_me {
|
|
t_string!(i18n, you_win).to_owned()
|
|
} else {
|
|
t_string!(i18n, opp_wins, name = opp_name_end_clone.as_str())
|
|
};
|
|
view! {
|
|
<div class="game-over-overlay">
|
|
<div class="game-over-box">
|
|
<h2>{t!(i18n, game_over)}</h2>
|
|
<p class="game-over-winner">{winner_text}</p>
|
|
<div class="game-over-score">
|
|
<span class="game-over-score-name">{my_name_end}</span>
|
|
<span class="game-over-score-nums">
|
|
{format!("{my_holes_end} — {opp_holes_end}")}
|
|
</span>
|
|
<span class="game-over-score-name">{opp_name_end.clone()}</span>
|
|
</div>
|
|
<div class="game-over-actions">
|
|
<button class="btn btn-secondary" on:click=move |_| {
|
|
cmd_tx_end_quit.unbounded_send(NetCommand::Disconnect).ok();
|
|
}>{t!(i18n, quit)}</button>
|
|
{is_bot_game.then(|| view! {
|
|
<button class="btn btn-primary" on:click=move |_| {
|
|
cmd_tx_end_replay.unbounded_send(NetCommand::PlayVsBot).ok();
|
|
}>{t!(i18n, play_again)}</button>
|
|
})}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
}
|
|
})}
|
|
|
|
</div>
|
|
}
|
|
}
|