initial commit.

crashing due to something about the bevy_mod_picking code.

.cargo/config.toml

@@ -0,0 +1,22 @@
+# Add the contents of this file to `config.toml` to enable "fast build" configuration. Please read the notes below.
+
+# NOTE: For maximum performance, build using a nightly compiler
+# If you are using rust stable, remove the "-Zshare-generics=y" below (as well as "-Csplit-debuginfo=unpacked" when building on macOS).
+
+[target.x86_64-unknown-linux-gnu]
+linker = "/usr/bin/clang"
+rustflags = ["-Clink-arg=-fuse-ld=lld"] #, "-Zshare-generics=y"]
+
+# NOTE: you must manually install https://github.com/michaeleisel/zld on mac. you can easily do this with the "brew" package manager:
+# `brew install michaeleisel/zld/zld`
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld", "-Zshare-generics=y"]
+
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"
+rustflags = ["-Zshare-generics=y"]
+
+# Optional: Uncommenting the following improves compile times, but reduces the amount of debug info to 'line number tables only'
+# In most cases the gains are negligible, but if you are on macos and have slow compile times you should see significant gains.
+#[profile.dev]
+#debug = 1

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "bevy-chess"
+version = "0.1.0"
+authors = ["jmelesky <code@phaedrusdeinus.org>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bevy = "0.5.0"
+bevy_mod_picking = "0.4.0"
+
+

src/board.rs

@@ -0,0 +1,98 @@
+use bevy::{
+    prelude::*,
+};
+use bevy_mod_picking::*;
+
+
+pub struct Square {
+    pub x: u8,
+    pub y: u8,
+}
+
+impl Square {
+    fn is_white(&self) -> bool {
+        (self.x + self.y + 1) % 2 == 0
+    }
+}
+
+#[derive(Default)]
+struct SelectedSquare {
+    entity: Option<Entity>,
+}
+
+
+pub struct BoardPlugin;
+impl Plugin for BoardPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.init_resource::<SelectedSquare>()
+            .add_startup_system(create_board.system())
+            .add_system(color_squares.system());
+    }
+}
+
+
+
+fn create_board(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // add meshes and materials
+    let mesh = meshes.add(Mesh::from(shape::Plane {size: 1.0}));
+
+    for i in 0..8 {
+        for j in 0..8 {
+            commands
+                .spawn_bundle(PbrBundle {
+                    mesh: mesh.clone(),
+                    material: if (i + j + 1) % 2 == 0 {
+                        materials.add(Color::rgb(1.0, 0.9, 0.9).into())
+                    } else {
+                        materials.add(Color::rgb(0.0, 0.1, 0.1).into())
+                    },
+                    transform: Transform::from_translation(Vec3::new(i as f32, 0.0, j as f32)),
+                    ..Default::default()
+                })
+                .insert_bundle(PickableBundle::default())
+                .insert(Square {
+                    x: i,
+                    y: j,
+                });
+        }
+    }
+}
+
+
+fn color_squares(
+    selected_square: Res<SelectedSquare>,
+    camera: Res<PickingCamera>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    query: Query<(Entity, &Square, &Handle<StandardMaterial>)>,
+) {
+    let top_entity = if let Some((entity, _intersection)) = camera.intersect_top() {
+        Some(entity)
+    } else {
+        None
+    };
+
+    for (entity, square, material_handle) in query.iter() {
+        // get the material
+        let material = materials.get_mut(material_handle).unwrap();
+
+        // change its color
+        material.base_color = if Some(entity) == top_entity {
+            Color::rgb(0.8, 0.3, 0.3)
+        } else if Some(entity) == selected_square.entity {
+            Color::rgb(0.9, 0.1, 0.1)
+        } else if square.is_white() {
+            Color::rgb(1.0, 0.9, 0.9)
+        } else {
+            Color::rgb(0.0, 0.1, 0.1)
+        };
+    }
+}
+
+
+
+
+

