Jengamon/acerola_jam0_gam - Change WQS2WD437EWG2CKPOY5TDWPEBE3US7LGHVAH2HVYQ7RW2L6FHJ5AC

fix: more modulear

Created by Jengamon on March 3, 2024

WQS2WD437EWG2CKPOY5TDWPEBE3US7LGHVAH2HVYQ7RW2L6FHJ5AC

Dependencies

In channels

main

Change contents

File addition: player.rs (----------)

[5.15]

use super::{movement_pointer, PlayerAssets};
use bevy::prelude::*;
use bevy_ecs_ldtk::LdtkEntity;
use bevy_prototype_lyon::{entity::ShapeBundle, geometry::GeometryBuilder, shapes};
use leafwing_input_manager::prelude::*;
use moonshine_spawn::{spawn_children, SpawnChildren};
#[derive(Component)]
pub(crate) struct DashState(pub bool);
pub(crate) fn handle_dashing(mut query: Query<(&mut DashState, &ActionState<PlayerAction>)>) {
    for (mut dash_state, action_state) in query.iter_mut() {
        // handle hold dash
        if action_state.just_pressed(&PlayerAction::HoldDash) {
            dash_state.0 = true;
        } else if action_state.just_released(&PlayerAction::HoldDash) {
            dash_state.0 = false;
        }
        // Handle toggle dash
        if action_state.just_pressed(&PlayerAction::ToggleDash) {
            dash_state.0 = !dash_state.0;
        }
    }
}
pub(crate) fn move_player(
    mut query: Query<
        (
            &ActionState<PlayerAction>,
            &mut Transform,
            Option<&mut Sprite>,
            &DashState,
            &mut movement_pointer::MovementDirection,
        ),
        With<Player>,
    >,
    time: Res<Time>,
) {
    for (action_state, mut transform, maybe_sprite, dash, mut md) in query.iter_mut() {
        // Right now, treat our joystick as a velocity.
        if let Some(dad) = action_state.clamped_axis_pair(&PlayerAction::Move) {
            const SPEED: f32 = 350.0;
            const DASH_SPEED: f32 = 700.0;
            let movement = dad.xy();
            if let Some(movement_norm) = movement.try_normalize() {
                let speed = if dash.0 { DASH_SPEED } else { SPEED };
                transform.translation += movement_norm.extend(0.0) * speed * time.delta_seconds();
                md.0 = movement_norm;
                md.1 = speed;
                if let Some(mut sprite) = maybe_sprite {
                    // If we have a sprite, flip x if we moved in a negative x dir
                    // Might not be necessary
                    let x_movement = movement_norm.x;
                    match x_movement.signum() {
                        x if x == 1.0 && x_movement > f32::EPSILON => {
                            sprite.flip_x = false;
                        }
                        // cuz neg
                        x if x == -1.0 && x_movement < f32::EPSILON => {
                            sprite.flip_x = true;
                        }
                        _ => {}
                    }
                }
            } else {
                md.0 = Vec2::ZERO;
                md.1 = 0.0;
            }
        }
    }
}
#[derive(Actionlike, PartialEq, Eq, Hash, Clone, Copy, Debug, Reflect)]
pub(crate) enum PlayerAction {
    Move,
    LightAttack,
    HeavyAttack,
    // Dash variants, both should just enable dash, but one
    // needs to be held, while the other toggles dash on and off
    HoldDash,
    ToggleDash,
    // X axis - switching between cards
    // +Y axis - above deadzone, use card
    // -Y axis - above deadzone, held, exhaust hand
    Hand,
}
#[derive(Component, Default)]
pub(crate) struct Player;
#[derive(Bundle, Default, LdtkEntity)]
pub(crate) struct PlayerBlueprint {
    pub(crate) player: Player,
}
#[derive(Bundle)]
pub(crate) struct PlayerBundle {
    pub(crate) input_manager_bundle: InputManagerBundle<PlayerAction>,
    // For now, use a mesh
    // mesh: MaterialMesh2dBundle<ColorMaterial>,
    pub(crate) sprite_sheet: SpriteSheetBundle,
    // used to render a pointed arrow
    pub(crate) movement_dir: movement_pointer::MovementDirection,
    pub(crate) dash: DashState,
    // moonshine children
    pub(crate) children: SpawnChildren,
}
pub(crate) fn process_player_start(
    mut commands: Commands,
    new_entity_instances: Query<(Entity, &Transform), Added<Player>>,
    // mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    player_assets: Res<PlayerAssets>,
) {
    for (entity, transform) in new_entity_instances.iter() {
        commands.entity(entity).insert(PlayerBundle {
            input_manager_bundle: InputManagerBundle::with_map(default_input_map()),
            movement_dir: movement_pointer::MovementDirection(Vec2::X, 0.0),
            dash: DashState(false),
            sprite_sheet: SpriteSheetBundle {
                texture: player_assets.texture.clone(),
                atlas: TextureAtlas {
                    layout: player_assets.layout.clone(),
                    index: 0,
                },
                transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),
                ..default()
            },
            // mesh: MaterialMesh2dBundle {
            //     mesh: meshes
            //         .add(Rectangle {
            //             half_size: (16.0, 24.0).into(),
            //         })
            //         .into(),
            //     // Be careful not to overwrite the LDtk transform
            //     // Change our origin
            //     transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),
            //     material: materials.add(Color::PURPLE),
            //     ..default()
            // },
            children: spawn_children(|cb| {
                cb.spawn(movement_pointer::MovementPointerBundle {
                    pointer: movement_pointer::MovementPointer,
                    shape: ShapeBundle {
                        spatial: SpatialBundle {
                            transform: Transform::default().with_scale(Vec3::new(0.5, 1.0, 1.0)),
                            ..default()
                        },
                        path: GeometryBuilder::build_as(&shapes::RegularPolygon {
                            sides: 3,
                            feature: shapes::RegularPolygonFeature::Apothem(5.0),
                            ..default()
                        }),
                        material: materials.add(Color::ORANGE_RED),
                        ..default()
                    },
                });
            }),
        });
    }
}
pub(crate) fn default_input_map() -> InputMap<PlayerAction> {
    let mut map = InputMap::default();
    map.insert(PlayerAction::Move, DualAxis::left_stick());
    map.insert(PlayerAction::Move, VirtualDPad::wasd());
    map.insert(PlayerAction::LightAttack, KeyCode::KeyZ);
    map.insert(PlayerAction::HeavyAttack, KeyCode::KeyX);
    map.insert(PlayerAction::HoldDash, GamepadButtonType::RightTrigger);
    map.insert(PlayerAction::HoldDash, KeyCode::ShiftLeft);
    map.insert(PlayerAction::ToggleDash, KeyCode::KeyC);
    map.insert(PlayerAction::Hand, VirtualDPad::gamepad_face_buttons());
    map.insert(PlayerAction::Hand, VirtualDPad::arrow_keys());
    map
}

