games
/
game-jam-casino
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

cargo fmt

Browse Source
main
Elijah C. Voigt 1 year ago
parent fdce4410db
commit a787e0e6c3
6 changed files with 228 additions and 218 deletions
Show Stats Download Patch File Download Diff File

9
examples/text_image.rs
Unescape Escape View File

@ -1,12 +1,14 @@
use std::f32::consts::PI;
use bevy::{
input::common_conditions::input_just_pressed, prelude::*, render::{
input::common_conditions::input_just_pressed,
prelude::*,
render::{
camera::RenderTarget,
render_resource::{
Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
},
}
},
};
fn main() {
@ -15,8 +17,7 @@ fn main() {
.add_systems(Startup, add_texture)
.add_systems(
Update,
rotate_mesh
.run_if(input_just_pressed(KeyCode::Space)),
rotate_mesh.run_if(input_just_pressed(KeyCode::Space)),
)
.run();
}

193
src/camera.rs
Unescape Escape View File

@ -5,9 +5,15 @@ pub(crate) struct CameraPlugin;
impl Plugin for CameraPlugin {
fn build(&self, app: &mut App) {
app.add_systems(Update, move_editor_fly_camera);
app.add_systems(Update, rotate_editor_fly_camera);
}
app.add_systems(
Update,
move_editor_fly_camera.run_if(any_with_component::<FlyCamera>),
);
app.add_systems(
Update,
rotate_editor_fly_camera.run_if(any_with_component::<FlyCamera>),
);
}
}
#[derive(Component)]
@ -16,97 +22,102 @@ pub(crate) struct FlyCamera;
/// Fly camera system for moving around like a drone
/// TODO: Only if key is pressed!
fn move_editor_fly_camera(
mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
windows: Query<&Window>,
primary_window: Query<Entity, With<PrimaryWindow>>,
keys: Res<ButtonInput<KeyCode>>,
time: Res<Time>,
mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
windows: Query<&Window>,
primary_window: Query<Entity, With<PrimaryWindow>>,
keys: Res<ButtonInput<KeyCode>>,
time: Res<Time>,
) {
(keys.any_pressed([
KeyCode::KeyW,
KeyCode::KeyS,
KeyCode::KeyA,
KeyCode::KeyD,
KeyCode::KeyQ,
KeyCode::KeyE
])).then(|| {
// Iterate over all cameras
cameras.iter_mut().for_each(|(c, mut t)| {
// Determine which window this camera is attached to
let target_window = match c.target {
RenderTarget::Window(wr) => match wr {
WindowRef::Entity(e) => Some(e),
WindowRef::Primary => Some(primary_window.get_single().unwrap()),
},
_ => None,
};
let window = windows.get(target_window.unwrap()).unwrap();
(keys.any_pressed([
KeyCode::KeyW,
KeyCode::KeyS,
KeyCode::KeyA,
KeyCode::KeyD,
KeyCode::KeyQ,
KeyCode::KeyE,
]))
.then(|| {
// Iterate over all cameras
cameras.iter_mut().for_each(|(c, mut t)| {
// Determine which window this camera is attached to
let target_window = match c.target {
RenderTarget::Window(wr) => match wr {
WindowRef::Entity(e) => Some(e),
WindowRef::Primary => Some(primary_window.get_single().unwrap()),
},
_ => None,
};
let window = windows.get(target_window.unwrap()).unwrap();
// If the target window is focused
window.focused.then(|| {
let move_speed = 4.0;
let mut delta = Vec3::ZERO;
if keys.pressed(KeyCode::KeyW) {
delta += t.forward() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyS) {
delta += t.back() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyA) {
delta += t.left() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyD) {
delta += t.right() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyE) {
delta += Vec3::Y * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyQ) {
delta += Vec3::NEG_Y * move_speed * time.delta_seconds()
}
t.translation += delta;
});
});
});
// If the target window is focused
window.focused.then(|| {
let move_speed = 4.0;
let mut delta = Vec3::ZERO;
if keys.pressed(KeyCode::KeyW) {
delta += t.forward() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyS) {
delta += t.back() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyA) {
delta += t.left() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyD) {
delta += t.right() * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyE) {
delta += Vec3::Y * move_speed * time.delta_seconds()
}
if keys.pressed(KeyCode::KeyQ) {
delta += Vec3::NEG_Y * move_speed * time.delta_seconds()
}
t.translation += delta;
});
});
});
}
fn rotate_editor_fly_camera(
mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
windows: Query<&Window>,
primary_window: Query<Entity, With<PrimaryWindow>>,
mouse: Res<ButtonInput<MouseButton>>,
mut cursor_events: EventReader<CursorMoved>,
mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
windows: Query<&Window>,
primary_window: Query<Entity, With<PrimaryWindow>>,
mouse: Res<ButtonInput<MouseButton>>,
mut cursor_events: EventReader<CursorMoved>,
) {
(cursor_events.len() > 0).then(|| {
// Iterate over all cameras
cameras.iter_mut().for_each(|(c, mut t)| {
// Determine which window this camera is attached to
let target_window = match c.target {
RenderTarget::Window(wr) => match wr {
WindowRef::Entity(e) => Some(e),
WindowRef::Primary => Some(primary_window.get_single().unwrap()),
},
_ => None,
};
let window = windows.get(target_window.unwrap()).unwrap();
if mouse.pressed(MouseButton::Middle) {
cursor_events.read().filter_map(|CursorMoved { delta, window, .. }| {
(*window == target_window.unwrap()).then_some(delta)
}).for_each(|delta| {
if let Some(Vec2 { x, y }) = delta {
// Cribbing from bevy_flycam
// Link: https://github.com/sburris0/bevy_flycam/blob/baffe50e0961ad1491d467fa6ab5551f9f21db8f/src/lib.rs#L145-L151
let (mut yaw, mut pitch, _) = t.rotation.to_euler(EulerRot::YXZ);
let window_scale = window.height().min(window.width());
let sensitivity = 0.00012;
pitch -= (sensitivity * y * window_scale).to_radians();
yaw -= (sensitivity * x * window_scale).to_radians();
t.rotation = Quat::from_axis_angle(Vec3::Y, yaw) * Quat::from_axis_angle(Vec3::X, pitch);
}
});
} else {
cursor_events.clear();
}
});
});
}
(cursor_events.len() > 0).then(|| {
// Iterate over all cameras
cameras.iter_mut().for_each(|(c, mut t)| {
// Determine which window this camera is attached to
let target_window = match c.target {
RenderTarget::Window(wr) => match wr {
WindowRef::Entity(e) => Some(e),
WindowRef::Primary => Some(primary_window.get_single().unwrap()),
},
_ => None,
};
let window = windows.get(target_window.unwrap()).unwrap();
if mouse.pressed(MouseButton::Middle) {
cursor_events
.read()
.filter_map(|CursorMoved { delta, window, .. }| {
(*window == target_window.unwrap()).then_some(delta)
})
.for_each(|delta| {
if let Some(Vec2 { x, y }) = delta {
// Cribbing from bevy_flycam
// Link: https://github.com/sburris0/bevy_flycam/blob/baffe50e0961ad1491d467fa6ab5551f9f21db8f/src/lib.rs#L145-L151
let (mut yaw, mut pitch, _) = t.rotation.to_euler(EulerRot::YXZ);
let window_scale = window.height().min(window.width());
let sensitivity = 0.00012;
pitch -= (sensitivity * y * window_scale).to_radians();
yaw -= (sensitivity * x * window_scale).to_radians();
t.rotation = Quat::from_axis_angle(Vec3::Y, yaw)
* Quat::from_axis_angle(Vec3::X, pitch);
}
});
} else {
cursor_events.clear();
}
});
});
}

