Add stocks UI

.gitignore

@@ -10,7 +10,3 @@ imported_assets
 *_old.glb
 /replay.json
 *.replay.tmp
-
-# Python debugger formatter tests
-__pycache__/
-*.pyc

README.md

@@ -2,15 +2,6 @@
 
 Fancy heavily advanced platform fighting game
 
-## Debugging fixed-point values with lldb
-
-If using CodeLLDB:
-```json
-"preRunCommands": [
-    "command script import ${workspaceFolder}/tools/lldb_fixed.py"
-]
-```
-
 ## Direct P2P Debugging
 
 ```text
@@ -25,9 +16,18 @@ cargo run -- --debug-match --players 2 --local-port 7001 \
 
 ## Production Build
 
+Production builds use the `production` Cargo profile and do not dynamically
+link Bevy or Rust. Development builds retain Bevy dynamic linking for faster
+iteration. Cargo stores the production profile under `target/production`,
+separate from development artifacts under `target/debug`.
+
 ```sh
 cargo run --locked \
   --bin process-assets --no-default-features --features debug_features
 cargo build --locked \
   --profile production --no-default-features --features debug_features
-```
+```
+
+The asset preprocessing command must be run from the repository root. It
+populates `imported_assets/Default`, which is then consumed by the production
+game without running the asset processor at startup.

src/fighter/baked_animation/mod.rs

@@ -4,8 +4,8 @@ mod asset_baking;
 mod runtime;
 mod visual_binding;
 
-pub use crate::math::fixed_transform::FixedMat4;
 pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