Insertion in src/main.rs at line 4 [5.49]
[6.112]
[7.9679]
```
mod camera;
```
Insertion in src/main.rs at line 9 [5.49]
[8.3578]
[7.9694]
```
mod player;
```

Replacement in src/main.rs at line 19 [5.49]

B:BD[9.123] → [9.123:230]

use bevy_smooth_pixel_camera::{
    components::PixelCamera, viewport::ViewportSize, PixelCameraPlugin,
};

[9.123]

[10.0]

use bevy_smooth_pixel_camera::PixelCameraPlugin;

Replacement in src/main.rs at line 23 [5.49]

B:BD[11.160] → [9.231:298]

use moonshine_spawn::{spawn_children, SpawnChildren, SpawnPlugin};

[11.160]

use moonshine_spawn::SpawnPlugin;

Replacement in src/main.rs at line 59 [5.49]

∅:D[10.375] → [11.264:323]

B:BD[11.264] → [11.264:323]

            InputManagerPlugin::<PlayerAction>::default(),

[10.375]

[12.34]

            InputManagerPlugin::<player::PlayerAction>::default(),

Replacement in src/main.rs at line 84 [5.49]

∅:D[13.36] → [9.532:600]

B:BD[9.532] → [9.532:600]

B:BD[9.600] → [14.0:48]

            .register_ldtk_entity::<PlayerBlueprint>("PlayerStart")
            .add_systems(Startup, setup_camera)