src/main.rs

@@ -0,0 +1,64 @@
+use bevy::prelude::*;
+use bevy_mod_picking::*;
+
+
+mod pieces;
+use pieces::*;
+
+mod board;
+use board::*;
+
+
+fn main() {
+    App::build()
+    // antialiasing at 4 samples
+        .insert_resource(Msaa { samples: 4})
+    // change title and size of window
+        .insert_resource(WindowDescriptor {
+            title: "Chess!".to_string(),
+            width: 1600.0,
+            height: 1000.0,
+            ..Default::default()
+        })
+        .add_plugins(DefaultPlugins)
+        .add_plugin(PickingPlugin)
+        .add_plugin(BoardPlugin)
+        .add_startup_system(setup.system())
+        .add_startup_system(create_pieces.system())
+        .run();
+}
+
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_matrix(Mat4::from_rotation_translation(
+            Quat::from_xyzw(-0.3, -0.5, -0.3, 0.5).normalize(),
+            Vec3::new(-7.0, 20.0, 4.0),
+        )),
+        ..Default::default()
+    })
+        .insert_bundle(PickingCameraBundle::default());
+
+    // Light
+
+    commands.spawn_bundle(LightBundle {
+        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+        ..Default::default()
+    });
+}
+
+
+
+
+
+
+
+
+
+
+

src/pieces.rs

