crates/content/src/part/outfitspace.rs

@@ -1,5 +1,3 @@
-use std::ops::{Add, AddAssign, Sub, SubAssign};
-
 pub(crate) mod syntax {
 	use serde::Deserialize;
 
@@ -11,8 +9,6 @@ pub(crate) mod syntax {
 	}
 }
 
-// TODO: user-defined space values
-
 /// Represents outfit space, either that available in a ship
 /// or that used by an outfit.
 #[derive(Debug, Clone, Copy)]
@@ -29,7 +25,7 @@ pub struct OutfitSpace {
 }
 
 impl OutfitSpace {
-	/// Make a new, zeroed OutfitSpace
+	/// Make a new, zero OutfitSpace
 	pub fn new() -> Self {
 		Self {
 			outfit: 0,
@@ -38,52 +34,26 @@ impl OutfitSpace {
 		}
 	}
 
-	/// Can this outfit contain `smaller`?
+	/// Does this outfit contain `smaller`?
 	pub fn can_contain(&self, smaller: &Self) -> bool {
-		self.outfit >= smaller.outfit
+		self.outfit >= (smaller.outfit + smaller.weapon + smaller.engine)
 			&& self.weapon >= smaller.weapon
 			&& self.engine >= smaller.engine
 	}
-}
 
-impl Sub for OutfitSpace {
+	/// Free outfit space
-	type Output = Self;
+	pub fn free(&mut self, rhs: &Self) {
-
+		self.outfit += rhs.outfit + rhs.weapon + rhs.engine;
-	fn sub(self, rhs: Self) -> Self::Output {
-		OutfitSpace {
-			outfit: self.outfit - rhs.outfit,
-			weapon: self.weapon - rhs.weapon,
-			engine: self.engine - rhs.engine,
-		}
-	}
-}
-
-impl SubAssign for OutfitSpace {
-	fn sub_assign(&mut self, rhs: Self) {
-		self.outfit -= rhs.outfit;
-		self.weapon -= rhs.weapon;
-		self.engine -= rhs.engine;
-	}
-}
-
-impl Add for OutfitSpace {
-	type Output = Self;
-
-	fn add(self, rhs: Self) -> Self::Output {
-		OutfitSpace {
-			outfit: self.outfit + rhs.outfit,
-			weapon: self.weapon + rhs.weapon,
-			engine: self.engine + rhs.engine,
-		}
-	}
-}
-
-impl AddAssign for OutfitSpace {
-	fn add_assign(&mut self, rhs: Self) {
-		self.outfit += rhs.outfit;
 		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 {

crates/content/src/part/ship.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, hash::Hash};
+use std::collections::HashMap;
 
 use anyhow::{bail, Context, Result};
 use cgmath::Point2;
@@ -160,28 +160,11 @@ pub struct EnginePoint {
 /// 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: Point2<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 {
@@ -362,18 +345,6 @@ impl crate::Build for Ship {
 				}
 			};
 
-			// TODO: document this
-			let mut guns = Vec::new();
-			for g in ship.guns {
-				guns.push(GunPoint {
-					idx: guns.len() as u32,
-					pos: Point2 {
-						x: g.x * size * aspect / 2.0,
-						y: g.y * size / 2.0,
-					},
-				})
-			}
-
 			ct.ships.push(Self {
 				aspect,
 				collapse,
@@ -399,7 +370,16 @@ impl crate::Build for Ship {
 					})
 					.collect(),
 
-				guns,
+				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())

crates/gameobject/src/gamedata.rs

@@ -1,47 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-	handles::GameShipHandle,
-	ship::Ship,
-	ship::{OutfitSet, ShipPersonality},
-};
-use content::ShipHandle;
-use galactica_content as content;
-
-/// Keeps track of all objects in the galaxy.
-/// This struct does NO physics, it keeps track of data exclusively.
-pub struct GameData {
-	// Universal counter.
-	// Used to create unique handles for game objects.
-	index: u64,
-	ships: HashMap<GameShipHandle, Ship>,
-}
-
-impl GameData {
-	pub fn new() -> Self {
-		Self {
-			index: 0,
-			ships: HashMap::new(),
-		}
-	}
-
-	/// Spawn a ship
-	pub fn create_ship(
-		&mut self,
-		ct: &content::Content,
-		ship: ShipHandle,
-		faction: content::FactionHandle,
-		personality: ShipPersonality,
-		outfits: OutfitSet,
-	) -> GameShipHandle {
-		let handle = GameShipHandle { index: self.index };
-		self.index += 1;
-		self.ships
-			.insert(handle, Ship::new(ct, ship, faction, personality, outfits));
-		return handle;
-	}
-
-	pub fn get_ship(&self, handle: GameShipHandle) -> Option<&Ship> {
-		self.ships.get(&handle)
-	}
-}

crates/gameobject/src/handles.rs

@@ -1,5 +0,0 @@
-/// A lightweight representation of a ship in the galaxy
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct GameShipHandle {
-	pub(crate) index: u64,
-}

crates/gameobject/src/lib.rs

@@ -4,11 +4,14 @@
 //! of every ship in the game, but it has no understanding of physics.
 //! That is done in `galactica_world`.
 
-mod gamedata;
+mod outfits;
-mod handles;
+mod projectile;
-pub mod ship;
+mod ship;
 mod system;
+mod systemobject;
 
-pub use gamedata::*;
+pub use outfits::{OutfitSet, OutfitStatSum, ShipGun};
-pub use handles::*;
+pub use projectile::Projectile;
-pub use system::{System, SystemObject};
+pub use ship::Ship;
+pub use system::System;
+pub use systemobject::SystemObject;

crates/gameobject/src/outfits.rs

@@ -0,0 +1,203 @@
+use content::{EnginePoint, OutfitHandle, SpriteHandle};
+use galactica_content as content;
+
+/// Represents a gun attached to a specific ship at a certain gunpoint.
+#[derive(Debug)]
+pub struct ShipGun {
+	/// The kind of gun this is
+	pub kind: content::Gun,
+
+	/// How many seconds we must wait before this gun can fire
+	pub cooldown: f32,
+
+	/// Index of the gunpoint this gun is attached to
+	pub point: usize,
+}
+
+impl ShipGun {
+	/// Make a new shipgun
+	pub fn new(kind: &content::Gun, point: usize) -> Self {
+		Self {
+			kind: kind.clone(),
+			point,
+			cooldown: 0.0,
+		}
+	}
+}
+
+/// This struct keeps track of the combined stats of a set of outfits.
+/// It does NOT check for sanity (e.g, removing an outfit that was never added)
+/// That is handled by ShipOutfits.
+#[derive(Debug)]
+pub struct OutfitStatSum {
+	pub engine_thrust: f32,
+	pub steer_power: f32,
+	pub engine_flare_sprites: Vec<content::SpriteHandle>,
+	pub shield_strength: f32,
+
+	// Delay, generation
+	pub shield_generators: Vec<(OutfitHandle, f32, f32)>,
+}
+
+impl OutfitStatSum {
+	pub fn new() -> Self {
+		Self {
+			engine_thrust: 0.0,
+			steer_power: 0.0,
+			engine_flare_sprites: Vec::new(),
+			shield_strength: 0.0,
+			shield_generators: Vec::new(),
+		}
+	}
+
+	pub fn add(&mut self, o: &content::Outfit) {
+		self.engine_thrust += o.engine_thrust;
+		if let Some(t) = o.engine_flare_sprite {
+			self.engine_flare_sprites.push(t);
+		};
+		self.steer_power += o.steer_power;
+		self.shield_strength += o.shield_strength;
+		self.shield_generators
+			.push((o.handle, o.shield_delay, o.shield_generation));
+	}
+
+	pub fn remove(&mut self, o: &content::Outfit) {
+		self.engine_thrust -= o.engine_thrust;
+		if let Some(t) = o.engine_flare_sprite {
+			self.engine_flare_sprites.remove(
+				self.engine_flare_sprites
+					.iter()
+					.position(|x| *x == t)
+					.unwrap(),
+			);
+		}
+		self.steer_power -= o.steer_power;
+		self.shield_strength -= o.shield_strength;
+		{
+			// Assume such an index exists
+			let index = self
+				.shield_generators
+				.iter()
+				.position(|(h, _, _)| *h == o.handle)
+				.unwrap();
+			self.shield_generators.remove(index);
+		}
+	}
+}
+
+/// Represents a set of 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 OutfitSet {
+	/// The total sum of the stats this set of outfits provides
+	stats: OutfitStatSum,
+
+	//pub total_space: content::OutfitSpace,
+	available_space: content::OutfitSpace,
+	outfits: Vec<content::OutfitHandle>,
+	guns: Vec<ShipGun>,
+	enginepoints: Vec<content::EnginePoint>,
+	gunpoints: Vec<content::GunPoint>,
+}
+
+impl<'a> OutfitSet {
+	/// Make a new outfit array
+	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(),
+		}
+	}
+
+	/// Does this outfit set contain the specified outfit?
+	pub fn contains_outfit(&self, o: content::OutfitHandle) -> bool {
+		match self.outfits.iter().position(|x| *x == o) {
+			Some(_) => true,
+			None => false,
+		}
+	}
+
+	pub fn stat_sum(&self) -> &OutfitStatSum {
+		&self.stats
+	}
+
+	/// Add an outfit to this ship.
+	/// Returns true on success, and false on failure
+	/// TODO: failure reason enum
+	pub fn add(&mut self, ct: &content::Content, o: content::OutfitHandle) -> bool {
+		let outfit = ct.get_outfit(o);
+		if !self.available_space.can_contain(&outfit.space) {
+			return false;
+		}
+		self.available_space.occupy(&outfit.space);
+		self.stats.add(&outfit);
+		self.outfits.push(o);
+		return true;
+	}
+
+	/// Remove an outfit from this set
+	pub fn remove(&mut self, ct: &content::Content, o: content::OutfitHandle) {
+		let outfit = ct.get_outfit(o);
+		let i = match self.outfits.iter().position(|x| *x == o) {
+			Some(i) => i,
+			None => panic!("removed non-existing outfit"),
+		};
+		self.available_space.free(&outfit.space);
+		self.outfits.remove(i);
+	}
+
+	/// 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, ct: &content::Content, g: content::GunHandle) -> 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;
+		}
+		let gun = ct.get_gun(g);
+
+		// All points are taken
+		if p.is_none() {
+			return false;
+		}
+
+		let sg = ShipGun::new(gun, p.unwrap());
+		self.guns.push(sg);
+		return true;
+	}
+
+	/// Iterate over all guns in this outfitset
+	pub fn iter_guns(&mut self) -> impl Iterator<Item = &mut ShipGun> {
+		self.guns.iter_mut()
+	}
+
+	/// Iterate over all guns and the gunpoints they're attached to
+	pub fn iter_guns_points(&mut self) -> impl Iterator<Item = (&mut ShipGun, &content::GunPoint)> {
+		self.guns
+			.iter_mut()
+			.map(|x| (&self.gunpoints[x.point], x))
+			.map(|(a, b)| (b, a))
+	}
+
+	// TODO: move to ship
+	/// Iterate over all ships in this physics system
+	pub fn iter_enginepoints(&self) -> impl Iterator<Item = &EnginePoint> + '_ {
+		self.enginepoints.iter()
+	}
+
+	pub fn get_flare_sprite(&self) -> Option<SpriteHandle> {
+		self.stats.engine_flare_sprites.iter().next().map(|x| *x)
+	}
+}

