462 lines
10 KiB
Rust
462 lines
10 KiB
Rust
use anyhow::{bail, Context, Result};
|
|
use galactica_util::to_radians;
|
|
use nalgebra::{Point2, Rotation2, Vector2};
|
|
use rapier2d::geometry::{Collider, ColliderBuilder};
|
|
use std::{collections::HashMap, fmt::Debug, hash::Hash};
|
|
|
|
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 thumbnail: 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>,
|
|
pub damage: Option<Damage>,
|
|
}
|
|
|
|
#[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,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct Damage {
|
|
pub hull: f32,
|
|
pub effects: Vec<DamageEffectSpawner>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct DamageEffectSpawner {
|
|
pub effect: EffectReference,
|
|
pub frequency: f32,
|
|
pub pos: Option<[f32; 2]>,
|
|
}
|
|
|
|
// 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,
|
|
|
|
/// This ship's thumbnail
|
|
pub thumbnail: 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 collider: CollisionDebugWrapper,
|
|
|
|
/// 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,
|
|
|
|
/// Damaged ship effects
|
|
pub damage: ShipDamage,
|
|
}
|
|
|
|
/// Hack to give `Collider` a fake debug method.
|
|
/// Pretend this is transparent, get the collider with .0.
|
|
#[derive(Clone)]
|
|
pub struct CollisionDebugWrapper(pub Collider);
|
|
|
|
impl Debug for CollisionDebugWrapper {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
"CollisionDebugWrapper".fmt(f)
|
|
}
|
|
}
|
|
|
|
/// 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: Vector2<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 index in this ship
|
|
pub idx: u32,
|
|
|
|
/// This gun point's position, in game units,
|
|
/// relative to the ship's center.
|
|
pub pos: Vector2<f32>,
|
|
}
|
|
|
|
impl Eq for GunPoint {}
|
|
impl PartialEq for GunPoint {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.idx == other.idx
|
|
}
|
|
}
|
|
|
|
// We use a hashmap of these in OutfitSet
|
|
impl Hash for GunPoint {
|
|
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
|
self.idx.hash(state);
|
|
}
|
|
}
|
|
|
|
/// 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>,
|
|
}
|
|
|
|
/// Parameters for damaged ship effects
|
|
#[derive(Debug, Clone)]
|
|
pub struct ShipDamage {
|
|
/// Show damaged ship effects if hull is below this value
|
|
pub hull: f32,
|
|
|
|
/// Effects to create during collapse
|
|
pub effects: Vec<DamageEffectSpawner>,
|
|
}
|
|
|
|
/// An effect shown when a ship is damaged
|
|
#[derive(Debug, Clone)]
|
|
pub struct DamageEffectSpawner {
|
|
/// The effect to create
|
|
pub effect: EffectHandle,
|
|
|
|
/// How often to create this effect
|
|
pub frequency: f32,
|
|
|
|
/// Where to create is effect.
|
|
/// Position is random if None.
|
|
pub pos: Option<Point2<f32>>,
|
|
}
|
|
|
|
/// An effect shown 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 this effect.
|
|
/// 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 sprite = match ct.sprite_index.get(&ship.sprite) {
|
|
None => bail!(
|
|
"In ship `{}`: sprite `{}` doesn't exist",
|
|
ship_name,
|
|
ship.sprite
|
|
),
|
|
Some(t) => *t,
|
|
};
|
|
|
|
let thumbnail = match ct.sprite_index.get(&ship.thumbnail) {
|
|
None => bail!(
|
|
"In ship `{}`: thumbnail sprite `{}` doesn't exist",
|
|
ship_name,
|
|
ship.thumbnail
|
|
),
|
|
Some(t) => *t,
|
|
};
|
|
|
|
let size = ship.size;
|
|
let aspect = ct.get_sprite(sprite).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::new(p[0] * (size / 2.0) * aspect, 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::new(
|
|
p[0] * (size / 2.0) * aspect,
|
|
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![],
|
|
}
|
|
}
|
|
};
|
|
|
|
let damage = {
|
|
if let Some(c) = ship.damage {
|
|
let mut effects = Vec::new();
|
|
for e in c.effects {
|
|
effects.push(DamageEffectSpawner {
|
|
effect: e
|
|
.effect
|
|
.to_handle(build_context, ct)
|
|
.with_context(|| format!("while loading ship `{}`", ship_name))?,
|
|
frequency: e.frequency,
|
|
pos: e.pos.map(|p| {
|
|
Point2::new(p[0] * (size / 2.0) * aspect, p[1] * size / 2.0)
|
|
}),
|
|
});
|
|
}
|
|
|
|
ShipDamage {
|
|
hull: c.hull,
|
|
effects: effects,
|
|
}
|
|
} else {
|
|
// Default damage effects
|
|
ShipDamage {
|
|
hull: 0.0,
|
|
effects: vec![],
|
|
}
|
|
}
|
|
};
|
|
|
|
// TODO: document this
|
|
let mut guns = Vec::new();
|
|
for g in ship.guns {
|
|
guns.push(GunPoint {
|
|
idx: guns.len() as u32,
|
|
|
|
// Angle adjustment, since sprites point north
|
|
// and 0 degrees is east in the game
|
|
pos: Rotation2::new(to_radians(-90.0))
|
|
* Vector2::new(g.x * size * aspect / 2.0, g.y * size / 2.0),
|
|
})
|
|
}
|
|
|
|
// Build rapier2d collider
|
|
let collider = {
|
|
let indices: Vec<[u32; 2]> = (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();
|
|
|
|
let points: Vec<Point2<f32>> = ship
|
|
.collision
|
|
.iter()
|
|
.map(|x| {
|
|
// Angle adjustment: rotate collider to match sprite
|
|
// (Sprites (and their colliders) point north, but 0 is east in the game world)
|
|
// We apply this pointwise so that local points inside the collider work as we expect.
|
|
//
|
|
// If we don't, rapier2 will compute local points pre-rotation,
|
|
// which will break effect placement on top of ships (i.e, collapse effects)
|
|
Rotation2::new(to_radians(-90.0))
|
|
* Point2::new(x[0] * (size / 2.0) * aspect, x[1] * size / 2.0)
|
|
})
|
|
.collect();
|
|
|
|
ColliderBuilder::convex_decomposition(&points[..], &indices[..])
|
|
.mass(ship.mass)
|
|
.build()
|
|
};
|
|
|
|
ct.ships.push(Self {
|
|
sprite,
|
|
thumbnail,
|
|
aspect,
|
|
collapse,
|
|
damage,
|
|
name: ship_name,
|
|
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: Vector2::new(e.x * size * aspect / 2.0, e.y * size / 2.0),
|
|
size: e.size,
|
|
})
|
|
.collect(),
|
|
|
|
guns,
|
|
|
|
collider: CollisionDebugWrapper(collider),
|
|
});
|
|
}
|
|
|
|
return Ok(());
|
|
}
|
|
}
|