haw-gj13-game/src/game/player.rs

use std::{hash::Hash, time::Duration};

use animation::AnimBundle;
use bevy::{ecs::system::SystemId, prelude::*, sprite::MaterialMesh2dBundle, utils::HashMap};

use bevy_rapier2d::prelude::*;

use crate::{AppState, METER};

use super::{scene::PlayerCoords, set::IngameSet};

mod animation;

#[derive(Component)]
struct Player {
    move_cooldown: Timer,
}

impl Default for Player {
    fn default() -> Self {
        Self {
            move_cooldown: Timer::from_seconds(0.01, TimerMode::Repeating),
        }
    }
}

#[derive(Resource)]
pub struct PlayerSpawnOneshot(pub SystemId);

impl FromWorld for PlayerSpawnOneshot {
    fn from_world(world: &mut World) -> Self {
        Self(world.register_system(add_player))
    }
}

pub(super) fn player_plugin(app: &mut App) {
    app.add_systems(Update, (move_player, debug_player_pos))
        .init_resource::<PlayerSpawnOneshot>();
}

#[derive(Component, Hash, PartialEq, Eq, Default)]
enum PlayerAnimations {
    #[default]
    Idle,
    Walk,
}

fn debug_player_pos(query: Query<&Transform, With<Player>>) {
    let trans = query.single();
    dbg!(trans);
}
fn move_player(
    kb_input: Res<ButtonInput<KeyCode>>,
    mut query: Query<(
        &mut Velocity,
        &Transform,
        &mut Player,
        &mut KinematicCharacterController,
    )>,
    mut camera_query: Query<&mut Transform, (With<Camera2d>, Without<Player>)>,
    time: Res<Time>,
) {
    let (mut vel, p_transform, mut player, mut controller) = query.single_mut();
    let (mut cam_transform) = camera_query.single_mut();
    if player.move_cooldown.tick(time.delta()).finished() {
        let mut moved = false;
        let mut mv = 0;
        let mut jump = false;

        if kb_input.pressed(KeyCode::KeyA) {
            moved = true;
            mv -= 1;
        }
        if kb_input.pressed(KeyCode::KeyD) {
            moved = true;
            mv += 1;
        }

        let orig = cam_transform.translation;
        println!("{orig:?}");
        cam_transform.translation -= ((orig - p_transform.translation.xy().extend(0.0)) / 30.0);

        if moved {
            dbg!(mv);
            controller.translation = Some(Vec2::new(mv as f32 * 6., 0.));
        }
    }
}

fn add_player(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
    asset_server: Res<AssetServer>,
    player_coords: Res<PlayerCoords>,
) {
    let tex_idle = asset_server.load("idle.png");
    let layout_idle = TextureAtlasLayout::from_grid(UVec2::splat(512), 2, 1, None, None);
    let layout_idle_handle = texture_atlas_layouts.add(layout_idle);

    let tex_walk = asset_server.load("walk.png");
    let layout_walk = TextureAtlasLayout::from_grid(UVec2::splat(512), 4, 1, None, None);
    let layout_walk_handle = texture_atlas_layouts.add(layout_walk);

    let anims = animation::AnimationManager::default()
        .insert(
            PlayerAnimations::Idle,
            animation::Animation::new(
                TextureAtlas {
                    layout: layout_idle_handle,
                    index: 0,
                },
                2,
                4,
                tex_idle,
            ),
        )
        .insert(
            PlayerAnimations::Walk,
            animation::Animation::new(
                TextureAtlas {
                    layout: layout_walk_handle,
                    index: 0,
                },
                2,
                4,
                tex_walk,
            ),
        );

    commands
        .spawn((
            Player::default(),
            AnimBundle {
                tag: PlayerAnimations::Idle,
                mgr: anims,
            },
            SpriteBundle {
                transform: (*player_coords).into(),
                ..Default::default()
            },
        ))
        .insert((
            RigidBody::Dynamic,
            player_coords.get_collider(),
            Velocity::default(),
        ))
        .insert(KinematicCharacterController {
            //translation: todo!(),
            //custom_shape: todo!(),
            //custom_mass: todo!(),
            //up: todo!(),
            //offset: todo!(),
            //slide: todo!(),
            //autostep: Some(CharacterAutostep {
            //    max_height: CharacterLength::Relative(0.1),
            //    min_width: CharacterLength::Absolute(1.0),
            //    include_dynamic_bodies: false,
            //}),
            //max_slope_climb_angle: todo!(),
            //min_slope_slide_angle: todo!(),
            //apply_impulse_to_dynamic_bodies: todo!(),
            //snap_to_ground: Some(CharacterLength::Absolute(1.0)),
            //filter_flags: todo!(),
            //filter_groups: todo!(),
            //normal_nudge_factor: todo!(),
            ..Default::default()
        });
}