[13.36]

[15.173]

            .register_ldtk_entity::<player::PlayerBlueprint>("PlayerStart")
            .add_systems(Startup, camera::setup_camera)

Replacement in src/main.rs at line 109 [5.49]

B:BD[9.837] → [9.837:879]

B:BD[9.879] → [16.0:36]

                    process_player_start,
                    handle_dashing,

[9.837]

[8.3579]

                    player::process_player_start,
                    player::handle_dashing,

Replacement in src/main.rs at line 113 [5.49]

∅:D[4.86] → [17.0:68]

B:BD[16.120] → [17.0:68]

                    move_player,
                    update_camera,

[4.86]

[15.487]

                    player::move_player,
                    camera::update_camera,

Replacement in src/main.rs at line 120 [5.49]

B:BD[15.619] → [17.69:137]

                (update_camera).run_if(in_state(GameState::InRun)),

[15.619]

[7.9797]

                (camera::update_camera).run_if(in_state(GameState::InRun)),

Deletion in src/main.rs at line 283 [5.49]

B:BD[7.10861] → [7.10861:10870]

∅:D[15.1103] → [16.191:781]

∅:D[7.10870] → [16.191:781]

B:BD[18.53] → [16.191:781]

∅:D[18.53] → [9.1473:1589]

∅:D[16.781] → [9.1473:1589]

B:BD[9.1473] → [9.1473:1589]

B:BD[9.1589] → [15.1104:1137]

∅:D[15.1137] → [16.782:806]

B:BD[9.1589] → [16.782:806]

B:BD[16.806] → [8.3643:3697]

∅:D[16.842] → [9.1633:1673]

∅:D[8.3697] → [9.1633:1673]

B:BD[9.1633] → [9.1633:1673]

B:BD[9.1673] → [19.322:343]

∅:D[20.83] → [9.1673:1677]

∅:D[19.343] → [9.1673:1677]

B:BD[9.1673] → [9.1673:1677]

B:BD[9.1677] → [15.1138:1226]

∅:D[16.917] → [9.1745:1882]

∅:D[15.1226] → [9.1745:1882]

B:BD[9.1745] → [9.1745:1882]

B:BD[9.1882] → [20.84:122]

B:BD[20.122] → [16.918:962]

B:BD[16.962] → [21.0:37]

∅:D[21.37] → [16.1027:1028]

B:BD[16.1027] → [16.1027:1028]

B:BD[16.1028] → [21.38:312]

B:BD[21.312] → [22.0:30]

B:BD[15.1306] → [15.1306:1363]

B:BD[15.1363] → [3.0:618]

∅:D[3.618] → [15.1433:1451]

B:BD[15.1433] → [15.1433:1451]

∅:D[15.1451] → [21.365:463]

B:BD[21.365] → [21.365:463]

∅:D[21.463] → [9.2076:2086]

∅:D[16.1216] → [9.2076:2086]

B:BD[9.2076] → [9.2076:2086]

∅:D[9.2086] → [11.631:1081]

B:BD[11.631] → [11.631:1081]

B:BD[11.1081] → [9.2087:2117]

∅:D[9.2117] → [11.1102:1118]

B:BD[11.1102] → [11.1102:1118]

B:BD[9.2153] → [9.2153:2240]

∅:D[9.2240] → [11.1118:1158]

B:BD[11.1118] → [11.1118:1158]

B:BD[11.1178] → [11.1178:1238]