179
src/editor.rs
Unescape Escape View File

@ -5,117 +5,118 @@ pub(crate) struct EditorPlugin;
impl Plugin for EditorPlugin {
fn build(&self, app: &mut App) {
app.init_state::<EditorState>();
app.add_systems(Startup, init_editor);
app.add_systems(Update, toggle_editor.run_if(input_just_pressed(KeyCode::F3)));
app.add_systems(OnEnter(EditorState::Open), open_editor);
app.add_systems(OnExit(EditorState::Open), close_editor);
app.add_systems(Update, origin_directions.run_if(in_state(EditorState::Open)));
app.add_systems(Update, world_plane.run_if(in_state(EditorState::Open)));
}
app.init_state::<EditorState>();
app.add_systems(Startup, init_editor);
app.add_systems(
Update,
toggle_editor.run_if(input_just_pressed(KeyCode::F3)),
);
app.add_systems(OnEnter(EditorState::Open), open_editor);
app.add_systems(OnExit(EditorState::Open), close_editor);
app.add_systems(
Update,
origin_directions.run_if(in_state(EditorState::Open)),
);
app.add_systems(Update, world_plane.run_if(in_state(EditorState::Open)));
}
}
/// State tracking if the editor is open
#[derive(States, Debug, Clone, PartialEq, Eq, Hash, Default, Component)]
enum EditorState {
#[default]
Closed,
Open,
Closed,
Open,
}
#[derive(Component)]
struct Editor;
/// Spawns all base editor entities including window, camera, and UI elements
fn init_editor(
mut commands: Commands
) {
// Spawn root editor entity hierarchy
commands.spawn(SpatialBundle { ..default() })
.with_children(|parent| {
let editor_window = parent.spawn((
Editor,
Window {
title: "Editor".into(),
name: Some("Editor".into()),
visible: false,
..default()
},
)).id();
fn init_editor(mut commands: Commands) {
// Spawn root editor entity hierarchy
commands
.spawn(SpatialBundle { ..default() })
.with_children(|parent| {
let editor_window = parent
.spawn((
Editor,
Window {
title: "Editor".into(),
name: Some("Editor".into()),
visible: false,
..default()
},
))
.id();
// Spawn editor camera
let _editor_camera = parent.spawn((
Editor,
FlyCamera,
Camera3dBundle {
camera: Camera {
target: RenderTarget::Window(WindowRef::Entity(editor_window)),
..default()
},
transform: Transform::from_xyz(1.0, 1.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
},
)).id();
});
// Spawn editor camera
let _editor_camera = parent
.spawn((
Editor,
FlyCamera,
Camera3dBundle {
camera: Camera {
target: RenderTarget::Window(WindowRef::Entity(editor_window)),
..default()
},
transform: Transform::from_xyz(1.0, 1.0, 1.0)
.looking_at(Vec3::ZERO, Vec3::Y),
..default()
},
))
.id();
});
}
fn open_editor(
mut ws: Query<&mut Window, With<Editor>>,
) {
ws.iter_mut().for_each(|mut w| {
w.visible = true;
});
fn open_editor(mut ws: Query<&mut Window, With<Editor>>) {
ws.iter_mut().for_each(|mut w| {
w.visible = true;
});
}
fn close_editor(
mut ws: Query<&mut Window, With<Editor>>,
) {
ws.iter_mut().for_each(|mut w| {
w.visible = false;
});
fn close_editor(mut ws: Query<&mut Window, With<Editor>>) {
ws.iter_mut().for_each(|mut w| {
w.visible = false;
});
}
fn toggle_editor(
state: Res<State<EditorState>>,
mut next_state: ResMut<NextState<EditorState>>,
keys: Res<ButtonInput<KeyCode>>,
mut catch: Local<bool>,
state: Res<State<EditorState>>,
mut next_state: ResMut<NextState<EditorState>>,
keys: Res<ButtonInput<KeyCode>>,
mut catch: Local<bool>,
) {
if keys.pressed(KeyCode::F3) && !*catch {
*catch = true;
match state.get() {
EditorState::Open => next_state.set(EditorState::Closed),
EditorState::Closed => next_state.set(EditorState::Open),
}
} else {
*catch = false;
}
if keys.pressed(KeyCode::F3) && !*catch {
*catch = true;
match state.get() {
EditorState::Open => next_state.set(EditorState::Closed),
EditorState::Closed => next_state.set(EditorState::Open),
}
} else {
*catch = false;
}
}
fn origin_directions(
mut gizmos: Gizmos
) {
gizmos.arrow(Vec3::ZERO, Vec3::X, Color::RED);
gizmos.arrow(Vec3::ZERO, Vec3::Y, Color::GREEN);
gizmos.arrow(Vec3::ZERO, Vec3::Z, Color::BLUE);
fn origin_directions(mut gizmos: Gizmos) {
gizmos.arrow(Vec3::ZERO, Vec3::X, Color::RED);
gizmos.arrow(Vec3::ZERO, Vec3::Y, Color::GREEN);
gizmos.arrow(Vec3::ZERO, Vec3::Z, Color::BLUE);
}
fn world_plane(
mut gizmos: Gizmos
) {
(-10..=10).into_iter().for_each(|x| {
(-10..=10).into_iter().for_each(|z| {
{
let start = Vec3::new(x as f32, 0.0, -10.0);
let end = Vec3::new(x as f32, 0.0, 10.0);
gizmos.line(start, end, Color::GRAY);
}
{
let start = Vec3::new(-10.0, 0.0, z as f32);
let end = Vec3::new(10.0, 0.0, z as f32);
gizmos.line(start, end, Color::GRAY);
}
});
});
}
fn world_plane(mut gizmos: Gizmos) {
(-10..=10).into_iter().for_each(|x| {
(-10..=10).into_iter().for_each(|z| {
{
let start = Vec3::new(x as f32, 0.0, -10.0);
let end = Vec3::new(x as f32, 0.0, 10.0);
gizmos.line(start, end, Color::GRAY);
}
{
let start = Vec3::new(-10.0, 0.0, z as f32);
let end = Vec3::new(10.0, 0.0, z as f32);
gizmos.line(start, end, Color::GRAY);
}
});
});
}

28
src/game/dice.rs
Unescape Escape View File

@ -141,22 +141,20 @@ fn move_die(
}| {
match state {
ButtonState::Pressed => {
q.iter_mut().for_each(|mut t| {
match key_code {
KeyCode::ArrowLeft => {
t.translation -= Vec3::X * time.delta_seconds() * 1000.0
}
KeyCode::ArrowRight => {
t.translation += Vec3::X * time.delta_seconds() * 1000.0
}
KeyCode::ArrowDown => {
t.translation -= Vec3::Y * time.delta_seconds() * 1000.0
}
KeyCode::ArrowUp => {
t.translation += Vec3::Y * time.delta_seconds() * 1000.0
}
_ => (),
q.iter_mut().for_each(|mut t| match key_code {
KeyCode::ArrowLeft => {
t.translation -= Vec3::X * time.delta_seconds() * 1000.0
}
KeyCode::ArrowRight => {
t.translation += Vec3::X * time.delta_seconds() * 1000.0
}
KeyCode::ArrowDown => {
t.translation -= Vec3::Y * time.delta_seconds() * 1000.0
}
KeyCode::ArrowUp => {
t.translation += Vec3::Y * time.delta_seconds() * 1000.0
}
_ => (),
});
}
_ => (),

31
src/main.rs
Unescape Escape View File

@ -29,13 +29,14 @@ use crate::prelude::*;
fn main() {
let mut app = App::new();
app.add_plugins(bevy::DefaultPlugins
.set(low_latency_window_plugin())
.set(WindowPlugin {
exit_condition: ExitCondition::OnPrimaryClosed,
close_when_requested: false,
..default()
})
app.add_plugins(
bevy::DefaultPlugins
.set(low_latency_window_plugin())
.set(WindowPlugin {
exit_condition: ExitCondition::OnPrimaryClosed,
close_when_requested: false,
..default()
}),
);
app.add_plugins(bevy_mod_picking::DefaultPickingPlugins);
app.add_plugins(menu::MenuPlugin);
@ -43,8 +44,9 @@ fn main() {
app.add_plugins(game::GamePlugin);
app.add_plugins(editor::EditorPlugin);
app.add_plugins(camera::CameraPlugin);
app.add_systems(Update,
handle_window_close.run_if(on_event::<WindowCloseRequested>())
app.add_systems(
Update,
handle_window_close.run_if(on_event::<WindowCloseRequested>()),
);
app.run();
}
@ -75,12 +77,9 @@ fn handle_window_close(
if primary.contains(*window) {
commands.entity(*window).remove::<Window>();
} else {
secondary
.get_mut(*window)
.iter_mut()
.for_each(|w| {
w.visible = false;
});
secondary.get_mut(*window).iter_mut().for_each(|w| {
w.visible = false;
});
}
});
}
}

6
src/prelude.rs
Unescape Escape View File

@ -2,6 +2,7 @@ pub(crate) use std::fmt::Debug;
/// Bevy imports
pub(crate) use bevy::ecs::system::EntityCommand;
pub(crate) use bevy::input::common_conditions::input_just_pressed;
pub(crate) use bevy::input::keyboard::KeyboardInput;
pub(crate) use bevy::input::ButtonState;
pub(crate) use bevy::prelude::*;
@ -9,14 +10,14 @@ pub(crate) use bevy::render::camera::RenderTarget;
pub(crate) use bevy::render::render_resource::{
Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
};
pub(crate) use bevy::window::ExitCondition;
pub(crate) use bevy::window::WindowRef;
pub(crate) use bevy::window::{PrimaryWindow, WindowCloseRequested};
pub(crate) use bevy::window::ExitCondition;
pub(crate) use bevy::input::common_conditions::input_just_pressed;
/// Bevy Plugins
pub(crate) use bevy_mod_picking::prelude::*;
pub(crate) use crate::camera::FlyCamera;
/// Intra-project imports
pub(crate) use crate::ecs::schedule::common_conditions::*;
pub(crate) use crate::game::GameChoice;
@ -30,4 +31,3 @@ pub(crate) use crate::ui::style::UiStyle;
pub(crate) use crate::ui::title::UiTitle;
pub(crate) use crate::ui::EmitEvent;
pub(crate) use crate::ui::SetState;
pub(crate) use crate::camera::FlyCamera;

Write Preview
Loading…
Cancel
Save