crates/gameobject/src/ship.rs

@@ -0,0 +1,112 @@
+use rand::Rng;
+use std::time::Instant;
+
+use crate::{OutfitSet, Projectile};
+use galactica_content as content;
+
+#[derive(Debug)]
+pub struct Ship {
+	pub handle: content::ShipHandle,
+	pub faction: content::FactionHandle,
+	pub outfits: OutfitSet,
+	pub last_hit: Instant,
+
+	// TODO: unified ship stats struct, like space
+	// TODO: unified outfit stats struct: check
+	pub hull: f32,
+	pub shields: f32,
+}
+
+impl Ship {
+	pub fn new(
+		ct: &content::Content,
+		handle: content::ShipHandle,
+		faction: content::FactionHandle,
+		outfits: OutfitSet,
+	) -> Self {
+		let s = ct.get_ship(handle);
+		let shields = outfits.stat_sum().shield_strength;
+		Ship {
+			handle: handle,
+			faction,
+			outfits,
+			hull: s.hull,
+			shields,
+			last_hit: Instant::now(),
+		}
+	}
+
+	pub fn is_dead(&self) -> bool {
+		self.hull <= 0.0
+	}
+
+	/// Called whenever a projectile hits this ship.
+	/// Returns true if that projectile should be destroyed and false otherwise.
+	pub fn handle_projectile_collision(&mut self, ct: &content::Content, p: &Projectile) -> bool {
+		let f = ct.get_faction(self.faction);
+		let r = f.relationships.get(&p.faction).unwrap();
+		match r {
+			content::Relationship::Hostile => {
+				let mut d = p.content.damage;
+				if self.is_dead() {
+					return true;
+				}
+				if self.shields >= d {
+					self.shields -= d
+				} else {
+					d -= self.shields;
+					self.shields = 0.0;
+					self.hull -= d;
+				}
+				self.last_hit = Instant::now();
+
+				return true;
+			}
+			_ => return false,
+		}
+	}
+
+	pub fn fire_guns(&mut self) -> Vec<(Projectile, content::GunPoint)> {
+		if self.is_dead() {
+			return vec![];
+		}
+
+		self.outfits
+			.iter_guns_points()
+			.filter(|(g, _)| g.cooldown <= 0.0)
+			.map(|(g, p)| {
+				let mut rng = rand::thread_rng();
+				g.cooldown = g.kind.rate + &rng.gen_range(-g.kind.rate_rng..=g.kind.rate_rng);
+
+				let lifetime = g.kind.projectile.lifetime
+					+ rng.gen_range(
+						-g.kind.projectile.lifetime_rng..=g.kind.projectile.lifetime_rng,
+					);
+
+				(
+					Projectile {
+						content: g.kind.projectile.clone(),
+						lifetime: 0f32.max(lifetime),
+						faction: self.faction,
+					},
+					p.clone(),
+				)
+			})
+			.collect()
+	}
+
+	pub fn step(&mut self, t: f32) {
+		let time_since = self.last_hit.elapsed().as_secs_f32();
+		if self.shields != self.outfits.stat_sum().shield_strength {
+			for (_, d, g) in &self.outfits.stat_sum().shield_generators {
+				if time_since >= *d {
+					self.shields += g * t;
+					if self.shields > self.outfits.stat_sum().shield_strength {
+						self.shields = self.outfits.stat_sum().shield_strength;
+						break;
+					}
+				}
+			}
+		}
+	}
+}

