You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
823 lines
27 KiB
Rust
823 lines
27 KiB
Rust
use bevy::utils::HashSet;
|
|
|
|
use crate::audio::AudioEvent;
|
|
use crate::prelude::*;
|
|
|
|
pub(crate) struct GamePlugin;
|
|
|
|
impl Plugin for GamePlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_event::<Move>()
|
|
.add_event::<Selection>()
|
|
.add_state::<TurnState>()
|
|
.insert_resource(Score { ..default() })
|
|
.add_systems(Startup, setup_board)
|
|
.add_systems(OnEnter(GameState::Play), hide_valid_moves)
|
|
.add_systems(
|
|
Update,
|
|
(
|
|
menu::exit_to_menu.run_if(in_state(GameState::Play)),
|
|
update_board
|
|
.run_if(on_event::<Move>())
|
|
.after(handle_selection),
|
|
set_side.run_if(on_event::<Move>()).after(update_board),
|
|
cancel_place.run_if(|buttons: Res<Input<MouseButton>>| -> bool {
|
|
buttons.just_pressed(MouseButton::Right)
|
|
}),
|
|
handle_selection.run_if(on_event::<Selection>()),
|
|
show_valid_moves.run_if(any_component_added::<Selected>),
|
|
hide_valid_moves.run_if(any_component_removed::<Selected>()),
|
|
manage_score.run_if(any_component_added::<Captured>),
|
|
check_endgame.run_if(resource_changed::<Board>()),
|
|
),
|
|
)
|
|
.add_systems(OnEnter(GameState::Endgame), set_endgame)
|
|
.add_systems(OnExit(GameState::Endgame), clear_endgame)
|
|
.add_systems(
|
|
PreUpdate,
|
|
asserts::<display3d::Display3d>
|
|
.run_if(in_state(DisplayState::Display3d))
|
|
.run_if(in_state(GameState::Play)),
|
|
)
|
|
.add_systems(
|
|
PostUpdate,
|
|
(debug_board.run_if(resource_exists::<debug::DebugEnabled>()),),
|
|
);
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default, States)]
|
|
pub(crate) enum TurnState {
|
|
SideA,
|
|
// HACK: Opening animation starts on B side
|
|
#[default]
|
|
SideB,
|
|
}
|
|
|
|
impl std::ops::Not for TurnState {
|
|
type Output = Self;
|
|
|
|
fn not(self) -> Self::Output {
|
|
match self {
|
|
TurnState::SideA => TurnState::SideB,
|
|
TurnState::SideB => TurnState::SideA,
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allow comparison between turn state and sides
|
|
impl PartialEq<Side> for TurnState {
|
|
fn eq(&self, other: &Side) -> bool {
|
|
match (self, other) {
|
|
(TurnState::SideA, Side::A) | (TurnState::SideB, Side::B) => true,
|
|
(TurnState::SideB, Side::A) | (TurnState::SideA, Side::B) => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Component, Clone, PartialEq, Copy, Hash)]
|
|
pub(crate) enum Piece {
|
|
Pawn,
|
|
Drone,
|
|
Queen,
|
|
}
|
|
|
|
#[derive(Debug, Component, Clone, PartialEq)]
|
|
pub(crate) enum Tile {
|
|
Dark,
|
|
Light,
|
|
}
|
|
|
|
pub(crate) fn tiles() -> impl Iterator<Item = (BoardIndex, Tile)> {
|
|
(0..32).map(|i| {
|
|
let x = i % 8;
|
|
let y = i / 8;
|
|
let s = (x % 2) ^ (y % 2);
|
|
|
|
let index = BoardIndex { x, y };
|
|
let tile = if s == 0 { Tile::Dark } else { Tile::Light };
|
|
|
|
(index, tile)
|
|
})
|
|
}
|
|
|
|
#[derive(Debug, Component)]
|
|
pub(crate) struct BoardComponent;
|
|
|
|
#[derive(Debug, Component)]
|
|
pub(crate) struct ValidMove;
|
|
|
|
#[derive(Debug, Component)]
|
|
pub(crate) struct Captured;
|
|
|
|
// manually for the type.
|
|
impl std::fmt::Display for Piece {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
match self {
|
|
Piece::Queen => write!(f, "@"),
|
|
Piece::Drone => write!(f, "^"),
|
|
Piece::Pawn => write!(f, "*"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub(crate) enum GameError {
|
|
NullMove,
|
|
InvalidIndex,
|
|
InvalidMove,
|
|
}
|
|
|
|
/// Tracks the score of each side of the game
|
|
#[derive(Debug, Resource, Default)]
|
|
pub(crate) struct Score {
|
|
a: usize,
|
|
b: usize,
|
|
}
|
|
|
|
impl Score {
|
|
fn increment(&mut self, side: Side) {
|
|
match side {
|
|
Side::A => self.a += 1,
|
|
Side::B => self.b += 1,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get(&self, side: Side) -> usize {
|
|
match side {
|
|
Side::A => self.a,
|
|
Side::B => self.b,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The board is setup like this:
|
|
/// ```text
|
|
/// 0 1 2 3 4 5 6 7
|
|
/// +--+--+--+-----+--+--+--+
|
|
/// a | | | | l | d| Q| Q|
|
|
/// +--+--+--+--l--+--+--+--+
|
|
/// b |d |p |p | l | p| d| Q|
|
|
/// +--+--+--+--l--+--+--+--+
|
|
/// c |Q |d |p | l | p| p| d|
|
|
/// +--+--+--+--l--+--+--+--+
|
|
/// d |Q |Q |d | l | | | |
|
|
/// +--+--+--+-----+--+--+--+
|
|
/// ````
|
|
#[derive(Debug, Resource)]
|
|
pub(crate) struct Board {
|
|
inner: Vec<Vec<Option<Piece>>>,
|
|
moves: Vec<Move>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Event, Clone)]
|
|
pub(crate) struct Move {
|
|
pub epoch: usize,
|
|
pub from: BoardIndex,
|
|
pub to: Option<BoardIndex>,
|
|
}
|
|
|
|
/// Enum for the Capture event flow
|
|
#[derive(Debug, Clone, Copy, Resource)]
|
|
pub(crate) enum CaptureFlow {
|
|
// Run the "fade out" animation
|
|
FadeOut(Entity),
|
|
// Put the captured piece next to the board
|
|
Store(Entity),
|
|
// Run the "fade in" animation
|
|
FadeIn(Entity),
|
|
}
|
|
|
|
impl CaptureFlow {
|
|
/// The capture flow so we can move from one "capture flow state" to the next
|
|
/// Fade out, then store, then fade in
|
|
pub(crate) fn next(&self) -> Option<Self> {
|
|
match self {
|
|
Self::FadeOut(e) => Some(Self::Store(e.clone())),
|
|
Self::Store(e) => Some(Self::FadeIn(e.clone())),
|
|
Self::FadeIn(_) => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Component, PartialEq, Clone, Default, Copy, Eq, Hash)]
|
|
pub(crate) struct BoardIndex {
|
|
pub x: usize,
|
|
pub y: usize,
|
|
}
|
|
|
|
#[derive(Debug, Component, PartialEq, Clone, Default, Copy, Eq, Hash)]
|
|
pub(crate) struct Previous {
|
|
board_index: BoardIndex
|
|
}
|
|
|
|
#[derive(Debug, Component, PartialEq, Clone, Copy)]
|
|
pub(crate) enum Side {
|
|
A,
|
|
B,
|
|
}
|
|
|
|
impl std::ops::Not for Side {
|
|
type Output = Self;
|
|
|
|
fn not(self) -> Self::Output {
|
|
match self {
|
|
Side::A => Side::B,
|
|
Side::B => Side::A,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Board {
|
|
/// Returns the piece at the given location
|
|
pub(crate) fn at(&self, BoardIndex { x, y }: BoardIndex) -> Option<&Piece> {
|
|
self.inner[y][x].as_ref()
|
|
}
|
|
|
|
/// Show all pieces on one side of the board
|
|
/// OPTIMIZE: This is only used to tell if a side is empty, so it is more work than we need to do.
|
|
pub(crate) fn on(&self, side: Side) -> Vec<(&Piece, BoardIndex)> {
|
|
match side {
|
|
Side::A => {
|
|
// X: 0..3, Y: 0..3
|
|
(0..=3).flat_map(|x| {
|
|
(0..=3).map(move |y| {
|
|
self.at(BoardIndex { x, y }).map(|p| (p, BoardIndex { x, y }))
|
|
})
|
|
}).filter_map(|r| r)
|
|
.collect()
|
|
}
|
|
Side::B => {
|
|
// X: 4..7, Y: 0..3
|
|
(4..=7).flat_map(|x| {
|
|
(0..=3).map(move |y| {
|
|
self.at(BoardIndex { x, y }).map(|p| (p, BoardIndex { x, y }))
|
|
})
|
|
}).filter_map(|r| r)
|
|
.collect()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns a list of all pieces on the board with their location
|
|
pub(crate) fn pieces(&self) -> Vec<(BoardIndex, Piece)> {
|
|
self.inner
|
|
.iter()
|
|
.enumerate()
|
|
.flat_map(|(y, nested)| {
|
|
nested.iter().enumerate().filter_map(move |(x, p)| {
|
|
p.as_ref().map(|val| (BoardIndex { x, y }, val.clone()))
|
|
})
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Moves a piece from -> to
|
|
pub(crate) fn move_piece(
|
|
&mut self,
|
|
from: BoardIndex,
|
|
to: BoardIndex,
|
|
) -> Result<Vec<Move>, GameError> {
|
|
if from == to {
|
|
Err(GameError::NullMove)
|
|
} else {
|
|
match self.at(from.clone()) {
|
|
Some(from_piece) => {
|
|
// Check if this is a valid move for this piece
|
|
if self.valid_moves(from).contains(&to) {
|
|
// The current epoch is the last epoch + 1
|
|
let epoch = self.current_epoch();
|
|
|
|
// Local moves vec we can return
|
|
let mut moves = vec![];
|
|
|
|
// If the position we are moving to is occupied, capture the removal in the ledger
|
|
if self.inner[to.y][to.x].is_some() {
|
|
moves.push(Move {
|
|
epoch,
|
|
from: to.clone(),
|
|
to: None,
|
|
});
|
|
}
|
|
|
|
// Capture the intened move in the moves ledger
|
|
moves.push(Move {
|
|
epoch,
|
|
from: from.clone(),
|
|
to: Some(to.clone()),
|
|
});
|
|
|
|
self.inner[to.y][to.x] = Some(*from_piece);
|
|
self.inner[from.y][from.x] = None;
|
|
|
|
self.moves.extend(moves.clone());
|
|
|
|
Ok(moves)
|
|
} else {
|
|
Err(GameError::InvalidMove)
|
|
}
|
|
}
|
|
None => Err(GameError::NullMove),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns the Side of a piece
|
|
pub(crate) fn side(BoardIndex { x, .. }: BoardIndex) -> Result<Side, GameError> {
|
|
match x {
|
|
0..=3 => Ok(Side::A),
|
|
4..=7 => Ok(Side::B),
|
|
_ => Err(GameError::InvalidIndex),
|
|
}
|
|
}
|
|
|
|
/// Returns the possible moves the piece at this tile can make.
|
|
/// TODO: Implement "no jumping" over pieces
|
|
pub(crate) fn valid_moves(&self, current_board_index: BoardIndex) -> HashSet<BoardIndex> {
|
|
let BoardIndex { x, y } = current_board_index;
|
|
|
|
let f = |(a, b): (Option<usize>, Option<usize>)| {
|
|
if let (Some(this_x), Some(this_y)) = (a, b) {
|
|
// This has a valid x position
|
|
let valid_x = (0..=7).contains(&this_x);
|
|
if valid_x {
|
|
// It has a valid y position
|
|
let valid_y = (0..=3).contains(&this_y);
|
|
if valid_y {
|
|
// The checked board index
|
|
let this_board_index = BoardIndex {
|
|
x: this_x,
|
|
y: this_y,
|
|
};
|
|
// Only propose tiles that are empty or capture a piece on the other side
|
|
let valid_capture = {
|
|
match self.at(this_board_index) {
|
|
Some(_) => {
|
|
let same_side = Board::side(current_board_index);
|
|
Board::side(this_board_index) != same_side
|
|
}
|
|
None => true,
|
|
}
|
|
};
|
|
if valid_capture {
|
|
// You cannot move a piece from SideB->SideA when it was just moved from SideA->SideB
|
|
// Move rejection is not allowed
|
|
let rejection = {
|
|
if let Some(Move {
|
|
from: last_from,
|
|
to: Some(last_to),
|
|
..
|
|
}) = self.moves.last()
|
|
{
|
|
// TODO: I think this is more logic than we need to express
|
|
// the sentiment...
|
|
Board::side(*last_from) == Board::side(this_board_index)
|
|
&& Board::side(*last_to) == Board::side(current_board_index)
|
|
&& Board::side(this_board_index)
|
|
!= Board::side(current_board_index)
|
|
} else {
|
|
false
|
|
}
|
|
};
|
|
// If all tests pass, this is a valid move
|
|
(!rejection).then_some(this_board_index)
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
};
|
|
|
|
match self.at(BoardIndex { x, y }) {
|
|
// One space in any diagonal
|
|
Some(Piece::Pawn) => std::iter::empty()
|
|
.chain(
|
|
(-1..=1)
|
|
.zip(-1..=1)
|
|
.map(move |(a, b)| (x.checked_add_signed(a), y.checked_add_signed(b))),
|
|
)
|
|
.chain(
|
|
(-1..=1)
|
|
.zip((-1..=1).rev())
|
|
.map(move |(a, b)| (x.checked_add_signed(a), y.checked_add_signed(b))),
|
|
)
|
|
.filter_map(f)
|
|
.collect(),
|
|
// One or two spaces in either horizontal
|
|
Some(Piece::Drone) => std::iter::empty()
|
|
.chain((-2..=2).map(|i| (x.checked_add_signed(i), Some(y))))
|
|
.chain((-2..=2).map(|i| (Some(x), y.checked_add_signed(i))))
|
|
.filter_map(f)
|
|
.collect(),
|
|
// Any distance in any straight line
|
|
Some(Piece::Queen) => std::iter::empty()
|
|
.chain((-7..=7).map(|i| (x.checked_add_signed(i), Some(y))))
|
|
.chain((-3..=3).map(|i| (Some(x), y.checked_add_signed(i))))
|
|
.chain(
|
|
(-3..=3)
|
|
.zip(-3..=3)
|
|
.map(move |(a, b)| (x.checked_add_signed(a), y.checked_add_signed(b))),
|
|
)
|
|
.chain(
|
|
(-3..=3)
|
|
.zip((-3..=3).rev())
|
|
.map(move |(a, b)| (x.checked_add_signed(a), y.checked_add_signed(b))),
|
|
)
|
|
.filter_map(f)
|
|
.collect(),
|
|
None => std::iter::empty().collect(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn current_epoch(&self) -> usize {
|
|
self.moves.last().unwrap_or(&Move { ..default() }).epoch + 1
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Display for Board {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
self.inner.iter().rev().for_each(|row| {
|
|
let _ = write!(f, "+--+--+--+--+--+--+--+--+\n");
|
|
let _ = write!(f, "|");
|
|
row.iter().for_each(|piece| {
|
|
let _ = match piece {
|
|
Some(p) => write!(f, "{} |", p),
|
|
None => write!(f, " |"),
|
|
};
|
|
});
|
|
let _ = write!(f, "\n");
|
|
});
|
|
let _ = write!(f, "+--+--+--+--+--+--+--+--+");
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Marker component for currently selected entities
|
|
#[derive(Debug, Default, Component)]
|
|
pub(crate) struct Selected;
|
|
|
|
/// Marker component for selectable entities
|
|
#[derive(Debug, Default, Component)]
|
|
pub(crate) struct Selectable;
|
|
|
|
/// Event for selecting board indexes for Moves
|
|
#[derive(Debug, Default, Event, Clone)]
|
|
pub(crate) struct Selection(pub BoardIndex);
|
|
|
|
fn setup_board(mut commands: Commands) {
|
|
use Piece::*;
|
|
commands.insert_resource(Board {
|
|
moves: vec![],
|
|
inner: vec![
|
|
vec![
|
|
Some(Queen),
|
|
None, // Some(Queen),
|
|
None, // Some(Drone),
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
],
|
|
vec![
|
|
None, // Some(Queen),
|
|
None, // Some(Drone),
|
|
None, // Some(Pawn),
|
|
None, // None,
|
|
None, // None,
|
|
None, // Some(Pawn),
|
|
None, // Some(Pawn),
|
|
None, // Some(Drone),
|
|
],
|
|
vec![
|
|
None, // Some(Drone),
|
|
None, // Some(Pawn),
|
|
None, // Some(Pawn),
|
|
None, // None,
|
|
None, // None,
|
|
None, // Some(Pawn),
|
|
None, // Some(Drone),
|
|
None, // Some(Queen),
|
|
],
|
|
vec![
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None, // Some(Drone),
|
|
None, // Some(Queen),
|
|
Some(Queen),
|
|
],
|
|
],
|
|
});
|
|
}
|
|
|
|
fn debug_board(board: Res<Board>, mut debug_info: ResMut<debug::DebugInfo>) {
|
|
debug_info.set("board".into(), format!("\n{}", *board));
|
|
}
|
|
|
|
/// Update this method to use a diff between the board and the state of the 2d/3d worlds
|
|
pub(crate) fn update_board(
|
|
mut audio_events: EventWriter<AudioEvent>,
|
|
mut events: EventReader<Move>,
|
|
mut pieces: Query<(Entity, &mut BoardIndex), With<Piece>>,
|
|
selected: Query<Entity, With<Selected>>,
|
|
mut commands: Commands,
|
|
mut played: Local<bool>,
|
|
curr_state: Res<State<TurnState>>,
|
|
mut next_state: ResMut<NextState<TurnState>>,
|
|
) {
|
|
events.read().for_each(|Move { from, to, .. }| {
|
|
pieces.iter_mut().for_each(|(entity, mut index)| {
|
|
if *index == *from {
|
|
match to {
|
|
Some(to_idx) => {
|
|
info!("Moving piece {:?} {:?} -> {:?}", entity, from, to_idx);
|
|
*index = to_idx.clone();
|
|
if !(*played) {
|
|
audio_events.send(audio::AudioEvent::PutDown);
|
|
audio_events.send(audio::AudioEvent::StopIdle);
|
|
*played = true;
|
|
if *from != *to_idx {
|
|
let ns = !*curr_state.get();
|
|
info!("Piece moved, switching sides: {:?}", ns);
|
|
next_state.set(ns);
|
|
}
|
|
}
|
|
}
|
|
None => {
|
|
info!("Capturing piece {:?}", entity);
|
|
commands
|
|
.entity(entity)
|
|
.remove::<BoardIndex>()
|
|
.insert(Captured);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
selected.iter().for_each(|entity| {
|
|
debug!("De-selecting selected piece {:?}", entity);
|
|
commands.entity(entity).remove::<Selected>();
|
|
});
|
|
});
|
|
*played = false;
|
|
}
|
|
|
|
// Track the last spot that a piece was at
|
|
fn track_previous_move(
|
|
events: Query<&BoardIndex, (With<Piece>, Changed<BoardIndex>)>,
|
|
mut commands: Commands,
|
|
) {
|
|
todo!()
|
|
}
|
|
|
|
#[derive(Debug, Component)]
|
|
struct Endgame;
|
|
|
|
fn check_endgame(
|
|
board: Res<Board>,
|
|
mut next_state: ResMut<NextState<GameState>>,
|
|
) {
|
|
if board.on(Side::A).is_empty() || board.on(Side::B).is_empty() {
|
|
warn!("The game is over!");
|
|
next_state.set(GameState::Endgame);
|
|
}
|
|
}
|
|
|
|
fn set_endgame(
|
|
score: Res<Score>,
|
|
mut commands: Commands,
|
|
) {
|
|
commands
|
|
.spawn((
|
|
Endgame,
|
|
NodeBundle {
|
|
style: Style {
|
|
width: Val::Percent(100.0),
|
|
height: Val::Percent(100.0),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
flex_direction: FlexDirection::Column,
|
|
position_type: PositionType::Absolute,
|
|
..default()
|
|
},
|
|
background_color: Color::NONE.into(),
|
|
visibility: Visibility::Inherited,
|
|
..default()
|
|
},
|
|
))
|
|
.with_children(|parent| {
|
|
parent.spawn(TextBundle::from_section(
|
|
"S C O R E",
|
|
TextStyle {
|
|
font_size: 48.0,
|
|
color: Color::ORANGE_RED,
|
|
..default()
|
|
},
|
|
));
|
|
parent.spawn(TextBundle::from_section(
|
|
format!("BLUE {}", score.b),
|
|
TextStyle {
|
|
font_size: 32.0,
|
|
color: Color::BLUE,
|
|
..default()
|
|
},
|
|
));
|
|
parent.spawn(TextBundle::from_section(
|
|
format!("RED {}", score.a),
|
|
TextStyle {
|
|
font_size: 32.0,
|
|
color: Color::RED,
|
|
..default()
|
|
},
|
|
));
|
|
});
|
|
}
|
|
|
|
fn clear_endgame(
|
|
query: Query<Entity, With<Endgame>>,
|
|
mut commands: Commands,
|
|
) {
|
|
query.iter().for_each(|e| {
|
|
commands.entity(e).despawn_recursive();
|
|
})
|
|
}
|
|
|
|
/// We only track 3D (hack, for now) to prevent duplicates
|
|
/// TODO: We can calculate this declaratively:
|
|
/// * All pieces without a BoardIndex are "captured"
|
|
/// * All captured pieces have their captured side preserved
|
|
/// We can iterate over these pieces and calculate the score on the fly
|
|
fn manage_score(
|
|
events: Query<&Side, (Added<Captured>, With<display3d::Display3d>)>,
|
|
mut debug_info: ResMut<debug::DebugInfo>,
|
|
mut score: ResMut<Score>,
|
|
) {
|
|
events.iter().for_each(|side| {
|
|
score.increment(!*side);
|
|
debug_info.set("score".into(), format!("A:{}|B:{}", score.a, score.b));
|
|
});
|
|
}
|
|
|
|
pub(crate) fn set_side(mut events: Query<(&mut Side, &BoardIndex), Changed<BoardIndex>>) {
|
|
events
|
|
.iter_mut()
|
|
.for_each(|(mut side, idx)| match Board::side(*idx) {
|
|
Ok(s) => {
|
|
debug!("Set side event {:?} {:?} -> {:?}", idx, side, s);
|
|
if *side != s {
|
|
*side = s
|
|
}
|
|
}
|
|
Err(e) => warn!("{:?}", e),
|
|
});
|
|
}
|
|
|
|
// TODO: Handle 3d Pickup (Not showing hover animation, but still selected?)
|
|
// TODO: Handle cancel move (currently 2d just drops it in place)
|
|
fn handle_selection(
|
|
mut selections: EventReader<Selection>,
|
|
mut move_events: EventWriter<Move>,
|
|
selected: Query<(Entity, &BoardIndex), (With<Selected>, With<Piece>)>,
|
|
pieces: Query<(Entity, &BoardIndex), (With<Selectable>, Without<Selected>, With<Piece>)>,
|
|
mut board: ResMut<Board>,
|
|
mut commands: Commands,
|
|
mut audio_event: EventWriter<AudioEvent>,
|
|
mut done: Local<bool>, // Tracks if moves/audio submitted already even if multiple pieces (2d/3d) are moved.
|
|
mut latest: Local<Option<BoardIndex>>, // Tracks the last one worked on
|
|
) {
|
|
selections.read().for_each(|Selection(index)| {
|
|
|
|
// Skip indexes already processed
|
|
if Some(*index) != *latest {
|
|
// Set the latest index to the current index
|
|
*latest = Some(*index);
|
|
// Reset the "done" marker
|
|
*done = false;
|
|
|
|
// There are no currently selected entities
|
|
// Mark the piece at this index as selected
|
|
if selected.is_empty() {
|
|
pieces
|
|
.iter()
|
|
.filter(|(_, this_index)| *this_index == index)
|
|
.for_each(|(piece, piece_index)| {
|
|
info!("Selecting {:?} at {:?}", piece, piece_index);
|
|
commands.entity(piece).insert(Selected);
|
|
if !(*done) {
|
|
audio_event.send(audio::AudioEvent::PickUp);
|
|
audio_event.send(AudioEvent::Idle);
|
|
*done = true;
|
|
}
|
|
});
|
|
}
|
|
// There is a currently selected entity, so submit moves
|
|
else {
|
|
assert!(
|
|
selected.iter().len() <= 2,
|
|
"There are too many pieces selected!"
|
|
);
|
|
selected.iter().for_each(|(_, current_index)| {
|
|
match board.move_piece(*current_index, *index) {
|
|
Ok(moves) => {
|
|
// De-select the piece
|
|
info!("Applying moves {:?}", moves);
|
|
if !(*done) {
|
|
moves.iter().for_each(|m| move_events.send(m.clone()));
|
|
*done = true;
|
|
}
|
|
}
|
|
Err(GameError::NullMove) => warn!("Null move!"),
|
|
Err(GameError::InvalidIndex) | Err(GameError::InvalidMove) => {
|
|
warn!("Invalid index/move!");
|
|
if !(*done) {
|
|
audio_event.send(AudioEvent::Invalid);
|
|
*done = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
*done = false;
|
|
*latest = None;
|
|
}
|
|
|
|
/// Triggered when right-mouse-button clicked
|
|
fn cancel_place(current: Query<&BoardIndex, With<Selected>>, mut events: EventWriter<Move>) {
|
|
current.iter().for_each(|board_index| {
|
|
info!("De-selecting piece at {:?}", board_index);
|
|
events.send(Move {
|
|
from: board_index.clone(),
|
|
to: Some(board_index.clone()),
|
|
..default()
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Panics if more than two pieces are selected at a time
|
|
fn asserts<T: Component>(
|
|
selected_pieces: Query<Entity, (With<Piece>, With<T>, With<Selected>)>,
|
|
selected_tiles: Query<Entity, (With<Tile>, With<T>, With<Selected>)>,
|
|
cameras: Query<Entity, (With<Camera>, With<T>)>,
|
|
) {
|
|
if selected_pieces.iter().len() > 2 {
|
|
selected_pieces.iter().for_each(|e| {
|
|
info!("Too many pieces selected, one of which is: {:?}", e);
|
|
});
|
|
panic!(
|
|
"More than two pieces selected {:?}",
|
|
selected_pieces.iter().len()
|
|
);
|
|
}
|
|
if selected_tiles.iter().len() > 2 {
|
|
panic!(
|
|
"More than two tiles selected {:?}",
|
|
selected_tiles.iter().len()
|
|
);
|
|
}
|
|
if cameras.iter().len() != 1 {
|
|
panic!(
|
|
"There should be 1 cameras in this state, but there is only {}",
|
|
cameras.iter().len()
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Spawn "Valid move" indicators when a piece is selected
|
|
/// Another system registers these new entities and associates the correct models and plays animations.
|
|
fn show_valid_moves(
|
|
events: Query<&BoardIndex, (With<Piece>, Added<Selected>)>,
|
|
board: Res<Board>,
|
|
mut indicators: Query<(&BoardIndex, &mut Visibility), With<ValidMove>>,
|
|
) {
|
|
// When a piece is selected
|
|
events.iter().for_each(|idx| {
|
|
// Iterate over all ValidMove entities
|
|
// For each one with a ValidMove index, make it visible
|
|
board.valid_moves(*idx).iter().for_each(|idx| {
|
|
indicators.iter_mut().for_each(|(i, mut vis)| {
|
|
if i == idx {
|
|
*vis = Visibility::Inherited;
|
|
}
|
|
});
|
|
})
|
|
});
|
|
}
|
|
|
|
/// Hide "Valid Move" indicators when a piece is de-selected
|
|
fn hide_valid_moves(mut indicators: Query<&mut Visibility, With<ValidMove>>) {
|
|
indicators.iter_mut().for_each(|mut visibility| {
|
|
*visibility = Visibility::Hidden;
|
|
});
|
|
}
|