bevyjam/src/levels.rs

#![allow(clippy::too_many_arguments)]

use std::time::Duration;

pub use stored::*;

use crate::game::*;

use bevy::{prelude::*, reflect::TypeUuid};
use serde::{Deserialize, Serialize};

#[derive(Component)]
pub struct ZoomTimer(pub Timer);

impl Default for ZoomTimer {
	fn default() -> Self {
		Self(Timer::new(Duration::new(2, 0), false))
	}
}

pub fn setup_level(
	level_startup_event: &mut EventWriter<LevelStartupEvent>,
	camera_query: &mut Query<&mut Transform, With<Camera>>,
	zoom_timer: &mut ResMut<ZoomTimer>,
) {
	let mut transform = camera_query.single_mut();
	transform.translation = Default::default();

	zoom_timer.0.reset();

	level_startup_event.send(LevelStartupEvent);
}

pub fn despawn_level(
	mut commands: Commands,
	mut character_list: ResMut<CharacterList>,
	level_query: Query<Entity, With<Level>>,
) {
	character_list.0.clear();
	for entity in level_query.iter() {
		commands.entity(entity).despawn_recursive();
	}
}

// This is a bad design, to be refactored some days
pub fn post_setup_level(
	mut commands: Commands,
	character_meshes: Res<CharacterMeshes>,
	mut meshes: ResMut<Assets<Mesh>>,
	mut materials: ResMut<Assets<ColorMaterial>>,
	current_level: Res<CurrentLevel>,
	mut level_startup_event: EventReader<LevelStartupEvent>,
	asset_server: Res<AssetServer>,
	mut character_list: ResMut<CharacterList>,
	stored_levels_assets: Res<Assets<StoredLevels>>,
	stored_levels_handle: Res<Handle<StoredLevels>>,
) {
	for _ in level_startup_event.iter() {
		if let Some(level_id) = current_level.0 {
			if let Some(stored_level) = stored_levels_assets
				.get(&stored_levels_handle)
				.unwrap()
				.levels
				.get(level_id.0 as usize)
			{
				spawn_stored_level(
					&mut commands,
					&character_meshes,
					&mut meshes,
					&mut materials,
					&asset_server,
					&mut character_list,
					stored_level,
				);
			}
		}
	}
}

pub fn spawn_stored_level(
	commands: &mut Commands,
	character_meshes: &Res<CharacterMeshes>,
	meshes: &mut ResMut<Assets<Mesh>>,
	materials: &mut ResMut<Assets<ColorMaterial>>,
	asset_server: &Res<AssetServer>,
	character_list: &mut ResMut<CharacterList>,

	stored_level: &StoredLevel,
) {
	let font = asset_server.get_handle("UacariLegacy-Thin.ttf");
	spawn_platforms(
		commands,
		meshes,
		materials,
		stored_level.platforms.iter().map(|platform| {
			(
				Transform::from_xyz(platform.pos.x, platform.pos.y, 0.),
				platform.size,
			)
		}),
	);
	spawn_characters(
		commands,
		character_meshes,
		materials,
		character_list,
		stored_level.characters.iter().map(|character| {
			(
				Transform::from_xyz(character.pos.x, character.pos.y, 0.),
				character.color.into(),
			)
		}),
	);
	for absorbing_filter in stored_level.absorbing_filters.iter() {
		spawn_absorbing_filter(
			commands,
			meshes,
			materials,
			Transform::from_xyz(absorbing_filter.pos.x, absorbing_filter.pos.y, 2.),
			absorbing_filter.size,
			absorbing_filter.color.into(),
		);
	}
	for rotating_filter in stored_level.rotating_filters.iter() {
		spawn_rotating_filter(
			commands,
			asset_server,
			Transform::from_xyz(rotating_filter.pos.x, rotating_filter.pos.y, 2.),
			rotating_filter.angle,
		);
	}
	for melty_platform in stored_level.melty_platforms.iter() {
		spawn_melty_platform(
			commands,
			meshes,
			materials,
			asset_server,
			Transform::from_xyz(melty_platform.pos.x, melty_platform.pos.y, 2.),
			melty_platform.color.into(),
		);
	}
	for text in stored_level.texts.iter() {
		commands
			.spawn_bundle(Text2dBundle {
				text: Text::from_section(
					&text.text,
					TextStyle {
						font: font.clone(),
						font_size: text.font_size,
						color: Color::WHITE,
					},
				)
				.with_alignment(TextAlignment::CENTER),
				transform: Transform::from_xyz(text.pos.x, text.pos.y, 0.),
				..Default::default()
			})
			.insert(Level);
	}
}

pub mod stored {
	use super::*;

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "1fbba930-644b-0d62-2514-4b302b945327"]
	pub struct StoredLevels {
		pub levels: Vec<StoredLevel>,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "a1464a30-1f57-a654-d56c-ded41032af0b"]
	pub struct StoredLevel {
		pub comment: String,
		pub characters: Vec<StoredCharacter>,
		pub platforms: Vec<StoredPlatform>,
		pub absorbing_filters: Vec<StoredAbsorbingFilter>,
		pub rotating_filters: Vec<StoredRotatingFilter>,
		pub melty_platforms: Vec<StoredMeltyPlatform>,
		pub texts: Vec<StoredText>,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "1c798f8c-ef15-c528-693e-76becdef6b10"]
	pub struct StoredCharacter {
		pub pos: Vec2,
		pub color: Vec4,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "31696095-59de-93be-b5e9-333c2afbc900"]
	pub struct StoredPlatform {
		pub pos: Vec2,
		pub size: Vec2,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "bcad7fff-0605-c4e3-3cd4-42d5bbaad926"]
	pub struct StoredAbsorbingFilter {
		pub pos: Vec2,
		pub size: Vec2,
		pub color: Vec4,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "fa2843f2-6e34-601b-6c46-4827b0370b3f"]
	pub struct StoredRotatingFilter {
		pub pos: Vec2,
		pub angle: f32,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "cb0773ef-eca6-9b96-dcba-f4240ebdcf40"]
	pub struct StoredMeltyPlatform {
		pub pos: Vec2,
		pub color: Vec4,
	}

	#[derive(Deserialize, Serialize, TypeUuid)]
	#[uuid = "72f6321a-f01f-6eea-9b17-3159837a2fd3"]
	pub struct StoredText {
		pub pos: Vec2,
		pub font_size: f32,
		pub text: String,
	}
}