+pub use crate::math::fixed_transform::FixedMat4;
 pub use runtime::{
     BakedAnimationClip, BakedFighterAnimations, FighterBoneIndexMap, FighterBoneMatrices,
     update_fighter_bone_matrices,
@@ -164,20 +164,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn repeated_pose_updates_reuse_scratch_and_output_buffers() {
-        let mut matrices = FighterBoneMatrices::default();
-        let names = ["root".into(), "hand".into()];
-        let parents = [None, Some(0)];
-        let pose = [FixedMat4::IDENTITY, FixedMat4::IDENTITY];
-
-        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
-        let capacities = matrices.buffer_capacities();
-        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
-
-        assert_eq!(capacities, matrices.buffer_capacities());
-    }
-
     #[test]
     fn model_scale_affects_gameplay_bones_without_changing_visual_locals() {
         let mut root = FixedMat4::IDENTITY;

src/fighter/baked_animation/runtime.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use super::BAKED_ANIMATION_FPS;
+use super::{BAKED_ANIMATION_FPS};
 
 use crate::{
     fighter::{
@@ -12,8 +12,8 @@ use crate::{
         manifest::FighterManifest,
         visual::FighterAnimations,
     },
-    math::fixed_transform::FixedMat4,
     math::int::FGi32,
+    math::fixed_transform::FixedMat4
 };
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -70,24 +70,12 @@ pub struct FighterBoneMatrices {
     previous_frame_matrices: Vec<FixedMat4>,
     local_matrices: Vec<FixedMat4>,
     previous_local_matrices: Vec<FixedMat4>,
-    model_matrices: Vec<Option<FixedMat4>>,
 }
 
 #[derive(Component, Clone, Debug, Default)]
 pub struct FighterBoneIndexMap(pub HashMap<String, usize>);
 
 impl FighterBoneMatrices {
-    #[cfg(test)]
-    pub(super) fn buffer_capacities(&self) -> [usize; 5] {
-        [
-            self.matrices.capacity(),
-            self.local_matrices.capacity(),
-            self.previous_frame_matrices.capacity(),
-            self.previous_local_matrices.capacity(),
-            self.model_matrices.capacity(),
-        ]
-    }
-
     pub fn get(&self, bone: &str) -> Option<(FixedMat4, FixedMat4)> {
         let index = self.bone_names.iter().position(|name| name == bone)?;
         Some((
@@ -154,19 +142,13 @@ impl FighterBoneMatrices {
             assert_eq!(self.bone_names, bone_names, "baked bone names changed");
             assert_eq!(self.parents, parents, "baked bone parents changed");
         }
-        self.matrices.reserve(local.len());
-        self.previous_frame_matrices.reserve(local.len());
-        self.local_matrices.reserve(local.len());
-        self.previous_local_matrices.reserve(local.len());
-        self.model_matrices.reserve(local.len());
         std::mem::swap(&mut self.matrices, &mut self.previous_frame_matrices);
         std::mem::swap(&mut self.local_matrices, &mut self.previous_local_matrices);
         self.local_matrices.clear();
         self.local_matrices.extend_from_slice(local);
-        self.model_matrices.resize(local.len(), None);
+        let mut model = vec![None; local.len()];
-        self.model_matrices.fill(None);
         for index in 0..local.len() {
-            resolve_model_transform(index, parents, local, &mut self.model_matrices)
+            resolve_model_transform(index, parents, local, &mut model)
                 .expect("baked bone hierarchy should be valid");
         }
         let model_scale = FixedMat4 {
@@ -177,12 +159,10 @@ impl FighterBoneMatrices {
                 [FGi32::ZERO, FGi32::ZERO, FGi32::ZERO, FGi32::ONE],
             ],
         };
-        self.matrices.clear();
+        self.matrices = model
-        self.matrices.extend(
+            .into_iter()
-            self.model_matrices.iter().map(|matrix| {
+            .map(|matrix| model_scale.mul(matrix.expect("baked bone hierarchy should be valid")))
-                model_scale.mul(matrix.expect("baked bone hierarchy should be valid"))
+            .collect();
-            }),
-        );
     }
 }
 

src/fighter/collision.rs

@@ -50,29 +50,31 @@ pub fn air_collide_with_stage(
         translation.0 + ecb.get_bottom_point(),
     );
 
-    stage_collision
+    let mut intersect_results = vec![];
-        .stage_polys
+
-        .iter()
+    for (poly_idx, poly) in stage_collision.stage_polys.iter().enumerate() {
-        .enumerate()
+        if let Some(intersect_result) = poly.intersect_ray(ray_segment) {
-        .filter_map(|(poly_idx, poly)| {
+            intersect_results.push((
-            poly.intersect_ray(ray_segment).map(|intersect_result| {
+                AirCollisionWithStageResult {
-                (
+                    line_id: {
-                    AirCollisionWithStageResult {
+                        StageLineID {
-                        line_id: {
+                            polygon: poly_idx,
-                            StageLineID {
+                            segment: intersect_result.segment_idx,
-                                polygon: poly_idx,
+                        }
-                                segment: intersect_result.segment_idx,
-                            }
-                        },
-                        hit_position: intersect_result.position,
-                        hit_normal: intersect_result.normal,
                     },
-                    intersect_result
+                    hit_position: intersect_result.position,
-                        .position
+                    hit_normal: intersect_result.normal,
-                        .distance_squared(ray_segment.point2()),
+                },
-                )
+                intersect_result
-            })
+                    .position
-        })
+                    .distance_squared(ray_segment.point2()),
-        .max_by(|(_, a), (_, b)| a.cmp(b))
+            ));
-        .map(|(result, _)| result)
+        }
+    }
+    intersect_results.sort_by(|(_, a), (_, b)| a.cmp(b));
+
+    intersect_results
+        .iter()
+        .last()
+        .map(|(val, _)| val.to_owned().clone())
 }

src/replay.rs

@@ -152,20 +152,6 @@ fn validate(replay: &Replay) -> Result<(), String> {
     {
         return Err("replay frames must be strictly ordered".into());
     }
-    if replay
-        .frames
-        .windows(2)
-        .any(|frames| frames[0].frame.checked_add(1) != Some(frames[1].frame))
-    {
-        return Err("replay frames must be contiguous".into());
-    }
-    if replay
-        .checksums
-        .windows(2)
-        .any(|checksums| checksums[0].frame >= checksums[1].frame)
-    {
-        return Err("replay checksums must be strictly ordered".into());
-    }
     if replay
         .frames
         .iter()
@@ -187,21 +173,6 @@ impl Replay {
         handles.sort_unstable();
         handles != (0..handles.len()).collect::<Vec<_>>()
     }
-
-    fn frame(&self, frame: i32) -> Option<&ReplayFrame> {
-        let first_frame = self.frames.first()?.frame;
-        let index = frame.checked_sub(first_frame)? as usize;
-        self.frames
-            .get(index)
-            .filter(|recorded| recorded.frame == frame)
-    }
-
-    fn checksum(&self, frame: i32) -> Option<u128> {
-        self.checksums
-            .binary_search_by_key(&frame, |checksum| checksum.frame)
-            .ok()
-            .map(|index| self.checksums[index].checksum)
-    }
 }
 
 fn start_replay(mut commands: Commands, args: Res<Args>, loaded: Option<Res<LoadedReplay>>) {
@@ -239,7 +210,11 @@ fn replay_inputs(
                 .insert(frame.0, inputs.iter().map(|(input, _)| *input).collect());
         }
         ReplayMode::Playback { replay, mismatch } if !*mismatch => {
-            let Some(recorded) = replay.frame(frame.0) else {
+            let Some(recorded) = replay
+                .frames
+                .iter()
+                .find(|recorded| recorded.frame == frame.0)
+            else {
                 error!("Replay has no input for frame {}", frame.0);
                 *mismatch = true;
                 return;
@@ -260,15 +235,21 @@ fn record_checksum(
     let Some(mut runtime) = runtime else { return };
     if matches!(&runtime.mode, ReplayMode::Record { .. }) {
         runtime.checksums.insert(frame.0, checksum.0);
-    } else if let ReplayMode::Playback { replay, mismatch } = &mut runtime.mode
+    } else if let ReplayMode::Playback { replay, mismatch } = &mut runtime.mode {
-        && let Some(expected) = replay.checksum(frame.0)
+        if let Some(expected) = replay
-        && expected != checksum.0
+            .checksums
-    {
+            .iter()
-        error!(
+            .find(|value| value.frame == frame.0)
-            "Replay desync at frame {}: expected {:X}, got {:X}",
+            .map(|value| value.checksum)
-            frame.0, expected, checksum.0
+        {
-        );
+            if expected != checksum.0 {
-        *mismatch = true;
+                error!(
+                    "Replay desync at frame {}: expected {:X}, got {:X}",
+                    frame.0, expected, checksum.0
+                );
+                *mismatch = true;
+            }
+        }
     }
 }
 
@@ -426,41 +407,4 @@ mod tests {
             "unsupported replay version 1"
         );
     }
-
-    #[test]
-    fn playback_lookups_use_frame_offsets_and_support_sparse_checksums() {
-        let mut replay = sample();
-        replay.frames[0].frame = 10;
-        replay.frames.push(ReplayFrame {
-            frame: 11,
-            inputs: replay.frames[0].inputs.clone(),
-        });
-        replay.checksums.push(ReplayChecksum {
-            frame: 11,
-            checksum: 84,
-        });
-        replay.checksums[0].frame = 10;
-        validate(&replay).unwrap();
-
-        assert_eq!(replay.frame(10).unwrap().frame, 10);
-        assert_eq!(replay.frame(11).unwrap().frame, 11);
-        assert!(replay.frame(9).is_none());
-        assert_eq!(replay.checksum(10), Some(42));
-        assert_eq!(replay.checksum(11), Some(84));
-        assert_eq!(replay.checksum(12), None);
-    }
-
-    #[test]
-    fn noncontiguous_input_frames_are_rejected() {
-        let mut replay = sample();
-        replay.frames.push(ReplayFrame {
-            frame: 3,
-            inputs: replay.frames[0].inputs.clone(),
-        });
-
-        assert_eq!(
-            validate(&replay).unwrap_err(),
-            "replay frames must be contiguous"
-        );
-    }
 }

tools/lldb_fixed.py

@@ -1,123 +0,0 @@
-"""LLDB summaries for Rust's `fixed` crate.
-
-Load this file from LLDB with:
-
-    command script import /path/to/shinespark/tools/lldb_fixed.py
-
-The implementation does not use floating-point arithmetic, so displayed values
-are exact even for FixedI128/FixedU128 values.
-"""
-
-import re
-
-try:
-    import lldb
-except ImportError:
-    # Keep the pure parsing and formatting helpers testable without LLDB.
-    lldb = None
-
-
-_FIXED_TYPE_RE = re.compile(r"(?:^|::)Fixed([IU])(8|16|32|64|128)<(.+)>$")
-_DIRECT_TYPENUM_RE = re.compile(r"(?:^|::)U(\d+)$")
-_TYPENUM_BIT_RE = re.compile(r"(?:^|::)B([01])(?=\s*[,>])")
-
-
-def parse_fixed_type(type_name):
-    """Return (signed, storage_bits, fractional_bits), or None."""
-    if not type_name:
-        return None
-
-    match = _FIXED_TYPE_RE.search(type_name.replace(" ", ""))
-    if match is None:
-        return None
-
-    signed = match.group(1) == "I"
-    storage_bits = int(match.group(2))
-    fractional_type = match.group(3)
-
-    direct = _DIRECT_TYPENUM_RE.search(fractional_type)
-    if direct is not None:
-        fractional_bits = int(direct.group(1))
-    else:
-        # typenum represents UInt<N, B> as a binary tree. Its textual Rust
-        # type lists the bits from most significant to least significant.
-        digits = _TYPENUM_BIT_RE.findall(fractional_type)
-        if not digits:
-            return None
-        fractional_bits = int("".join(digits), 2)
-
-    if fractional_bits > storage_bits:
-        return None
-    return signed, storage_bits, fractional_bits
-
-
-def normalize_bits(raw_bits, signed, storage_bits):
-    """Interpret a possibly unsigned LLDB integer using the fixed type's width."""
-    mask = (1 << storage_bits) - 1
-    raw_bits &= mask
-    if signed and raw_bits >= 1 << (storage_bits - 1):
-        raw_bits -= 1 << storage_bits
-    return raw_bits
-
-
-def format_fixed(raw_bits, fractional_bits):
-    """Format a scaled integer exactly as a decimal string."""
-    if fractional_bits == 0:
-        return str(raw_bits)
-
-    negative = raw_bits < 0
-    magnitude = -raw_bits if negative else raw_bits
-    whole = magnitude >> fractional_bits
-    remainder = magnitude & ((1 << fractional_bits) - 1)
-
-    if remainder == 0:
-        result = str(whole)
-    else:
-        # remainder / 2^n == (remainder * 5^n) / 10^n, which gives a finite,
-        # exact decimal representation without converting through a float.
-        decimal = str(remainder * 5**fractional_bits).zfill(fractional_bits)
-        result = f"{whole}.{decimal.rstrip('0')}"
-
-    return f"-{result}" if negative else result
-
-
-def _parse_lldb_integer(value):
-    text = value.GetValue()
-    if text is not None:
-        try:
-            return int(text, 0)
-        except ValueError:
-            pass
-
-    # GetValueAsUnsigned is also useful on LLDB versions that do not render
-    # primitive values through GetValue. It is sufficient for all <= 64-bit
-    # fixed types; current LLDB versions render i128/u128 through GetValue.
-    return value.GetValueAsUnsigned()
-
-
-def fixed_summary(value, _internal_dict):
-    layout = parse_fixed_type(value.GetTypeName())
-    if layout is None:
-        return None
-
-    signed, storage_bits, fractional_bits = layout
-    bits = value.GetChildMemberWithName("bits")
-    if not bits.IsValid():
-        return None
-
-    raw_bits = _parse_lldb_integer(bits)
-    raw_bits = normalize_bits(raw_bits, signed, storage_bits)
-    return format_fixed(raw_bits, fractional_bits)
-
-
-def __lldb_init_module(debugger, _internal_dict):
-    # LLDB's type-name regex sees the concrete fixed type rather than project
-    # aliases such as FGi32 and FGWide.
-    debugger.HandleCommand(
-        "type summary add --python-function lldb_fixed.fixed_summary "
-        "--category Shinespark --regex "
-        "'^fixed::Fixed(I|U)(8|16|32|64|128)<.+>$'"
-    )
-    # A dedicated category makes the formatter work even when CodeLLDB has not
-    # enabled rustc's standard `Rust` formatter category yet.
-    debugger.HandleCommand("type category enable Shinespark")

tools/test_lldb_fixed.py

@@ -1,58 +0,0 @@
-import unittest
-
-import lldb_fixed
-
-
-class ParseFixedTypeTests(unittest.TestCase):
-    def test_direct_typenum_alias(self):
-        self.assertEqual(
-            lldb_fixed.parse_fixed_type("fixed::FixedI32<typenum::uint::U16>"),
-            (True, 32, 16),
-        )
-
-    def test_expanded_typenum(self):
-        type_name = (
-            "fixed::FixedI32<"
-            "typenum::uint::UInt<"
-            "typenum::uint::UInt<"
-            "typenum::uint::UInt<"
-            "typenum::uint::UInt<"
-            "typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, "
-            "typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, "
-            "typenum::bit::B0>>"
-        )
-        self.assertEqual(lldb_fixed.parse_fixed_type(type_name), (True, 32, 16))
-
-    def test_unsigned_type(self):
-        self.assertEqual(
-            lldb_fixed.parse_fixed_type("fixed::FixedU64<typenum::uint::U24>"),
-            (False, 64, 24),
-        )
-
-    def test_unrelated_type(self):
-        self.assertIsNone(lldb_fixed.parse_fixed_type("core::primitive::i32"))
-
-
-class FormatFixedTests(unittest.TestCase):
-    def test_q16_16(self):
-        self.assertEqual(lldb_fixed.format_fixed(3 << 15, 16), "1.5")
-        self.assertEqual(lldb_fixed.format_fixed(-(3 << 15), 16), "-1.5")
-        self.assertEqual(lldb_fixed.format_fixed(1, 16), "0.0000152587890625")
-
-    def test_integer_value_has_no_decimal_suffix(self):
-        self.assertEqual(lldb_fixed.format_fixed(12 << 16, 16), "12")
-
-    def test_q96_32(self):
-        raw = (1 << 100) + (1 << 31)
-        self.assertEqual(
-            lldb_fixed.format_fixed(raw, 32),
-            "295147905179352825856.5",
-        )
-
-    def test_twos_complement_normalization(self):
-        self.assertEqual(lldb_fixed.normalize_bits(0xFFFF8000, True, 32), -32768)
-        self.assertEqual(lldb_fixed.normalize_bits(0xFFFF8000, False, 32), 0xFFFF8000)
-
-
-if __name__ == "__main__":
-    unittest.main()