pop
/
martian-chess
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

selection refactor; not working

Browse Source
selection-refactor
Elijah Voigt 2 years ago
parent f32d462df6
commit 3473738edc
4 changed files with 234 additions and 190 deletions
Show Stats Download Patch File Download Diff File

21
src/audio.rs
Unescape Escape View File

@ -56,17 +56,22 @@ fn audio_events(
mut reader: EventReader<game::GameEvent>, mut reader: EventReader<game::GameEvent>,
studio: Res<FmodStudio>, studio: Res<FmodStudio>,
mut commands: Commands, mut commands: Commands,
pieces: Query<&game::Piece>,
) { ) {
reader.iter().for_each(|event| match event { reader.iter().for_each(|event| match event {
game::GameEvent::SelectPiece => { game::GameEvent::Select(entity, _) => {
commands.spawn(AudioSource::new( if pieces.contains(*entity) {
studio.0.get_event("event:/SFX/PickUpPiece").unwrap(), commands.spawn(AudioSource::new(
)); studio.0.get_event("event:/SFX/PickUpPiece").unwrap(),
));
}
} }
game::GameEvent::PlacePiece => { game::GameEvent::Place(entity, _) => {
commands.spawn(AudioSource::new( if pieces.contains(*entity) {
studio.0.get_event("event:/SFX/PutDownPiece").unwrap(), commands.spawn(AudioSource::new(
)); studio.0.get_event("event:/SFX/PutDownPiece").unwrap(),
));
}
} }
}) })
} }

243
src/display2d.rs
Unescape Escape View File