@@ -0,0 +1,336 @@
+use bevy::prelude::*;
+
+
+pub fn create_pieces(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // load all meshes
+    let king_handle: Handle<Mesh>       = asset_server.load("models/chess_kit/pieces.glb#Mesh0/Primitive0");
+    let king_cross_handle: Handle<Mesh> = asset_server.load("models/chess_kit/pieces.glb#Mesh1/Primitive0");
+    let pawn_handle: Handle<Mesh>       = asset_server.load("models/chess_kit/pieces.glb#Mesh2/Primitive0");
+    let knight_1_handle: Handle<Mesh>   = asset_server.load("models/chess_kit/pieces.glb#Mesh3/Primitive0");
+    let knight_2_handle: Handle<Mesh>   = asset_server.load("models/chess_kit/pieces.glb#Mesh4/Primitive0");
+    let rook_handle: Handle<Mesh>       = asset_server.load("models/chess_kit/pieces.glb#Mesh5/Primitive0");
+    let bishop_handle: Handle<Mesh>     = asset_server.load("models/chess_kit/pieces.glb#Mesh6/Primitive0");
+    let queen_handle: Handle<Mesh>      = asset_server.load("models/chess_kit/pieces.glb#Mesh7/Primitive0");
+
+    // create materials
+    let white_material = materials.add(Color::rgb(1.0, 0.8, 0.8).into());
+    let black_material = materials.add(Color::rgb(0.0, 0.2, 0.2).into());
+
+    spawn_rook(
+        &mut commands,
+        white_material.clone(),
+        rook_handle.clone(),
+        Vec3::new(0.0, 0.0, 0.0),
+    );
+    spawn_knight(
+        &mut commands,
+        white_material.clone(),
+        knight_1_handle.clone(),
+        knight_2_handle.clone(),
+        Vec3::new(0.0, 0.0, 1.0),
+    );
+    spawn_bishop(
+        &mut commands,
+        white_material.clone(),
+        bishop_handle.clone(),
+        Vec3::new(0.0, 0.0, 2.0),
+    );
+    spawn_queen(
+        &mut commands,
+        white_material.clone(),
+        queen_handle.clone(),
+        Vec3::new(0.0, 0.0, 3.0),
+    );
+    spawn_king(
+        &mut commands,
+        white_material.clone(),
+        king_handle.clone(),
+        king_cross_handle.clone(),
+        Vec3::new(0.0, 0.0, 4.0),
+    );
+    spawn_bishop(
+        &mut commands,
+        white_material.clone(),
+        bishop_handle.clone(),
+        Vec3::new(0.0, 0.0, 5.0),
+    );
+    spawn_knight(
+        &mut commands,
+        white_material.clone(),
+        knight_1_handle.clone(),
+        knight_2_handle.clone(),
+        Vec3::new(0.0, 0.0, 6.0),
+    );
+    spawn_rook(
+        &mut commands,
+        white_material.clone(),
+        rook_handle.clone(),
+        Vec3::new(0.0, 0.0, 7.0),
+    );
+
+    for i in 0..8 {
+        spawn_pawn(
+            &mut commands,
+            white_material.clone(),
+            pawn_handle.clone(),
+            Vec3::new(1.0, 0.0, i as f32),
+        );
+    }
+
+
+    spawn_rook(
+        &mut commands,
+        black_material.clone(),
+        rook_handle.clone(),
+        Vec3::new(7.0, 0.0, 0.0),
+    );
+    spawn_knight(
+        &mut commands,
+        black_material.clone(),
+        knight_1_handle.clone(),
+        knight_2_handle.clone(),
+        Vec3::new(7.0, 0.0, 1.0),
+    );
+    spawn_bishop(
+        &mut commands,
+        black_material.clone(),
+        bishop_handle.clone(),
+        Vec3::new(7.0, 0.0, 2.0),
+    );
+    spawn_queen(
+        &mut commands,
+        black_material.clone(),
+        queen_handle.clone(),
+        Vec3::new(7.0, 0.0, 3.0),
+    );
+    spawn_king(
+        &mut commands,
+        black_material.clone(),
+        king_handle.clone(),
+        king_cross_handle.clone(),
+        Vec3::new(7.0, 0.0, 4.0),
+    );
+    spawn_bishop(
+        &mut commands,
+        black_material.clone(),
+        bishop_handle.clone(),
+        Vec3::new(7.0, 0.0, 5.0),
+    );
+    spawn_knight(
+        &mut commands,
+        black_material.clone(),
+        knight_1_handle.clone(),
+        knight_2_handle.clone(),
+        Vec3::new(7.0, 0.0, 6.0),
+    );
+    spawn_rook(
+        &mut commands,
+        black_material.clone(),
+        rook_handle.clone(),
+        Vec3::new(7.0, 0.0, 7.0),
+    );
+
+    for i in 0..8 {
+        spawn_pawn(
+            &mut commands,
+            black_material.clone(),
+            pawn_handle.clone(),
+            Vec3::new(6.0, 0.0, i as f32),
+        );
+    }
+}
+
+
+
+fn spawn_king(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh: Handle<Mesh>,
+    mesh_cross: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh,
+                material: material.clone(),
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, -1.9));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+            parent.spawn_bundle(PbrBundle {
+                mesh: mesh_cross,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, -1.9));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+fn spawn_knight(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh_1: Handle<Mesh>,
+    mesh_2: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh: mesh_1,
+                material: material.clone(),
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, 0.9));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+            parent.spawn_bundle(PbrBundle {
+                mesh: mesh_2,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, 0.9));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+fn spawn_queen(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, -0.95));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+fn spawn_bishop(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.1, 0.0, 0.0));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+fn spawn_rook(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.1, 0.0, 1.8));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+fn spawn_pawn(
+    commands: &mut Commands,
+    material: Handle<StandardMaterial>,
+    mesh: Handle<Mesh>,
+    position: Vec3,
+) {
+    // spawn parent
+    commands
+        .spawn_bundle(PbrBundle {
+            transform: Transform::from_translation(position),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn_bundle(PbrBundle {
+                mesh,
+                material,
+                transform: {
+                    let mut transform = Transform::from_translation(Vec3::new(-0.2, 0.0, 2.6));
+                    transform.apply_non_uniform_scale(Vec3::new(0.2, 0.2, 0.2));
+                    transform
+                },
+                ..Default::default()
+            });
+        });
+}
+
+
+
+
+
+