576 lines
20 KiB
Rust
576 lines
20 KiB
Rust
use bevy::prelude::*;
|
|
use bevy_xpbd_3d::prelude::*;
|
|
use crate::{nature, settings, actor, audio, hud};
|
|
|
|
pub const ENGINE_SPEED_FACTOR: f32 = 30.0;
|
|
const MIN_INTERACT_DISTANCE: f32 = 30.0;
|
|
const NO_RIDE: u32 = 0;
|
|
|
|
pub struct ActorPlugin;
|
|
impl Plugin for ActorPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.register_type::<ChatBranch>();
|
|
app.add_systems(FixedUpdate, (
|
|
update_physics_lifeforms,
|
|
));
|
|
app.add_systems(Update, (
|
|
handle_new_conversations,
|
|
handle_send_messages,
|
|
handle_conversations,
|
|
handle_input,
|
|
handle_chat_scripts,
|
|
handle_vehicle_enter_exit,
|
|
handle_collisions,
|
|
));
|
|
app.add_event::<StartConversationEvent>();
|
|
app.add_event::<SendMessageEvent>();
|
|
app.add_event::<ChatScriptEvent>();
|
|
app.add_event::<VehicleEnterExitEvent>();
|
|
}
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct StartConversationEvent {
|
|
pub talker: Talker,
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct SendMessageEvent {
|
|
pub conv_id: String,
|
|
pub conv_label: String,
|
|
pub text: String,
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct ChatScriptEvent {
|
|
name: String,
|
|
param: String,
|
|
param2: String,
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct VehicleEnterExitEvent {
|
|
vehicle: Entity,
|
|
driver: Entity,
|
|
is_entering: bool,
|
|
is_player: bool
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Actor {
|
|
pub id: String,
|
|
pub hp: f32,
|
|
pub m: f32, // mass
|
|
pub v: Vec3, // velocity
|
|
pub angular_momentum: Quat,
|
|
pub inside_entity: u32,
|
|
pub camdistance: f32,
|
|
}
|
|
|
|
impl Default for Actor {
|
|
fn default() -> Self {
|
|
Self {
|
|
id: "".to_string(),
|
|
hp: 100.0,
|
|
m: 100.0,
|
|
v: Vec3::ZERO,
|
|
inside_entity: NO_RIDE,
|
|
angular_momentum: Quat::from_euler(EulerRot::XYZ, 0.001, 0.01, 0.003),
|
|
camdistance: 15.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component)] pub struct Player; // Attached to the suit of the player
|
|
#[derive(Component)] pub struct PlayerDrivesThis; // Attached to the entered vehicle
|
|
#[derive(Component)] pub struct PlayerCamera; // Attached to the actor to use as point of view
|
|
#[derive(Component)] pub struct PlayerInConversation;
|
|
#[derive(Component)] pub struct InConversationWithPlayer;
|
|
#[derive(Component)] pub struct ActorEnteringVehicle;
|
|
#[derive(Component)] pub struct ActorVehicleBeingEntered;
|
|
|
|
#[derive(Debug)]
|
|
#[derive(Component, Reflect, Default)]
|
|
#[reflect(Component)]
|
|
pub struct ChatBranch {
|
|
pub id: String,
|
|
pub name: String,
|
|
pub label: String,
|
|
pub delay: f64,
|
|
pub sound: String,
|
|
pub level: String,
|
|
pub reply: String,
|
|
pub goto: String,
|
|
pub choice: String,
|
|
pub script: String,
|
|
pub script_parameter: String,
|
|
pub script_parameter2: String,
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Chat {
|
|
pub id: String,
|
|
pub label: String,
|
|
pub timer: f64,
|
|
}
|
|
|
|
#[derive(Component)]
|
|
#[derive(Clone)]
|
|
pub struct Talker {
|
|
pub pronoun: String,
|
|
pub conv_id: String,
|
|
}
|
|
impl Default for Talker { fn default() -> Self { Self {
|
|
pronoun: "they/them".to_string(),
|
|
conv_id: "error".to_string(),
|
|
}}}
|
|
|
|
#[derive(Component)]
|
|
pub struct LifeForm {
|
|
pub is_alive: bool,
|
|
pub adrenaline: f32,
|
|
pub adrenaline_baseline: f32,
|
|
pub adrenaline_jolt: f32,
|
|
}
|
|
impl Default for LifeForm { fn default() -> Self { Self {
|
|
is_alive: true,
|
|
adrenaline: 0.3,
|
|
adrenaline_baseline: 0.3,
|
|
adrenaline_jolt: 0.0,
|
|
}}}
|
|
|
|
#[derive(Component)]
|
|
pub struct Vehicle;
|
|
|
|
#[derive(Copy, Clone, PartialEq)]
|
|
pub enum EngineType {
|
|
Monopropellant,
|
|
Rocket,
|
|
Ion,
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Engine {
|
|
pub thrust_forward: f32,
|
|
pub thrust_back: f32,
|
|
pub thrust_sideways: f32,
|
|
pub reaction_wheels: f32,
|
|
pub engine_type: EngineType,
|
|
pub warmup_seconds: f32,
|
|
pub current_warmup: f32,
|
|
}
|
|
impl Default for Engine {
|
|
fn default() -> Self {
|
|
Self {
|
|
thrust_forward: 1.0,
|
|
thrust_back: 1.0,
|
|
thrust_sideways: 1.0,
|
|
reaction_wheels: 1.0,
|
|
engine_type: EngineType::Monopropellant,
|
|
warmup_seconds: 1.5,
|
|
current_warmup: 0.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component)]
|
|
pub struct Suit {
|
|
pub oxygen: f32,
|
|
pub power: f32,
|
|
pub oxygen_max: f32,
|
|
pub power_max: f32,
|
|
pub integrity: f32, // [0.0 - 1.0]
|
|
}
|
|
impl Default for Suit { fn default() -> Self { SUIT_SIMPLE } }
|
|
|
|
const SUIT_SIMPLE: Suit = Suit {
|
|
power: 1e5,
|
|
power_max: 1e5,
|
|
oxygen: nature::OXY_D,
|
|
oxygen_max: nature::OXY_D,
|
|
integrity: 1e5,
|
|
};
|
|
|
|
pub fn update_physics_lifeforms(
|
|
time: Res<Time>,
|
|
mut query: Query<(&mut LifeForm, &mut Suit, &Actor)>,
|
|
) {
|
|
let d = time.delta_seconds();
|
|
for (mut lifeform, mut suit, actor) in query.iter_mut() {
|
|
if lifeform.adrenaline_jolt.abs() > 1e-3 {
|
|
lifeform.adrenaline_jolt *= 0.99;
|
|
}
|
|
else {
|
|
lifeform.adrenaline_jolt = 0.0
|
|
}
|
|
let speed = actor.v.length();
|
|
if speed > 1000.0 {
|
|
lifeform.adrenaline += 0.001;
|
|
}
|
|
lifeform.adrenaline = (lifeform.adrenaline - 0.0001 + lifeform.adrenaline_jolt * 0.01).clamp(0.0, 1.0);
|
|
|
|
let mut oxygen_drain = nature::OXY_S;
|
|
let integr_threshold = 0.5;
|
|
if suit.integrity < integr_threshold {
|
|
// The oxygen drain from suit integrity scales with (2 - 2x)^4,
|
|
// which is a function with ~16 at x=0 and 0 at x=1.
|
|
// Furthermore, x is divided by the integrity threshold (e.g. 0.5)
|
|
// to squeeze the function horizontally, and change the range for
|
|
// the x parameter from [0-1] to [0-integritythreshold]
|
|
//
|
|
// 16 |.
|
|
// |.
|
|
// |'.
|
|
// | '.
|
|
// | '..
|
|
// |______''....
|
|
// x=0 x=1
|
|
let drain_scaling = (2.0 - 2.0 * suit.integrity / integr_threshold).powf(4.0);
|
|
oxygen_drain += suit.oxygen * 0.01 * drain_scaling;
|
|
}
|
|
suit.oxygen = (suit.oxygen - oxygen_drain*d).clamp(0.0, suit.oxygen_max);
|
|
}
|
|
}
|
|
|
|
pub fn handle_input(
|
|
mut commands: Commands,
|
|
keyboard_input: Res<ButtonInput<KeyCode>>,
|
|
settings: ResMut<settings::Settings>,
|
|
q_talker: Query<(&Talker, &Transform), Without<actor::Player>>,
|
|
mut player: Query<(Entity, &mut Actor, &mut Transform), With<actor::Player>>,
|
|
mut q_vehicles: Query<(Entity, &mut Visibility, &Transform), (With<actor::Vehicle>, Without<actor::Player>)>,
|
|
mut ew_conv: EventWriter<StartConversationEvent>,
|
|
mut ew_vehicle: EventWriter<VehicleEnterExitEvent>,
|
|
q_player_drives: Query<Entity, With<PlayerDrivesThis>>,
|
|
) {
|
|
let mindist = MIN_INTERACT_DISTANCE * MIN_INTERACT_DISTANCE;
|
|
if keyboard_input.just_pressed(settings.key_interact) {
|
|
if let Ok((_player_entity, _player_actor, player)) = player.get_single() {
|
|
for (talker, transform) in &q_talker {
|
|
if transform.translation.distance_squared(player.translation) <= mindist {
|
|
ew_conv.send(StartConversationEvent{talker: talker.clone()});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if keyboard_input.just_pressed(settings.key_vehicle) {
|
|
// Entering Vehicles
|
|
if q_player_drives.is_empty() {
|
|
if let Ok((player_entity, _player_actor, player)) = player.get_single_mut() {
|
|
for (vehicle_entity, _visibility, vehicle_transform) in q_vehicles.iter_mut() {
|
|
if vehicle_transform.translation.distance_squared(player.translation) <= mindist {
|
|
commands.entity(vehicle_entity).insert(ActorVehicleBeingEntered);
|
|
commands.entity(player_entity).insert(ActorEnteringVehicle);
|
|
ew_vehicle.send(VehicleEnterExitEvent{
|
|
vehicle: vehicle_entity,
|
|
driver: player_entity,
|
|
is_entering: q_player_drives.is_empty(),
|
|
is_player: true,
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Exiting Vehicles
|
|
else {
|
|
if let Ok((player_entity, _player_actor, _player)) = player.get_single_mut() {
|
|
for vehicle_entity in &q_player_drives {
|
|
commands.entity(vehicle_entity).insert(ActorVehicleBeingEntered);
|
|
commands.entity(player_entity).insert(ActorEnteringVehicle);
|
|
ew_vehicle.send(VehicleEnterExitEvent{
|
|
vehicle: vehicle_entity,
|
|
driver: player_entity,
|
|
is_entering: false,
|
|
is_player: true,
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle_vehicle_enter_exit(
|
|
mut commands: Commands,
|
|
mut er_vehicle: EventReader<VehicleEnterExitEvent>,
|
|
mut q_drivers: Query<(Entity, &mut Actor, &mut Visibility, &mut Transform), (Without<ActorVehicleBeingEntered>, With<ActorEnteringVehicle>)>,
|
|
mut q_vehicles: Query<(Entity, &mut Actor, &mut Visibility, &mut Transform), (With<ActorVehicleBeingEntered>, Without<ActorEnteringVehicle>)>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
) {
|
|
for event in er_vehicle.read() {
|
|
for (driver, mut driver_actor, mut driver_vis, mut driver_trans) in q_drivers.iter_mut() {
|
|
if driver == event.driver {
|
|
for (vehicle, mut vehicle_actor, mut vehicle_vis, mut vehicle_trans) in q_vehicles.iter_mut() {
|
|
if vehicle == event.vehicle {
|
|
if event.is_entering {
|
|
// Entering Vehicle
|
|
*driver_vis = Visibility::Hidden;
|
|
if event.is_player {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::EnterVehicle));
|
|
//player_actor.inside_entity = entity.index();
|
|
*vehicle_vis = Visibility::Hidden;
|
|
driver_actor.v = vehicle_actor.v;
|
|
commands.entity(driver).remove::<PlayerCamera>();
|
|
commands.entity(vehicle).insert(PlayerCamera);
|
|
commands.entity(vehicle).insert(PlayerDrivesThis);
|
|
}
|
|
}
|
|
else {
|
|
// Exiting Vehicle
|
|
*driver_vis = Visibility::Inherited;
|
|
if event.is_player {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Switch));
|
|
*vehicle_vis = Visibility::Inherited;
|
|
vehicle_actor.v = driver_actor.v;
|
|
vehicle_actor.angular_momentum = driver_actor.angular_momentum;
|
|
*vehicle_trans = driver_trans.clone();
|
|
commands.entity(vehicle).remove::<PlayerCamera>();
|
|
commands.entity(driver).insert(PlayerCamera);
|
|
commands.entity(vehicle).remove::<PlayerDrivesThis>();
|
|
}
|
|
else {
|
|
*driver_trans = vehicle_trans.clone();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle_new_conversations(
|
|
mut commands: Commands,
|
|
mut er_conv: EventReader<StartConversationEvent>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
q_conv: Query<&Chat>,
|
|
time: Res<Time>,
|
|
) {
|
|
let label = "INIT";
|
|
for event in er_conv.read() {
|
|
// check for existing chats with this id
|
|
let id = &event.talker.conv_id;
|
|
let chats: Vec<&Chat> = q_conv.iter().filter(|c| c.id == *id).collect();
|
|
if chats.len() > 0 {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Ping));
|
|
continue;
|
|
}
|
|
|
|
// no existing chats yet, let's create a new one
|
|
commands.spawn(Chat {
|
|
id: id.to_string(),
|
|
label: label.to_string(),
|
|
timer: time.elapsed_seconds_f64(),
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
pub fn handle_send_messages(
|
|
mut commands: Commands,
|
|
mut er_sendmsg: EventReader<SendMessageEvent>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
mut ew_chatscript: EventWriter<ChatScriptEvent>,
|
|
mut q_conv: Query<(Entity, &mut Chat)>,
|
|
time: Res<Time>,
|
|
chat_branches: Query<&ChatBranch>,
|
|
mut log: ResMut<hud::Log>,
|
|
) {
|
|
let now = time.elapsed_seconds_f64();
|
|
|
|
for event in er_sendmsg.read() {
|
|
for (entity, mut chat) in &mut q_conv {
|
|
if chat.id != event.conv_id {
|
|
continue;
|
|
}
|
|
if event.conv_label == "EXIT" {
|
|
info!("Despawning chat.");
|
|
commands.entity(entity).despawn();
|
|
continue;
|
|
}
|
|
|
|
let branches: Vec<&ChatBranch> = chat_branches.iter()
|
|
.filter(|branch| branch.id == event.conv_id
|
|
&& branch.label == event.conv_label
|
|
&& branch.choice == event.text)
|
|
.collect();
|
|
if branches.len() != 1 {
|
|
error!("Expected 1 branch with ID '{}' and label '{}', but got {}! Aborting conversation.", chat.id, chat.label, branches.len());
|
|
continue;
|
|
}
|
|
let branch = branches[0];
|
|
// TODO despawn the choices
|
|
|
|
if !branch.reply.is_empty() {
|
|
match branch.level.as_str() {
|
|
"chat" => log.chat(branch.reply.clone(), branch.name.clone()),
|
|
"info" => log.info(branch.reply.clone()),
|
|
"warn" => log.warning(branch.reply.clone()),
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
chat.label = branch.goto.clone();
|
|
chat.timer = now + branch.delay;
|
|
if branch.sound != "" {
|
|
let sfx = audio::str2sfx(branch.sound.as_str());
|
|
ew_sfx.send(audio::PlaySfxEvent(sfx));
|
|
}
|
|
let choices: Vec<&ChatBranch> = chat_branches.iter()
|
|
.filter(|branch| branch.id == chat.id && branch.label == chat.label)
|
|
.collect();
|
|
for choice in choices {
|
|
if choice.choice.as_str() != hud::CHOICE_NONE {
|
|
commands.spawn(hud::ChoiceAvailable {
|
|
conv_id: choice.id.clone(),
|
|
conv_label: choice.label.clone(),
|
|
recipient: choice.name.clone(),
|
|
text: choice.choice.clone(),
|
|
});
|
|
}
|
|
}
|
|
if !branch.script.is_empty() {
|
|
ew_chatscript.send(ChatScriptEvent {
|
|
name: branch.script.clone(),
|
|
param: branch.script_parameter.clone(),
|
|
param2: branch.script_parameter2.clone(),
|
|
});
|
|
}
|
|
}
|
|
break; // let's only handle one of these per frame
|
|
}
|
|
}
|
|
|
|
pub fn handle_conversations(
|
|
mut commands: Commands,
|
|
mut log: ResMut<hud::Log>,
|
|
mut q_conv: Query<(Entity, &mut Chat)>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
mut ew_chatscript: EventWriter<ChatScriptEvent>,
|
|
time: Res<Time>,
|
|
chat_branches: Query<&ChatBranch>, // TODO: use Table for faster iteration?
|
|
) {
|
|
let now = time.elapsed_seconds_f64();
|
|
for (entity, mut chat) in &mut q_conv {
|
|
if chat.label == "EXIT" {
|
|
info!("Despawning chat.");
|
|
commands.entity(entity).despawn();
|
|
continue;
|
|
}
|
|
if now < chat.timer {
|
|
continue;
|
|
}
|
|
|
|
let branches: Vec<&ChatBranch> = chat_branches.iter()
|
|
.filter(|branch| branch.id == chat.id
|
|
&& branch.label == chat.label
|
|
&& branch.choice == "")
|
|
.collect();
|
|
if branches.len() != 1 {
|
|
error!("Expected 1 branch with ID '{}' and label '{}', but got {}! Aborting conversation.", chat.id, chat.label, branches.len());
|
|
continue;
|
|
}
|
|
let branch = branches[0];
|
|
|
|
if !branch.reply.is_empty() {
|
|
match branch.level.as_str() {
|
|
"chat" => log.chat(branch.reply.clone(), branch.name.clone()),
|
|
"info" => log.info(branch.reply.clone()),
|
|
"warn" => log.warning(branch.reply.clone()),
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
if chat.label == "EXIT" {
|
|
// TODO: isn't this dead code?
|
|
continue;
|
|
}
|
|
chat.label = branch.goto.clone();
|
|
if branch.sound != "" {
|
|
let sfx = audio::str2sfx(branch.sound.as_str());
|
|
ew_sfx.send(audio::PlaySfxEvent(sfx));
|
|
}
|
|
chat.timer = now + branch.delay;
|
|
|
|
let choices: Vec<&ChatBranch> = chat_branches.iter()
|
|
.filter(|branch| branch.id == chat.id && branch.label == chat.label)
|
|
.collect();
|
|
for choice in choices {
|
|
if choice.choice.as_str() != hud::CHOICE_NONE {
|
|
commands.spawn(hud::ChoiceAvailable {
|
|
conv_id: choice.id.clone(),
|
|
conv_label: choice.label.clone(),
|
|
recipient: choice.name.clone(),
|
|
text: choice.choice.clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
if !branch.script.is_empty() {
|
|
ew_chatscript.send(ChatScriptEvent {
|
|
name: branch.script.clone(),
|
|
param: branch.script_parameter.clone(),
|
|
param2: branch.script_parameter2.clone(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle_chat_scripts(
|
|
mut er_chatscript: EventReader<ChatScriptEvent>,
|
|
mut q_actor: Query<(&mut Actor, &mut Suit), Without<Player>>,
|
|
mut q_player: Query<(&mut Actor, &mut Suit), With<Player>>,
|
|
) {
|
|
for script in er_chatscript.read() {
|
|
match script.name.as_str() {
|
|
"refilloxygen" => if let Ok(mut amount) = script.param.parse::<f32>() {
|
|
for (mut _actor, mut suit) in q_player.iter_mut() {
|
|
if script.param2.is_empty() {
|
|
suit.oxygen = (suit.oxygen + amount).clamp(0.0, suit.oxygen_max);
|
|
}
|
|
else {
|
|
let mut found_other = false;
|
|
info!("param2={}", script.param2);
|
|
for (other_actor, mut other_suit) in q_actor.iter_mut() {
|
|
if !other_actor.id.is_empty() {
|
|
info!("ID={}", other_actor.id);
|
|
}
|
|
if other_actor.id == script.param2 {
|
|
found_other = true;
|
|
amount = amount
|
|
.clamp(0.0, other_suit.oxygen)
|
|
.clamp(0.0, suit.oxygen_max - suit.oxygen);
|
|
other_suit.oxygen = other_suit.oxygen - amount;
|
|
suit.oxygen = (suit.oxygen + amount).clamp(0.0, suit.oxygen_max);
|
|
break;
|
|
}
|
|
}
|
|
if !found_other {
|
|
error!("Script error: could not find actor with ID `{}`", script.param2);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
error!("Invalid parameter for command `{}`: `{}`", script.name, script.param);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_collisions(
|
|
mut collision_event_reader: EventReader<Collision>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
q_player: Query<Entity, With<Player>>,
|
|
) {
|
|
if let Ok(player) = q_player.get_single() {
|
|
for Collision(contacts) in collision_event_reader.read() {
|
|
if contacts.entity1 == player || contacts.entity2 == player {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Crash));
|
|
}
|
|
}
|
|
}
|
|
}
|