2024-01-09 17:23:54 -08:00
|
|
|
use std::{collections::HashMap, time::Instant};
|
2024-01-08 22:38:36 -08:00
|
|
|
|
2024-01-08 23:05:07 -08:00
|
|
|
use super::{OutfitSet, ShipPersonality};
|
2024-01-09 21:45:30 -08:00
|
|
|
use galactica_content::{Content, FactionHandle, GunPoint, Outfit, ShipHandle};
|
2024-01-09 17:23:54 -08:00
|
|
|
use rand::{rngs::ThreadRng, Rng};
|
2024-01-08 22:38:36 -08:00
|
|
|
|
2024-01-11 22:10:36 -08:00
|
|
|
/// Ship state machine.
|
|
|
|
/// Any ship we keep track of is in one of these states.
|
|
|
|
/// Dead ships don't exist---they removed once their collapse
|
|
|
|
/// sequence fully plays out.
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
pub enum ShipState {
|
|
|
|
/// This ship is alive and well in open space
|
|
|
|
Flying, // TODO: system, position (also in collapse)?
|
|
|
|
|
|
|
|
/// This ship has been destroyed, and is playing its collapse sequence.
|
2024-01-11 22:28:02 -08:00
|
|
|
Collapsing {
|
|
|
|
/// Total collapse sequence length, in seconds
|
|
|
|
total: f32,
|
|
|
|
|
|
|
|
/// How many seconds of the collapse sequence we've played
|
|
|
|
elapsed: f32,
|
|
|
|
},
|
2024-01-11 22:10:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ShipState {
|
|
|
|
/// True if this ship has been destroyed and has finished it's collapse sequence.
|
|
|
|
/// Ships are deleted once this is true.
|
|
|
|
pub fn should_be_removed(&self) -> bool {
|
|
|
|
match self {
|
|
|
|
Self::Collapsing { elapsed, total } => elapsed >= total,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Is this ship playing its collapse sequence?
|
|
|
|
pub fn is_collapsing(&self) -> bool {
|
|
|
|
match self {
|
|
|
|
Self::Collapsing { .. } => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// If this ship is collapsing, return total collapse time and remaining collapse time.
|
|
|
|
/// Otherwise, return None
|
|
|
|
pub fn collapse_state(&self) -> Option<(f32, f32)> {
|
|
|
|
match self {
|
|
|
|
Self::Collapsing {
|
|
|
|
total,
|
|
|
|
elapsed: remaining,
|
|
|
|
} => Some((*total, *remaining)),
|
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Is this ship flying in open space?
|
|
|
|
pub fn is_flying(&self) -> bool {
|
|
|
|
match self {
|
|
|
|
Self::Flying => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-11 22:28:02 -08:00
|
|
|
/// Represents all attributes of a single ship
|
2024-01-11 11:28:11 -08:00
|
|
|
#[derive(Debug, Clone)]
|
2024-01-11 22:28:02 -08:00
|
|
|
pub struct ShipData {
|
2024-01-08 22:38:36 -08:00
|
|
|
// Metadata values
|
2024-01-09 21:45:30 -08:00
|
|
|
ct_handle: ShipHandle,
|
|
|
|
faction: FactionHandle,
|
2024-01-08 23:05:07 -08:00
|
|
|
outfits: OutfitSet,
|
|
|
|
|
|
|
|
personality: ShipPersonality,
|
2024-01-08 22:38:36 -08:00
|
|
|
|
2024-01-11 22:10:36 -08:00
|
|
|
/// Ship state machine. Keeps track of all possible ship state.
|
|
|
|
/// TODO: document this, draw a graph
|
|
|
|
state: ShipState,
|
|
|
|
|
2024-01-08 22:38:36 -08:00
|
|
|
// State values
|
2024-01-08 23:05:07 -08:00
|
|
|
// TODO: unified ship stats struct, like outfit space
|
|
|
|
hull: f32,
|
|
|
|
shields: f32,
|
2024-01-09 17:23:54 -08:00
|
|
|
gun_cooldowns: HashMap<GunPoint, f32>,
|
|
|
|
rng: ThreadRng,
|
2024-01-08 22:38:36 -08:00
|
|
|
|
|
|
|
// Utility values
|
|
|
|
/// The last time this ship was damaged
|
2024-01-08 23:05:07 -08:00
|
|
|
last_hit: Instant,
|
2024-01-08 22:38:36 -08:00
|
|
|
}
|
|
|
|
|
2024-01-11 22:28:02 -08:00
|
|
|
impl ShipData {
|
|
|
|
/// Create a new ShipData
|
|
|
|
pub(crate) fn new(
|
2024-01-09 21:45:30 -08:00
|
|
|
ct: &Content,
|
|
|
|
ct_handle: ShipHandle,
|
|
|
|
faction: FactionHandle,
|
2024-01-08 23:05:07 -08:00
|
|
|
personality: ShipPersonality,
|
2024-01-08 22:38:36 -08:00
|
|
|
) -> Self {
|
|
|
|
let s = ct.get_ship(ct_handle);
|
2024-01-11 22:28:02 -08:00
|
|
|
ShipData {
|
2024-01-08 22:38:36 -08:00
|
|
|
ct_handle,
|
|
|
|
faction,
|
2024-01-09 17:23:54 -08:00
|
|
|
outfits: OutfitSet::new(s.space, &s.guns),
|
2024-01-08 23:05:07 -08:00
|
|
|
personality,
|
2024-01-08 22:38:36 -08:00
|
|
|
last_hit: Instant::now(),
|
2024-01-09 17:23:54 -08:00
|
|
|
rng: rand::thread_rng(),
|
2024-01-08 22:38:36 -08:00
|
|
|
|
2024-01-11 22:10:36 -08:00
|
|
|
// TODO: ships must always start landed on planets
|
|
|
|
state: ShipState::Flying,
|
|
|
|
|
2024-01-08 22:38:36 -08:00
|
|
|
// Initial stats
|
|
|
|
hull: s.hull,
|
2024-01-09 17:23:54 -08:00
|
|
|
shields: 0.0,
|
|
|
|
gun_cooldowns: s.guns.iter().map(|x| (x.clone(), 0.0)).collect(),
|
2024-01-08 22:38:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-09 17:23:54 -08:00
|
|
|
/// Add an outfit to this ship
|
2024-01-09 21:45:30 -08:00
|
|
|
pub fn add_outfit(&mut self, o: &Outfit) -> super::OutfitAddResult {
|
2024-01-09 20:51:28 -08:00
|
|
|
let r = self.outfits.add(o);
|
|
|
|
self.shields = self.outfits.get_shield_strength();
|
|
|
|
return r;
|
2024-01-09 17:23:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Remove an outfit from this ship
|
2024-01-09 21:45:30 -08:00
|
|
|
pub fn remove_outfit(&mut self, o: &Outfit) -> super::OutfitRemoveResult {
|
2024-01-09 17:23:54 -08:00
|
|
|
self.outfits.remove(o)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Try to fire a gun.
|
|
|
|
/// Will panic if `which` isn't a point on this ship.
|
|
|
|
/// Returns `true` if this gun was fired,
|
|
|
|
/// and `false` if it is on cooldown or empty.
|
2024-01-11 22:28:02 -08:00
|
|
|
pub(crate) fn fire_gun(&mut self, ct: &Content, which: &GunPoint) -> bool {
|
2024-01-09 17:23:54 -08:00
|
|
|
let c = self.gun_cooldowns.get_mut(which).unwrap();
|
|
|
|
|
|
|
|
if *c > 0.0 {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
let g = self.outfits.get_gun(which);
|
|
|
|
if g.is_some() {
|
|
|
|
let g = ct.get_outfit(g.unwrap());
|
|
|
|
let gun = g.gun.as_ref().unwrap();
|
|
|
|
*c = 0f32.max(gun.rate + self.rng.gen_range(-gun.rate_rng..=gun.rate_rng));
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-08 22:38:36 -08:00
|
|
|
/// Hit this ship with the given amount of damage
|
2024-01-11 22:28:02 -08:00
|
|
|
pub(crate) fn apply_damage(&mut self, ct: &Content, mut d: f32) {
|
2024-01-11 22:10:36 -08:00
|
|
|
if self.state.is_collapsing() {
|
2024-01-08 22:38:36 -08:00
|
|
|
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();
|
2024-01-11 22:10:36 -08:00
|
|
|
|
|
|
|
if self.hull <= 0.0 {
|
|
|
|
// This ship has been destroyed, update state
|
|
|
|
self.state = ShipState::Collapsing {
|
|
|
|
total: ct.get_ship(self.ct_handle).collapse.length,
|
|
|
|
elapsed: 0.0,
|
|
|
|
}
|
|
|
|
}
|
2024-01-08 22:38:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Update this ship's state by `t` seconds
|
2024-01-11 22:28:02 -08:00
|
|
|
pub(crate) fn step(&mut self, t: f32) {
|
2024-01-11 22:10:36 -08:00
|
|
|
match self.state {
|
|
|
|
ShipState::Collapsing {
|
|
|
|
ref mut elapsed, ..
|
|
|
|
} => {
|
|
|
|
*elapsed += t;
|
2024-01-09 17:23:54 -08:00
|
|
|
}
|
|
|
|
|
2024-01-11 22:10:36 -08:00
|
|
|
ShipState::Flying => {
|
|
|
|
// Cooldown guns
|
|
|
|
for (_, c) in &mut self.gun_cooldowns {
|
|
|
|
if *c > 0.0 {
|
|
|
|
*c -= t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Regenerate shields
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2024-01-08 22:38:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-01-08 23:05:07 -08:00
|
|
|
|
|
|
|
// Misc getters, so internal state is untouchable
|
2024-01-11 22:28:02 -08:00
|
|
|
impl ShipData {
|
2024-01-11 22:10:36 -08:00
|
|
|
/// Get this ship's state
|
|
|
|
pub fn get_state(&self) -> &ShipState {
|
|
|
|
&self.state
|
2024-01-09 11:34:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get a handle to this ship's content
|
2024-01-09 21:45:30 -08:00
|
|
|
pub fn get_content(&self) -> ShipHandle {
|
2024-01-09 11:34:54 -08:00
|
|
|
self.ct_handle
|
|
|
|
}
|
|
|
|
|
2024-01-08 23:05:07 -08:00
|
|
|
/// Get this ship's current hull.
|
|
|
|
/// Use content handle to get maximum hull
|
|
|
|
pub fn get_hull(&self) -> f32 {
|
2024-01-09 11:34:54 -08:00
|
|
|
self.hull
|
2024-01-08 23:05:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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
|
2024-01-09 21:45:30 -08:00
|
|
|
pub fn get_faction(&self) -> FactionHandle {
|
2024-01-08 23:05:07 -08:00
|
|
|
self.faction
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get this ship's content handle
|
2024-01-09 21:45:30 -08:00
|
|
|
pub fn get_ship(&self) -> ShipHandle {
|
2024-01-08 23:05:07 -08:00
|
|
|
self.ct_handle
|
|
|
|
}
|
|
|
|
}
|