@ -8,10 +8,7 @@ use bevy::{
/// TODO: Custom Asset: SpriteSheetAtlas Mapper /// TODO: Custom Asset: SpriteSheetAtlas Mapper
/// TODO: Handle Cursor! /// TODO: Handle Cursor!
/// ///
use crate::{ use crate::{game::*, prelude::*};
game::{ActiveTile, Board, BoardIndex, Piece, Side, Tile},
prelude::*,
};
const SCALE: f32 = 4.0; const SCALE: f32 = 4.0;
const TILE_SIZE: f32 = 16.0; const TILE_SIZE: f32 = 16.0;
@ -26,25 +23,19 @@ impl Plugin for Display2dPlugin {
.add_systems( .add_systems(
Update, Update,
( (
active_tile.run_if(in_state(GameState::Display2d)),
menu::exit_to_menu.run_if(in_state(GameState::Display2d)), menu::exit_to_menu.run_if(in_state(GameState::Display2d)),
select_piece.run_if(in_state(GameState::Display2d)), select_2d.run_if(on_event::<MouseButtonInput>()),
move_piece move_piece
.run_if(in_state(GameState::Display2d)) .run_if(in_state(GameState::Display2d))
.run_if(any_with_component::<game::Selected>()), .run_if(any_with_component::<game::Selected>()),
place_piece place_piece
.run_if(in_state(GameState::Display2d)) .run_if(in_state(GameState::Display2d))
.run_if(any_with_component::<game::Selected>()), .run_if(any_with_component::<game::Selected>()),
cancel_place
.run_if(in_state(GameState::Display2d))
.run_if(on_event::<MouseButtonInput>()),
snap_back_cancel
.run_if(in_state(GameState::Display2d))
.run_if(any_component_removed::<game::Selected>()),
update_background.run_if(on_event::<WindowResized>()), update_background.run_if(on_event::<WindowResized>()),
set_transform set_2d_transform
.after(game::update_board::<Display2d>) .run_if(any_component_changed::<BoardIndex>)
.run_if(any_component_changed::<BoardIndex>), .before(game::update_board::<Display2d>)
.after(game::manage_piece),
set_piece_sprite.run_if(any_component_changed::<Side>), set_piece_sprite.run_if(any_component_changed::<Side>),
set_tile_sprite.run_if(any_component_added::<game::Tile>), set_tile_sprite.run_if(any_component_added::<game::Tile>),
), ),
@ -232,91 +223,99 @@ fn set_tile_sprite(
} }
/// Sets a piece location given it's board index /// Sets a piece location given it's board index
fn set_transform( fn set_2d_transform(
mut events: Query< mut events: Query<
(&mut Transform, &BoardIndex), (Entity, &mut Transform, &BoardIndex),
( (
With<Display2d>, With<Display2d>,
Or<(Changed<BoardIndex>, Added<BoardIndex>)>, Or<(Changed<BoardIndex>, Added<BoardIndex>)>,
), ),
>, >,
pieces: Query<Entity, (With<game::Piece>, With<Display2d>)>,
) { ) {
events.iter_mut().for_each(|(mut t, i)| { events.iter_mut().for_each(|(e, mut t, i)| {
let x = SCALE * 16.0 * ((i.x as f32) - 3.5); let x = SCALE * 16.0 * ((i.x as f32) - 3.5);
let y = SCALE * 16.0 * ((i.y as f32) - 1.5); let y = SCALE * 16.0 * ((i.y as f32) - 1.5);
*t = Transform::from_scale(Vec3::splat(SCALE)).with_translation(Vec3::new(x, y, 0.0)); let z = if pieces.contains(e) { 1.0 } else { 0.0 };
*t = Transform::from_scale(Vec3::splat(SCALE)).with_translation(Vec3::new(x, y, z));
debug!("setting position of {:?} to {:?}", i, t); debug!("setting position of {:?} to {:?}", i, t);
}); });
} }
fn active_tile( fn select_2d(
mut events: EventReader<CursorMoved>,
sprite_q: Query<(
&TextureAtlasSprite,
&Handle<TextureAtlas>,
&GlobalTransform,
&BoardIndex,
)>,
camera_q: Query<(&Camera, &GlobalTransform), With<Display2d>>,
atlases: Res<Assets<TextureAtlas>>,
mut active: ResMut<ActiveTile>,
) {
events.iter().for_each(|CursorMoved { position, .. }| {
if let Some(position) = camera_q
.iter()
.find_map(|(camera, transform)| camera.viewport_to_world_2d(transform, *position))
{
let idx = sprite_q.iter().find_map(
|(TextureAtlasSprite { index, anchor, .. }, handle, transform, board_index)| {
// Implementation credit goes to the sprite bevy_mod_picking backend
// TODO: Upstream changes
let pos = transform.translation();
let size = {
let sprite_size = atlases
.get(handle)
.map(|atlas| atlas.textures.get(*index).expect("Get this rect texture"))
.expect("get this rect")
.size();
let (transform_scale, _, _) = transform.to_scale_rotation_translation();
sprite_size * transform_scale.truncate()
};
let center = pos.truncate() - (anchor.as_vec() * size);
let rect = Rect::from_center_half_size(center, size / 2.0);
rect.contains(position).then_some(board_index)
},
);
if active.idx != idx.cloned() {
active.idx = idx.cloned();
}
}
});
}
fn select_piece(
mut events: EventReader<MouseButtonInput>, mut events: EventReader<MouseButtonInput>,
pieces: Query<(Entity, &BoardIndex), (With<game::Piece>, With<Display2d>)>, sprite_q: Query<
active: Res<ActiveTile>, (
mut commands: Commands, Entity,
&TextureAtlasSprite,
&Handle<TextureAtlas>,
&GlobalTransform,
&BoardIndex,
),
(Without<game::Selected>, With<Display2d>),
>,
cameras: Query<(&Camera, &GlobalTransform), With<Display2d>>,
atlases: Res<Assets<TextureAtlas>>,
windows: Query<&Window, With<PrimaryWindow>>,
mut writer: EventWriter<game::GameEvent>, mut writer: EventWriter<game::GameEvent>,
) { ) {
events events
.iter() .iter()
.filter_map(|MouseButtonInput { button, state, .. }| { .filter(|ev| ev.state == ButtonState::Pressed)
active.idx.as_ref().and_then(|index| { .for_each(|_| {
pieces.iter().find_map(|(entity, board_idx)| { windows
(board_idx == index).then_some((entity, button, state)) .iter()
.filter_map(|window| window.cursor_position())
.find_map(|position| {
cameras
.iter()
.filter_map(|(camera, gt)| camera.viewport_to_world_2d(gt, position))
.find_map(|pos| {
// TODO: Sort by Z-Index
sprite_q
.iter()
.filter_map(
|(
entity,
TextureAtlasSprite { index, anchor, .. },
handle,
transform,
board_index,
)| {
// Implementation credit goes to the sprite bevy_mod_picking backend
// TODO: Upstream changes (related to sprite atlas correct behavior)
let p = transform.translation();
let size = {
let sprite_size = atlases
.get(handle)
.map(|atlas| {
atlas
.textures
.get(*index)
.expect("Get this rect texture")
})
.expect("get this rect")
.size();
let (transform_scale, _, _) =
transform.to_scale_rotation_translation();
sprite_size * transform_scale.truncate()
};
let center = p.truncate() - (anchor.as_vec() * size);
let rect = Rect::from_center_half_size(center, size / 2.0);
rect.contains(pos).then_some((entity, board_index, p.z))
},
)
.max_by_key(|(_, _, z)| z.round() as usize)
})
}) })
}) .iter()
}) .for_each(|(e, &ref i, _)| {
.filter_map(|(entity, button, state)| { info!("Select piece in 2d {:?} {:?}", e, i);
((*button, *state) == (MouseButton::Left, ButtonState::Pressed)).then_some(entity) writer.send(game::GameEvent::Select(*e, i.clone()));
}) });
.for_each(|entity| {
commands.entity(entity).insert(game::Selected);
writer.send(game::GameEvent::SelectPiece);
}); });
} }
@ -339,86 +338,48 @@ fn move_piece(
} }
/// ///
/// TODO: Only place piece if spot is valid move for the selected entity /// 2D Placement Logic
/// ///
fn place_piece( fn place_piece(
mut events: EventReader<MouseButtonInput>, mut events: EventReader<MouseButtonInput>,
current: Query< active_piece: Query<
(Entity, &BoardIndex), (Entity, &BoardIndex),
(With<game::Selected>, With<game::Piece>, With<Display2d>), (With<game::Piece>, With<game::Selected>, With<Display2d>),
>, >,
pieces: Query<&BoardIndex, (Without<game::Selected>, With<game::Piece>, With<Display2d>)>, active_tile: Query<&BoardIndex, (With<game::Tile>, With<game::Selected>, With<Display2d>)>,
active: Res<ActiveTile>,
mut board: ResMut<Board>, mut board: ResMut<Board>,
mut commands: Commands,
mut game_events: EventWriter<game::GameEvent>, mut game_events: EventWriter<game::GameEvent>,
mut move_events: EventWriter<game::Move>, mut move_events: EventWriter<game::Move>,
) { ) {
events events
.iter() .iter()
.filter_map(|MouseButtonInput { button, state, .. }| { .filter_map(|event| match event {
if (*button, *state) == (MouseButton::Left, ButtonState::Pressed) { MouseButtonInput {
active.idx.as_ref() button: MouseButton::Left,
} else { state: ButtonState::Pressed,
None ..
} } => active_tile.get_single().ok(),
_ => None,
}) })
.filter_map(|idx| { .filter_map(|to| {
if !current.is_empty() { active_piece
(!pieces.iter().any(|board_index| board_index == idx)).then_some(( .get_single()
current.single().0, .map(|(entity, from)| (entity, from, to))
current.single().1, .ok()
idx,
))
} else {
None
}
}) })
.for_each(|(entity, from, to)| match board.move_piece(from, to) { .for_each(|(entity, from, to)| match board.move_piece(from, to) {
Ok(moves) => { Ok(moves) => {
commands.entity(entity).remove::<game::Selected>(); info!("Moving piece {:?} {:?} -> {:?}", entity, from, to);
moves.iter().for_each(|m| { moves.iter().for_each(|m| {
move_events.send(m.clone()); move_events.send(m.clone());
}); });
game_events.send(game::GameEvent::PlacePiece); game_events.send(game::GameEvent::Place(entity, to.clone()));
}
Err(game::GameError::NullMove) => {
warn!("Null move!");
game_events.send(game::GameEvent::Place(entity, from.clone()))
} }
Err(game::GameError::NullMove) => game_events.send(game::GameEvent::PlacePiece),
Err(game::GameError::InvalidMove) => warn!("Invalid move!"), Err(game::GameError::InvalidMove) => warn!("Invalid move!"),
Err(game::GameError::InvalidIndex) => warn!("Invalid index!"), Err(game::GameError::InvalidIndex) => warn!("Invalid index!"),
}) })
} }
fn cancel_place(
mut events: EventReader<MouseButtonInput>,
current: Query<Entity, (With<game::Selected>, With<game::Piece>, With<Display2d>)>,
mut commands: Commands,
mut writer: EventWriter<game::GameEvent>,
) {
events
.iter()
.filter(|MouseButtonInput { button, state, .. }| {
(*button, *state) == (MouseButton::Right, ButtonState::Pressed)
})
.for_each(|_| {
if let Ok(entity) = current.get_single() {
commands.entity(entity).remove::<game::Selected>();
writer.send(game::GameEvent::PlacePiece);
}
})
}
fn snap_back_cancel(
mut events: RemovedComponents<game::Selected>,
query: Query<&game::BoardIndex, (With<game::Piece>, With<Display2d>)>,
mut move_events: EventWriter<game::Move>,
) {
events.iter().for_each(|entity| {
if let Ok(idx) = query.get(entity) {
move_events.send(game::Move {
epoch: 0,
from: idx.clone(),
to: Some(idx.clone()),
});
}
})
}

98
src/display3d.rs
Unescape Escape View File

@ -7,7 +7,6 @@ use crate::{
}; };
use bevy::{ use bevy::{
core_pipeline::Skybox, core_pipeline::Skybox,
ecs::removal_detection::RemovedComponentReader,
input::mouse::{MouseButtonInput, MouseMotion, MouseWheel}, input::mouse::{MouseButtonInput, MouseMotion, MouseWheel},
render::render_resource::{TextureViewDescriptor, TextureViewDimension}, render::render_resource::{TextureViewDescriptor, TextureViewDimension},
window::PrimaryWindow, window::PrimaryWindow,
@ -36,6 +35,7 @@ impl Plugin for Display3dPlugin {
.run_if(on_event::<MouseButtonInput>()), .run_if(on_event::<MouseButtonInput>()),
pick_up.run_if(any_component_added::<game::Selected>), pick_up.run_if(any_component_added::<game::Selected>),
put_down.run_if(any_component_removed::<game::Selected>()), put_down.run_if(any_component_removed::<game::Selected>()),
place_piece.run_if(any_component_changed::<game::BoardIndex>),
), ),
) )
.add_systems( .add_systems(
@ -153,6 +153,7 @@ fn initialize(mut commands: Commands, board: Res<game::Board>, assets: Res<Asset
Display3d, Display3d,
index, index,
tile, tile,
game::Selecting,
PbrBundle { PbrBundle {
mesh: assets.hitbox_shape.clone(), mesh: assets.hitbox_shape.clone(),
material: assets.hitbox_material.clone(), material: assets.hitbox_material.clone(),
@ -164,13 +165,12 @@ fn initialize(mut commands: Commands, board: Res<game::Board>, assets: Res<Asset
// Pieces // Pieces
board.pieces().iter().for_each(|(index, piece)| { board.pieces().iter().for_each(|(index, piece)| {
let side = Board::side(index).expect("Spawn valid side");
parent.spawn(( parent.spawn((
side, Board::side(index).expect("Spawn valid side"),
Display3d, Display3d,
piece.clone(), piece.clone(),
index.clone(), index.clone(),
game::Selecting,
SceneBundle { ..default() }, SceneBundle { ..default() },
)); ));
}); });
@ -415,71 +415,73 @@ fn set_piece_texture(
/// Function for selecting entities based on ray intersection /// Function for selecting entities based on ray intersection
/// There is a bug where we are selecting multiple entities... /// There is a bug where we are selecting multiple entities...
/// Refactor:
/// * Emit event that an object was selected by finding the parent (or self) with the Selecting component.
/// * Downstream systems can listen for this event and act accoringly (piece, tiles, etc)
fn select_3d( fn select_3d(
mut events: EventReader<MouseButtonInput>, mut events: EventReader<MouseButtonInput>,
mut writer: EventWriter<game::GameEvent>,
query: Query<(Entity, &Handle<Mesh>, &GlobalTransform)>, query: Query<(Entity, &Handle<Mesh>, &GlobalTransform)>,
meshes: Res<Assets<Mesh>>, meshes: Res<Assets<Mesh>>,
cameras: Query<(&Camera, &GlobalTransform)>, cameras: Query<(&Camera, &GlobalTransform)>,
windows: Query<&Window, With<PrimaryWindow>>, windows: Query<&Window, With<PrimaryWindow>>,
parents: Query<Entity, (With<game::Piece>, With<Display3d>)>, candidates: Query<(Entity, &game::BoardIndex), With<Display3d>>,
children: Query<&Children>, children: Query<&Parent>,
mut commands: Commands,
selected: Query<Entity, (With<game::Selected>, With<game::Piece>, With<Display3d>)>,
) { ) {
events events
.iter() .iter()
.filter(|ev| ev.state == ButtonState::Pressed) .filter(|ev| ev.state == ButtonState::Pressed)
.for_each(|_| { .for_each(|_| {
windows.iter().for_each(|window| { windows
window.cursor_position().and_then(|pos| { .iter()
cameras.iter().for_each(|(camera, gt)| { .filter_map(|window| window.cursor_position())
camera.viewport_to_world(gt, pos).and_then(|ray| { .for_each(|pos| {
cameras
.iter()
.filter_map(|(camera, gt)| camera.viewport_to_world(gt, pos))
.for_each(|ray| {
query query
.iter() .iter()
.filter_map(|(entity, handle, gt)| { .filter_map(|(entity, handle, gt)| {
meshes.get(handle).map(|mesh| (entity, mesh, gt)) meshes.get(handle).map(|mesh| (entity, mesh, gt))
}) })
.for_each(|(entity, mesh, gt)| { .for_each(|(entity, mesh, gt)| {
hit3d::intersects(&ray, mesh, &gt).and_then(|_hit| { if let Some(_hit) = hit3d::intersects(&ray, mesh, &gt) {
parents // The hit was on an entity directly
.iter() if let Ok((e, i)) = candidates.get(entity) {
.find(|&parent| { writer.send(game::GameEvent::Select(e, i.clone()));
children // The hit was on an entity which may have a parent which
.iter_descendants(parent) // may be selectable
.any(|child| child == entity) } else {
}) children
.iter() .iter_ancestors(entity)
.for_each(|&parent| { .find_map(|a| candidates.get(a).ok())
selected.iter().for_each(|s| { .iter()
if s != parent { .for_each(|(e, &ref i)| {
commands writer.send(game::GameEvent::Select(
.entity(s) *e,
.remove::<game::Selected>(); i.clone(),
} ));
}); });
commands.entity(parent).insert(game::Selected); }
}); }
Some(())
});
}); });
Some(())
}); });
});
Some(())
}); });
});
}); });
} }
fn selected_gizmo( fn selected_gizmo(
selected: Query<&Transform, (With<game::Selected>, With<game::Piece>, With<Display3d>)>, selected: Query<&GlobalTransform, (With<game::Selected>, With<Display3d>)>,
mut gizmos: Gizmos, mut gizmos: Gizmos,
) { ) {
selected.iter().for_each(|transform| { selected.iter().for_each(|gt| {
gizmos.cuboid(transform.clone(), Color::GREEN); info!("Adding selected gizmo at {:?}", gt);
gizmos.cuboid(gt.clone(), Color::GREEN);
}) })
} }
/// Pick up a piece when it is selected
fn pick_up( fn pick_up(
mut events: Query< mut events: Query<
(Entity, &game::Piece), (Entity, &game::Piece),
@ -518,6 +520,7 @@ fn pick_up(
}); });
} }
/// Put down a piece when it is de-selected
fn put_down( fn put_down(
mut events: RemovedComponents<game::Selected>, mut events: RemovedComponents<game::Selected>,
mut query: Query<&game::Piece, (With<game::Piece>, With<Display3d>)>, mut query: Query<&game::Piece, (With<game::Piece>, With<Display3d>)>,
@ -547,6 +550,7 @@ fn put_down(
}) })
} }
/// Set the transformation of a tile hitbox
fn set_tile_hitbox( fn set_tile_hitbox(
mut events: Query<(&mut Transform, &BoardIndex), (With<Display3d>, Added<game::Tile>)>, mut events: Query<(&mut Transform, &BoardIndex), (With<Display3d>, Added<game::Tile>)>,
) { ) {
@ -554,3 +558,19 @@ fn set_tile_hitbox(
*transform = Transform::from_translation(board_translation(index)); *transform = Transform::from_translation(board_translation(index));
}); });
} }
// Place a piece at a newly selected tile
fn place_piece(
mut events: Query<
(Entity, &BoardIndex, &mut Transform),
(
With<Display3d>,
With<game::Piece>,
Changed<game::BoardIndex>,
),
>,
) {
events
.iter_mut()
.for_each(|(entity, idx, mut transform)| todo!("Place 3d piece in new location"))
}

