Initial project import
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-06-05 21:44:45 -04:00
commit f29712d158
259 files changed
+52069

No files matched your search

+415
View File
@@ -0,0 +1,415 @@
use bevy::prelude::*;
use bevy::window::{CursorGrabMode, CursorOptions, PrimaryWindow};
use bevy_egui::PrimaryEguiContext;
use game::player::PlayerCamera;
use game::{GameInputEnabled, GameInputFocused, SimEnabled};
use protocol::PlayerInputIntent;
use sim::{Crouching, Grounded, JumpState, Player, PlayerVelocity};
use crate::camera::EditorCamera;
use crate::scene_io::SceneIo;
/// Editor/game mode. `Playing` runs the real game sim; use [`PlayPossession`] for camera control.
#[derive(States, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum EditorMode {
#[default]
Editing,
Playing,
}
/// FPS vs editor fly camera while sim runs in Play mode.
#[derive(Resource, Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PlayPossession {
#[default]
Possessed,
Ejected,
}
/// Player/sim state captured on play enter, restored on play stop.
#[derive(Resource, Default, Clone)]
pub struct PlayModeSnapshot {
pub player: Option<PlayerSimSnapshot>,
}
#[derive(Clone)]
pub struct PlayerSimSnapshot {
pub transform: Transform,
pub velocity: Vec3,
pub intent: PlayerInputIntent,
pub jump_coyote: f32,
pub jump_buffer: f32,
pub grounded: bool,
pub crouching: bool,
pub camera_local: Transform,
}
/// When true, Play mode is active but the fixed-step sim is frozen.
#[derive(Resource, Debug, Clone, Copy, Default)]
pub struct PlayPaused(pub bool);
/// Request one fixed-step sim tick while paused in Play mode (H3).
#[derive(Resource, Debug, Default)]
pub struct PlayStepOnce(pub bool);
pub struct EditorStatePlugin;
impl Plugin for EditorStatePlugin {
fn build(&self, app: &mut App) {
app.init_state::<EditorMode>()
.init_resource::<PlayPossession>()
.init_resource::<PlayPaused>()
.init_resource::<PlayStepOnce>()
.init_resource::<PlayModeSnapshot>()
.add_systems(PostStartup, init_player_camera_for_editor)
.add_systems(
Update,
(
toggle_editor_mode,
toggle_play_pause,
toggle_play_step,
toggle_play_possession,
sync_mode_resources_and_cameras,
sync_play_input_focus,
)
.chain(),
)
.add_systems(
OnEnter(EditorMode::Playing),
(
enter_play_mode,
reset_possession,
reset_play_paused,
grab_play_cursor,
),
)
.add_systems(
OnEnter(EditorMode::Editing),
(exit_play_mode, reset_play_paused, release_play_cursor),
);
}
}
/// Scene tools (selection, gizmos, undo, fly cam) are active in Edit mode or ejected PIE.
pub fn scene_tools_active(mode: Res<State<EditorMode>>, possession: Res<PlayPossession>) -> bool {
match mode.get() {
EditorMode::Editing => true,
EditorMode::Playing => *possession == PlayPossession::Ejected,
}
}
fn toggle_editor_mode(
keys: Res<ButtonInput<KeyCode>>,
state: Res<State<EditorMode>>,
mut next: ResMut<NextState<EditorMode>>,
) {
if keys.just_pressed(KeyCode::F5) {
next.set(match state.get() {
EditorMode::Editing => EditorMode::Playing,
EditorMode::Playing => EditorMode::Editing,
});
}
}
fn toggle_play_possession(
keys: Res<ButtonInput<KeyCode>>,
mode: Res<State<EditorMode>>,
mut possession: ResMut<PlayPossession>,
mut cursor: Single<&mut CursorOptions, With<PrimaryWindow>>,
mut editor_cameras: Query<&mut Transform, With<EditorCamera>>,
player: Query<&GlobalTransform, With<Player>>,
player_cameras: Query<&GlobalTransform, With<PlayerCamera>>,
) {
if *mode.get() != EditorMode::Playing || !keys.just_pressed(KeyCode::F8) {
return;
}
match *possession {
PlayPossession::Possessed => {
*possession = PlayPossession::Ejected;
if let Ok(camera_gt) = player_cameras.single() {
for mut editor_transform in &mut editor_cameras {
*editor_transform = Transform {
translation: camera_gt.translation(),
rotation: camera_gt.rotation(),
..default()
};
}
} else if let Ok(player_gt) = player.single() {
for mut editor_transform in &mut editor_cameras {
editor_transform.translation = player_gt.translation();
}
}
release_play_cursor_internal(&mut cursor);
}
PlayPossession::Ejected => {
*possession = PlayPossession::Possessed;
grab_play_cursor_internal(&mut cursor);
}
}
}
fn toggle_play_pause(
keys: Res<ButtonInput<KeyCode>>,
mode: Res<State<EditorMode>>,
mut paused: ResMut<PlayPaused>,
) {
if *mode.get() != EditorMode::Playing || !keys.just_pressed(KeyCode::F6) {
return;
}
paused.0 = !paused.0;
}
fn toggle_play_step(
keys: Res<ButtonInput<KeyCode>>,
mode: Res<State<EditorMode>>,
paused: Res<PlayPaused>,
mut step: ResMut<PlayStepOnce>,
) {
if *mode.get() != EditorMode::Playing || !paused.0 || !keys.just_pressed(KeyCode::F7) {
return;
}
step.0 = true;
}
fn reset_play_paused(mut paused: ResMut<PlayPaused>) {
paused.0 = false;
}
fn reset_possession(mut possession: ResMut<PlayPossession>) {
*possession = PlayPossession::Possessed;
}
pub(crate) fn init_player_camera_for_editor(
mut player_cameras: Query<&mut Camera, (With<PlayerCamera>, Without<EditorCamera>)>,
) {
for mut camera in &mut player_cameras {
camera.order = 1;
camera.is_active = false;
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn sync_mode_resources_and_cameras(
state: Res<State<EditorMode>>,
possession: Res<PlayPossession>,
paused: Res<PlayPaused>,
mut step: ResMut<PlayStepOnce>,
mut input_enabled: ResMut<GameInputEnabled>,
mut sim_enabled: ResMut<SimEnabled>,
mut editor_cameras: Query<&mut Camera, With<EditorCamera>>,
mut player_cameras: Query<&mut Camera, (With<PlayerCamera>, Without<EditorCamera>)>,
mut egui_cameras: Query<
&mut Camera,
(
With<PrimaryEguiContext>,
Without<EditorCamera>,
Without<PlayerCamera>,
),
>,
mut last_mode: Local<Option<(EditorMode, PlayPossession)>>,
) {
let mode = *state.get();
let playing = mode == EditorMode::Playing;
let ejected = playing && *possession == PlayPossession::Ejected;
let possessed = playing && *possession == PlayPossession::Possessed;
sim_enabled.0 = playing && (!paused.0 || step.0);
input_enabled.0 = possessed && !paused.0;
if step.0 {
step.0 = false;
}
for mut camera in &mut editor_cameras {
camera.is_active = !playing || ejected;
}
for mut camera in &mut player_cameras {
camera.is_active = possessed;
}
for mut camera in &mut egui_cameras {
camera.clear_color = if !playing || ejected {
ClearColorConfig::None
} else {
ClearColorConfig::Custom(Color::BLACK)
};
}
let key = (mode, *possession);
if *last_mode != Some(key) {
*last_mode = Some(key);
info!("EditorMode -> {mode:?}, possession -> {possession:?}");
}
}
fn sync_play_input_focus(
mode: Res<State<EditorMode>>,
possession: Res<PlayPossession>,
paused: Res<PlayPaused>,
mut focused: ResMut<GameInputFocused>,
) {
focused.0 =
*mode.get() == EditorMode::Playing && *possession == PlayPossession::Possessed && !paused.0;
}
fn enter_play_mode(world: &mut World) {
let snapshot = snapshot_player_sim(world);
world.resource_mut::<PlayModeSnapshot>().player = Some(snapshot);
}
fn exit_play_mode(world: &mut World) {
if let Some(snapshot) = world.resource_mut::<PlayModeSnapshot>().player.take() {
restore_player_sim(world, &snapshot);
}
if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
scene_io.dirty = true;
}
}
fn snapshot_player_sim(world: &mut World) -> PlayerSimSnapshot {
let player_data = {
let mut player_query = world.query_filtered::<(
&Transform,
&PlayerVelocity,
&PlayerInputIntent,
&JumpState,
&Grounded,
&Crouching,
), With<Player>>();
player_query.iter(world).next().map(
|(transform, velocity, intent, jump, grounded, crouching)| {
(
*transform,
velocity.0,
*intent,
jump.coyote,
jump.buffer,
grounded.0,
crouching.0,
)
},
)
};
let Some((transform, velocity, intent, jump_coyote, jump_buffer, grounded, crouching)) =
player_data
else {
return PlayerSimSnapshot {
transform: Transform::default(),
velocity: Vec3::ZERO,
intent: PlayerInputIntent::default(),
jump_coyote: 0.0,
jump_buffer: 0.0,
grounded: false,
crouching: false,
camera_local: Transform::IDENTITY,
};
};
let camera_local = {
let mut camera_query = world.query_filtered::<&Transform, With<PlayerCamera>>();
camera_query
.iter(world)
.next()
.copied()
.unwrap_or(Transform::IDENTITY)
};
PlayerSimSnapshot {
transform,
velocity,
intent,
jump_coyote,
jump_buffer,
grounded,
crouching,
camera_local,
}
}
fn restore_player_sim(world: &mut World, snapshot: &PlayerSimSnapshot) {
let mut player_query = world.query_filtered::<(
&mut Transform,
&mut PlayerVelocity,
&mut PlayerInputIntent,
&mut JumpState,
&mut Grounded,
&mut Crouching,
), With<Player>>();
if let Some((mut transform, mut velocity, mut intent, mut jump, mut grounded, mut crouching)) =
player_query.iter_mut(world).next()
{
*transform = snapshot.transform;
velocity.0 = snapshot.velocity;
*intent = snapshot.intent;
*jump = JumpState {
coyote: snapshot.jump_coyote,
buffer: snapshot.jump_buffer,
};
grounded.0 = snapshot.grounded;
crouching.0 = snapshot.crouching;
}
let mut camera_query = world.query_filtered::<&mut Transform, With<PlayerCamera>>();
for mut camera in camera_query.iter_mut(world) {
*camera = snapshot.camera_local;
}
}
fn grab_play_cursor(mut cursor: Single<&mut CursorOptions, With<PrimaryWindow>>) {
grab_play_cursor_internal(&mut cursor);
}
fn release_play_cursor(mut cursor: Single<&mut CursorOptions, With<PrimaryWindow>>) {
release_play_cursor_internal(&mut cursor);
}
fn grab_play_cursor_internal(cursor: &mut CursorOptions) {
cursor.grab_mode = CursorGrabMode::Locked;
cursor.visible = false;
}
fn release_play_cursor_internal(cursor: &mut CursorOptions) {
cursor.grab_mode = CursorGrabMode::None;
cursor.visible = true;
}
/// Toggles possess/eject from UI (mirrors F8 handling in [`toggle_play_possession`]).
pub fn toggle_play_possession_world(world: &mut World) {
if *world.resource::<State<EditorMode>>().get() != EditorMode::Playing {
return;
}
let next = match *world.resource::<PlayPossession>() {
PlayPossession::Possessed => PlayPossession::Ejected,
PlayPossession::Ejected => PlayPossession::Possessed,
};
*world.resource_mut::<PlayPossession>() = next;
let mut cursor = world
.query_filtered::<&mut CursorOptions, With<PrimaryWindow>>()
.single_mut(world)
.expect("primary window cursor");
match next {
PlayPossession::Possessed => grab_play_cursor_internal(&mut cursor),
PlayPossession::Ejected => {
release_play_cursor_internal(&mut cursor);
let camera_pose = world
.query_filtered::<&GlobalTransform, With<PlayerCamera>>()
.single(world)
.ok()
.map(|gt| (gt.translation(), gt.rotation()));
if let Some((translation, rotation)) = camera_pose {
let mut editor_query = world.query_filtered::<&mut Transform, With<EditorCamera>>();
for mut editor_transform in editor_query.iter_mut(world) {
*editor_transform = Transform {
translation,
rotation,
..default()
};
}
}
}
}
}