crates/gameobject/src/ship/mod.rs

@@ -1,7 +0,0 @@
-mod outfitset;
-mod personality;
-mod ship;
-
-pub use outfitset::*;
-pub use personality::*;
-pub use ship::*;

crates/gameobject/src/ship/outfitset.rs

@@ -1,187 +0,0 @@
-use std::collections::HashMap;
-
-use content::{GunPoint, OutfitHandle, OutfitSpace};
-use galactica_content as content;
-
-/// Possible outcomes when adding an outfit
-pub enum OutfitAddResult {
-	/// An outfit was successfully added
-	Ok,
-
-	/// An outfit could not be added because we don't have enough free space.
-	/// The string tells us what kind of space we need:
-	/// `outfit,` `weapon,` `engine,` etc. Note that these sometimes overlap:
-	/// outfits may need outfit AND weapon space. In these cases, this result
-	/// should name the "most specific" kind of space we lack.
-	NotEnoughSpace(String),
-}
-
-/// Possible outcomes when removing an outfit
-pub enum OutfitRemoveResult {
-	/// This outfit was successfully removed
-	Ok,
-
-	/// This outfit isn't in this set
-	NotExist,
-	// TODO:
-	// This is where we'll add non-removable outfits,
-	// outfits that provide space, etc
-}
-
-/// A simple data class, used to keep track of delayed shield generators
-#[derive(Debug)]
-pub(crate) struct ShieldGenerator {
-	pub outfit: OutfitHandle,
-	pub delay: f32,
-	pub generation: f32,
-}
-
-/// This struct keeps track of a ship's outfit loadout.
-#[derive(Debug)]
-pub struct OutfitSet {
-	/// What outfits does this statsum contain?
-	outfits: HashMap<OutfitHandle, u32>,
-
-	/// Space available in this outfitset.
-	/// set at creation and never changes.
-	total_space: OutfitSpace,
-
-	/// Space used by the outfits in this set.
-	/// This may be negative if certain outfits provide space!
-	used_space: OutfitSpace,
-
-	/// The gun points available in this ship.
-	/// If value is None, this point is free.
-	/// if value is Some, this point is taken.
-	gun_points: HashMap<GunPoint, Option<OutfitHandle>>,
-
-	// Outfit values
-	// This isn't strictly necessary, but we don't want to
-	// re-compute this on each frame.
-	engine_thrust: f32,
-	steer_power: f32,
-	shield_strength: f32,
-
-	// Delay, generation
-	// TODO: struct
-	shield_generators: Vec<ShieldGenerator>,
-}
-
-impl OutfitSet {
-	pub fn new(available_space: OutfitSpace, gun_points: &[GunPoint]) -> Self {
-		Self {
-			outfits: HashMap::new(),
-			total_space: available_space,
-			used_space: OutfitSpace::new(),
-			gun_points: gun_points.iter().map(|x| (x.clone(), None)).collect(),
-
-			engine_thrust: 0.0,
-			steer_power: 0.0,
-			shield_strength: 0.0,
-			shield_generators: Vec::new(),
-		}
-	}
-
-	pub fn add(&mut self, o: &content::Outfit) -> OutfitAddResult {
-		if !(self.total_space - self.used_space).can_contain(&o.space) {
-			return OutfitAddResult::NotEnoughSpace("TODO".to_string());
-		}
-
-		self.used_space += o.space;
-
-		self.engine_thrust += o.engine_thrust;
-		self.steer_power += o.steer_power;
-		self.shield_strength += o.shield_strength;
-		self.shield_generators.push(ShieldGenerator {
-			outfit: o.handle,
-			delay: o.shield_delay,
-			generation: o.shield_generation,
-		});
-
-		return OutfitAddResult::Ok;
-	}
-
-	pub fn remove(&mut self, o: &content::Outfit) -> OutfitRemoveResult {
-		if !self.outfits.contains_key(&o.handle) {
-			return OutfitRemoveResult::NotExist;
-		} else {
-			let n = *self.outfits.get(&o.handle).unwrap();
-			if n == 1u32 {
-				self.outfits.remove(&o.handle);
-			} else {
-				*self.outfits.get_mut(&o.handle).unwrap() -= 1;
-			}
-		}
-
-		self.used_space -= o.space;
-
-		self.engine_thrust -= o.engine_thrust;
-		self.steer_power -= o.steer_power;
-		self.shield_strength -= o.shield_strength;
-
-		{
-			// This index will exist, since we checked the hashmap
-			let index = self
-				.shield_generators
-				.iter()
-				.position(|g| g.outfit == o.handle)
-				.unwrap();
-			self.shield_generators.remove(index);
-		}
-
-		return OutfitRemoveResult::Ok;
-	}
-}
-
-// Simple getters to make sure nobody meddles with our internal state
-impl OutfitSet {
-	/// The number of outfits in this set
-	pub fn len(&self) -> u32 {
-		self.outfits.iter().map(|(_, x)| x).sum()
-	}
-
-	/// Iterate over all outfits
-	pub fn iter_outfits(&self) -> impl Iterator<Item = (&OutfitHandle, &u32)> {
-		self.outfits.iter()
-	}
-
-	/// Iterate over all gun points
-	pub fn iter_gun_points(&self) -> impl Iterator<Item = (&GunPoint, &Option<OutfitHandle>)> {
-		self.gun_points.iter()
-	}
-
-	/// Iterate over all shield generators
-	pub(crate) fn iter_shield_generators(&self) -> impl Iterator<Item = &ShieldGenerator> {
-		self.shield_generators.iter()
-	}
-
-	/// Get maximum possible shield regen
-	pub fn get_max_shield_regen(&self) -> f32 {
-		self.shield_generators.iter().map(|x| x.generation).sum()
-	}
-
-	/// Total available outfit space
-	pub fn get_total_space(&self) -> &OutfitSpace {
-		&self.total_space
-	}
-
-	/// Used outfit space
-	pub fn get_used_space(&self) -> &OutfitSpace {
-		&self.used_space
-	}
-
-	/// Total foward thrust
-	pub fn get_engine_thrust(&self) -> f32 {
-		self.engine_thrust
-	}
-
-	/// Total steer power
-	pub fn get_steer_power(&self) -> f32 {
-		self.steer_power
-	}
-
-	/// Total shield strength
-	pub fn get_shield_strength(&self) -> f32 {
-		self.shield_strength
-	}
-}