62
src/game.rs
Unescape Escape View File

@ -13,6 +13,8 @@ impl Plugin for GamePlugin {
( (
update_board::<display2d::Display2d>.run_if(on_event::<Move>()), update_board::<display2d::Display2d>.run_if(on_event::<Move>()),
update_board::<display3d::Display3d>.run_if(on_event::<Move>()), update_board::<display3d::Display3d>.run_if(on_event::<Move>()),
select_tile.run_if(on_event::<game::GameEvent>()),
manage_piece.run_if(on_event::<game::GameEvent>()),
set_side.run_if(on_event::<Move>()), // TODO: correct run_if? set_side.run_if(on_event::<Move>()), // TODO: correct run_if?
), ),
) )
@ -73,10 +75,12 @@ pub(crate) enum GameError {
InvalidIndex, InvalidIndex,
} }
/// Generic event for selecting an entity with a BoardIndex.
/// This can be a Piece or a Tile/Hitbox.
#[derive(Debug, Event)] #[derive(Debug, Event)]
pub(crate) enum GameEvent { pub(crate) enum GameEvent {
SelectPiece, Select(Entity, BoardIndex),
PlacePiece, Place(Entity, BoardIndex),
} }
/// The board is setup like this: /// The board is setup like this:
@ -210,6 +214,9 @@ pub(crate) struct ActiveTile {
#[derive(Debug, Default, Component)] #[derive(Debug, Default, Component)]
pub(crate) struct Selected; pub(crate) struct Selected;
#[derive(Debug, Default, Component)]
pub(crate) struct Selecting;
fn setup_board(mut commands: Commands) { fn setup_board(mut commands: Commands) {
use Piece::*; use Piece::*;
commands.insert_resource(Board { commands.insert_resource(Board {
@ -312,3 +319,54 @@ pub(crate) fn set_side(mut events: Query<(&mut Side, &BoardIndex), Changed<Board
Err(e) => warn!("{:?}", e), Err(e) => warn!("{:?}", e),
}); });
} }
/// Manage selection of 3d entities
pub(crate) fn manage_piece(
mut events: EventReader<game::GameEvent>,
mut pieces: Query<(Entity, &mut BoardIndex), With<Piece>>,
mut commands: Commands,
) {
events.iter().for_each(|event| match event {
game::GameEvent::Select(entity, _) => {
pieces.iter().for_each(|(e, _)| {
if e == *entity {
info!("Marking Piece {:?} as selected", e);
commands.entity(e).insert(game::Selected);
} else {
commands.entity(e).remove::<game::Selected>();
}
});
}
game::GameEvent::Place(entity, index) => {
if let Ok((_, mut idx)) = pieces.get_mut(*entity) {
info!("Placing Piece {:?} at {:?}", entity, idx);
*idx = index.clone();
debug!("Removing selected marker");
commands
.entity(*entity)
.insert(index.clone())
.remove::<game::Selected>();
}
}
});
}
/// Manage selection of tiles
fn select_tile(
mut events: EventReader<game::GameEvent>,
tiles: Query<Entity, With<game::Tile>>,
mut commands: Commands,
) {
events.iter().for_each(|event| match event {
game::GameEvent::Select(entity, _) => tiles.iter().for_each(|e| {
if e == *entity {
info!("Marking Tile {:?} as selected", e);
commands.entity(*entity).insert(game::Selected);
} else {
commands.entity(*entity).remove::<game::Selected>();
}
}),
game::GameEvent::Place(_, _) => error!("Cannot place tiles!"),
})
}

Write Preview
Loading…
Cancel
Save