content/engines.toml

@@ -0,0 +1,4 @@
+[engine."plasma"]
+
+thrust = 100
+flare.sprite_texture = "flare::ion"

content/guns.toml

@@ -1,7 +1,5 @@
 [gun."blaster"]
 
-space.weapon = 10
-
 # Angle of fire cone
 # Smaller angle = more accurate
 spread = 2

content/outfits.toml

@@ -1,7 +0,0 @@
-[outfit."plasma engines"]
-
-space.engine = 20
-
-engine.thrust = 100
-engine.flare_texture = "flare::ion"
-steering.power = 20

content/ship.toml

@@ -6,11 +6,6 @@ hull = 200
 linear_drag = 0.2
 angular_drag = 0.2
 
-
-space.outfit = 200
-space.engine = 50
-space.weapon = 50
-
 engines = [{ x = 0.0, y = -1.05, size = 50.0 }]
 guns = [{ x = 0.0, y = 1 }, { x = 0.1, y = 0.80 }, { x = -0.1, y = 0.80 }]
 

crates/content/src/lib.rs

@@ -18,23 +18,21 @@ use toml;
 use walkdir::WalkDir;
 
 pub use handle::{FactionHandle, TextureHandle};
-pub use part::{
+pub use part::{Engine, EnginePoint, Faction, Gun, GunPoint, Relationship, Ship, System, Texture};
-	EnginePoint, Faction, Gun, GunPoint, Outfit, OutfitSpace, Relationship, Ship, System, Texture,
-};
 
 mod syntax {
 	use anyhow::{bail, Result};
 	use serde::Deserialize;
 	use std::collections::HashMap;
 
-	use crate::part::{faction, gun, outfit, ship, system, texture};
+	use crate::part::{engine, faction, gun, ship, system, texture};
 
 	#[derive(Debug, Deserialize)]
 	pub struct Root {
 		pub gun: Option<HashMap<String, gun::syntax::Gun>>,
 		pub ship: Option<HashMap<String, ship::syntax::Ship>>,
 		pub system: Option<HashMap<String, system::syntax::System>>,
-		pub outfit: Option<HashMap<String, outfit::syntax::Outfit>>,
+		pub engine: Option<HashMap<String, engine::syntax::Engine>>,
 		pub texture: Option<HashMap<String, texture::syntax::Texture>>,
 		pub faction: Option<HashMap<String, faction::syntax::Faction>>,
 	}
@@ -45,7 +43,7 @@ mod syntax {
 				gun: None,
 				ship: None,
 				system: None,
-				outfit: None,
+				engine: None,
 				texture: None,
 				faction: None,
 			}
@@ -99,11 +97,11 @@ mod syntax {
 				}
 			}
 