crates/gameobject/src/ship/personality.rs

@@ -1,14 +0,0 @@
-/// Computer-controlled ship behavior variants.
-/// This is just a list, actual physics-aware
-/// behaviors are implemented in [`galactica-behavior`]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ShipPersonality {
-	/// This ship is controlled by a player
-	Player,
-
-	/// Does nothing
-	Dummy,
-
-	/// Points and shoots towards the nearest enemy
-	Point,
-}

crates/gameobject/src/ship/ship.rs

@@ -1,118 +0,0 @@
-use std::time::Instant;
-
-use super::{OutfitSet, ShipPersonality};
-use galactica_content as content;
-
-#[derive(Debug)]
-pub struct Ship {
-	// Metadata values
-	ct_handle: content::ShipHandle,
-	faction: content::FactionHandle,
-	outfits: OutfitSet,
-
-	personality: ShipPersonality,
-
-	// State values
-	// TODO: unified ship stats struct, like outfit space
-	hull: f32,
-	shields: f32,
-
-	// Utility values
-	/// The last time this ship was damaged
-	last_hit: Instant,
-}
-
-impl Ship {
-	pub(crate) fn new(
-		ct: &content::Content,
-		ct_handle: content::ShipHandle,
-		faction: content::FactionHandle,
-		personality: ShipPersonality,
-		outfits: OutfitSet,
-	) -> Self {
-		let s = ct.get_ship(ct_handle);
-		let shields = outfits.get_shield_strength();
-		Ship {
-			ct_handle,
-			faction,
-			outfits,
-			personality,
-			last_hit: Instant::now(),
-
-			// Initial stats
-			hull: s.hull,
-			shields,
-		}
-	}
-
-	/// If this ship is dead, it will be removed from the game.
-	pub fn is_dead(&self) -> bool {
-		self.hull <= 0.0
-	}
-
-	/// Hit this ship with the given amount of damage
-	pub fn apply_damage(&mut self, mut d: f32) {
-		if self.is_dead() {
-			return;
-		}
-		if self.shields >= d {
-			self.shields -= d
-		} else {
-			d -= self.shields;
-			self.shields = 0.0;
-			self.hull = 0f32.max(self.hull - d);
-		}
-		self.last_hit = Instant::now();
-	}
-
-	/// Update this ship's state by `t` seconds
-	pub fn step(&mut self, t: f32) {
-		let time_since = self.last_hit.elapsed().as_secs_f32();
-		if self.shields != self.outfits.get_shield_strength() {
-			for g in self.outfits.iter_shield_generators() {
-				if time_since >= g.delay {
-					self.shields += g.generation * t;
-					if self.shields > self.outfits.get_shield_strength() {
-						self.shields = self.outfits.get_shield_strength();
-						break;
-					}
-				}
-			}
-		}
-	}
-}
-
-// Misc getters, so internal state is untouchable
-impl Ship {
-	/// Get this ship's current hull.
-	/// Use content handle to get maximum hull
-	pub fn get_hull(&self) -> f32 {
-		return self.hull;
-	}
-
-	/// Get this ship's current shields.
-	/// Use get_outfits() for maximum shields
-	pub fn get_shields(&self) -> f32 {
-		self.shields
-	}
-
-	/// Get all outfits on this ship
-	pub fn get_outfits(&self) -> &OutfitSet {
-		&self.outfits
-	}
-
-	/// Get this ship's personality
-	pub fn get_personality(&self) -> ShipPersonality {
-		self.personality
-	}
-
-	/// Get this ship's faction
-	pub fn get_faction(&self) -> content::FactionHandle {
-		self.faction
-	}
-
-	/// Get this ship's content handle
-	pub fn get_ship(&self) -> content::ShipHandle {
-		self.ct_handle
-	}
-}

