Galactica/crates/content/src/part/ship.rs

use std::collections::HashMap;

use anyhow::{bail, Context, Result};
use cgmath::Point2;
use nalgebra::{point, Point};

use crate::{handle::SpriteHandle, Content, ContentBuildContext, EffectHandle, OutfitSpace};

pub(crate) mod syntax {
	use crate::part::{effect::syntax::EffectReference, outfitspace};
	use serde::Deserialize;

	// Raw serde syntax structs.
	// These are never seen by code outside this crate.

	#[derive(Debug, Deserialize)]
	pub struct Ship {
		pub sprite: String,
		pub size: f32,
		pub engines: Vec<Engine>,
		pub guns: Vec<Gun>,
		pub hull: f32,
		pub mass: f32,
		pub collision: Vec<[f32; 2]>,
		pub angular_drag: f32,
		pub linear_drag: f32,
		pub space: outfitspace::syntax::OutfitSpace,
		pub collapse: Option<Collapse>,
	}

	#[derive(Debug, Deserialize)]
	pub struct Engine {
		pub x: f32,
		pub y: f32,
		pub size: f32,
	}

	#[derive(Debug, Deserialize)]
	pub struct Gun {
		pub x: f32,
		pub y: f32,
	}

	// TODO:
	// plural or not? document!
	#[derive(Debug, Deserialize)]
	pub struct Collapse {
		pub length: f32,
		pub effects: Vec<CollapseEffectSpawner>,
		pub event: Vec<CollapseEvent>,
	}

	#[derive(Debug, Deserialize)]
	pub struct CollapseEffectSpawner {
		pub effect: EffectReference,
		pub count: f32,
		pub pos: Option<[f32; 2]>,
	}

	#[derive(Debug, Deserialize)]
	#[serde(untagged)]
	pub enum CollapseEvent {
		Effect(EffectCollapseEvent),
	}

	#[derive(Debug, Deserialize)]
	pub struct EffectCollapseEvent {
		pub time: f32,
		pub effects: Vec<CollapseEffectSpawner>,
	}
}

// Processed data structs.
// These are exported.

/// Represents a ship chassis.
#[derive(Debug, Clone)]
pub struct Ship {
	/// This ship's name
	pub name: String,

	/// This ship's sprite
	pub sprite: SpriteHandle,

	/// The size of this ship.
	/// Measured as unrotated height,
	/// in terms of game units.
	pub size: f32,

	/// The mass of this ship
	pub mass: f32,

	/// Engine points on this ship.
	/// This is where engine flares are drawn.
	pub engines: Vec<EnginePoint>,

	/// Gun points on this ship.
	/// A gun outfit can be mounted on each.
	pub guns: Vec<GunPoint>,

	/// This ship's hull strength
	pub hull: f32,

	/// Collision shape for this ship
	pub collision: Collision,

	/// Remove later
	pub aspect: f32,

	/// Reduction in angular velocity over time
	pub angular_drag: f32,

	/// Reduction in velocity over time
	pub linear_drag: f32,

	/// Outfit space in this ship
	pub space: OutfitSpace,

	/// Ship collapse sequence
	pub collapse: ShipCollapse,
}

/// Collision shape for this ship
#[derive(Debug, Clone)]
pub struct Collision {
	pub points: Vec<Point<f32, 2>>,
	pub indices: Vec<[u32; 2]>,
}

/// An engine point on a ship.
/// This is where flares are drawn.
#[derive(Debug, Clone)]
pub struct EnginePoint {
	/// This engine point's position, in game units,
	/// relative to the ship's center.
	pub pos: Point2<f32>,

	/// The size of the flare that should be drawn
	/// at this point, measured as height in game units.
	pub size: f32,
}

/// A gun point on a ship.
#[derive(Debug, Clone)]
pub struct GunPoint {
	/// This gun point's position, in game units,
	/// relative to the ship's center.
	pub pos: Point2<f32>,
}

/// Parameters for a ship's collapse sequence
#[derive(Debug, Clone)]
pub struct ShipCollapse {
	/// Collapse sequence length, in seconds
	pub length: f32,

	/// Effects to create during collapse
	pub effects: Vec<CollapseEffectSpawner>,