B:BD[11.1238] → [9.2241:2268]

B:BD[9.2268] → [15.1452:1539]

∅:D[15.1539] → [9.2315:2353]

B:BD[9.2315] → [9.2315:2353]

B:BD[9.2353] → [8.3698:3753]

∅:D[8.3753] → [16.1217:1238]

B:BD[9.2390] → [16.1217:1238]

∅:D[16.1238] → [9.2390:2445]

B:BD[9.2390] → [9.2390:2445]

∅:D[9.2445] → [11.1238:1241]

B:BD[11.1238] → [11.1238:1241]

B:BD[11.1241] → [9.2446:2569]

B:BD[9.2569] → [15.1540:1581]

∅:D[15.1581] → [9.2607:2657]

B:BD[9.2607] → [9.2607:2657]

B:BD[9.2657] → [15.1582:1620]

∅:D[15.1620] → [9.2657:2861]

B:BD[9.2657] → [9.2657:2861]

B:BD[9.2861] → [8.3754:3831]

∅:D[8.3831] → [16.1239:1275]

B:BD[18.164] → [16.1239:1275]

B:BD[16.1275] → [15.1621:1964]

∅:D[23.56] → [9.3290:3333]

∅:D[15.1964] → [9.3290:3333]

B:BD[9.3290] → [9.3290:3333]

B:BD[9.3333] → [15.1965:2514]

∅:D[15.2514] → [9.3333:3377]

B:BD[9.3333] → [9.3333:3377]

B:BD[9.3377] → [8.3832:3963]

∅:D[8.3963] → [9.3472:3847]

B:BD[9.3472] → [9.3472:3847]

B:BD[9.3847] → [14.653:727]

∅:D[14.727] → [9.3922:4165]