crates/gameobject/src/system.rs

@@ -1,8 +1,6 @@
-use cgmath::{Point3, Rad};
+use crate::SystemObject;
 use galactica_content as content;
 
-// TODO: rework
-
 pub struct System {
 	pub name: String,
 	pub bodies: Vec<SystemObject>,
@@ -27,11 +25,8 @@ impl System {
 
 		return s;
 	}
-}
 
-pub struct SystemObject {
+	//pub fn get_sprites(&self) -> Vec<ObjectSprite> {
-	pub sprite: content::SpriteHandle,
+	//	return self.bodies.iter().map(|x| x.get_sprite()).collect();
-	pub pos: Point3<f32>,
+	//}
-	pub size: f32,
-	pub angle: Rad<f32>,
 }

crates/gameobject/src/systemobject.rs

@@ -0,0 +1,10 @@
+use cgmath::{Point3, Rad};
+
+use galactica_content as content;
+
+pub struct SystemObject {
+	pub sprite: content::SpriteHandle,
+	pub pos: Point3<f32>,
+	pub size: f32,
+	pub angle: Rad<f32>,
+}

crates/world/src/world.rs

@@ -388,4 +388,13 @@ impl<'a> World {
 	pub fn iter_projectiles(&'a self) -> impl Iterator<Item = &ProjectileWorldObject> + '_ {
 		self.projectiles.values()
 	}
+
+	/*
+	/// Iterate over all projectile sprites in this physics system
+	pub fn get_projectile_sprites(&self) -> impl Iterator<Item = ObjectSprite> + '_ {
+		self.projectiles
+			.values()
+			.map(|x| x.get_sprite(&self.wrapper.rigid_body_set[x.rigid_body]))
+	}
+	*/
 }