refactor(engine): split card_plugin runtime code into submodules
Final runtime split for #118: the 2,536-line mod.rs becomes seven focused submodules along existing system boundaries — mod.rs 574 fan-step helpers, CardImageSet, markers, plugin build sync.rs 748 asset loading + card entity lifecycle (spawn/update/position) layout.rs 351 resize snapping, in-place resize, tableau fan spread stock.rs 291 empty-stock recycle hint + count badge highlights.rs 276 hint/right-click highlights, cursor hit-testing labels.rs 208 desktop text labels + Android corner labels anim.rs 200 flip animation, drag shadows Moved items are pub(super); code moved verbatim apart from relocating the two stock colour constants next to their consumers. No behaviour change; all 70 card tests pass unchanged. Refs #118 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
funman300
@@ -0,0 +1,748 @@
|
||||
//! Card asset loading and entity lifecycle: the sync systems that
|
||||
//! spawn, update, and position card entities from `GameStateResource`.
|
||||
|
||||
use super::*;
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use bevy::color::Color;
|
||||
use solitaire_core::{Foundation, KlondikePile, Tableau};
|
||||
use solitaire_core::{Card, Rank, Suit};
|
||||
use solitaire_core::{DrawStockConfig, game_state::GameState};
|
||||
|
||||
use crate::animation_plugin::{CARD_ANIM_Z_LIFT, CardAnim, EffectiveSlideDuration};
|
||||
use crate::card_animation::CardAnimation;
|
||||
use crate::events::StateChangedEvent;
|
||||
use crate::font_plugin::FontResource;
|
||||
use crate::layout::{Layout, LayoutResource};
|
||||
use crate::platform::USE_TOUCH_UI_LAYOUT;
|
||||
use crate::resources::GameStateResource;
|
||||
use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
|
||||
|
||||
/// Rebuild the [`CardEntityIndex`] from the live `CardEntity` set.
|
||||
///
|
||||
/// Runs in `PostUpdate` so that all spawn/despawn `Commands` issued by
|
||||
/// [`sync_cards_on_change`] and [`snap_cards_on_window_resize`] in `Update`
|
||||
/// have been flushed at the `Update -> PostUpdate` apply-deferred boundary.
|
||||
/// Rebuilding from scratch (rather than incrementally patching at every
|
||||
/// spawn/despawn site — waste cards churn on every draw) keeps a single writer
|
||||
/// and makes a stale entry structurally impossible.
|
||||
///
|
||||
/// Gated to changed frames only: `Changed<CardEntity>` fires the frame a card
|
||||
/// is spawned, `RemovedComponents<CardEntity>` the frame one is despawned. The
|
||||
/// `card` field is write-once (never mutated in place), so card-reposition
|
||||
/// frames don't trip `Changed` and correctly skip the O(52) rebuild.
|
||||
pub(super) fn rebuild_card_entity_index(
|
||||
mut index: ResMut<CardEntityIndex>,
|
||||
cards: Query<(Entity, &CardEntity)>,
|
||||
changed: Query<(), Changed<CardEntity>>,
|
||||
removed: RemovedComponents<CardEntity>,
|
||||
) {
|
||||
if changed.is_empty() && removed.is_empty() {
|
||||
return;
|
||||
}
|
||||
let map = &mut index.0;
|
||||
map.clear();
|
||||
for (entity, ce) in &cards {
|
||||
map.insert(ce.card.clone(), entity);
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the relative asset path for a card face PNG.
|
||||
///
|
||||
/// The path format is `cards/faces/classic/{RANK}{SUIT}.png`, e.g. `QS.png`
|
||||
/// for the Queen of Spades. Both `load_card_images` and the unit tests use
|
||||
/// this function so the filename formula is tested in isolation from the
|
||||
/// asset-loading machinery.
|
||||
///
|
||||
/// Note: this function verifies only the **code-side mapping**. If the PNG
|
||||
/// file at the returned path contains wrong artwork (e.g. `QS.png` has a
|
||||
/// diamond watermark baked in), that is an **asset content bug** and must be
|
||||
/// fixed by replacing the file — no code change can correct it.
|
||||
pub(super) fn card_face_asset_path(rank: Rank, suit: Suit) -> String {
|
||||
const SUIT_CHARS: [&str; 4] = ["C", "D", "H", "S"];
|
||||
const RANK_STRS: [&str; 13] = [
|
||||
"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
|
||||
];
|
||||
let suit_idx = match suit {
|
||||
Suit::Clubs => 0,
|
||||
Suit::Diamonds => 1,
|
||||
Suit::Hearts => 2,
|
||||
Suit::Spades => 3,
|
||||
};
|
||||
let rank_idx = match rank {
|
||||
Rank::Ace => 0,
|
||||
Rank::Two => 1,
|
||||
Rank::Three => 2,
|
||||
Rank::Four => 3,
|
||||
Rank::Five => 4,
|
||||
Rank::Six => 5,
|
||||
Rank::Seven => 6,
|
||||
Rank::Eight => 7,
|
||||
Rank::Nine => 8,
|
||||
Rank::Ten => 9,
|
||||
Rank::Jack => 10,
|
||||
Rank::Queen => 11,
|
||||
Rank::King => 12,
|
||||
};
|
||||
format!(
|
||||
"cards/faces/classic/{}{}.png",
|
||||
RANK_STRS[rank_idx], SUIT_CHARS[suit_idx]
|
||||
)
|
||||
}
|
||||
|
||||
/// Loads card face and back PNGs at startup via [`AssetServer`] and inserts
|
||||
/// [`CardImageSet`].
|
||||
///
|
||||
/// Faces: `assets/cards/faces/{RANK}{SUIT}.png` (e.g. `AC.png`, `10H.png`)
|
||||
/// Backs: `assets/cards/backs/back_{0..4}.png`
|
||||
///
|
||||
/// Under `MinimalPlugins` (tests) `AssetServer` is absent, so the system
|
||||
/// returns without inserting `CardImageSet` and the plugin falls back to
|
||||
/// solid-colour sprites.
|
||||
pub(super) fn load_card_images(asset_server: Option<Res<AssetServer>>, mut commands: Commands) {
|
||||
let Some(asset_server) = asset_server else {
|
||||
return;
|
||||
};
|
||||
|
||||
const SUITS: [Suit; 4] = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
|
||||
const RANKS: [Rank; 13] = [
|
||||
Rank::Ace,
|
||||
Rank::Two,
|
||||
Rank::Three,
|
||||
Rank::Four,
|
||||
Rank::Five,
|
||||
Rank::Six,
|
||||
Rank::Seven,
|
||||
Rank::Eight,
|
||||
Rank::Nine,
|
||||
Rank::Ten,
|
||||
Rank::Jack,
|
||||
Rank::Queen,
|
||||
Rank::King,
|
||||
];
|
||||
|
||||
let faces: [[Handle<Image>; 13]; 4] = std::array::from_fn(|si| {
|
||||
std::array::from_fn(|ri| asset_server.load(card_face_asset_path(RANKS[ri], SUITS[si])))
|
||||
});
|
||||
let backs =
|
||||
std::array::from_fn(|i| asset_server.load(format!("cards/backs/classic/back_{i}.png")));
|
||||
commands.insert_resource(CardImageSet {
|
||||
faces,
|
||||
backs,
|
||||
// Populated by the theme plugin once a `CardTheme` finishes loading.
|
||||
// Until then the legacy back fallback (`backs[selected_card_back]`)
|
||||
// is used.
|
||||
theme_back: None,
|
||||
});
|
||||
}
|
||||
|
||||
/// Builds the [`Sprite`] for a card, using PNG artwork when [`CardImageSet`] is
|
||||
/// available and falling back to a solid-colour sprite in tests.
|
||||
pub(super) fn card_sprite(
|
||||
card: &Card,
|
||||
face_up: bool,
|
||||
card_size: Vec2,
|
||||
back_colour: Color,
|
||||
card_images: Option<&CardImageSet>,
|
||||
selected_back: usize,
|
||||
) -> Sprite {
|
||||
if let Some(set) = card_images {
|
||||
let image = if face_up {
|
||||
let suit_idx = match card.suit() {
|
||||
Suit::Clubs => 0,
|
||||
Suit::Diamonds => 1,
|
||||
Suit::Hearts => 2,
|
||||
Suit::Spades => 3,
|
||||
};
|
||||
let rank_idx = match card.rank() {
|
||||
Rank::Ace => 0,
|
||||
Rank::Two => 1,
|
||||
Rank::Three => 2,
|
||||
Rank::Four => 3,
|
||||
Rank::Five => 4,
|
||||
Rank::Six => 5,
|
||||
Rank::Seven => 6,
|
||||
Rank::Eight => 7,
|
||||
Rank::Nine => 8,
|
||||
Rank::Ten => 9,
|
||||
Rank::Jack => 10,
|
||||
Rank::Queen => 11,
|
||||
Rank::King => 12,
|
||||
};
|
||||
set.faces[suit_idx][rank_idx].clone()
|
||||
} else if let Some(theme_back) = &set.theme_back {
|
||||
// Active theme provides its own back — always wins over the
|
||||
// legacy `selected_card_back` picker, so a theme switch swaps
|
||||
// faces *and* the back. The picker is treated as informational
|
||||
// only while a theme back is active (see settings_plugin).
|
||||
theme_back.clone()
|
||||
} else {
|
||||
let idx = selected_back.min(set.backs.len() - 1);
|
||||
set.backs[idx].clone()
|
||||
};
|
||||
Sprite {
|
||||
image,
|
||||
color: Color::WHITE,
|
||||
custom_size: Some(card_size),
|
||||
..default()
|
||||
}
|
||||
} else {
|
||||
// Terminal aesthetic: face background is uniformly CARD_FACE_COLOUR
|
||||
// regardless of colour-blind mode (CBM differentiation now lives in
|
||||
// the suit glyph colour, applied by `text_colour`, not the face
|
||||
// background). Pre-Terminal this branch dispatched through a
|
||||
// separate `face_colour(card, color_blind)` helper.
|
||||
let body_colour = if face_up {
|
||||
CARD_FACE_COLOUR
|
||||
} else {
|
||||
back_colour
|
||||
};
|
||||
Sprite {
|
||||
color: body_colour,
|
||||
custom_size: Some(card_size),
|
||||
..default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// When card-back selection changes in Settings, re-render all cards so the
|
||||
/// new back colour is applied immediately (without waiting for a state change).
|
||||
pub(super) fn resync_cards_on_settings_change(
|
||||
mut setting_events: MessageReader<SettingsChangedEvent>,
|
||||
mut state_events: MessageWriter<StateChangedEvent>,
|
||||
) {
|
||||
if setting_events.read().next().is_some() {
|
||||
state_events.write(StateChangedEvent);
|
||||
}
|
||||
}
|
||||
|
||||
/// Render the initial deal. Runs in `PostStartup`, so all `Startup` systems
|
||||
/// (including `TablePlugin::setup_table` which inserts `LayoutResource`)
|
||||
/// have already completed.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(super) fn sync_cards_startup(
|
||||
commands: Commands,
|
||||
game: Res<GameStateResource>,
|
||||
layout: Option<Res<LayoutResource>>,
|
||||
slide_dur: Option<Res<EffectiveSlideDuration>>,
|
||||
settings: Option<Res<SettingsResource>>,
|
||||
entities: Query<CardSyncData>,
|
||||
card_images: Option<Res<CardImageSet>>,
|
||||
font_res: Option<Res<FontResource>>,
|
||||
) {
|
||||
if let Some(layout) = layout {
|
||||
let slide_secs = slide_dur.map_or(0.15, |d| d.slide_secs);
|
||||
let selected_back = settings.as_ref().map_or(0, |s| s.0.selected_card_back);
|
||||
let back_colour = card_back_colour(selected_back);
|
||||
let color_blind = settings.as_ref().is_some_and(|s| s.0.color_blind_mode);
|
||||
let high_contrast = settings.as_ref().is_some_and(|s| s.0.high_contrast_mode);
|
||||
let font_handle = font_res.as_ref().map(|r| &r.0);
|
||||
sync_cards(
|
||||
commands,
|
||||
&game.0,
|
||||
&layout.0,
|
||||
slide_secs,
|
||||
back_colour,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
&entities,
|
||||
card_images.as_deref(),
|
||||
selected_back,
|
||||
font_handle,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(super) fn sync_cards_on_change(
|
||||
mut events: MessageReader<StateChangedEvent>,
|
||||
commands: Commands,
|
||||
game: Res<GameStateResource>,
|
||||
layout: Option<Res<LayoutResource>>,
|
||||
slide_dur: Option<Res<EffectiveSlideDuration>>,
|
||||
settings: Option<Res<SettingsResource>>,
|
||||
entities: Query<CardSyncData>,
|
||||
card_images: Option<Res<CardImageSet>>,
|
||||
font_res: Option<Res<FontResource>>,
|
||||
) {
|
||||
if events.read().next().is_none() {
|
||||
return;
|
||||
}
|
||||
if let Some(layout) = layout {
|
||||
let slide_secs = slide_dur.map_or(0.15, |d| d.slide_secs);
|
||||
let selected_back = settings.as_ref().map_or(0, |s| s.0.selected_card_back);
|
||||
let back_colour = card_back_colour(selected_back);
|
||||
let color_blind = settings.as_ref().is_some_and(|s| s.0.color_blind_mode);
|
||||
let high_contrast = settings.as_ref().is_some_and(|s| s.0.high_contrast_mode);
|
||||
let font_handle = font_res.as_ref().map(|r| &r.0);
|
||||
sync_cards(
|
||||
commands,
|
||||
&game.0,
|
||||
&layout.0,
|
||||
slide_secs,
|
||||
back_colour,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
&entities,
|
||||
card_images.as_deref(),
|
||||
selected_back,
|
||||
font_handle,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(super) fn sync_cards(
|
||||
mut commands: Commands,
|
||||
game: &GameState,
|
||||
layout: &Layout,
|
||||
slide_secs: f32,
|
||||
back_colour: Color,
|
||||
color_blind: bool,
|
||||
high_contrast: bool,
|
||||
entities: &Query<CardSyncData>,
|
||||
card_images: Option<&CardImageSet>,
|
||||
selected_back: usize,
|
||||
font_handle: Option<&Handle<Font>>,
|
||||
) {
|
||||
let positions = card_positions(game, layout);
|
||||
|
||||
// The waste buffer card exists only to keep its entity alive while the new
|
||||
// top card's slide animation plays — it must never be visible to the player.
|
||||
// Without this, the buffer sits at waste_base uncovered during the animation
|
||||
// and its rank/suit peek behind the incoming card.
|
||||
let waste_buffer_id: Option<Card> = {
|
||||
let visible = match game.draw_mode() {
|
||||
DrawStockConfig::DrawOne => 1_usize,
|
||||
DrawStockConfig::DrawThree => 3_usize,
|
||||
};
|
||||
let waste_cards = game.waste_cards();
|
||||
(waste_cards.len() > visible)
|
||||
.then_some(waste_cards)
|
||||
.and_then(|w| w.get(w.len().saturating_sub(visible + 1)).cloned())
|
||||
.map(|(c, _face_up)| c)
|
||||
};
|
||||
|
||||
// Map Card -> (Entity, current_translation, anim_end) for in-place
|
||||
// updates. `anim_end` is `Some(end_xy)` when a curve-based `CardAnimation`
|
||||
// is currently driving the card (e.g. a drag-rejection return tween).
|
||||
//
|
||||
// In the position loop below we compare `anim_end` against the new game-
|
||||
// state target position to decide whether to honour or cancel the tween:
|
||||
// • end ≈ target → animation is still heading to the right place; let
|
||||
// it finish (skip the snap/slide path).
|
||||
// • end ≠ target → the game state has changed (e.g. a new game started
|
||||
// while the win-cascade was mid-flight); cancel the
|
||||
// stale `CardAnimation` and apply the new position.
|
||||
let mut existing: HashMap<Card, (Entity, Vec3, Option<Vec2>, Option<CardChildrenKey>)> =
|
||||
HashMap::new();
|
||||
for (entity, marker, transform, anim, children_key) in entities.iter() {
|
||||
existing.insert(
|
||||
marker.card.clone(),
|
||||
(
|
||||
entity,
|
||||
transform.translation,
|
||||
anim.map(|a| a.end),
|
||||
children_key.copied(),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
let live_ids: HashSet<Card> = positions.iter().map(|(c, _, _)| c.0.clone()).collect();
|
||||
|
||||
// Despawn any entity whose card is no longer tracked.
|
||||
for (card, (entity, _, _, _)) in &existing {
|
||||
if !live_ids.contains(card) {
|
||||
commands.entity(*entity).despawn();
|
||||
}
|
||||
}
|
||||
|
||||
// For each card in the current state: spawn or update its entity, then
|
||||
// apply visibility. The waste buffer card is hidden so it cannot peek
|
||||
// behind the incoming top card during the draw slide animation.
|
||||
for ((card, face_up), position, z) in positions {
|
||||
let entity = match existing.get(&card) {
|
||||
Some(&(entity, cur, anim_end, children_key)) => {
|
||||
// If a CardAnimation is in flight, check whether its destination
|
||||
// still matches the game-state target. If the game moved the card
|
||||
// elsewhere (e.g. new game started during a win-cascade scatter),
|
||||
// cancel the stale tween so the card snaps/slides to its new home.
|
||||
let has_anim = match anim_end {
|
||||
Some(end_xy) if (end_xy - position).length() > 2.0 => {
|
||||
commands.entity(entity).remove::<CardAnimation>();
|
||||
false
|
||||
}
|
||||
Some(_) => true,
|
||||
None => false,
|
||||
};
|
||||
update_card_entity(
|
||||
&mut commands,
|
||||
entity,
|
||||
&card,
|
||||
face_up,
|
||||
position,
|
||||
z,
|
||||
layout,
|
||||
slide_secs,
|
||||
back_colour,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
cur,
|
||||
has_anim,
|
||||
children_key,
|
||||
card_images,
|
||||
selected_back,
|
||||
font_handle,
|
||||
);
|
||||
entity
|
||||
}
|
||||
None => spawn_card_entity(
|
||||
&mut commands,
|
||||
&card,
|
||||
face_up,
|
||||
position,
|
||||
z,
|
||||
layout,
|
||||
back_colour,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
card_images,
|
||||
selected_back,
|
||||
font_handle,
|
||||
),
|
||||
};
|
||||
let visibility = if waste_buffer_id.as_ref() == Some(&card) {
|
||||
Visibility::Hidden
|
||||
} else {
|
||||
Visibility::Inherited
|
||||
};
|
||||
commands.entity(entity).insert(visibility);
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns an ordered vec of ((card, face_up), position, z) for every card in the game.
|
||||
pub(super) fn card_positions(game: &GameState, layout: &Layout) -> Vec<((Card, bool), Vec2, f32)> {
|
||||
let mut out: Vec<((Card, bool), Vec2, f32)> = Vec::with_capacity(52);
|
||||
let piles = [
|
||||
(KlondikePile::Stock, true),
|
||||
(KlondikePile::Stock, false),
|
||||
(KlondikePile::Foundation(Foundation::Foundation1), false),
|
||||
(KlondikePile::Foundation(Foundation::Foundation2), false),
|
||||
(KlondikePile::Foundation(Foundation::Foundation3), false),
|
||||
(KlondikePile::Foundation(Foundation::Foundation4), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau1), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau2), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau3), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau4), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau5), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau6), false),
|
||||
(KlondikePile::Tableau(Tableau::Tableau7), false),
|
||||
];
|
||||
|
||||
// Draw-Three waste fan step, proportional to the column spacing so it scales
|
||||
// with the platform's H_GAP_DIVISOR. Shared with input_plugin's hit-test via
|
||||
// `waste_fan_step` so the two never drift (a drift puts the top fanned card's
|
||||
// click target on the card beneath it).
|
||||
let waste_fan_step = waste_fan_step(layout);
|
||||
|
||||
for (pile_type, is_stock_area) in piles {
|
||||
let Some(mut base) = layout.pile_positions.get(&pile_type).copied() else {
|
||||
continue;
|
||||
};
|
||||
if matches!(pile_type, KlondikePile::Stock) && is_stock_area {
|
||||
base.x -= tableau_col_step(layout);
|
||||
}
|
||||
let is_tableau = matches!(pile_type, KlondikePile::Tableau(_));
|
||||
let is_waste = matches!(pile_type, KlondikePile::Stock) && !is_stock_area;
|
||||
let cards = if matches!(pile_type, KlondikePile::Stock) {
|
||||
if is_stock_area {
|
||||
game.stock_cards()
|
||||
} else {
|
||||
game.waste_cards()
|
||||
}
|
||||
} else {
|
||||
game.pile(pile_type)
|
||||
};
|
||||
|
||||
// Tableau uses a two-speed fan: face-down cards are packed tighter
|
||||
// than face-up cards so the visible (playable) portion stands out.
|
||||
// Non-tableau piles stack with a negligible offset.
|
||||
//
|
||||
// Waste pile: only the top N cards are rendered to prevent bleed-through
|
||||
// while new cards animate in from the stock. Draw-One shows 1; Draw-Three
|
||||
// shows up to 3 fanned in X (matching the standard Klondike presentation).
|
||||
let render_start = if is_waste {
|
||||
let visible = match game.draw_mode() {
|
||||
DrawStockConfig::DrawOne => 1_usize,
|
||||
DrawStockConfig::DrawThree => 3_usize,
|
||||
};
|
||||
// Render one extra card so that the card sliding off the waste
|
||||
// during a draw animation is still present in the world at z=0
|
||||
// (hidden under the stack) rather than vanishing mid-tween.
|
||||
cards.len().saturating_sub(visible + 1)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
|
||||
let mut y_offset = 0.0_f32;
|
||||
let rendered_len = cards[render_start..].len();
|
||||
for (slot, (card, face_up)) in cards[render_start..].iter().enumerate() {
|
||||
let x_offset = if is_waste && matches!(game.draw_mode(), DrawStockConfig::DrawThree) {
|
||||
// When len > visible, slot 0 is a hidden buffer card kept at
|
||||
// x=0 to prevent a flash during the draw tween. When len ≤
|
||||
// visible (small pile), every card is visible and should fan
|
||||
// normally — no card is hidden, so the shift is 0.
|
||||
let visible = 3_usize;
|
||||
let hidden = rendered_len.saturating_sub(visible);
|
||||
slot.saturating_sub(hidden) as f32 * waste_fan_step
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let pos = Vec2::new(base.x + x_offset, base.y + y_offset);
|
||||
let z = 1.0 + (slot as f32) * STACK_FAN_FRAC;
|
||||
out.push(((card.clone(), *face_up), pos, z));
|
||||
if is_tableau {
|
||||
let step = if *face_up {
|
||||
layout.tableau_fan_frac
|
||||
} else {
|
||||
layout.tableau_facedown_fan_frac
|
||||
};
|
||||
y_offset -= layout.card_size.y * step;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub(super) fn all_cards(game: &GameState) -> Vec<(Card, bool)> {
|
||||
let mut cards: Vec<(Card, bool)> = Vec::with_capacity(52);
|
||||
cards.extend(game.stock_cards());
|
||||
cards.extend(game.waste_cards());
|
||||
for foundation in [
|
||||
Foundation::Foundation1,
|
||||
Foundation::Foundation2,
|
||||
Foundation::Foundation3,
|
||||
Foundation::Foundation4,
|
||||
] {
|
||||
cards.extend(game.pile(KlondikePile::Foundation(foundation)));
|
||||
}
|
||||
for tableau in [
|
||||
Tableau::Tableau1,
|
||||
Tableau::Tableau2,
|
||||
Tableau::Tableau3,
|
||||
Tableau::Tableau4,
|
||||
Tableau::Tableau5,
|
||||
Tableau::Tableau6,
|
||||
Tableau::Tableau7,
|
||||
] {
|
||||
cards.extend(game.pile(KlondikePile::Tableau(tableau)));
|
||||
}
|
||||
cards
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(super) fn spawn_card_entity(
|
||||
commands: &mut Commands,
|
||||
card: &Card,
|
||||
face_up: bool,
|
||||
pos: Vec2,
|
||||
z: f32,
|
||||
layout: &Layout,
|
||||
back_colour: Color,
|
||||
color_blind: bool,
|
||||
high_contrast: bool,
|
||||
card_images: Option<&CardImageSet>,
|
||||
selected_back: usize,
|
||||
font_handle: Option<&Handle<Font>>,
|
||||
) -> Entity {
|
||||
let sprite = card_sprite(
|
||||
card,
|
||||
face_up,
|
||||
layout.card_size,
|
||||
back_colour,
|
||||
card_images,
|
||||
selected_back,
|
||||
);
|
||||
|
||||
let mut entity = commands.spawn((
|
||||
CardEntity { card: card.clone() },
|
||||
sprite,
|
||||
Transform::from_xyz(pos.x, pos.y, z),
|
||||
Visibility::default(),
|
||||
));
|
||||
let entity_id = entity.id();
|
||||
// Every card gets a subtle drop-shadow child so the play surface reads
|
||||
// as physical instead of flat. Spawned in idle state; the drag-tracking
|
||||
// system retunes its offset / alpha when this card joins the dragged
|
||||
// stack.
|
||||
entity.with_children(|b| {
|
||||
add_card_shadow_child(b, layout.card_size);
|
||||
});
|
||||
// Every card gets a thin border frame so it reads as a distinct
|
||||
// rectangle against the dark felt, regardless of face state.
|
||||
entity.with_children(|b| {
|
||||
add_card_back_frame_child(b, layout.card_size);
|
||||
});
|
||||
// When PNG faces are loaded the rank/suit are baked into the image.
|
||||
// Only spawn the Text2d overlay in the solid-colour fallback (tests).
|
||||
// On Android we additionally spawn a large-print corner label even in
|
||||
// image mode so the rank/suit are legible at phone scale.
|
||||
if card_images.is_none() {
|
||||
entity.with_children(|b| {
|
||||
b.spawn((
|
||||
CardLabel,
|
||||
Text2d::new(label_for(card)),
|
||||
TextFont {
|
||||
font_size: layout.card_size.x * FONT_SIZE_FRAC,
|
||||
..default()
|
||||
},
|
||||
TextColor(text_colour(card, color_blind, high_contrast)),
|
||||
Transform::from_xyz(0.0, 0.0, 0.01),
|
||||
label_visibility(face_up),
|
||||
));
|
||||
});
|
||||
}
|
||||
if USE_TOUCH_UI_LAYOUT && card_images.is_some() {
|
||||
entity.with_children(|b| {
|
||||
add_android_corner_label(
|
||||
b,
|
||||
card,
|
||||
face_up,
|
||||
layout.card_size,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
font_handle,
|
||||
);
|
||||
});
|
||||
}
|
||||
// Record the appearance signature so subsequent `update_card_entity` calls
|
||||
// can skip rebuilding these children until one of the inputs changes.
|
||||
entity.insert(CardChildrenKey {
|
||||
face_up,
|
||||
card_size: layout.card_size,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
});
|
||||
entity_id
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(super) fn update_card_entity(
|
||||
commands: &mut Commands,
|
||||
entity: Entity,
|
||||
card: &Card,
|
||||
face_up: bool,
|
||||
pos: Vec2,
|
||||
z: f32,
|
||||
layout: &Layout,
|
||||
slide_secs: f32,
|
||||
back_colour: Color,
|
||||
color_blind: bool,
|
||||
high_contrast: bool,
|
||||
cur: Vec3,
|
||||
has_card_animation: bool,
|
||||
existing_children_key: Option<CardChildrenKey>,
|
||||
card_images: Option<&CardImageSet>,
|
||||
selected_back: usize,
|
||||
font_handle: Option<&Handle<Font>>,
|
||||
) {
|
||||
let target = Vec3::new(pos.x, pos.y, z);
|
||||
|
||||
// Always refresh the visual appearance.
|
||||
commands.entity(entity).insert(card_sprite(
|
||||
card,
|
||||
face_up,
|
||||
layout.card_size,
|
||||
back_colour,
|
||||
card_images,
|
||||
selected_back,
|
||||
));
|
||||
|
||||
// Skip the snap/slide path entirely when a curve-based `CardAnimation`
|
||||
// is driving this card (e.g. the drag-rejection return tween). Writing
|
||||
// `Transform` here would race that animation each frame and cause a
|
||||
// visible jump. The animation system snaps the final position itself
|
||||
// when it completes.
|
||||
if !has_card_animation {
|
||||
// Slide to the new position when it differs meaningfully; snap otherwise.
|
||||
if (cur.truncate() - target.truncate()).length() > 1.0 && slide_secs > 0.0 {
|
||||
// Lift the card immediately on the first frame of the animation so
|
||||
// it never appears behind a card that is already resting at the
|
||||
// destination slot. `advance_card_anims` will maintain this lift
|
||||
// throughout the tween and snap to `target` (without lift) on
|
||||
// completion.
|
||||
let start = Vec3::new(cur.x, cur.y, z + CARD_ANIM_Z_LIFT);
|
||||
commands
|
||||
.entity(entity)
|
||||
.insert(Transform::from_translation(start))
|
||||
.insert(CardAnim {
|
||||
start,
|
||||
target,
|
||||
elapsed: 0.0,
|
||||
duration: slide_secs,
|
||||
delay: 0.0,
|
||||
});
|
||||
} else {
|
||||
commands
|
||||
.entity(entity)
|
||||
.remove::<CardAnim>()
|
||||
.insert(Transform::from_xyz(pos.x, pos.y, z));
|
||||
}
|
||||
}
|
||||
|
||||
// Rebuild the card's child visuals (drop-shadow, border frame, and the
|
||||
// rank/suit label / large-print corner overlay) only when an input that
|
||||
// affects them actually changed. The child set depends solely on
|
||||
// `CardChildrenKey`; the face/back image is carried by the always-refreshed
|
||||
// `Sprite` above, so theme/card-back swaps need no child rebuild. Skipping
|
||||
// this on a position-only move avoids despawning and respawning the child
|
||||
// entities (incl. a `Text2d` glyph re-layout) for all 52 cards on every
|
||||
// `StateChangedEvent` — the spike that stuttered the slide animation on
|
||||
// high-resolution devices.
|
||||
let new_children_key = CardChildrenKey {
|
||||
face_up,
|
||||
card_size: layout.card_size,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
};
|
||||
if existing_children_key != Some(new_children_key) {
|
||||
commands.entity(entity).despawn_related::<Children>();
|
||||
commands.entity(entity).with_children(|b| {
|
||||
add_card_shadow_child(b, layout.card_size);
|
||||
});
|
||||
commands.entity(entity).with_children(|b| {
|
||||
add_card_back_frame_child(b, layout.card_size);
|
||||
});
|
||||
if card_images.is_none() {
|
||||
commands.entity(entity).with_children(|b| {
|
||||
b.spawn((
|
||||
CardLabel,
|
||||
Text2d::new(label_for(card)),
|
||||
TextFont {
|
||||
font_size: layout.card_size.x * FONT_SIZE_FRAC,
|
||||
..default()
|
||||
},
|
||||
TextColor(text_colour(card, color_blind, high_contrast)),
|
||||
Transform::from_xyz(0.0, 0.0, 0.01),
|
||||
label_visibility(face_up),
|
||||
));
|
||||
});
|
||||
}
|
||||
if USE_TOUCH_UI_LAYOUT && card_images.is_some() {
|
||||
commands.entity(entity).with_children(|b| {
|
||||
add_android_corner_label(
|
||||
b,
|
||||
card,
|
||||
face_up,
|
||||
layout.card_size,
|
||||
color_blind,
|
||||
high_contrast,
|
||||
font_handle,
|
||||
);
|
||||
});
|
||||
}
|
||||
commands.entity(entity).insert(new_children_key);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user