B:BD[9.3922] → [9.3922:4165]

    }
}
#[derive(Component)]
struct DashState(bool);
fn handle_dashing(mut query: Query<(&mut DashState, &ActionState<PlayerAction>)>) {
    for (mut dash_state, action_state) in query.iter_mut() {
        // handle hold dash
        if action_state.just_pressed(&PlayerAction::HoldDash) {
            dash_state.0 = true;
        } else if action_state.just_released(&PlayerAction::HoldDash) {
            dash_state.0 = false;
        }
        // Handle toggle dash
        if action_state.just_pressed(&PlayerAction::ToggleDash) {
            dash_state.0 = !dash_state.0;
        }
    }
}
fn move_player(
    mut query: Query<
        (
            &ActionState<PlayerAction>,
            &mut Transform,
            Option<&mut Sprite>,
            &DashState,
            &mut movement_pointer::MovementDirection,
        ),
        With<Player>,
    >,
    time: Res<Time>,
) {
    for (action_state, mut transform, maybe_sprite, dash, mut md) in query.iter_mut() {
        // Right now, treat our joystick as a velocity.
        if let Some(dad) = action_state.clamped_axis_pair(&PlayerAction::Move) {
            const SPEED: f32 = 350.0;
            const DASH_SPEED: f32 = 700.0;
            let movement = dad.xy();
            if let Some(movement_norm) = movement.try_normalize() {
                let speed = if dash.0 { DASH_SPEED } else { SPEED };
                transform.translation += movement_norm.extend(0.0) * speed * time.delta_seconds();
                md.0 = movement_norm;
                md.1 = speed;
                if let Some(mut sprite) = maybe_sprite {
                    // If we have a sprite, flip x if we moved in a negative x dir
                    // Might not be necessary
                    let x_movement = movement_norm.x;
                    match x_movement.signum() {
                        x if x == 1.0 && x_movement > f32::EPSILON => {
                            sprite.flip_x = false;
                        }
                        // cuz neg
                        x if x == -1.0 && x_movement < f32::EPSILON => {
                            sprite.flip_x = true;
                        }
                        _ => {}
                    }
                }
            } else {
                md.0 = Vec2::ZERO;
                md.1 = 0.0;
            }
        }
    }
}
#[derive(Actionlike, PartialEq, Eq, Hash, Clone, Copy, Debug, Reflect)]
enum PlayerAction {
    Move,
    LightAttack,
    HeavyAttack,
    // Dash variants, both should just enable dash, but one
    // needs to be held, while the other toggles dash on and off
    HoldDash,
    ToggleDash,
    // X axis - switching between cards
    // +Y axis - above deadzone, use card
    // -Y axis - above deadzone, held, exhaust hand
    Hand,
}
#[derive(Component, Default)]
struct Player;
#[derive(Bundle, Default, LdtkEntity)]
struct PlayerBlueprint {
    player: Player,
}
#[derive(Bundle)]
struct PlayerBundle {
    input_manager_bundle: InputManagerBundle<PlayerAction>,
    // For now, use a mesh
    // mesh: MaterialMesh2dBundle<ColorMaterial>,
    sprite_sheet: SpriteSheetBundle,
    // used to render a pointed arrow
    movement_dir: movement_pointer::MovementDirection,
    dash: DashState,
    // moonshine children
    children: SpawnChildren,
}
fn process_player_start(
    mut commands: Commands,
    new_entity_instances: Query<(Entity, &Transform), Added<Player>>,
    // mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    player_assets: Res<PlayerAssets>,
) {
    for (entity, transform) in new_entity_instances.iter() {
        commands.entity(entity).insert(PlayerBundle {
            input_manager_bundle: InputManagerBundle::with_map(default_input_map()),
            movement_dir: movement_pointer::MovementDirection(Vec2::X, 0.0),
            dash: DashState(false),
            sprite_sheet: SpriteSheetBundle {
                texture: player_assets.texture.clone(),
                atlas: TextureAtlas {
                    layout: player_assets.layout.clone(),
                    index: 0,
                },
                transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),
                ..default()
            },
            // mesh: MaterialMesh2dBundle {
            //     mesh: meshes
            //         .add(Rectangle {
            //             half_size: (16.0, 24.0).into(),
            //         })
            //         .into(),
            //     // Be careful not to overwrite the LDtk transform
            //     // Change our origin
            //     transform: (*transform) * Transform::default().with_translation(Vec3::Y * 8.0),
            //     material: materials.add(Color::PURPLE),
            //     ..default()
            // },
            children: spawn_children(|cb| {
                cb.spawn(movement_pointer::MovementPointerBundle {
                    pointer: movement_pointer::MovementPointer,
                    shape: ShapeBundle {
                        spatial: SpatialBundle {
                            transform: Transform::default().with_scale(Vec3::new(0.5, 1.0, 1.0)),
                            ..default()
                        },
                        path: GeometryBuilder::build_as(&shapes::RegularPolygon {
                            sides: 3,
                            feature: RegularPolygonFeature::Apothem(5.0),
                            ..default()
                        }),
                        material: materials.add(Color::ORANGE_RED),
                        ..default()
                    },
                });
            }),
        });

Deletion in src/main.rs at line 284 [5.49]

B:BD[9.4171] → [9.4171:4174]

∅:D[9.4174] → [11.1241:1564]

B:BD[11.1241] → [11.1241:1564]

B:BD[11.1564] → [16.1276:1349]

∅:D[16.1349] → [11.1564:1681]

B:BD[11.1564] → [11.1564:1681]

B:BD[11.1681] → [2.3:76]

∅:D[2.76] → [11.1742:1813]

B:BD[11.1742] → [11.1742:1813]

B:BD[9.5566] → [9.5566:5728]

B:BD[9.5728] → [7.10871:10938]

∅:D[7.10938] → [9.5728:5731]

B:BD[9.5728] → [9.5728:5731]

B:BD[9.5731] → [14.781:823]

∅:D[14.823] → [9.5798:5902]

B:BD[9.5798] → [9.5798:5902]

B:BD[9.5902] → [17.138:207]

B:BD[17.207] → [24.3710:3788]

∅:D[17.264] → [9.6028:6040]

∅:D[24.3788] → [9.6028:6040]

B:BD[9.6028] → [9.6028:6040]

B:BD[9.6040] → [7.10939:11010]

B:BD[7.11010] → [24.3789:3821]

∅:D[17.294] → [7.11038:11073]

∅:D[24.3821] → [7.11038:11073]

B:BD[7.11038] → [7.11038:11073]

∅:D[7.11073] → [9.6040:6048]

B:BD[9.6040] → [9.6040:6048]

}
fn default_input_map() -> InputMap<PlayerAction> {
    let mut map = InputMap::default();
    map.insert(PlayerAction::Move, DualAxis::left_stick());
    map.insert(PlayerAction::Move, VirtualDPad::wasd());
    map.insert(PlayerAction::LightAttack, KeyCode::KeyZ);
    map.insert(PlayerAction::HeavyAttack, KeyCode::KeyX);
    map.insert(PlayerAction::HoldDash, GamepadButtonType::RightTrigger);
    map.insert(PlayerAction::HoldDash, KeyCode::ShiftLeft);
    map.insert(PlayerAction::ToggleDash, KeyCode::KeyC);
    map.insert(PlayerAction::Hand, VirtualDPad::gamepad_face_buttons());
    map.insert(PlayerAction::Hand, VirtualDPad::arrow_keys());
    map
}
#[derive(Component)]
struct Camera;
#[derive(Bundle)]
struct CameraBundle {
    camera: Camera,
    camera_2d: Camera2dBundle,
    pixel_camera: PixelCamera,
    chroma_aberration: post_process::ChromaticAberattionSettings,
}
fn setup_camera(mut commands: Commands) {
    commands.spawn(CameraBundle {
        camera: Camera,
        camera_2d: Camera2dBundle::default(),
        pixel_camera: PixelCamera::from_size(ViewportSize::AutoMax {
            max_width: LOGICAL_WIDTH,
            max_height: LOGICAL_HEIGHT,
        }),
        chroma_aberration: post_process::ChromaticAberattionSettings {
            // intensity: 0.02,
            ..default()
        },
    });

Replacement in src/main.rs at line 286 [5.49]

B:BD[14.827] → [14.827:900]

fn setup_level(mut commands: Commands, asset_server: Res<AssetServer>) {

[14.827]

[9.6048]

pub(crate) fn setup_level(mut commands: Commands, asset_server: Res<AssetServer>) {

Deletion in src/main.rs at line 292 [5.49]

B:BD[9.6174] → [9.6174:6652]

B:BD[9.6652] → [17.295:367]

∅:D[17.367] → [9.6725:6873]

∅:D[21.537] → [9.6725:6873]

∅:D[16.1694] → [9.6725:6873]

B:BD[9.6725] → [9.6725:6873]

B:BD[11.2782] → [11.2782:2784]


fn update_camera(
    mut camera: Query<(&mut PixelCamera, &GlobalTransform), With<Camera>>,
    player: Query<&GlobalTransform, With<Player>>,
) {
    match (player.get_single(), camera.get_single_mut()) {
        (Ok(transform), Ok((mut camera, cam_transform))) => {
            // Lerp the camera to player's global translation point
            let source = cam_transform.translation();
            let goal = transform.translation();
            let diff = goal - source;
            let lerped = source + diff * 0.1; //* time.delta_seconds();
            camera.subpixel_pos = lerped.xy();
        }
        _ => {
            // Either the camera or the player doesnt exist
        }
    }
}

Replacement in src/debug.rs at line 3 [4.120]

B:BD[4.154] → [4.154:231]

use crate::{fundsp_kira, PlayerAction, You};
use crate::{DashState, Player};

[4.154]

[4.231]

use crate::{fundsp_kira, player::PlayerAction, You};
use crate::{player::DashState, player::Player};

File addition: camera.rs (----------)