comment unused constant

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dependencies]
 bevy = "0.8.0"
+# bevy_hanabi = "0.3.1"
 bevy-inspector-egui = "0.12.1"
 bevy_rapier2d = "0.16.2"
 cpal = "0.14.0"

README.md

@@ -13,6 +13,7 @@
 * level design
 * (?) can jump only from a surface (no mid-air jump)
 * (?) multiplayer
+* make WASM build work again (replace hanabi)
 * level reset
 * more audio
 
@@ -24,6 +25,8 @@ cargo build --release
 
 ### WASM
 
+Currently `bevy_hanabi` does not compile for WASM, and audio does not work on WASM.
+
 ```bash
 rustup target add wasm32-unknown-unknown
 cargo install wasm-bindgen-cli

src/game.rs

@@ -32,14 +32,13 @@ impl Plugin for GamePlugin {
 				SystemSet::on_update(AppState::Game)
 					.with_system(crate::levels::post_setup_level)
 					.with_system(keyboard_input_system)
-					.with_system(move_camera)
+					.with_system(character_particle_effect_system)
-					.with_system(character_particle_effect_system),
+					.with_system(move_camera),
 			)
 			.add_system_set(
 				SystemSet::on_update(AppState::Win)
 					.with_system(keyboard_input_system)
-					.with_system(move_camera)
+					.with_system(move_camera),
-					.with_system(character_particle_effect_system),
 			)
 			.add_system_to_stage(CoreStage::PostUpdate, collision_event_system);
 	}
@@ -220,6 +219,7 @@ fn keyboard_input_system(
 	if let Ok((mut selected_character_id, character_id_list)) = level_query.get_single_mut() {
 		if keyboard_input.just_pressed(KeyCode::Tab) {
 			let selected = if let Some(selected_character_id) = &mut selected_character_id.0 {
+
 				*selected_character_id = *character_id_list
 					.0
 					.range(*selected_character_id..)
@@ -249,8 +249,9 @@ fn keyboard_input_system(
 		if let Some(selected_character_id) = &selected_character_id.0 {
 			if let Some((_character_id, mut velocity, _color)) = characters
 				.iter_mut()
-				.find(|(character_id, _velocity, _color)| *character_id == selected_character_id)
+				.find(|(character_id, _velocity, _color)| {
-			{
+					*character_id == selected_character_id
+				}) {
 				velocity.linvel.x = 200. * (right_pressed as i8 - left_pressed as i8) as f32;
 
 				if keyboard_input.just_pressed(KeyCode::Space) {
@@ -268,15 +269,16 @@ fn keyboard_input_system(
 
 fn character_particle_effect_system(
 	mut characters: Query<(&CharacterId, &Transform, &CharacterColor)>,
-	mut particle_effect: ResMut<crate::particle_effect::ParticleEffectResource>,
+    mut particle_effect: ResMut<crate::particle_effect::ParticleEffectResource>,
 	mut level_query: Query<&SelectedCharacterId>,
 ) {
 	if let Ok(selected_character_id) = level_query.get_single_mut() {
 		if let Some(selected_character_id) = &selected_character_id.0 {
 			if let Some((_character_id, transform, color)) = characters
 				.iter_mut()
-				.find(|(character_id, _transform, _color)| *character_id == selected_character_id)
+				.find(|(character_id, _transform, _color)| {
-			{
+					*character_id == selected_character_id
+				}) {
 				particle_effect.translation = transform.translation;
 				particle_effect.color = color.0;
 			}
@@ -306,6 +308,7 @@ fn move_camera(
 	mut camera_query: Query<(&Camera, &mut Transform, &GlobalTransform)>,
 	characters: Query<(&CharacterId, &Transform), Without<Camera>>,
 	level_query: Query<&SelectedCharacterId>,
+	time: Res<Time>,
 ) {
 	const MARGIN: f32 = 128.0;
 
@@ -322,6 +325,8 @@ fn move_camera(
 					.world_to_viewport(camera_global_transform, transform.translation)
 					.unwrap();
 				let size = camera.logical_viewport_size().unwrap();
+
+				// force camera to be within margin
 				if pos.x < MARGIN {
 					camera_transform.translation.x += pos.x - MARGIN;
 				}

src/particle_effect.rs

@@ -1,25 +1,24 @@
 use bevy::{prelude::*, sprite::Mesh2dHandle};
 use rand::Rng;
-use rand_distr::{Distribution, UnitCircle};
+use rand_distr::{UnitCircle, Distribution};
 
 pub const POOL_COUNT: usize = 100;
 
 pub const MIN_VELOCITY: f32 = 10.0;
 pub const MAX_VELOCITY: f32 = 100.0;
-pub const _VELOCITY_SCALE: f32 = 0.1;
+// pub const VELOCITY_SCALE: f32 = 0.1;
 pub const PARTICLE_EFFECT_RADIUS: f32 = 70.0;
 
 pub struct ParticleEffectPlugin;
 
 impl Plugin for ParticleEffectPlugin {
-	fn build(&self, app: &mut App) {
+    fn build(&self, app: &mut App) {
-		app.init_resource::<ParticleMesh>()
+        app
-			.insert_resource(ParticleEffectResource::new(Vec3::new(
+			.init_resource::<ParticleMesh>()
-				10000.0, 10000.0, 0.0,
+            .insert_resource(ParticleEffectResource::new(Vec3::new(10000.0, 10000.0, 0.0)))
-			)))
+            .add_startup_system(particle_effect_startup)
-			.add_startup_system(particle_effect_startup)
 			.add_system(particle_effect_system);
-	}
+    }
 }
 
 pub struct ParticleMesh {
@@ -43,9 +42,9 @@ impl FromWorld for ParticleMesh {
 
 #[derive(bevy_inspector_egui::Inspectable)]
 pub struct ParticleEffectResource {
-	pub translation: Vec3,
+    pub translation: Vec3,
 	pub prev_translation: Vec3,
-	pub radius_squared: f32,
+    pub radius_squared: f32,
 	pub color: Color,
 }
 
@@ -68,69 +67,60 @@ pub struct ParticleComponent {
 impl ParticleComponent {
 	pub fn new() -> Self {
 		let mut particle_component: Self = Self::default();
-		particle_component.randomize_velocity(MIN_VELOCITY, MAX_VELOCITY);
+        particle_component.randomize_velocity(MIN_VELOCITY, MAX_VELOCITY);
-		particle_component
+        return particle_component;
 	}
 
 	pub fn randomize_velocity(&mut self, min_velocity: f32, max_velocity: f32) {
-		let random_direction: [f32; 2] = UnitCircle.sample(&mut rand::thread_rng());
+        let random_direction: [f32; 2] = UnitCircle.sample(&mut rand::thread_rng());
-		let random_magnitude: f32 = rand::thread_rng().gen_range(min_velocity..max_velocity);
+        let random_magnitude: f32 = rand::thread_rng().gen_range(min_velocity .. max_velocity);
-		self.velocity = Vec3::new(random_direction[0], random_direction[1], 0.0) * random_magnitude;
+        self.velocity = Vec3::new(random_direction[0], random_direction[1], 0.0) * random_magnitude;
 	}
 }
 
 fn particle_effect_startup(
-	mut commands: Commands,
+    mut commands: Commands,
 
 	particle_mesh: Res<ParticleMesh>,
 	mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-	for _p in 0..POOL_COUNT {
+    for _p in 0 .. POOL_COUNT {
-		let color_mesh = ColorMesh2dBundle {
+        let color_mesh = ColorMesh2dBundle {
 			mesh: particle_mesh.square.clone(),
 			material: materials.add(ColorMaterial::from(Color::WHITE)),
 			..default()
 		};
 
-		commands
+        commands
-			.spawn_bundle(color_mesh)
+            .spawn_bundle(color_mesh)
-			.insert(ParticleComponent::new());
+            .insert(ParticleComponent::new());
-	}
+    }
 }
 
 fn particle_effect_system(
 	mut materials: ResMut<Assets<ColorMaterial>>,
-	mut query: Query<(
+    mut query: Query<(&mut Transform, &mut ParticleComponent, &Handle<ColorMaterial>)>,
-		&mut Transform,
+    mut particle_effect: ResMut<ParticleEffectResource>,
-		&mut ParticleComponent,
+    time: Res<Time>,
-		&Handle<ColorMaterial>,
-	)>,
-	mut particle_effect: ResMut<ParticleEffectResource>,
-	time: Res<Time>,
 ) {
-	let delta_seconds: f32 = f32::max(0.001, time.delta_seconds());
+    let delta_seconds: f32 = f32::max(0.001, time.delta_seconds());
 	let delta_position: Vec3 = particle_effect.translation - particle_effect.prev_translation;
 	// let overall_velocity: Vec3 = delta_position / delta_seconds;
 	particle_effect.prev_translation = particle_effect.translation;
 
 	for (mut transform, mut particle_component, color_material) in query.iter_mut() {
-		// particle_component.velocity -= overall_velocity * VELOCITY_SCALE;
+        // particle_component.velocity -= overall_velocity * VELOCITY_SCALE;
-		transform.translation += particle_component.velocity * delta_seconds + delta_position;
+        transform.translation += particle_component.velocity * delta_seconds + delta_position;
 
-		let squared_distance: f32 = transform
+		let squared_distance: f32 = transform.translation.distance_squared(particle_effect.translation);
-			.translation
+        if squared_distance > particle_effect.radius_squared {
-			.distance_squared(particle_effect.translation);
-		if squared_distance > particle_effect.radius_squared {
 			transform.translation = particle_effect.translation;
 			particle_component.randomize_velocity(MIN_VELOCITY, MAX_VELOCITY);
 		}
 
 		if let Some(material) = materials.get_mut(color_material) {
 			material.color = particle_effect.color;
-			material.color.set_a(
+			material.color.set_a((particle_effect.radius_squared - squared_distance) / particle_effect.radius_squared);
-				(particle_effect.radius_squared - squared_distance)
-					/ particle_effect.radius_squared,
-			);
 		}
 	}
 }