pop
/
games
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed collision directionality bug

Browse Source
main
Elijah Voigt 3 days ago
parent 11864e1229
commit 39b11593ca
1 changed files with 169 additions and 271 deletions
Show Stats Download Patch File Download Diff File

370
src/bin/tetris/main.rs
Unescape Escape View File

@ -10,7 +10,7 @@ use games::*;
fn main() {
App::new()
.add_plugins(BaseGamePlugin {
name: "falling-block-rpg".into(),
name: "falling-block-adventure".into(),
target_resolution: (640.0, 480.0).into(),
game_type: GameType::Two,
..default()
@ -24,16 +24,11 @@ fn main() {
falling
.run_if(in_state(Falling::On))
.run_if(clock_cycle(1.0)),
set_shape.run_if(
any_component_added::<Shape>
.or(any_component_changed::<Shape>)
.or(any_component_added::<Orientation>)
.or(any_component_changed::<Orientation>),
),
update_relative_position,
update_position.after(update_relative_position),
update_shape_blocks
.run_if(any_component_added::<Shape>.or(any_component_changed::<Shape>)),
sync_singleton_to_ui::<Shape>.run_if(any_component_changed::<Shape>),
sync_singleton_to_ui::<Orientation>.run_if(any_component_changed::<Orientation>),
update_position,
add_piece.run_if(not(any_with_component::<Shape>)),
clear_line.run_if(any_component_changed::<LineBlocks>),
),
@ -84,37 +79,6 @@ struct Line(u8);
#[derive(Component, Debug)]
struct Block;
#[derive(Component, Event, Debug, Clone, Copy, PartialEq)]
#[require(GridPosition)]
struct RelativePosition {
x: i8,
y: i8,
}
impl RelativePosition {
fn up() -> Self {
RelativePosition { x: 0, y: 1 }
}
fn down() -> Self {
RelativePosition { x: 0, y: -1 }
}
fn left() -> Self {
RelativePosition { x: -1, y: 0 }
}
fn right() -> Self {
RelativePosition { x: 1, y: 0 }
}
}
impl From<(i8, i8)> for RelativePosition {
fn from((x, y): (i8, i8)) -> RelativePosition {
RelativePosition { x, y }
}
}
#[derive(Component, Debug, Clone, Copy, PartialEq)]
#[require(Transform, Visibility)]
struct GridPosition {
@ -123,65 +87,28 @@ struct GridPosition {
}
impl GridPosition {
fn move_up(&self) -> Self {
Self {
y: if self.y + 1 < Y_MAX {
self.y.saturating_add(1)
} else {
self.y
},
x: self.x,
}
}
fn move_down(&mut self) -> Self {
Self {
y: self.y.saturating_sub(1),
x: self.x,
}
}
fn move_left(&mut self) -> Self {
Self {
x: self.x.saturating_sub(1),
y: self.y,
}
}
fn with_offset(self, other_x: isize, other_y: isize) -> Result<GridPosition, GameError> {
let x = self.x as isize + other_x;
let y = self.y as isize + other_y;
fn move_right(&mut self) -> Self {
Self {
x: if self.x + 1 < X_MAX {
self.x.saturating_add(1)
if x > X_MAX as isize {
Err(GameError::OutOfBoundsLeft)
} else if x < 0 {
Err(GameError::OutOfBoundsRight)
} else if y < 0 {
Err(GameError::OutOfBoundsDown)
} else {
self.x
},
y: self.y,
Ok(GridPosition {
x: x as u32,
y: y as u32,
})
}
}
fn is_colliding_with(&self, other: &Self) -> bool {
self.x == other.x && self.y.saturating_sub(1) == other.y
}
fn add_relative(
&self,
RelativePosition { x: x1, y: y1 }: &RelativePosition,
) -> Result<Self, GameError> {
let x = self
.x
.checked_add_signed(*x1 as i32)
.ok_or(GameError::OutOfBoundsLeft)?;
let y = self
.y
.checked_add_signed(*y1 as i32)
.ok_or(GameError::OutOfBoundsDown)?;
if x >= X_MAX {
// TODO: y > Y_MAX?
Err(GameError::OutOfBoundsRight)
} else {
debug!("Moving to {x},{y}");
Ok(GridPosition { x, y })
}
impl Display for GridPosition {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "({},{})", self.x, self.y)
}
}
@ -208,7 +135,6 @@ impl From<&GridPosition> for Vec3 {
// Grid Positions start in the bottom left of the area
// So (0, 0) is the bottom left, (0, 9) is the bottom right, etc
// TODO: Custom offset allowing pieces like O and I to have correct center
let x_0 = -SCALE * 5.0 + (0.5 * SCALE);
let x = x_0 + ((*x as f32) * SCALE);
@ -336,7 +262,7 @@ fn init_debug_ui(mut commands: Commands) {
});
}
#[derive(Component, Debug)]
#[derive(Component, Debug, Clone, Copy)]
enum Shape {
M4(Mat4),
M3(Mat3),
@ -452,16 +378,18 @@ impl Shape {
*self = self.rotated();
}
// TODO: return impl Iterator<Item = &RelativePosition>
fn relative_coordinates(&self) -> impl Iterator<Item = RelativePosition> {
let mut v: Vec<RelativePosition> = Vec::new();
fn coordinates(
&self,
center: &GridPosition,
) -> impl Iterator<Item = Result<GridPosition, GameError>> {
let mut v: Vec<Result<GridPosition, GameError>> = Vec::new();
match self {
Self::M4(inner) => {
for (i, y) in (-1..3).rev().enumerate() {
let c = inner.col(i);
for (j, x) in (-1..3).enumerate() {
if c[j] == 1.0 {
v.push(RelativePosition { x, y });
v.push(center.with_offset(x, y));
}
}
}
@ -471,7 +399,7 @@ impl Shape {
let c = inner.col(i);
for (j, x) in (-1..2).enumerate() {
if c[j] == 1.0 {
v.push(RelativePosition { x, y });
v.push(center.with_offset(x, y));
}
}
}
@ -480,10 +408,6 @@ impl Shape {
v.into_iter()
}
fn coordinates(&self, center: &GridPosition) -> impl Iterator<Item = Result<GridPosition, GameError>> {
self.relative_coordinates().map(|rp| center.add_relative(&rp))
}
fn as_ascii(&self) -> String {
let mut output = String::default();
@ -493,52 +417,19 @@ impl Shape {
let col = this.col(i).to_array();
output += format!("{}{}{}{}\n", col[0], col[1], col[2], col[3]).as_str();
}
},
}
Self::M3(this) => {
for i in 0..3 {
let col = this.col(i).to_array();
output += format!("{}{}{}\n", col[0], col[1], col[2]).as_str();
}
},
}
};
output
}
}
fn set_shape(
query: Query<
(Entity, &Shape, &Orientation),
Or<(Added<Shape>, Changed<Shape>)>,
>,
mut blocks: Query<&mut RelativePosition, With<ShapeBlock>>,
mut commands: Commands,
visuals: Res<Visuals>,
) {
query.iter().for_each(|(e, s, o)| {
debug!("Setting piece: {e:?} {s:?} {o:?}");
if blocks.is_empty() {
let mesh = Mesh2d(visuals.mesh.clone());
let mat = MeshMaterial2d(visuals.material.clone());
commands
.entity(e)
.with_related_entities::<ShapeBlock>(|parent| {
s.relative_coordinates().for_each(|rp| {
parent
.spawn((mesh.clone(), mat.clone(), rp, Block))
.observe(movement);
});
});
} else {
let mut p = s.relative_coordinates();
blocks.iter_mut().for_each(|mut rp| {
*rp = p.next().unwrap();
});
}
});
}
fn update_position(
mut changed: Query<
(Entity, &GridPosition, &mut Transform),
@ -552,29 +443,38 @@ fn update_position(
gp, v3
);
debug_assert!(gp.x < X_MAX, "block x > x_max");
t.translation = gp.into();
});
}
fn update_relative_position(
shape: Single<&GridPosition, With<ShapeBlocks>>,
mut query: Query<
(Entity, &mut GridPosition, &RelativePosition),
(
Without<ShapeBlocks>,
Or<(Added<RelativePosition>, Changed<RelativePosition>)>,
),
>,
// TODO: Inline this to when movement occurs
fn update_shape_blocks(
query: Query<(Entity, &Shape, &Orientation, &GridPosition), Or<(Added<Shape>, Changed<Shape>)>>,
mut blocks: Query<&mut GridPosition, (With<ShapeBlock>, Without<Shape>)>,
mut commands: Commands,
visuals: Res<Visuals>,
) {
query.iter_mut().for_each(|(e, mut gp, rp)| {
debug!(
"Updating {e} grid position to {:?} + {:?} = {:?}",
gp,
rp,
gp.add_relative(rp).unwrap()
);
*gp = (*shape).add_relative(rp).unwrap();
query.iter().for_each(|(e, s, o, center)| {
info!("Setting piece: {e:?} {o:?} {center:?}\n{}", s.as_ascii());
if blocks.is_empty() {
let mesh = Mesh2d(visuals.mesh.clone());
let mat = MeshMaterial2d(visuals.material.clone());
commands
.entity(e)
.with_related_entities::<ShapeBlock>(|parent| {
s.coordinates(center).for_each(|gp| {
parent
.spawn((mesh.clone(), mat.clone(), gp.unwrap(), Block))
.observe(movement);
});
});
} else {
let mut p = s.coordinates(center);
blocks.iter_mut().for_each(|mut gp| {
*gp = p.next().unwrap().unwrap();
});
}
});
}
@ -590,23 +490,21 @@ fn kb_input(
key_code, state, ..
}| {
if let ButtonState::Pressed = state {
// TODO: Restict movement based on size/orientation of piece
// Check if children would be outside play area...
query.iter_mut().for_each(|(e, o, mut s)| {
match key_code {
// Up arrow should rotate if in falling mode
// Only move up if in falling::off mode
KeyCode::ArrowUp => {
commands.entity(e).trigger(o.prev());
commands.entity(e).trigger(Movement::Rotate);
}
KeyCode::ArrowDown => {
commands.entity(e).trigger(RelativePosition::down());
commands.entity(e).trigger(Movement::Down);
}
KeyCode::ArrowLeft => {
commands.entity(e).trigger(RelativePosition::left());
commands.entity(e).trigger(Movement::Left);
}
KeyCode::ArrowRight => {
commands.entity(e).trigger(RelativePosition::right());
commands.entity(e).trigger(Movement::Right);
}
KeyCode::Space => next.set(match curr.get() {
Falling::On => Falling::Off,
@ -641,7 +539,7 @@ fn draw_grid(mut gizmos: Gizmos) {
fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
shape.iter_mut().for_each(|e| {
info!("Making {:?} fall", e);
commands.entity(e).trigger(RelativePosition::down());
commands.entity(e).trigger(Movement::Down);
});
}
@ -662,9 +560,12 @@ fn clock_cycle(n: f32) -> impl FnMut(Res<Time>, Local<f32>) -> bool {
fn add_piece(mut commands: Commands) {
// TODO: Choose a different piece
commands
.spawn((Orientation::default(), GridPosition::default(), Shape::default()))
.observe(movement)
.observe(rotation);
.spawn((
Orientation::default(),
GridPosition::default(),
Shape::default(),
))
.observe(movement);
}
/// When a line reaches 10 blocks, clear it
@ -681,87 +582,100 @@ fn clear_line(
});
}
#[derive(Event, Copy, Clone, PartialEq)]
enum Movement {
Down,
Left,
Right,
Rotate,
}
// TODO: When out of bounds left/right, try to move piece away from wall
fn movement(
trigger: Trigger<RelativePosition>,
mut grid_positions: Query<&mut GridPosition, Or<(With<RelativePosition>, With<Shape>)>>,
parent: Query<&ShapeBlocks>,
inactive: Query<
&GridPosition,
(
Without<RelativePosition>,
Without<Shape>,
),
>,
trigger: Trigger<Movement>,
mut grid_positions: Query<&mut GridPosition, Or<(With<ShapeBlock>, With<ShapeBlocks>)>>,
mut shape: Query<&mut Shape>,
inactive: Query<&GridPosition, (Without<ShapeBlock>, Without<ShapeBlocks>)>,
mut commands: Commands,
) {
// Do a bunch of checks if this move is valid
for block in parent.iter_descendants(trigger.target()) {
let block_gp = grid_positions.get(block).unwrap();
match block_gp.add_relative(trigger.event()) {
if let (Ok(this_shape), Ok(center)) = (
shape.get_mut(trigger.target()),
grid_positions.get(trigger.target()),
) {
let (new_center, new_shape) = match trigger.event() {
Movement::Down => (center.with_offset(0, -1), *this_shape),
Movement::Left => (center.with_offset(-1, 0), *this_shape),
Movement::Right => (center.with_offset(1, 0), *this_shape),
Movement::Rotate => (Ok(*center), this_shape.rotated()),
};
info!(
"Proposed change: {:?}\n{}",
new_center,
new_shape.as_ascii()
);
match new_center {
Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing
Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>();
}
Err(GameError::Collision) => panic!("This shouldn't happen!"),
Ok(new_center) => {
let new_blocks = new_shape.coordinates(&new_center);
for block_gp in new_blocks {
match block_gp {
Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => {
// Hit the left/right wall, just ignore this move
return;
}
} // Do nothing
Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>();
return;
}
Err(GameError::Collision) => {
// Do nothing. add_relative does not return this variant
}
Ok(new_block_gp) => {
let collision = inactive
.iter()
.any(|inactive_block_gp| new_block_gp == *inactive_block_gp);
if collision {
Err(GameError::Collision) => panic!("This shouldn't happen!"),
Ok(gp) => {
for other_gp in inactive.iter() {
// If there would be a collision between blocks
if gp == *other_gp {
// And we are moving down
if *trigger.event() == Movement::Down {
// De-activate this piece
commands.entity(trigger.target()).remove::<Shape>();
}
// Regardless, cancel the move
return;
}
}
}
// Move shape itself
if let Ok(mut shape_gp) = grid_positions.get_mut(trigger.target()) {
*shape_gp = shape_gp.add_relative(trigger.event()).unwrap();
}
// Move the blocks of this shape
parent.iter_descendants(trigger.target()).for_each(|block| {
info!("Propogating movement {:?} to child {:?}", trigger.event(), block);
commands.entity(block).trigger(*trigger.event());
});
}
fn rotation(trigger: Trigger<Orientation>, mut q: Query<&mut Orientation>) {
let mut o = q.get_mut(trigger.target()).unwrap();
// If children would go out of bounds going left, move slightly to the right
// If that would cause collision, deactive piece
// If children would go out of bounds going right, move slightly to the left
// If that would cause collision, deactive piece
// If children would not go out of bounds going down
*o = trigger.event().clone();
// Update center
let mut gp = grid_positions.get_mut(trigger.target()).unwrap();
*gp = new_center;
// Update shape/rotation
let mut s = shape.get_mut(trigger.target()).unwrap();
*s = new_shape;
}
}
} else {
warn!("Triggered movement on non-shape entity");
}
}
// TODO: Just despawn?
fn deactive_shape(
trigger: Trigger<OnRemove, Shape>,
grid_positions: Query<&GridPosition>,
parent: Query<&ShapeBlocks>,
lines: Query<(Entity, &Line), With<LineBlocks>>,
mut commands: Commands,
) {
let v: Vec<Entity> = parent.iter_descendants(trigger.target()).collect();
parent.iter_descendants(trigger.target()).for_each(|block| {
commands.entity(block).remove::<RelativePosition>();
let GridPosition { y, .. } = grid_positions.get(block).unwrap();
let parent_line = lines.iter().find_map(|(e, Line(i))| (*y == *i as u32).then_some(e)).unwrap();
commands.entity(parent_line).add_one_related::<LineBlock>(block);
});
commands
.entity(trigger.target())
.remove_related::<ShapeBlock>(v.as_slice())
.despawn();
commands.entity(trigger.target()).despawn();
}
// TODO: When Orientation changed, perform matrix multiplication or something(?)
#[cfg(test)]
mod test {
use super::*;
@ -832,22 +746,6 @@ mod test {
assert_eq!(shape.as_ascii(), expected_up);
}
#[test]
fn test_relative_coordinates() {
let shape = Shape::new_t();
let expected: Vec<RelativePosition> = vec![
(0, 1).into(),
(-1, 0).into(),
(0, 0).into(),
(1, 0).into(),
];
let actual: Vec<RelativePosition> = shape.relative_coordinates().collect();
assert_eq!(actual, expected);
}
#[test]
fn test_coordinates() {
let shape = Shape::new_t();

Write Preview
Loading…
Cancel
Save