-			if let Some(a) = other.outfit {
+			if let Some(a) = other.engine {
-				if self.outfit.is_none() {
+				if self.engine.is_none() {
-					self.outfit = Some(a);
+					self.engine = Some(a);
 				} else {
-					let sg = self.outfit.as_mut().unwrap();
+					let sg = self.engine.as_mut().unwrap();
 					for (k, v) in a {
 						if sg.contains_key(&k) {
 							bail!("Repeated engine name {k}");
@@ -167,11 +165,11 @@ pub struct Content {
 	/// Ship bodies
 	pub ships: Vec<part::ship::Ship>,
 
-	/// Ship guns
+	/// Gun outfits
 	pub guns: Vec<part::gun::Gun>,
 
-	/// Outfits
+	/// Engine outfits
-	pub outfits: Vec<part::outfit::Outfit>,
+	pub engines: Vec<part::engine::Engine>,
 
 	/// Textures
 	pub textures: Vec<part::texture::Texture>,
@@ -258,7 +256,7 @@ impl Content {
 			systems: Vec::new(),
 			ships: Vec::new(),
 			guns: Vec::new(),
-			outfits: Vec::new(),
+			engines: Vec::new(),
 			textures: Vec::new(),
 			factions: Vec::new(),
 			texture_index: HashMap::new(),
@@ -277,8 +275,8 @@ impl Content {
 		if root.gun.is_some() {
 			part::gun::Gun::build(root.gun.take().unwrap(), &mut content)?;
 		}
-		if root.outfit.is_some() {
+		if root.engine.is_some() {
-			part::outfit::Outfit::build(root.outfit.take().unwrap(), &mut content)?;
+			part::engine::Engine::build(root.engine.take().unwrap(), &mut content)?;
 		}
 		if root.system.is_some() {
 			part::system::System::build(root.system.take().unwrap(), &mut content)?;

crates/content/src/part/engine.rs

@@ -0,0 +1,62 @@
+use std::collections::HashMap;
+
+use anyhow::{bail, Result};
+
+use crate::{handle::TextureHandle, Content};
+
+pub(crate) mod syntax {
+	use serde::Deserialize;
+	// Raw serde syntax structs.
+	// These are never seen by code outside this crate.
+
+	#[derive(Debug, Deserialize)]
+	pub struct Engine {
+		pub thrust: f32,
+		pub flare: Flare,
+	}
+
+	#[derive(Debug, Deserialize)]
+	pub struct Flare {
+		pub sprite_texture: String,
+	}
+}
+
+/// Represents an (foward) engine outfit that may be attached to a ship.
+#[derive(Debug, Clone)]
+pub struct Engine {
+	/// The name of this outfit
+	pub name: String,
+
+	/// How much thrust this engine produces
+	pub thrust: f32,
+
+	/// The flare sprite this engine creates.
+	/// Its location and size is determined by a ship's
+	/// engine points.
+	pub flare_sprite_texture: TextureHandle,
+}
+
+impl crate::Build for Engine {
+	type InputSyntax = HashMap<String, syntax::Engine>;
+
+	fn build(engine: Self::InputSyntax, ct: &mut Content) -> Result<()> {
+		for (engine_name, engine) in engine {
+			let th = match ct.texture_index.get(&engine.flare.sprite_texture) {
+				None => bail!(
+					"In engine `{}`: texture `{}` doesn't exist",
+					engine_name,
+					engine.flare.sprite_texture
+				),
+				Some(t) => *t,
+			};
+
+			ct.engines.push(Self {
+				name: engine_name,
+				thrust: engine.thrust,
+				flare_sprite_texture: th,
+			});
+		}
+
+		return Ok(());
+	}
+}

crates/content/src/part/gun.rs

@@ -5,10 +5,7 @@ use cgmath::Deg;
 
 use crate::{handle::TextureHandle, Content};
 
-use super::OutfitSpace;
-
 pub(crate) mod syntax {
-	use super::super::shared;
 	use serde::Deserialize;
 	// Raw serde syntax structs.
 	// These are never seen by code outside this crate.
@@ -19,7 +16,6 @@ pub(crate) mod syntax {
 		pub spread: f32,
 		pub rate: f32,
 		pub rate_rng: f32,
-		pub space: shared::syntax::OutfitSpace,
 	}
 
 	#[derive(Debug, Deserialize)]
@@ -57,9 +53,6 @@ pub struct Gun {
 	/// Random variation of projectile delay, in seconds.
 	/// Each shot waits (rate += rate_rng).
 	pub rate_rng: f32,
-
-	/// How much space this gun uses
-	pub space: OutfitSpace,
 }
 
 /// Represents a projectile that a [`Gun`] produces.
@@ -105,7 +98,6 @@ impl crate::Build for Gun {
 
 			ct.guns.push(Self {
 				name: gun_name,
-				space: gun.space.into(),
 				spread: Deg(gun.spread),
 				rate: gun.rate,
 				rate_rng: gun.rate_rng,

crates/content/src/part/mod.rs

@@ -1,17 +1,15 @@
 //! Content parts
 
+pub mod engine;
 pub mod faction;
 pub mod gun;
-pub mod outfit;
-mod shared;
 pub mod ship;
 pub mod system;
 pub mod texture;
 
+pub use engine::Engine;
 pub use faction::{Faction, Relationship};
 pub use gun::{Gun, Projectile};
-pub use outfit::Outfit;
-pub use shared::OutfitSpace;
 pub use ship::{EnginePoint, GunPoint, Ship};
 pub use system::{Object, System};
 pub use texture::Texture;

crates/content/src/part/outfit.rs

@@ -1,92 +0,0 @@
-use std::collections::HashMap;
-
-use anyhow::{bail, Result};
-
-use crate::{handle::TextureHandle, Content};
-
-use super::OutfitSpace;
-
-pub(crate) mod syntax {
-	use super::super::shared;
-	use serde::Deserialize;
-	// Raw serde syntax structs.
-	// These are never seen by code outside this crate.
-
-	#[derive(Debug, Deserialize)]
-	pub struct Outfit {
-		pub engine: Option<Engine>,
-		pub steering: Option<Steering>,
-		pub space: shared::syntax::OutfitSpace,
-	}
-
-	#[derive(Debug, Deserialize)]
-	pub struct Engine {
-		pub thrust: f32,
-		pub flare_texture: String,
-	}
-
-	#[derive(Debug, Deserialize)]
-	pub struct Steering {
-		pub power: f32,
-	}
-}
-
-/// Represents an outfit that may be attached to a ship.
-#[derive(Debug, Clone)]
-pub struct Outfit {
-	/// The name of this outfit
-	pub name: String,
-
-	/// How much engine thrust this outfit produces
-	pub engine_thrust: f32,
-
-	/// How much steering power this outfit provids
-	pub steer_power: f32,
-
-	/// The engine flare sprite this outfit creates.
-	/// Its location and size is determined by a ship's
-	/// engine points.
-	pub engine_flare_texture: Option<TextureHandle>,
-
-	/// How much space this outfit requires
-	pub space: OutfitSpace,
-}
-
-impl crate::Build for Outfit {
-	type InputSyntax = HashMap<String, syntax::Outfit>;
-
-	fn build(outfits: Self::InputSyntax, ct: &mut Content) -> Result<()> {
-		for (outfit_name, outfit) in outfits {
-			let mut o = Self {
-				name: outfit_name.clone(),
-				engine_thrust: 0.0,
-				steer_power: 0.0,
-				engine_flare_texture: None,
-				space: OutfitSpace::from(outfit.space),
-			};
-
-			// Engine stats
-			if let Some(engine) = outfit.engine {
-				let th = match ct.texture_index.get(&engine.flare_texture) {
-					None => bail!(
-						"In outfit `{}`: texture `{}` doesn't exist",
-						outfit_name,
-						engine.flare_texture
-					),
-					Some(t) => *t,
-				};
-				o.engine_thrust = engine.thrust;
-				o.engine_flare_texture = Some(th);
-			}
-
-			// Steering stats
-			if let Some(steer) = outfit.steering {
-				o.steer_power = steer.power;
-			}
-
-			ct.outfits.push(o);
-		}
-
-		return Ok(());
-	}
-}

crates/content/src/part/shared.rs

@@ -1,67 +0,0 @@
-pub(crate) mod syntax {
-	use serde::Deserialize;
-
-	#[derive(Debug, Deserialize)]
-	pub struct OutfitSpace {
-		pub outfit: Option<u32>,
-		pub weapon: Option<u32>,
-		pub engine: Option<u32>,
-	}
-}
-
-/// Represents outfit space, either that available in a ship
-/// or that used by an outfit.
-#[derive(Debug, Clone, Copy)]
-pub struct OutfitSpace {
-	/// Total available outfit space.
-	/// This should be greater than weapon and engine.
-	pub outfit: u32,
-
-	/// Space for weapons
-	pub weapon: u32,
-
-	/// Space for engine
-	pub engine: u32,
-}
-
-impl OutfitSpace {
-	/// Make a new, zero OutfitSpace
-	pub fn new() -> Self {
-		Self {
-			outfit: 0,
-			weapon: 0,
-			engine: 0,
-		}
-	}
-
-	/// Does this outfit contain `smaller`?
-	pub fn can_contain(&self, smaller: Self) -> bool {
-		self.outfit >= (smaller.outfit + smaller.weapon + smaller.engine)
-			&& self.weapon >= smaller.weapon
-			&& self.engine >= smaller.engine
-	}
-
-	/// Free outfit space
-	pub fn free(&mut self, rhs: &Self) {
-		self.outfit += rhs.outfit + rhs.weapon + rhs.engine;
-		self.weapon += rhs.weapon;
-		self.engine += rhs.engine;
-	}
-
-	/// Occupy outfit space
-	pub fn occupy(&mut self, rhs: &Self) {
-		self.outfit -= rhs.outfit + rhs.weapon + rhs.engine;
-		self.weapon -= rhs.weapon;
-		self.engine -= rhs.engine;
-	}
-}
-
-impl From<syntax::OutfitSpace> for OutfitSpace {
-	fn from(value: syntax::OutfitSpace) -> Self {
-		Self {
-			outfit: value.outfit.unwrap_or(0),
-			engine: value.engine.unwrap_or(0),
-			weapon: value.weapon.unwrap_or(0),
-		}
-	}
-}

crates/content/src/part/ship.rs

@@ -6,12 +6,8 @@ use nalgebra::{point, Point};
 
 use crate::{handle::TextureHandle, Content};
 
-use super::OutfitSpace;
-
 pub(crate) mod syntax {
-	use super::super::shared;
 	use serde::Deserialize;
-
 	// Raw serde syntax structs.
 	// These are never seen by code outside this crate.
 
@@ -26,7 +22,6 @@ pub(crate) mod syntax {
 		pub collision: Collision,
 		pub angular_drag: f32,
 		pub linear_drag: f32,
-		pub space: shared::syntax::OutfitSpace,
 	}
 
 	#[derive(Debug, Deserialize)]
@@ -91,9 +86,6 @@ pub struct Ship {
 
 	/// Reduction in velocity over time
 	pub linear_drag: f32,
-
-	/// Outfit space in this ship
-	pub space: OutfitSpace,
 }
 
 /// Collision shape for this ship
@@ -146,7 +138,6 @@ impl crate::Build for Ship {
 				name: ship_name,
 				sprite_texture: th,
 				mass: ship.mass,
-				space: OutfitSpace::from(ship.space),
 				angular_drag: ship.angular_drag,
 				linear_drag: ship.linear_drag,
 				size,

src/game/game.rs

@@ -31,31 +31,29 @@ impl Game {
 	pub fn new(ct: Content) -> Self {
 		let mut physics = Physics::new();
 
-		let mut o1 = outfits::ShipOutfits::new(&ct.ships[0]);
-		o1.add(ct.outfits[0].clone());
-		o1.add_gun(ct.guns[0].clone());
-		o1.add_gun(ct.guns[0].clone());
-
 		let h1 = physics.add_ship(
 			&ct.ships[0],
-			o1,
+			vec![
+				outfits::ShipOutfit::Gun(outfits::ShipGun::new(&ct.guns[0], 1)),
+				outfits::ShipOutfit::Gun(outfits::ShipGun::new(&ct.guns[0], 2)),
+				outfits::ShipOutfit::Engine(ct.engines[0].clone()),
+			],
 			Point2 { x: 0.0, y: 0.0 },
 			FactionHandle { index: 0 },
 		);
 
 		let h2 = physics.add_ship(
 			&ct.ships[0],
-			outfits::ShipOutfits::new(&ct.ships[0]),
+			vec![],
 			Point2 { x: 300.0, y: 300.0 },
 			FactionHandle { index: 0 },
 		);
-
-		let mut o2 = outfits::ShipOutfits::new(&ct.ships[0]);
-		o2.add(ct.outfits[0].clone());
-		o2.add_gun(ct.guns[0].clone());
 		let h3 = physics.add_ship(
 			&ct.ships[0],
-			o2,
+			vec![outfits::ShipOutfit::Gun(outfits::ShipGun::new(
+				&ct.guns[0],
+				0,
+			))],
 			Point2 {
 				x: -300.0,
 				y: 300.0,

src/game/outfits.rs

@@ -1,10 +1,8 @@
 use cgmath::{Deg, Point3};
-use content::{OutfitSpace, TextureHandle};
 
 use crate::{content, render::SubSprite};
 
 /// Represents a gun attached to a specific ship at a certain gunpoint.
-#[derive(Debug)]
 pub struct ShipGun {
 	pub kind: content::Gun,
 	pub cooldown: f32,
@@ -12,66 +10,39 @@ pub struct ShipGun {
 }
 
 impl ShipGun {
-	pub fn new(kind: content::Gun, point: usize) -> Self {
+	pub fn new(kind: &content::Gun, point: usize) -> Self {
 		Self {
-			kind: kind,
+			kind: kind.clone(),
 			point,
 			cooldown: 0.0,
 		}
 	}
 }
 
-/// This struct keeps track of the combined stats of a set of outfits.
+/// Represents a specific outfit attached to a specific ship
-/// It does NOT check for sanity (e.g, removing an outfit that was never added)
+pub enum ShipOutfit {
-/// That is handled by ShipOutfits.
+	Gun(ShipGun),
-#[derive(Debug)]
+	Engine(content::Engine),
-pub struct OutfitStatSum {
-	pub engine_thrust: f32,
-	pub steer_power: f32,
-	pub engine_flare_textures: Vec<TextureHandle>,
 }
 
-impl OutfitStatSum {
+impl ShipOutfit {
-	pub fn new() -> Self {
+	pub fn gun(&mut self) -> Option<&mut ShipGun> {
-		Self {
+		match self {
-			engine_thrust: 0.0,
+			Self::Gun(g) => Some(g),
-			steer_power: 0.0,
+			_ => None,
-			engine_flare_textures: Vec::new(),
 		}
 	}
 
-	pub fn add(&mut self, o: &content::Outfit) {
+	pub fn engine(&self) -> Option<&content::Engine> {
-		self.engine_thrust += o.engine_thrust;
+		match self {
-		if let Some(t) = o.engine_flare_texture {
+			Self::Engine(e) => Some(e),
-			self.engine_flare_textures.push(t);
+			_ => None,
-		};
-		self.steer_power += o.steer_power;
 		}
-
-	pub fn remove(&mut self, o: &content::Outfit) {
-		self.engine_thrust -= o.engine_thrust;
-		if let Some(t) = o.engine_flare_texture {
-			self.engine_flare_textures.remove(
-				self.engine_flare_textures
-					.iter()
-					.position(|x| *x == t)
-					.unwrap(),
-			);
-		}
-		self.steer_power -= o.steer_power;
 	}
 }
 
-/// Represents all the outfits attached to a ship.
-/// Keeps track of the sum of their stats, so it mustn't be re-computed every frame.
-#[derive(Debug)]
 pub struct ShipOutfits {
-	pub stats: OutfitStatSum,
+	outfits: Vec<ShipOutfit>,
-	pub total_space: OutfitSpace,
-
-	available_space: OutfitSpace,
-	outfits: Vec<content::Outfit>,
-	guns: Vec<ShipGun>,
 	enginepoints: Vec<content::EnginePoint>,
 	gunpoints: Vec<content::GunPoint>,
 
@@ -83,107 +54,66 @@ pub struct ShipOutfits {
 impl<'a> ShipOutfits {
 	pub fn new(content: &content::Ship) -> Self {
 		Self {
-			stats: OutfitStatSum::new(),
 			outfits: Vec::new(),
-			guns: Vec::new(),
-			available_space: content.space.clone(),
-			total_space: content.space.clone(),
 			enginepoints: content.engines.clone(),
 			gunpoints: content.guns.clone(),
 			engine_flare_sprites: vec![],
 		}
 	}
 
-	/// Does this outfit set contain the specified outfit?
+	pub fn add(&mut self, o: ShipOutfit) {
-	pub fn contains_outfit(&self, o: &content::Outfit) -> bool {
-		match self.outfits.iter().position(|x| x.name == o.name) {
-			Some(_) => true,
-			None => false,
-		}
-	}
-
-	/// Add an outfit to this ship.
-	/// Returns true on success, and false on failure
-	/// TODO: failure reason enum
-	pub fn add(&mut self, o: content::Outfit) -> bool {
-		if !self.available_space.can_contain(o.space) {
-			return false;
-		}
-		self.available_space.occupy(&o.space);
-		self.stats.add(&o);
 		self.outfits.push(o);
 		self.update_engine_flares();
-		return true;
-	}
-
-	/// TODO: is outfit in set?
-	pub fn remove(&mut self, o: content::Outfit) {
-		let i = match self.outfits.iter().position(|x| x.name == o.name) {
-			Some(i) => i,
-			None => panic!("Removed non-existing outfit"),
-		};
-		self.available_space.free(&o.space);
-		self.outfits.remove(i);
-		self.stats.remove(&o);
-		self.update_engine_flares();
-	}
-
-	/// Add a gun to this outfit set.
-	/// This automatically attaches the gun to the first available gunpoint,
-	/// and returns false (applying no changes) if no points are available.
-	pub fn add_gun(&mut self, gun: content::Gun) -> bool {
-		// Find first unused point
-		let mut p = None;
-		'outer: for i in 0..self.gunpoints.len() {
-			for g in &self.guns {
-				if g.point == i {
-					continue 'outer;
-				}
-			}
-			p = Some(i);
-			break;
-		}
-
-		// All points are taken
-		if p.is_none() {
-			return false;
-		}
-
-		let sg = ShipGun::new(gun, p.unwrap());
-		self.guns.push(sg);
-		return true;
 	}
 
 	pub fn iter_guns(&mut self) -> impl Iterator<Item = &mut ShipGun> {
-		self.guns.iter_mut()
+		self.outfits
+			.iter_mut()
+			.map(|x| x.gun())
+			.filter(|x| x.is_some())
+			.map(|x| x.unwrap())
 	}
 
 	pub fn iter_guns_points(&mut self) -> impl Iterator<Item = (&mut ShipGun, &content::GunPoint)> {
-		self.guns
+		self.outfits
 			.iter_mut()
+			.map(|x| x.gun())
+			.filter(|x| x.is_some())
+			.map(|x| x.unwrap())
 			.map(|x| (&self.gunpoints[x.point], x))
 			.map(|(a, b)| (b, a))
 	}
 
+	pub fn iter_engines(&self) -> impl Iterator<Item = &content::Engine> {
+		self.outfits
+			.iter()
+			.map(|x| x.engine())
+			.filter(|x| x.is_some())
+			.map(|x| x.unwrap())
+	}
+
+	pub fn iter_enginepoints(&self) -> impl Iterator<Item = &content::EnginePoint> {
+		self.enginepoints.iter()
+	}
+
 	pub fn update_engine_flares(&mut self) {
 		// TODO: better way to pick flare texture
 		self.engine_flare_sprites.clear();
-		let t = if let Some(e) = self.stats.engine_flare_textures.iter().next() {
+		let t = if let Some(e) = self.iter_engines().next() {
-			e
+			e.flare_sprite_texture
 		} else {
 			return;
 		};
 
 		self.engine_flare_sprites = self
-			.enginepoints
+			.iter_enginepoints()
-			.iter()
 			.map(|p| SubSprite {
 				pos: Point3 {
 					x: p.pos.x,
 					y: p.pos.y,
 					z: 1.0,
 				},
-				texture: *t,
+				texture: t,
 				angle: Deg(0.0),
 				size: p.size,
 			})

src/objects/ship.rs

@@ -52,13 +52,18 @@ pub struct Ship {
 impl Ship {
 	pub fn new(
 		c: &content::Ship,
-		outfits: outfits::ShipOutfits,
+		outfits: Vec<outfits::ShipOutfit>,
 		physics_handle: ShipHandle,
 		faction: FactionHandle,
 	) -> Self {
+		let mut o = outfits::ShipOutfits::new(c);
+		for x in outfits.into_iter() {
+			o.add(x)
+		}
+
 		Ship {
 			physics_handle,
-			outfits,
+			outfits: o,
 			sprite_texture: c.sprite_texture,
 			size: c.size,
 			hull: c.hull,
@@ -130,18 +135,17 @@ impl Ship {
 		let engine_force = ship_rot * t;
 
 		if self.controls.thrust {
-			r.apply_impulse(
+			for e in self.outfits.iter_engines() {
-				vector![engine_force.x, engine_force.y] * self.outfits.stats.engine_thrust,
+				r.apply_impulse(vector![engine_force.x, engine_force.y] * e.thrust, true);
-				true,
+			}
-			);
 		}
 
 		if self.controls.right {
-			r.apply_torque_impulse(self.outfits.stats.steer_power * -100.0 * t, true);
+			r.apply_torque_impulse(-1000.0 * t, true);
 		}
 
 		if self.controls.left {
-			r.apply_torque_impulse(self.outfits.stats.steer_power * 100.0 * t, true);
+			r.apply_torque_impulse(1000.0 * t, true);
 		}
 
 		let p = if self.controls.guns {

src/physics/physics.rs

@@ -82,7 +82,7 @@ impl Physics {
 	pub fn add_ship(
 		&mut self,
 		ct: &content::Ship,
-		outfits: outfits::ShipOutfits,
+		outfits: Vec<outfits::ShipOutfit>,
 		position: Point2<f32>,
 		faction: FactionHandle,
 	) -> ShipHandle {