	/// Scripted events during ship collapse
	pub events: Vec<CollapseEvent>,
}

/// A scripted event during a ship collapse sequence
#[derive(Debug, Clone)]
pub struct CollapseEffectSpawner {
	/// The effect to create
	pub effect: EffectHandle,

	/// How many effects to create
	pub count: f32,

	/// Where to create these effects.
	/// Position is random if None.
	pub pos: Option<Point2<f32>>,
}

/// A scripted event during a ship collapse sequence
#[derive(Debug, Clone)]
pub enum CollapseEvent {
	/// A scripted effect during a ship collapse sequence
	Effect(EffectCollapseEvent),
}

/// A scripted effect during a ship collapse sequence
#[derive(Debug, Clone)]
pub struct EffectCollapseEvent {
	/// When to trigger this event
	pub time: f32,

	/// The effect to create
	pub effects: Vec<CollapseEffectSpawner>,
}

impl crate::Build for Ship {
	type InputSyntaxType = HashMap<String, syntax::Ship>;

	fn build(
		ship: Self::InputSyntaxType,
		build_context: &mut ContentBuildContext,
		ct: &mut Content,
	) -> Result<()> {
		for (ship_name, ship) in ship {
			let handle = match ct.sprite_index.get(&ship.sprite) {
				None => bail!(
					"In ship `{}`: sprite `{}` doesn't exist",
					ship_name,
					ship.sprite
				),
				Some(t) => *t,
			};

			let size = ship.size;
			let aspect = ct.get_sprite(handle).aspect;

			let collapse = if let Some(c) = ship.collapse {
				let mut effects = Vec::new();
				for e in c.effects {
					effects.push(CollapseEffectSpawner {
						effect: e
							.effect
							.to_handle(build_context, ct)
							.with_context(|| format!("while loading ship `{}`", ship_name))?,
						count: e.count,
						pos: e.pos.map(|p| Point2 {
							x: p[0] * (size / 2.0) * aspect,
							y: p[1] * size / 2.0,
						}),
					});
				}

				let mut events = Vec::new();
				for e in c.event {
					match e {
						syntax::CollapseEvent::Effect(e) => {
							let mut effects = Vec::new();
							for g in e.effects {
								effects.push(CollapseEffectSpawner {
									effect: g.effect.to_handle(build_context, ct).with_context(
										|| format!("while loading ship `{}`", ship_name),
									)?,
									count: g.count,
									pos: g.pos.map(|p| Point2 {
										x: p[0] * (size / 2.0) * aspect,
										y: p[1] * size / 2.0,
									}),
								})
							}

							events.push(CollapseEvent::Effect(EffectCollapseEvent {
								time: e.time,
								effects,
							}))
						}
					}
				}

				ShipCollapse {
					length: c.length,
					effects,
					events,
				}
			} else {
				// Default collapse sequence
				ShipCollapse {
					length: 0.0,
					effects: vec![],
					events: vec![],
				}
			};

			ct.ships.push(Self {
				aspect,
				collapse,
				name: ship_name,
				sprite: handle,
				mass: ship.mass,
				space: OutfitSpace::from(ship.space),
				angular_drag: ship.angular_drag,
				linear_drag: ship.linear_drag,
				size,
				hull: ship.hull,

				engines: ship
					.engines
					.iter()
					.map(|e| EnginePoint {
						pos: Point2 {
							x: e.x * size * aspect / 2.0,
							y: e.y * size / 2.0,
						},
						size: e.size,
					})
					.collect(),

				guns: ship
					.guns
					.iter()
					.map(|e| GunPoint {
						pos: Point2 {
							x: e.x * size * aspect / 2.0,
							y: e.y * size / 2.0,
						},
					})
					.collect(),

				collision: Collision {
					indices: (0..ship.collision.len())
						.map(|x| {
							// Auto-generate mesh lines:
							// [ [0, 1], [1, 2], ..., [n, 0] ]
							let next = if x == ship.collision.len() - 1 {
								0
							} else {
								x + 1
							};
							[x as u32, next as u32]
						})
						.collect(),
					points: ship
						.collision
						.iter()
						.map(|x| point![x[0] * (size / 2.0) * aspect, x[1] * size / 2.0])
						.collect(),
				},
			});
		}

		return Ok(());
	}
}