Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 EIREXE
|
f22f5c5dbc |
@@ -50,94 +50,3 @@ jobs:
|
||||
|
||||
- name: Run unit tests
|
||||
run: cargo test --locked --lib -j 4
|
||||
|
||||
production-build:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- name: Check out source
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Install Rust toolchain
|
||||
run: |
|
||||
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
|
||||
sh -s -- -y --profile minimal
|
||||
echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
|
||||
"$HOME/.cargo/bin/rustup" toolchain install nightly-2026-09-14 --profile minimal
|
||||
|
||||
- name: Install Windows build tooling
|
||||
run: |
|
||||
"$HOME/.cargo/bin/rustup" target add x86_64-pc-windows-msvc --toolchain nightly-2026-09-14
|
||||
"$HOME/.cargo/bin/cargo" install cargo-xwin --locked
|
||||
|
||||
- name: Cache production Rust dependencies and build artifacts
|
||||
uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
|
||||
with:
|
||||
prefix-key: v2-rust
|
||||
shared-key: linux-nightly-production
|
||||
cache-bin: false
|
||||
|
||||
- name: Install Linux dependencies
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install --no-install-recommends -y \
|
||||
clang-19 \
|
||||
libasound2-dev \
|
||||
libudev-dev \
|
||||
libusb-1.0-0-dev \
|
||||
libwayland-dev \
|
||||
libx11-dev \
|
||||
libxkbcommon-dev \
|
||||
libxkbcommon-x11-0 \
|
||||
lld-19 \
|
||||
llvm-19 \
|
||||
mesa-vulkan-drivers \
|
||||
mold \
|
||||
pkg-config
|
||||
sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-19 100
|
||||
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-19 100
|
||||
echo "/usr/lib/llvm-19/bin" >> "$GITHUB_PATH"
|
||||
rm -f "$HOME/.cache/cargo-xwin/clang-cl"
|
||||
|
||||
- name: Preprocess assets
|
||||
run: cargo run --locked --bin process-assets --no-default-features --features debug_features -j 4
|
||||
|
||||
- name: Build production binary
|
||||
run: cargo build --locked --profile production --no-default-features --features debug_features -j 4
|
||||
|
||||
- name: Build Windows production binary
|
||||
run: |
|
||||
clang --version
|
||||
cargo xwin build --locked --target x86_64-pc-windows-msvc --profile production --no-default-features --features debug_features -j 4 --bin shinespark
|
||||
|
||||
- name: Verify production binary is not Bevy/Rust dynamically linked
|
||||
run: |
|
||||
! readelf -d target/production/shinespark | grep -E 'libbevy_dylib|libstd-.*\.so'
|
||||
|
||||
- name: Package Linux Steam depot
|
||||
if: github.event_name == 'push' && github.ref == 'refs/heads/master'
|
||||
run: |
|
||||
mkdir -p build/game
|
||||
cp target/production/shinespark build/game/shinespark
|
||||
cp target/x86_64-pc-windows-msvc/production/shinespark.exe build/game/shinespark.exe
|
||||
cp -R imported_assets build/game/imported_assets
|
||||
|
||||
- if: github.event_name == 'push' && github.ref == 'refs/heads/master'
|
||||
uses: CyberAndrii/steam-totp@v1
|
||||
name: Generate Steam TOTP
|
||||
id: steam-totp
|
||||
with:
|
||||
shared_secret: ${{ secrets.STEAM_SHARED_SECRET }}
|
||||
|
||||
- name: Deploy Linux build to Steam
|
||||
if: github.event_name == 'push' && github.ref == 'refs/heads/master'
|
||||
uses: game-ci/steam-deploy@v3
|
||||
with:
|
||||
username: ${{ secrets.STEAM_USERNAME }}
|
||||
password: ${{ secrets.STEAM_PASSWORD }}
|
||||
totp: ${{ steps.steam-totp.outputs.code }}
|
||||
appId: 3409670
|
||||
buildDescription: ${{ github.sha }}
|
||||
rootPath: build
|
||||
depot1Path: game
|
||||
releaseBranch: master
|
||||
|
||||
@@ -10,7 +10,3 @@ imported_assets
|
||||
*_old.glb
|
||||
/replay.json
|
||||
*.replay.tmp
|
||||
|
||||
# Python debugger formatter tests
|
||||
__pycache__/
|
||||
*.pyc
|
||||
|
||||
Generated
+118
-7
@@ -94,6 +94,12 @@ version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
|
||||
|
||||
[[package]]
|
||||
name = "adler32"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
|
||||
|
||||
[[package]]
|
||||
name = "ahash"
|
||||
version = "0.8.12"
|
||||
@@ -2090,6 +2096,14 @@ dependencies = [
|
||||
"thread_local",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bevy_wind_waker_shader"
|
||||
version = "0.6.0"
|
||||
source = "git+https://github.com/lavaeater/bevy_wind_waker_shader.git#1b017c3ef6a4fbdaff115df9ec5ae4954b2fb6ba"
|
||||
dependencies = [
|
||||
"bevy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bevy_window"
|
||||
version = "0.19.0"
|
||||
@@ -2218,6 +2232,32 @@ dependencies = [
|
||||
"varinteger",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitfields"
|
||||
version = "3.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ca5a55e8cbc3b75d1f002a3b62261ab67954755f7e7866f079b8aa63a409b549"
|
||||
dependencies = [
|
||||
"bitfields-impl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitfields-impl"
|
||||
version = "3.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "797cb6b6e8d5e8c2ecbb5ef52b7c273596d58ce1ab79ef2a6c38fa8dca0817c5"
|
||||
dependencies = [
|
||||
"derive_more",
|
||||
"getset",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"rustversion",
|
||||
"strum",
|
||||
"strum_macros",
|
||||
"syn 2.0.119",
|
||||
"thiserror 2.0.19",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
@@ -3202,6 +3242,16 @@ dependencies = [
|
||||
"windows-sys 0.60.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "filetime"
|
||||
version = "0.2.29"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "find-msvc-tools"
|
||||
version = "0.1.9"
|
||||
@@ -3418,9 +3468,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "gc-adapter-neo"
|
||||
version = "1.1.1"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a8d3e10c6c4b928cb559f641765ebaa40f5f099bf51bc0227af7431859f8bd84"
|
||||
checksum = "120a5b3858ae854c4674ae41a38173e8ea04b814fb3212fd3bdd1b04d414a9d7"
|
||||
dependencies = [
|
||||
"binread",
|
||||
"modular-bitfield",
|
||||
@@ -3473,6 +3523,17 @@ dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "getset"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6cf442baaabe4213ce7d1239afc26c039180b6456da2cededa316ae2c8a77a77"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ggrs"
|
||||
version = "0.13.0"
|
||||
@@ -4250,6 +4311,26 @@ version = "0.2.189"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
|
||||
|
||||
[[package]]
|
||||
name = "libflate"
|
||||
version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5ff4ae71b685bbad2f2f391fe74f6b7659a34871c08b210fdc039e43bee07d18"
|
||||
dependencies = [
|
||||
"adler32",
|
||||
"crc32fast",
|
||||
"libflate_lz77",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libflate_lz77"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a52d3a8bfc85f250440e4424db7d857e241a3aebbbe301f3eb606ab15c39acbf"
|
||||
dependencies = [
|
||||
"rle-decode-fast",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.8.9"
|
||||
@@ -4290,13 +4371,15 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "libusb1-sys"
|
||||
version = "0.7.0"
|
||||
version = "0.4.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "da050ade7ac4ff1ba5379af847a10a10a8e284181e060105bf8d86960ce9ce0f"
|
||||
checksum = "be241693102a24766d0b8526c8988771edac2842630d7e730f8e9fbc014f3703"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"libc",
|
||||
"libflate",
|
||||
"pkg-config",
|
||||
"tar",
|
||||
"vcpkg",
|
||||
]
|
||||
|
||||
@@ -5802,6 +5885,12 @@ dependencies = [
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rle-decode-fast"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
|
||||
|
||||
[[package]]
|
||||
name = "robust"
|
||||
version = "1.2.0"
|
||||
@@ -5872,9 +5961,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rusb"
|
||||
version = "0.9.4"
|
||||
version = "0.6.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ab9f9ff05b63a786553a4c02943b74b34a988448671001e9a27e2f0565cc05a4"
|
||||
checksum = "f6f32cd45962594f9f8cd4547b5757132715600e2c8840aa9ccd3d1a9ed6fdc6"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"libusb1-sys",
|
||||
@@ -6081,8 +6170,9 @@ dependencies = [
|
||||
"bevy_asset_loader",
|
||||
"bevy_egui",
|
||||
"bevy_ggrs",
|
||||
"bevy_wind_waker_shader",
|
||||
"bincode",
|
||||
"blake3",
|
||||
"bitfields",
|
||||
"clap",
|
||||
"enum_cycling",
|
||||
"enum_cycling_derive",
|
||||
@@ -6452,6 +6542,17 @@ dependencies = [
|
||||
"slotmap",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tar"
|
||||
version = "0.4.46"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
|
||||
dependencies = [
|
||||
"filetime",
|
||||
"libc",
|
||||
"xattr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "termcolor"
|
||||
version = "1.4.1"
|
||||
@@ -7857,6 +7958,16 @@ version = "0.13.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
|
||||
|
||||
[[package]]
|
||||
name = "xattr"
|
||||
version = "1.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"rustix 1.1.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "xcursor"
|
||||
version = "0.3.11"
|
||||
|
||||
+4
-14
@@ -6,17 +6,11 @@ authors = [""]
|
||||
|
||||
[workspace]
|
||||
|
||||
[features]
|
||||
default = ["development", "debug_features"]
|
||||
development = ["bevy/dynamic_linking", "bevy/file_watcher"]
|
||||
debug_features = ["bevy/free_camera"]
|
||||
|
||||
[dependencies]
|
||||
bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "bevy_settings"] }
|
||||
bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "dynamic_linking", "free_camera", "file_watcher", "bevy_settings"] }
|
||||
# Loads the scenes you author in the editor (assets/*.bsn) and builds
|
||||
# physics colliders from them. An ordinary dependency; remove it if you
|
||||
# stop using authored scenes.
|
||||
blake3 = { version = "1.8.5", features = [ "pure" ] }
|
||||
thiserror = "2"
|
||||
avian3d = "0.7"
|
||||
arrayvec = "0.7.8"
|
||||
@@ -28,13 +22,15 @@ serde_json = "1.0.145"
|
||||
bincode = "1.3.3"
|
||||
gltf = "1.4.1"
|
||||
ron = "0.12.0"
|
||||
bitfields = "3.0.0"
|
||||
clap = { version = "4.6.6", features = ["derive"] }
|
||||
bevy_wind_waker_shader = { git = "https://github.com/lavaeater/bevy_wind_waker_shader.git" }
|
||||
fixed = { version = "1.31.0", features = ["serde", "serde-str"] }
|
||||
strum = "0.28.0"
|
||||
strum_macros = "0.28.0"
|
||||
bevy_asset_loader = "0.27.0"
|
||||
ron_asset_manager = "0.9.0"
|
||||
gc-adapter-neo = { version = "1.1.1", features = ["libusb"] }
|
||||
gc-adapter-neo = { version = "1.1.0", features = ["libusb"] }
|
||||
rhai = "1.26.0"
|
||||
enum_cycling = "0.2.1"
|
||||
enum_cycling_derive = "0.2.1"
|
||||
@@ -43,9 +39,3 @@ fixed_math = "0.4.1"
|
||||
# Enable a large amount of optimization in the dev profile for dependencies.
|
||||
[profile.dev.package."*"]
|
||||
opt-level = 3
|
||||
|
||||
[profile.production]
|
||||
inherits = "release"
|
||||
lto = "thin"
|
||||
codegen-units = 1
|
||||
strip = "symbols"
|
||||
|
||||
@@ -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
|
||||
@@ -22,12 +13,3 @@ cargo run -- --debug-match --players 2 --local-port 7000 \
|
||||
cargo run -- --debug-match --players 2 --local-port 7001 \
|
||||
--net-player 0=127.0.0.1:7000 --net-player 1=local
|
||||
```
|
||||
|
||||
## Production Build
|
||||
|
||||
```sh
|
||||
cargo run --locked \
|
||||
--bin process-assets --no-default-features --features debug_features
|
||||
cargo build --locked \
|
||||
--profile production --no-default-features --features debug_features
|
||||
```
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 42 KiB |
@@ -1,36 +0,0 @@
|
||||
use bevy::{
|
||||
app::ScheduleRunnerPlugin,
|
||||
asset::{AssetMode, AssetPlugin, processor::AssetProcessor, processor::ProcessorState},
|
||||
gltf::GltfPlugin,
|
||||
image::{CompressedImageFormats, ImageLoader, ImagePlugin},
|
||||
prelude::*,
|
||||
tasks::block_on,
|
||||
text::TextPlugin,
|
||||
};
|
||||
use shinespark::AssetProcessingPlugin;
|
||||
use std::{process::ExitCode, time::Duration};
|
||||
|
||||
fn main() -> ExitCode {
|
||||
let mut app = App::new();
|
||||
app.add_plugins(MinimalPlugins.set(ScheduleRunnerPlugin::run_loop(Duration::from_millis(50))))
|
||||
.add_plugins(AssetPlugin {
|
||||
mode: AssetMode::Processed,
|
||||
use_asset_processor_override: Some(true),
|
||||
..default()
|
||||
})
|
||||
.add_plugins((ImagePlugin::default(), TextPlugin, GltfPlugin::default()))
|
||||
.register_asset_loader(ImageLoader::new(CompressedImageFormats::NONE))
|
||||
.add_plugins(AssetProcessingPlugin)
|
||||
.add_systems(Update, finish_when_processed);
|
||||
|
||||
app.run();
|
||||
ExitCode::SUCCESS
|
||||
}
|
||||
|
||||
fn finish_when_processed(processor: Option<Res<AssetProcessor>>, mut exit: MessageWriter<AppExit>) {
|
||||
if processor
|
||||
.is_some_and(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
|
||||
{
|
||||
exit.write(AppExit::Success);
|
||||
}
|
||||
}
|
||||
@@ -32,15 +32,9 @@ use crate::{
|
||||
#[derive(Deref, Component, Default, Hash, Debug, Copy, Clone)]
|
||||
pub struct FighterKnockbackVelocity(pub FGVec2);
|
||||
|
||||
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash, PartialEq)]
|
||||
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash)]
|
||||
pub struct FighterDamage(FGi32);
|
||||
|
||||
impl std::fmt::Display for FighterDamage {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{:.2}", self.0)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Hash, Clone)]
|
||||
pub enum HitReactionKind {
|
||||
Flinch,
|
||||
@@ -54,7 +48,6 @@ pub struct FighterHitReaction {
|
||||
pub hitstop_frames: HitStop,
|
||||
pub hitstun_frames: u32,
|
||||
pub kind: HitReactionKind,
|
||||
pub damage: FighterDamage,
|
||||
}
|
||||
|
||||
#[derive(Component, DerefMut, Deref, Debug, Default, Hash, Clone)]
|
||||
|
||||
@@ -11,9 +11,9 @@ use crate::{
|
||||
pub fn resolve_fighter_hits(
|
||||
mut pending_hits: ResMut<FighterPendingHits>,
|
||||
mut attacker: Query<(
|
||||
&mut FighterStaleMoveQueue,
|
||||
&FighterStaleMoveQueue,
|
||||
&FighterFacingDirection,
|
||||
&mut FighterHitboxes,
|
||||
&FighterHitboxes,
|
||||
&Player,
|
||||
&mut FighterHitstop,
|
||||
&mut FighterHitstopShake,
|
||||
@@ -42,7 +42,7 @@ pub fn resolve_fighter_hits(
|
||||
let damage_data = hits[hit_offset..next_defender]
|
||||
.iter()
|
||||
.filter_map(|hit| {
|
||||
let Ok((stale_move_queue, facing_dir, _, player, _, _)) =
|
||||
let Ok((stale_move_queue, facing_dir, _hitboxes, player, _, _)) =
|
||||
attacker.get(hit.attacker)
|
||||
else {
|
||||
return None;
|
||||
@@ -52,6 +52,7 @@ pub fn resolve_fighter_hits(
|
||||
let damage_received = stale_move_queue
|
||||
.get_attack_damage_multiplier(hit.attack_kind)
|
||||
* hitbox.damage.0;
|
||||
|
||||
Some((
|
||||
hit.attacker,
|
||||
damage_received,
|
||||
@@ -89,7 +90,6 @@ pub fn resolve_fighter_hits(
|
||||
angle
|
||||
};
|
||||
|
||||
// Attacker hitstop and data
|
||||
let hitstop = HitStop::calculate(FighterDamage(attack_damage), false);
|
||||
reactions.push((
|
||||
attacker_entity,
|
||||
@@ -100,7 +100,6 @@ pub fn resolve_fighter_hits(
|
||||
hitstun_frames: knockback.get_hitstun_frames(&game_settings),
|
||||
hitstop_frames: hitstop,
|
||||
kind: HitReactionKind::Flinch,
|
||||
damage: FighterDamage(attack_damage)
|
||||
},
|
||||
));
|
||||
}
|
||||
@@ -108,7 +107,7 @@ pub fn resolve_fighter_hits(
|
||||
receiver_damage.0 += total_damage_received_this_frame;
|
||||
|
||||
for (attacker_entity, _, reaction) in &reactions {
|
||||
let Ok((.., _, mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity) else {
|
||||
let Ok((.., mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
@@ -135,19 +134,6 @@ pub fn resolve_fighter_hits(
|
||||
hit_offset = next_defender;
|
||||
}
|
||||
|
||||
for hit in hits {
|
||||
let Ok((mut stale_move_queue, _facing_direction, mut hitboxes, ..)) = attacker.get_mut(hit.attacker) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if let Some(ref mut hitbox) = hitboxes.0 {
|
||||
if !hitbox.stalled {
|
||||
hitbox.stalled = true;
|
||||
stale_move_queue.push(hitbox.kind);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -151,10 +151,7 @@ type FighterBakeProcessor = LoadTransformAndSave<
|
||||
>;
|
||||
|
||||
pub struct BakedAnimationPlugin;
|
||||
|
||||
pub struct BakedAnimationAssetProcessingPlugin;
|
||||
|
||||
impl Plugin for BakedAnimationAssetProcessingPlugin {
|
||||
impl Plugin for BakedAnimationPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.init_asset::<BakedFighterAnimations>()
|
||||
.register_asset_loader(FighterBakeSourceLoader)
|
||||
@@ -163,13 +160,7 @@ impl Plugin for BakedAnimationAssetProcessingPlugin {
|
||||
FighterBakeTransformer,
|
||||
BakedFighterAnimationsSaver,
|
||||
))
|
||||
.set_default_asset_processor::<FighterBakeProcessor>("fighterbake");
|
||||
}
|
||||
}
|
||||
|
||||
impl Plugin for BakedAnimationPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_plugins(BakedAnimationAssetProcessingPlugin)
|
||||
.set_default_asset_processor::<FighterBakeProcessor>("fighterbake")
|
||||
.add_systems(
|
||||
bevy_ggrs::prelude::GgrsSchedule,
|
||||
super::runtime::update_fighter_bone_matrices
|
||||
|
||||
@@ -4,8 +4,8 @@ mod asset_baking;
|
||||
mod runtime;
|
||||
mod visual_binding;
|
||||
|
||||
pub use asset_baking::BakedAnimationPlugin;
|
||||
pub use crate::math::fixed_transform::FixedMat4;
|
||||
pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
|
||||
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;
|
||||
|
||||
@@ -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);
|
||||
self.model_matrices.fill(None);
|
||||
let mut model = vec![None; local.len()];
|
||||
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.extend(
|
||||
self.model_matrices.iter().map(|matrix| {
|
||||
model_scale.mul(matrix.expect("baked bone hierarchy should be valid"))
|
||||
}),
|
||||
);
|
||||
self.matrices = model
|
||||
.into_iter()
|
||||
.map(|matrix| model_scale.mul(matrix.expect("baked bone hierarchy should be valid")))
|
||||
.collect();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+14
-12
@@ -50,13 +50,11 @@ pub fn air_collide_with_stage(
|
||||
translation.0 + ecb.get_bottom_point(),
|
||||
);
|
||||
|
||||
stage_collision
|
||||
.stage_polys
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(poly_idx, poly)| {
|
||||
poly.intersect_ray(ray_segment).map(|intersect_result| {
|
||||
(
|
||||
let mut intersect_results = vec![];
|
||||
|
||||
for (poly_idx, poly) in stage_collision.stage_polys.iter().enumerate() {
|
||||
if let Some(intersect_result) = poly.intersect_ray(ray_segment) {
|
||||
intersect_results.push((
|
||||
AirCollisionWithStageResult {
|
||||
line_id: {
|
||||
StageLineID {
|
||||
@@ -70,9 +68,13 @@ pub fn air_collide_with_stage(
|
||||
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())
|
||||
}
|
||||
|
||||
@@ -259,7 +259,6 @@ pub struct FighterActiveAttack {
|
||||
pub active_hitboxes: Vec<usize>,
|
||||
pub solved_hitboxes: Vec<attack::FighterSolvedHitbox>,
|
||||
pub hit_fighters: Vec<Entity>,
|
||||
pub stalled: bool
|
||||
}
|
||||
|
||||
#[derive(Component, Clone, Debug, Default, Hash)]
|
||||
|
||||
@@ -47,13 +47,13 @@ impl FighterStateImpl for GroundAttackState {
|
||||
fn on_enter(&mut self, state_context: &mut EnterContext) {
|
||||
state_context.play_animation(self.attack_kind.get_animation(), false);
|
||||
let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
|
||||
state_context.stale_move_queue.push(self.attack_kind);
|
||||
state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
|
||||
kind: self.attack_kind,
|
||||
script,
|
||||
active_hitboxes: Vec::new(),
|
||||
solved_hitboxes: Vec::new(),
|
||||
hit_fighters: Vec::new(),
|
||||
stalled: false
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
+7
-38
@@ -28,13 +28,13 @@ use bevy::{
|
||||
tasks::block_on,
|
||||
};
|
||||
use bevy_asset_loader::prelude::*;
|
||||
use bevy_wind_waker_shader::prelude::*;
|
||||
use clap::Parser;
|
||||
use ron_asset_manager::RonAssetPlugin;
|
||||
|
||||
use crate::{
|
||||
camera::MatchCameraPlugin, fighter::manifest::FighterManifest, game_settings::GameSettings,
|
||||
match_runtime::MatchRuntimePlugin, menus::style::FGUiStyle, schedule::GameplaySchedulePlugin,
|
||||
stage::manifest::StageManifest, ui::InGameUIPlugin,
|
||||
schedule::GameplaySchedulePlugin, stage::manifest::StageManifest,
|
||||
};
|
||||
|
||||
mod args;
|
||||
@@ -44,7 +44,6 @@ pub mod fighter;
|
||||
pub mod game_settings;
|
||||
pub mod input;
|
||||
pub mod match_loading;
|
||||
pub mod match_runtime;
|
||||
mod math;
|
||||
pub mod menus;
|
||||
pub mod netcode;
|
||||
@@ -54,7 +53,6 @@ pub mod schedule;
|
||||
pub mod scripting;
|
||||
pub mod stage;
|
||||
pub mod texture_reference;
|
||||
pub mod ui;
|
||||
|
||||
#[derive(States, Debug, Clone, Copy, Eq, PartialEq, Hash, Default)]
|
||||
pub enum AppState {
|
||||
@@ -83,20 +81,6 @@ pub enum AppState {
|
||||
#[derive(Default)]
|
||||
pub struct GamePlugin;
|
||||
|
||||
/// Registers every custom asset loader used by the game and asset processor.
|
||||
pub struct GameAssetPlugin;
|
||||
|
||||
impl Plugin for GameAssetPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_plugins((
|
||||
RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
|
||||
RonAssetPlugin::<StageManifest>::create("stage.ron"),
|
||||
RonAssetPlugin::<GameSettings>::create("ron"),
|
||||
RonAssetPlugin::<FGUiStyle>::create("stylesheet.ron"),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
impl Plugin for GamePlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
// Each module owns its own systems, rollback registrations and
|
||||
@@ -105,10 +89,10 @@ impl Plugin for GamePlugin {
|
||||
app.init_state::<AppState>()
|
||||
.add_plugins((
|
||||
SettingsPlugin::new("moe.eirteam.shinespark.debug_settings"),
|
||||
WindWakerShaderPlugin::default(),
|
||||
// Brings up GGRS (and with it `GgrsSchedule`), so it goes first.
|
||||
netcode::FighterNetcodePlugin::default(),
|
||||
GameplaySchedulePlugin,
|
||||
MatchRuntimePlugin,
|
||||
input::FighterInputPlugin,
|
||||
replay::ReplayPlugin,
|
||||
debug_tools::DebugToolsPlugin,
|
||||
@@ -117,8 +101,9 @@ impl Plugin for GamePlugin {
|
||||
scripting::importer::FighterScriptImportPlugin,
|
||||
stage::StagePlugin,
|
||||
MatchCameraPlugin,
|
||||
GameAssetPlugin,
|
||||
InGameUIPlugin,
|
||||
RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
|
||||
RonAssetPlugin::<StageManifest>::create("stage.ron"),
|
||||
RonAssetPlugin::<GameSettings>::create("ron"),
|
||||
))
|
||||
.add_plugins(menus::MenuPlugin)
|
||||
.add_loading_state(
|
||||
@@ -171,27 +156,11 @@ impl Plugin for GamePlugin {
|
||||
}
|
||||
}
|
||||
|
||||
/// Registers the custom asset loaders and processors used by CI and release
|
||||
/// builds. The processing binary adds this plugin without starting the game.
|
||||
pub struct AssetProcessingPlugin;
|
||||
|
||||
impl Plugin for AssetProcessingPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_plugins((
|
||||
GameAssetPlugin,
|
||||
scripting::importer::FighterScriptImportPlugin,
|
||||
fighter::baked_animation::BakedAnimationAssetProcessingPlugin,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
fn wait_for_asset_processor(
|
||||
processor: Option<Res<AssetProcessor>>,
|
||||
mut next_state: ResMut<NextState<AppState>>,
|
||||
) {
|
||||
if !cfg!(feature = "development")
|
||||
|| processor
|
||||
.is_none_or(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
|
||||
if processor.is_none_or(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
|
||||
{
|
||||
next_state.set(AppState::LoadCommonAssets);
|
||||
}
|
||||
|
||||
+7
-16
@@ -1,11 +1,8 @@
|
||||
use bevy::asset::AssetMode::Processed;
|
||||
#[cfg(feature = "debug_features")]
|
||||
use bevy::camera_controller::free_camera::FreeCameraPlugin;
|
||||
use bevy::image::{ImageAddressMode, ImagePlugin, ImageSamplerDescriptor};
|
||||
use bevy::prelude::*;
|
||||
#[cfg(feature = "debug_features")]
|
||||
use bevy_egui::EguiPlugin;
|
||||
#[cfg(feature = "debug_features")]
|
||||
use bevy_inspector_egui::quick::WorldInspectorPlugin;
|
||||
|
||||
fn main() -> AppExit {
|
||||
@@ -23,22 +20,16 @@ fn main() -> AppExit {
|
||||
})
|
||||
.set(AssetPlugin {
|
||||
mode: Processed,
|
||||
use_asset_processor_override: Some(cfg!(feature = "development")),
|
||||
..default()
|
||||
});
|
||||
|
||||
let mut app = App::new();
|
||||
app.add_plugins(default_plugins)
|
||||
App::new()
|
||||
.add_plugins(default_plugins)
|
||||
.add_plugins(avian3d::prelude::PhysicsPlugins::default())
|
||||
.add_plugins(shinespark::GamePlugin)
|
||||
.insert_resource(Time::<Fixed>::from_hz(60.0));
|
||||
|
||||
#[cfg(feature = "debug_features")]
|
||||
app.add_plugins((
|
||||
FreeCameraPlugin,
|
||||
EguiPlugin::default(),
|
||||
WorldInspectorPlugin::default(),
|
||||
));
|
||||
|
||||
app.run()
|
||||
.add_plugins(FreeCameraPlugin)
|
||||
.add_plugins(EguiPlugin::default())
|
||||
.add_plugins(WorldInspectorPlugin::default()) // adds default options and `InspectorEguiImpl`s
|
||||
.insert_resource(Time::<Fixed>::from_hz(60.0))
|
||||
.run()
|
||||
}
|
||||
|
||||
+33
-126
@@ -8,29 +8,28 @@ use bevy_ggrs::prelude::Session;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
AppState,
|
||||
args::Args,
|
||||
fighter::{
|
||||
FighterId, FighterRoster,
|
||||
animation::AnimKind,
|
||||
attack::{AttackKind, FighterAttackScriptAssets},
|
||||
baked_animation::{BAKED_ANIMATION_FPS, BakedFighterAnimations},
|
||||
baked_animation::{BakedFighterAnimations, BAKED_ANIMATION_FPS},
|
||||
manifest::{FighterManifest, FighterManifestRegistry},
|
||||
spawn_fighter,
|
||||
visual::FighterAnimations,
|
||||
FighterId, FighterRoster,
|
||||
},
|
||||
input::{LocalInputAssignments, LocalInputSource},
|
||||
match_runtime::MatchState,
|
||||
math::{int::FGi32, vec::FGVec2},
|
||||
netcode::{
|
||||
session::{create_session, ConnectionStatus, SessionConfig},
|
||||
GGRSCfg,
|
||||
session::{ConnectionStatus, SessionConfig, create_session},
|
||||
},
|
||||
scripting::FighterAttackScript,
|
||||
stage::{
|
||||
self,
|
||||
manifest::{StageId, StageManifest, StageManifestRegistry},
|
||||
},
|
||||
AppState,
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -39,49 +38,10 @@ pub struct MatchPlayer {
|
||||
pub fighter: FighterId,
|
||||
}
|
||||
|
||||
#[derive(Resource, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub struct MatchConfig {
|
||||
#[derive(Resource, Debug, Clone, PartialEq, Eq)]
|
||||
pub struct PendingMatch {
|
||||
pub stage: StageId,
|
||||
pub players: Vec<MatchPlayer>,
|
||||
pub rules: MatchRules,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
pub enum MatchRules {
|
||||
Stock {
|
||||
starting_stocks: u8,
|
||||
time_limit_frames: Option<u32>,
|
||||
},
|
||||
Timed {
|
||||
time_limit_frames: u32,
|
||||
},
|
||||
}
|
||||
|
||||
impl Default for MatchRules {
|
||||
fn default() -> Self {
|
||||
Self::Stock {
|
||||
starting_stocks: 3,
|
||||
time_limit_frames: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MatchRules {
|
||||
fn validate(&self) -> Result<(), &'static str> {
|
||||
match self {
|
||||
Self::Stock {
|
||||
starting_stocks: 0, ..
|
||||
} => Err("stock matches must start with at least one stock"),
|
||||
Self::Stock {
|
||||
time_limit_frames: Some(0),
|
||||
..
|
||||
} => Err("stock match time limits must be greater than zero frames"),
|
||||
Self::Timed {
|
||||
time_limit_frames: 0,
|
||||
} => Err("timed match limits must be greater than zero frames"),
|
||||
_ => Ok(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct SelectedFighterAssets {
|
||||
@@ -99,7 +59,7 @@ pub struct MatchAssets {
|
||||
|
||||
impl MatchAssets {
|
||||
fn requested(world: &World) -> Self {
|
||||
let config = world.resource::<MatchConfig>();
|
||||
let request = world.resource::<PendingMatch>();
|
||||
let asset_server = world.resource::<AssetServer>();
|
||||
let registry = world.resource::<FighterManifestRegistry>();
|
||||
let stage_registry = world.resource::<StageManifestRegistry>();
|
||||
@@ -107,7 +67,7 @@ impl MatchAssets {
|
||||
let stage_manifests = world.resource::<Assets<StageManifest>>();
|
||||
|
||||
let stage_handle = stage_registry
|
||||
.get(config.stage)
|
||||
.get(request.stage)
|
||||
.expect("Startup validation guarantees every stage has a manifest");
|
||||
let stage_manifest = stage_manifests
|
||||
.get(&stage_handle)
|
||||
@@ -115,7 +75,7 @@ impl MatchAssets {
|
||||
|
||||
Self {
|
||||
stage: asset_server.load(stage_manifest.model_path.clone()),
|
||||
fighters: config
|
||||
fighters: request
|
||||
.players
|
||||
.iter()
|
||||
.map(|player| {
|
||||
@@ -181,10 +141,10 @@ pub struct MatchRoot;
|
||||
pub fn initiate_match(
|
||||
commands: &mut Commands,
|
||||
next_state: &mut NextState<AppState>,
|
||||
config: MatchConfig,
|
||||
request: PendingMatch,
|
||||
) {
|
||||
commands.remove_resource::<crate::netcode::session::MatchDisconnected>();
|
||||
commands.insert_resource(config);
|
||||
commands.insert_resource(request);
|
||||
next_state.set(AppState::LoadingMatch);
|
||||
}
|
||||
|
||||
@@ -206,9 +166,12 @@ pub fn initiate_default_match(
|
||||
if let Some(path) = &args.play_replay {
|
||||
match crate::replay::load(path) {
|
||||
Ok(replay) => {
|
||||
let config = replay.match_config.clone();
|
||||
let request = PendingMatch {
|
||||
stage: replay.match_config.stage,
|
||||
players: replay.match_config.players.clone(),
|
||||
};
|
||||
commands.insert_resource(crate::replay::LoadedReplay(replay));
|
||||
initiate_match(&mut commands, &mut next_state, config);
|
||||
initiate_match(&mut commands, &mut next_state, request);
|
||||
}
|
||||
Err(error) => {
|
||||
error!("Replay load failed: {error}");
|
||||
@@ -252,17 +215,16 @@ pub fn initiate_default_match(
|
||||
initiate_match(
|
||||
&mut commands,
|
||||
&mut next_state,
|
||||
MatchConfig {
|
||||
PendingMatch {
|
||||
stage: StageId::TestStage,
|
||||
players,
|
||||
rules: MatchRules::default(),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
pub fn prepare_match(
|
||||
mut commands: Commands,
|
||||
config: Res<MatchConfig>,
|
||||
request: Res<PendingMatch>,
|
||||
assets: Res<MatchAssets>,
|
||||
gltfs: Res<Assets<Gltf>>,
|
||||
baked_animations: Res<Assets<BakedFighterAnimations>>,
|
||||
@@ -274,7 +236,7 @@ pub fn prepare_match(
|
||||
args: Res<Args>,
|
||||
mut next_state: ResMut<NextState<AppState>>,
|
||||
) {
|
||||
if !valid_player_handles(&config.players) {
|
||||
if !valid_player_handles(&request.players) {
|
||||
fail_match(
|
||||
&mut next_state,
|
||||
"player handles must be unique and cover 0..player_count",
|
||||
@@ -282,12 +244,7 @@ pub fn prepare_match(
|
||||
return;
|
||||
}
|
||||
|
||||
if let Err(error) = config.rules.validate() {
|
||||
fail_match(&mut next_state, error);
|
||||
return;
|
||||
}
|
||||
|
||||
if assets.fighters.len() != config.players.len() {
|
||||
if assets.fighters.len() != request.players.len() {
|
||||
fail_match(
|
||||
&mut next_state,
|
||||
"loaded character assets do not match the requested player slots",
|
||||
@@ -439,7 +396,7 @@ pub fn prepare_match(
|
||||
));
|
||||
}
|
||||
|
||||
let session_config = match SessionConfig::from_args(&args, config.players.len()) {
|
||||
let session_config = match SessionConfig::from_args(&args, request.players.len()) {
|
||||
Ok(config) => config,
|
||||
Err(error) => {
|
||||
fail_match(
|
||||
@@ -449,7 +406,7 @@ pub fn prepare_match(
|
||||
return;
|
||||
}
|
||||
};
|
||||
let session = match create_session(&args, config.players.len()) {
|
||||
let session = match create_session(&args, request.players.len()) {
|
||||
Ok(session) => session,
|
||||
Err(error) => {
|
||||
fail_match(
|
||||
@@ -463,7 +420,7 @@ pub fn prepare_match(
|
||||
let root = commands.spawn((Name::new("Match"), MatchRoot)).id();
|
||||
|
||||
let stage_handle = stage_registry
|
||||
.get(config.stage)
|
||||
.get(request.stage)
|
||||
.expect("Initialization check should ensure all stages exist");
|
||||
let stage_manifest = stage_manifests
|
||||
.get(&stage_handle)
|
||||
@@ -476,11 +433,11 @@ pub fn prepare_match(
|
||||
stage_manifest.camera.clone(),
|
||||
);
|
||||
|
||||
let mut fighter_roster = Vec::with_capacity(config.players.len());
|
||||
let mut fighter_roster = Vec::with_capacity(request.players.len());
|
||||
for (index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale))) in
|
||||
config.players.iter().zip(prepared).enumerate()
|
||||
request.players.iter().zip(prepared).enumerate()
|
||||
{
|
||||
let spawn_x = (index as i32 * 2 + 1 - config.players.len() as i32) * 5;
|
||||
let spawn_x = (index as i32 * 2 + 1 - request.players.len() as i32) * 5;
|
||||
fighter_roster.push(spawn_fighter(
|
||||
&mut commands,
|
||||
player.handle,
|
||||
@@ -494,7 +451,6 @@ pub fn prepare_match(
|
||||
}
|
||||
|
||||
commands.insert_resource(FighterRoster(fighter_roster));
|
||||
commands.insert_resource(MatchState::from_config(&config));
|
||||
commands.insert_resource(session_config);
|
||||
commands.insert_resource(ConnectionStatus::default());
|
||||
commands.insert_resource::<Session<GGRSCfg>>(session);
|
||||
@@ -531,8 +487,7 @@ pub fn cleanup_match(
|
||||
commands.remove_resource::<ConnectionStatus>();
|
||||
commands.remove_resource::<stage::line::StageCollision>();
|
||||
commands.remove_resource::<MatchAssets>();
|
||||
commands.remove_resource::<MatchConfig>();
|
||||
commands.remove_resource::<MatchState>();
|
||||
commands.remove_resource::<PendingMatch>();
|
||||
commands.remove_resource::<FighterRoster>();
|
||||
}
|
||||
|
||||
@@ -541,8 +496,8 @@ mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn match_config_keeps_duplicate_fighter_slots() {
|
||||
let config = MatchConfig {
|
||||
fn match_request_keeps_duplicate_fighter_slots() {
|
||||
let request = PendingMatch {
|
||||
stage: StageId::TestStage,
|
||||
players: vec![
|
||||
MatchPlayer {
|
||||
@@ -554,13 +509,12 @@ mod tests {
|
||||
fighter: FighterId::TestFighter,
|
||||
},
|
||||
],
|
||||
rules: MatchRules::default(),
|
||||
};
|
||||
|
||||
assert_eq!(config.players.len(), 2);
|
||||
assert_eq!(config.players[0].handle, 0);
|
||||
assert_eq!(config.players[1].handle, 1);
|
||||
assert!(valid_player_handles(&config.players));
|
||||
assert_eq!(request.players.len(), 2);
|
||||
assert_eq!(request.players[0].handle, 0);
|
||||
assert_eq!(request.players[1].handle, 1);
|
||||
assert!(valid_player_handles(&request.players));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -579,53 +533,6 @@ mod tests {
|
||||
assert!(!valid_player_handles(&players));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn match_rules_reject_zero_limits() {
|
||||
assert!(
|
||||
MatchRules::Stock {
|
||||
starting_stocks: 0,
|
||||
time_limit_frames: None,
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
MatchRules::Stock {
|
||||
starting_stocks: 3,
|
||||
time_limit_frames: Some(0),
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
MatchRules::Timed {
|
||||
time_limit_frames: 0,
|
||||
}
|
||||
.validate()
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn match_rules_accept_valid_modes() {
|
||||
assert!(MatchRules::default().validate().is_ok());
|
||||
assert!(
|
||||
MatchRules::Stock {
|
||||
starting_stocks: 3,
|
||||
time_limit_frames: Some(60),
|
||||
}
|
||||
.validate()
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
MatchRules::Timed {
|
||||
time_limit_frames: 60,
|
||||
}
|
||||
.validate()
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn match_loading_waits_for_attack_scripts() {
|
||||
let mut attack_scripts = HashMap::new();
|
||||
|
||||
@@ -1,102 +0,0 @@
|
||||
//! Rollback-simulated state for an active match.
|
||||
|
||||
use bevy::prelude::*;
|
||||
use bevy_ggrs::prelude::*;
|
||||
|
||||
use crate::match_loading::{MatchConfig, MatchRules};
|
||||
|
||||
#[derive(Resource, Clone, Debug, Hash, PartialEq, Eq)]
|
||||
pub struct MatchState {
|
||||
pub elapsed_frames: u32,
|
||||
/// Indexed by the player's session handle.
|
||||
pub players: Vec<PlayerMatchState>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
|
||||
pub struct PlayerMatchState {
|
||||
pub stocks_remaining: Option<u8>,
|
||||
pub score: i32,
|
||||
pub deaths: u32,
|
||||
}
|
||||
|
||||
impl MatchState {
|
||||
pub fn from_config(config: &MatchConfig) -> Self {
|
||||
let stocks_remaining = match &config.rules {
|
||||
MatchRules::Stock {
|
||||
starting_stocks, ..
|
||||
} => Some(*starting_stocks),
|
||||
MatchRules::Timed { .. } => None,
|
||||
};
|
||||
|
||||
Self {
|
||||
elapsed_frames: 0,
|
||||
players: (0..config.players.len())
|
||||
.map(|_| PlayerMatchState {
|
||||
stocks_remaining,
|
||||
score: 0,
|
||||
deaths: 0,
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct MatchRuntimePlugin;
|
||||
|
||||
impl Plugin for MatchRuntimePlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.rollback_resource_with_clone::<MatchState>()
|
||||
.checksum_resource_with_hash::<MatchState>();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::{fighter::FighterId, match_loading::MatchPlayer, stage::manifest::StageId};
|
||||
|
||||
fn config(rules: MatchRules) -> MatchConfig {
|
||||
MatchConfig {
|
||||
stage: StageId::TestStage,
|
||||
players: vec![
|
||||
MatchPlayer {
|
||||
handle: 1,
|
||||
fighter: FighterId::TestFighter,
|
||||
},
|
||||
MatchPlayer {
|
||||
handle: 0,
|
||||
fighter: FighterId::TestFighter,
|
||||
},
|
||||
],
|
||||
rules,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stock_state_starts_with_configured_stocks() {
|
||||
let state = MatchState::from_config(&config(MatchRules::Stock {
|
||||
starting_stocks: 4,
|
||||
time_limit_frames: Some(60),
|
||||
}));
|
||||
|
||||
assert_eq!(state.elapsed_frames, 0);
|
||||
assert_eq!(state.players.len(), 2);
|
||||
assert!(state.players.iter().all(|player| {
|
||||
player.stocks_remaining == Some(4) && player.score == 0 && player.deaths == 0
|
||||
}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timed_state_has_no_stock_counter() {
|
||||
let state = MatchState::from_config(&config(MatchRules::Timed {
|
||||
time_limit_frames: 60,
|
||||
}));
|
||||
|
||||
assert!(
|
||||
state
|
||||
.players
|
||||
.iter()
|
||||
.all(|player| player.stocks_remaining.is_none())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -241,7 +241,7 @@ pub fn copy_cursor_transform_to_token(
|
||||
character_boxes: Query<(&CharacterBox, &ComputedNode, &UiGlobalTransform)>,
|
||||
match_config: Res<MenuMatchConfig>,
|
||||
cursors: Query<&UiGlobalTransform, With<FGMenuCursor>>,
|
||||
cam: Single<&Camera>,
|
||||
cam: Single<&Camera, With<IsDefaultUiCamera>>,
|
||||
ui_scale: Res<UiScale>,
|
||||
) -> Result {
|
||||
let camera = cam.into_inner();
|
||||
|
||||
+1
-1
@@ -181,7 +181,7 @@ pub fn cursor_input(
|
||||
}
|
||||
|
||||
pub fn update_cursor_transform(
|
||||
camera: Single<&Camera>,
|
||||
camera: Single<&Camera, With<IsDefaultUiCamera>>,
|
||||
query: Query<(&mut Node, &PointerLocation), With<FGMenuCursor>>,
|
||||
ui_scale: Res<UiScale>,
|
||||
) {
|
||||
|
||||
@@ -3,7 +3,7 @@ use thiserror::Error;
|
||||
|
||||
use crate::{
|
||||
fighter::FighterId,
|
||||
match_loading::{MatchConfig, MatchPlayer, MatchRules},
|
||||
match_loading::{MatchPlayer, PendingMatch},
|
||||
stage::manifest::StageId,
|
||||
};
|
||||
|
||||
@@ -60,7 +60,7 @@ impl MenuMatchConfig {
|
||||
!has_unselected_fighter
|
||||
}
|
||||
|
||||
pub fn to_match_config(&self) -> Result<MatchConfig, MenuMatchConfigErrors> {
|
||||
pub fn to_pending_match(&self) -> Result<PendingMatch, MenuMatchConfigErrors> {
|
||||
let mut match_players = vec![];
|
||||
|
||||
let stage = self.stage.ok_or(MenuMatchConfigErrors::StageNotSelected)?;
|
||||
@@ -78,28 +78,9 @@ impl MenuMatchConfig {
|
||||
});
|
||||
}
|
||||
|
||||
Ok(MatchConfig {
|
||||
Ok(PendingMatch {
|
||||
players: match_players,
|
||||
stage,
|
||||
rules: MatchRules::default(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn menu_config_uses_default_match_rules() {
|
||||
let menu = MenuMatchConfig {
|
||||
stage: Some(StageId::TestStage),
|
||||
players: vec![MenuMatchPlayerSlot {
|
||||
slot: 0,
|
||||
fighter: Some(FighterId::TestFighter),
|
||||
}],
|
||||
};
|
||||
|
||||
assert_eq!(menu.to_match_config().unwrap().rules, MatchRules::default());
|
||||
}
|
||||
}
|
||||
|
||||
+18
-15
@@ -6,10 +6,12 @@ use bevy::{
|
||||
prelude::*,
|
||||
};
|
||||
|
||||
use ron_asset_manager::RonAssetPlugin;
|
||||
|
||||
use crate::{
|
||||
AppState,
|
||||
game_settings::CommonAssets,
|
||||
menus::{character_select::CharacterSelectScreen, main_menu::MainMenu},
|
||||
menus::{character_select::CharacterSelectScreen, main_menu::MainMenu, style::FGUiStyle},
|
||||
};
|
||||
pub mod button;
|
||||
pub mod character_select;
|
||||
@@ -25,8 +27,6 @@ pub mod style;
|
||||
|
||||
#[derive(Component, Clone, Default)]
|
||||
pub struct MenuMarker {}
|
||||
#[derive(Component, Clone, Default)]
|
||||
pub struct MenuCameraMarker {}
|
||||
|
||||
pub struct MenuPlugin;
|
||||
|
||||
@@ -40,7 +40,6 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
|
||||
bsn! {
|
||||
#MenuRoot
|
||||
MenuMarker
|
||||
Transform
|
||||
Node {
|
||||
width: percent(100),
|
||||
height: percent(100),
|
||||
@@ -49,11 +48,6 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
|
||||
flex_direction: FlexDirection::Column,
|
||||
}
|
||||
Children [
|
||||
(
|
||||
#MenuCamera
|
||||
Camera
|
||||
Camera2d
|
||||
),
|
||||
(
|
||||
#MenuContainer
|
||||
Node {
|
||||
@@ -73,18 +67,15 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
|
||||
|
||||
pub fn despawn_menu(
|
||||
existing_menu: Option<Single<Entity, With<MenuMarker>>>,
|
||||
existing_menu_camera: Option<Single<Entity, With<MenuCameraMarker>>>,
|
||||
mut commands: Commands,
|
||||
) {
|
||||
if let Some(entity) = existing_menu {
|
||||
commands
|
||||
.entity(entity.into_inner())
|
||||
.remove::<Camera2d>()
|
||||
.remove::<Camera>()
|
||||
.despawn();
|
||||
}
|
||||
|
||||
if let Some(menu_cam) = existing_menu_camera {
|
||||
commands.entity(*menu_cam).despawn();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn spawn_menu(
|
||||
@@ -95,6 +86,8 @@ pub fn spawn_menu(
|
||||
if let Some(entity) = existing_menu {
|
||||
commands
|
||||
.entity(entity.into_inner())
|
||||
.remove::<Camera2d>()
|
||||
.remove::<Camera>()
|
||||
.despawn();
|
||||
}
|
||||
commands.queue_spawn_scene(wrap_menu(menu));
|
||||
@@ -122,7 +115,16 @@ impl Plugin for MenuPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_systems(
|
||||
OnEnter(AppState::MainMenu),
|
||||
build_menu::<MainMenu>,
|
||||
(build_menu::<MainMenu>, |mut commands: Commands| {
|
||||
commands.spawn((Camera2d, IsDefaultUiCamera));
|
||||
commands.spawn((
|
||||
Camera2d,
|
||||
Camera {
|
||||
order: 1,
|
||||
..default()
|
||||
},
|
||||
));
|
||||
}),
|
||||
)
|
||||
.add_message::<character_select::PlayerSlotAssigned>()
|
||||
.init_resource::<navigation::UINavigationActionState>()
|
||||
@@ -220,6 +222,7 @@ impl Plugin for MenuPlugin {
|
||||
//---------
|
||||
// STAGE SELECT END
|
||||
//---------
|
||||
.add_plugins(RonAssetPlugin::<FGUiStyle>::create("stylesheet.ron"))
|
||||
.add_systems(
|
||||
Update,
|
||||
(
|
||||
|
||||
@@ -77,7 +77,7 @@ pub fn stage_selected(
|
||||
initiate_match(
|
||||
&mut commands,
|
||||
&mut next_state,
|
||||
match_config.to_match_config()?,
|
||||
match_config.to_pending_match()?,
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
|
||||
+39
-96
@@ -12,12 +12,16 @@ use clap::ValueEnum;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
AppState, args::Args, input::FighterInputFrame, match_loading::MatchConfig, netcode::GGRSCfg,
|
||||
AppState,
|
||||
args::Args,
|
||||
input::FighterInputFrame,
|
||||
match_loading::{MatchPlayer, PendingMatch},
|
||||
netcode::GGRSCfg,
|
||||
schedule::GameplaySet,
|
||||
};
|
||||
|
||||
const MAGIC: &[u8; 8] = b"SPRPLY01";
|
||||
pub const REPLAY_VERSION: u32 = 2;
|
||||
pub const REPLAY_VERSION: u32 = 1;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ValueEnum)]
|
||||
pub enum ReplayFormat {
|
||||
@@ -30,11 +34,17 @@ pub enum ReplayFormat {
|
||||
pub struct Replay {
|
||||
pub replay_version: u32,
|
||||
pub game_version: String,
|
||||
pub match_config: MatchConfig,
|
||||
pub match_config: ReplayMatch,
|
||||
pub frames: Vec<ReplayFrame>,
|
||||
pub checksums: Vec<ReplayChecksum>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
pub struct ReplayMatch {
|
||||
pub stage: crate::stage::manifest::StageId,
|
||||
pub players: Vec<MatchPlayer>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||||
pub struct ReplayFrame {
|
||||
pub frame: i32,
|
||||
@@ -152,20 +162,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 +183,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 +220,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,43 +245,49 @@ 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
|
||||
&& let Some(expected) = replay.checksum(frame.0)
|
||||
&& expected != checksum.0
|
||||
} else if let ReplayMode::Playback { replay, mismatch } = &mut runtime.mode {
|
||||
if let Some(expected) = replay
|
||||
.checksums
|
||||
.iter()
|
||||
.find(|value| value.frame == frame.0)
|
||||
.map(|value| value.checksum)
|
||||
{
|
||||
if expected != checksum.0 {
|
||||
error!(
|
||||
"Replay desync at frame {}: expected {:X}, got {:X}",
|
||||
frame.0, expected, checksum.0
|
||||
);
|
||||
*mismatch = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn stop_recording(
|
||||
mut commands: Commands,
|
||||
stop_request: Option<Res<StopReplayRecording>>,
|
||||
runtime: Option<ResMut<ReplayRuntime>>,
|
||||
config: Option<Res<MatchConfig>>,
|
||||
request: Option<Res<PendingMatch>>,
|
||||
) {
|
||||
if stop_request.is_none() {
|
||||
return;
|
||||
}
|
||||
commands.remove_resource::<StopReplayRecording>();
|
||||
finish_recording_inner(&mut commands, runtime, config);
|
||||
finish_recording_inner(&mut commands, runtime, request);
|
||||
}
|
||||
|
||||
fn finish_recording(
|
||||
mut commands: Commands,
|
||||
runtime: Option<ResMut<ReplayRuntime>>,
|
||||
config: Option<Res<MatchConfig>>,
|
||||
request: Option<Res<PendingMatch>>,
|
||||
) {
|
||||
finish_recording_inner(&mut commands, runtime, config);
|
||||
finish_recording_inner(&mut commands, runtime, request);
|
||||
}
|
||||
|
||||
fn finish_recording_inner(
|
||||
commands: &mut Commands,
|
||||
runtime: Option<ResMut<ReplayRuntime>>,
|
||||
config: Option<Res<MatchConfig>>,
|
||||
request: Option<Res<PendingMatch>>,
|
||||
) {
|
||||
let Some(mut runtime) = runtime else { return };
|
||||
let ReplayMode::Record { path, format } = &runtime.mode else {
|
||||
@@ -305,13 +296,16 @@ fn finish_recording_inner(
|
||||
if runtime.finished || runtime.frames.is_empty() {
|
||||
return;
|
||||
}
|
||||
let Some(config) = config else { return };
|
||||
let Some(request) = request else { return };
|
||||
let path = path.clone();
|
||||
let format = *format;
|
||||
let replay = Replay {
|
||||
replay_version: REPLAY_VERSION,
|
||||
game_version: env!("CARGO_PKG_VERSION").into(),
|
||||
match_config: config.as_ref().clone(),
|
||||
match_config: ReplayMatch {
|
||||
stage: request.stage,
|
||||
players: request.players.clone(),
|
||||
},
|
||||
frames: runtime
|
||||
.frames
|
||||
.iter()
|
||||
@@ -361,7 +355,7 @@ mod tests {
|
||||
use super::*;
|
||||
use crate::{
|
||||
fighter::FighterId,
|
||||
match_loading::{MatchPlayer, MatchRules},
|
||||
match_loading::MatchPlayer,
|
||||
math::{int::FGi32, vec::FGVec2},
|
||||
stage::manifest::StageId,
|
||||
};
|
||||
@@ -370,15 +364,12 @@ mod tests {
|
||||
Replay {
|
||||
replay_version: REPLAY_VERSION,
|
||||
game_version: "test".into(),
|
||||
match_config: MatchConfig {
|
||||
match_config: ReplayMatch {
|
||||
stage: StageId::TestStage,
|
||||
players: vec![MatchPlayer {
|
||||
handle: 0,
|
||||
fighter: FighterId::TestFighter,
|
||||
}],
|
||||
rules: MatchRules::Timed {
|
||||
time_limit_frames: 21_600,
|
||||
},
|
||||
},
|
||||
frames: vec![ReplayFrame {
|
||||
frame: 1,
|
||||
@@ -415,52 +406,4 @@ mod tests {
|
||||
replay.frames[0].inputs.clear();
|
||||
assert!(validate(&replay).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_replay_version_is_rejected() {
|
||||
let mut replay = sample();
|
||||
replay.replay_version = 1;
|
||||
|
||||
assert_eq!(
|
||||
validate(&replay).unwrap_err(),
|
||||
"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"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
use bevy::prelude::*;
|
||||
|
||||
use crate::{
|
||||
fighter::manifest::{FighterManifest, FighterManifestRegistry},
|
||||
match_loading::MatchConfig,
|
||||
ui::{errors::UIErrors, fighter_info::FighterInfoUI},
|
||||
};
|
||||
|
||||
#[derive(Component, FromTemplate)]
|
||||
pub struct BattleUI {}
|
||||
|
||||
pub fn spawn_battle_ui(
|
||||
mut commands: Commands,
|
||||
config: Res<MatchConfig>,
|
||||
fighter_registry: Res<FighterManifestRegistry>,
|
||||
manifests: Res<Assets<FighterManifest>>,
|
||||
) -> Result {
|
||||
let mut fighter_uis = vec![];
|
||||
|
||||
for player in &config.players {
|
||||
let manifest = fighter_registry
|
||||
.get(player.fighter)
|
||||
.ok_or_else(|| UIErrors::FighterManifestHandleNotFound(player.fighter))?;
|
||||
let manifest = manifests
|
||||
.get(manifest)
|
||||
.ok_or_else(|| UIErrors::FighterManifestNotFound(player.fighter))?;
|
||||
|
||||
fighter_uis.push(FighterInfoUI::build(manifest, player));
|
||||
}
|
||||
|
||||
let scene = bsn! {
|
||||
BattleUI {
|
||||
}
|
||||
Node {
|
||||
width: percent(100),
|
||||
height: percent(100),
|
||||
flex_direction: FlexDirection::Column,
|
||||
align_items: AlignItems::Center,
|
||||
justify_content: JustifyContent::End,
|
||||
}
|
||||
Children [
|
||||
(
|
||||
#FighterInfos
|
||||
Node {
|
||||
width: percent(100),
|
||||
flex_direction: FlexDirection::Row,
|
||||
align_items: AlignItems::End,
|
||||
justify_content: JustifyContent::SpaceEvenly,
|
||||
}
|
||||
Children [
|
||||
{fighter_uis}
|
||||
]
|
||||
)
|
||||
]
|
||||
};
|
||||
|
||||
commands.spawn_scene(scene);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn cleanup_battle_ui(mut commands: Commands, battle_ui: Query<Entity, With<BattleUI>>) {
|
||||
for entity in battle_ui {
|
||||
commands.entity(entity).despawn();
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
use bevy::{scene::SpawnSceneError};
|
||||
|
||||
use crate::{fighter::FighterId};
|
||||
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum UIErrors {
|
||||
#[error("Scene spawn failed: {0:?}")]
|
||||
SceneSpawnFailed(#[from] SpawnSceneError),
|
||||
#[error("Fighter manifest handle not found for fighter id {0:?}")]
|
||||
FighterManifestHandleNotFound(FighterId),
|
||||
|
||||
#[error("Fighter manifest not found for fighter id {0:?}")]
|
||||
FighterManifestNotFound(FighterId),
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
use bevy::prelude::*;
|
||||
|
||||
use crate::{
|
||||
fighter::{attack::FighterDamage, manifest::FighterManifest}, match_loading::{MatchPlayer}, match_runtime::MatchState, player::Player, ui::stock_icon::BattleUIStockIcon,
|
||||
};
|
||||
|
||||
#[derive(Component, FromTemplate)]
|
||||
pub struct FighterInfoUI {
|
||||
percentage_text: Entity,
|
||||
stock_icon_container: Entity,
|
||||
_name_text: Entity,
|
||||
player_handle: usize,
|
||||
visible_damage: FighterDamage,
|
||||
visible_stocks: u8,
|
||||
}
|
||||
|
||||
impl FighterInfoUI {
|
||||
pub fn build(_manifest: &FighterManifest, match_player: &MatchPlayer) -> impl Scene {
|
||||
let fighter_name = "El grande padre";
|
||||
bsn! {
|
||||
FighterInfoUI {
|
||||
percentage_text: #PercentageText,
|
||||
stock_icon_container: #StockIconContainer,
|
||||
_name_text: #NameText,
|
||||
player_handle: {match_player.handle}
|
||||
}
|
||||
Node {
|
||||
flex_direction: FlexDirection::Column,
|
||||
align_items: AlignItems::Center,
|
||||
justify_content: JustifyContent::Center,
|
||||
}
|
||||
Children [
|
||||
(
|
||||
#StockIconContainer
|
||||
Node
|
||||
)
|
||||
(
|
||||
#PercentageText
|
||||
Text("0.00%")
|
||||
TextFont {
|
||||
font_size: px(crate::menus::style::H2_SIZE),
|
||||
}
|
||||
),
|
||||
(
|
||||
#NameText
|
||||
Text({fighter_name})
|
||||
)
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update_fighter_info_damage(
|
||||
fighters: Query<(&Player, &FighterDamage)>,
|
||||
ui_elements: Query<&mut FighterInfoUI>,
|
||||
mut commands: Commands,
|
||||
) {
|
||||
for mut ui_element in ui_elements {
|
||||
let Some((_, damage)) = fighters
|
||||
.iter()
|
||||
.find(|(player, _)| player.handle == ui_element.player_handle)
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if *damage != ui_element.visible_damage {
|
||||
commands
|
||||
.entity(ui_element.percentage_text)
|
||||
.insert(Text(format!("{}%", damage)));
|
||||
ui_element.visible_damage = damage.clone();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update_fighter_info_stocks(
|
||||
match_state: Res<MatchState>,
|
||||
ui_elements: Query<&mut FighterInfoUI>,
|
||||
mut commands: Commands,
|
||||
) {
|
||||
|
||||
for mut ui_element in ui_elements {
|
||||
let handle = ui_element.player_handle;
|
||||
let Some(match_player) = match_state.players.get(handle) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let Some(stocks) = match_player.stocks_remaining else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if stocks != ui_element.visible_stocks {
|
||||
commands
|
||||
.entity(ui_element.stock_icon_container)
|
||||
.despawn_children()
|
||||
.with_children(|spawner| {
|
||||
for _ in 0..stocks {
|
||||
spawner.spawn_empty().apply_scene(BattleUIStockIcon::scene());
|
||||
}
|
||||
});
|
||||
ui_element.visible_stocks = stocks;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
use bevy::prelude::*;
|
||||
|
||||
use crate::{
|
||||
AppState,
|
||||
match_loading::{MatchConfig, MatchRules},
|
||||
match_runtime::MatchState,
|
||||
};
|
||||
|
||||
pub mod battle_ui;
|
||||
pub mod errors;
|
||||
pub mod fighter_info;
|
||||
pub mod stock_icon;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct InGameUIPlugin;
|
||||
|
||||
impl Plugin for InGameUIPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_systems(OnEnter(AppState::InMatch), battle_ui::spawn_battle_ui)
|
||||
.add_systems(OnExit(AppState::InMatch), battle_ui::cleanup_battle_ui)
|
||||
.add_systems(PostUpdate, fighter_info::update_fighter_info_damage)
|
||||
.add_systems(
|
||||
PostUpdate,
|
||||
fighter_info::update_fighter_info_stocks.run_if(
|
||||
resource_exists::<MatchState>
|
||||
.and_then(resource_exists::<MatchConfig>)
|
||||
.and_then(|match_config: Res<MatchConfig>| {
|
||||
if let MatchRules::Stock { .. } = match_config.rules {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
use bevy::prelude::*;
|
||||
|
||||
#[derive(SceneComponent, Clone, FromTemplate)]
|
||||
pub struct BattleUIStockIcon;
|
||||
|
||||
impl BattleUIStockIcon {
|
||||
pub fn scene() -> impl Scene {
|
||||
bsn! {
|
||||
Node {
|
||||
width: px(32),
|
||||
height: px(32),
|
||||
border_radius: BorderRadius::MAX,
|
||||
}
|
||||
BackgroundColor({bevy::color::palettes::css::RED})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user