814 lines
29 KiB
Rust
814 lines
29 KiB
Rust
// ▄████████▄ + ███ + ▄█████████ ███ +
|
|
// ███▀ ▀███ + + ███ ███▀ + ███ + +
|
|
// ███ + ███ ███ ███ █████████ ███ ███ ███ ███
|
|
// ███ +███ ███ ███ ███ ███▐██████ ███ ███ ███
|
|
// ███ + ███ ███+ ███ +███ ███ + ███ ███ + ███
|
|
// ███▄ ▄███ ███▄ ███ ███ + ███ + ███ ███▄ ███
|
|
// ▀████████▀ + ▀███████ ███▄ ███▄ ▀████ ▀███████
|
|
// + + + ███
|
|
// + ▀████████████████████████████████████████████████████▀
|
|
//
|
|
// This module handles player input, and coordinates interplay between other modules
|
|
|
|
use crate::prelude::*;
|
|
use actor::PlayerCamera;
|
|
use bevy::color::palettes::css;
|
|
use bevy::prelude::*;
|
|
use bevy::scene::SceneInstance;
|
|
use bevy::window::{PrimaryWindow, Window, WindowMode};
|
|
use bevy_xpbd_3d::prelude::*;
|
|
use fastrand;
|
|
use std::collections::HashMap;
|
|
|
|
pub const CHEAT_WARP_1: &str = "pizzeria";
|
|
pub const CHEAT_WARP_2: &str = "busstopclippy2";
|
|
pub const CHEAT_WARP_3: &str = "busstopclippy3";
|
|
pub const RACE_TARGET_RADIUS: f64 = 5.0;
|
|
pub const RACE_SCORE_ACHIEVEMENT: u64 = 25;
|
|
|
|
pub struct GamePlugin;
|
|
impl Plugin for GamePlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(Startup, setup);
|
|
app.add_systems(
|
|
Update,
|
|
handle_cheats.run_if(game_running).run_if(in_control),
|
|
);
|
|
app.add_systems(Update, debug.run_if(game_running));
|
|
app.add_systems(PostUpdate, handle_game_event);
|
|
app.add_systems(Update, handle_window_focus);
|
|
app.add_systems(PreUpdate, handle_player_death);
|
|
app.add_systems(
|
|
PostUpdate,
|
|
update_id2pos
|
|
.run_if(game_running)
|
|
.in_set(bevy_xpbd_3d::plugins::sync::SyncSet::PositionToTransform),
|
|
);
|
|
app.add_systems(PostUpdate, update_id2v);
|
|
app.add_systems(
|
|
Update,
|
|
handle_achievement_event
|
|
.run_if(game_running)
|
|
.run_if(on_event::<AchievementEvent>()),
|
|
);
|
|
app.add_systems(Update, check_achievements.run_if(game_running));
|
|
app.add_systems(Update, handle_race.run_if(alive).run_if(game_running));
|
|
app.insert_resource(Id2Pos(HashMap::new()));
|
|
app.insert_resource(Id2V(HashMap::new()));
|
|
app.insert_resource(JupiterPos(DVec3::ZERO));
|
|
app.insert_resource(var::AchievementTracker::default());
|
|
app.insert_resource(var::Settings::default());
|
|
app.insert_resource(var::GameVars::default());
|
|
app.insert_resource(RaceState::default());
|
|
app.insert_resource(AchievementCheckTimer(Timer::from_seconds(
|
|
1.0,
|
|
TimerMode::Repeating,
|
|
)));
|
|
app.add_event::<PlayerDiesEvent>();
|
|
app.add_event::<GameEvent>();
|
|
app.add_event::<AchievementEvent>();
|
|
}
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct PlayerDiesEvent(pub actor::DamageType);
|
|
#[derive(Resource)]
|
|
pub struct Id2Pos(pub HashMap<String, DVec3>);
|
|
#[derive(Resource)]
|
|
pub struct Id2V(pub HashMap<String, DVec3>);
|
|
#[derive(Resource)]
|
|
pub struct JupiterPos(pub DVec3);
|
|
#[derive(Resource)]
|
|
pub struct AchievementCheckTimer(pub Timer);
|
|
#[derive(Resource, Default)]
|
|
pub struct RaceState {
|
|
pub initialized: bool,
|
|
pub started: bool,
|
|
pub start_countdown: f64,
|
|
pub timeout: f64,
|
|
pub score: f64,
|
|
}
|
|
#[derive(Component)]
|
|
pub struct RaceTarget;
|
|
|
|
#[derive(Event)]
|
|
pub enum AchievementEvent {
|
|
RepairSuit,
|
|
TalkTo(String),
|
|
RideVehicle(String),
|
|
DrinkPizza,
|
|
InJupitersShadow,
|
|
FindEarth,
|
|
RaceScore,
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub enum GameEvent {
|
|
SetAR(Turn),
|
|
SetMusic(Cycle),
|
|
SetSound(Cycle),
|
|
SetMap(Turn),
|
|
SetFullscreen(Turn),
|
|
SetMenu(Turn),
|
|
SetThirdPerson(Turn),
|
|
SetRotationStabilizer(Turn),
|
|
SetShadows(Turn),
|
|
UpdateFlashlight,
|
|
Achievement(String),
|
|
PhoneCall,
|
|
}
|
|
|
|
pub enum Turn {
|
|
On,
|
|
Off,
|
|
Toggle,
|
|
Unchanged,
|
|
}
|
|
|
|
impl Turn {
|
|
pub fn to_bool(&self, current_state: bool) -> bool {
|
|
match self {
|
|
Turn::On => true,
|
|
Turn::Off => false,
|
|
Turn::Toggle => !current_state,
|
|
Turn::Unchanged => current_state,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum Cycle {
|
|
First,
|
|
Last,
|
|
Next,
|
|
Previous,
|
|
Unchanged,
|
|
}
|
|
|
|
impl Cycle {
|
|
pub fn to_index<T>(&self, current_index: usize, vector: &Vec<T>) -> Option<usize> {
|
|
if vector.is_empty() {
|
|
return None;
|
|
}
|
|
match self {
|
|
Cycle::First => Some(0),
|
|
Cycle::Last => Some(vector.len() - 1),
|
|
Cycle::Next => {
|
|
let index = current_index.saturating_add(1);
|
|
if index >= vector.len() {
|
|
Some(0)
|
|
} else {
|
|
Some(index)
|
|
}
|
|
}
|
|
Cycle::Previous => {
|
|
if current_index == 0 {
|
|
Some(vector.len() - 1)
|
|
} else {
|
|
Some(current_index - 1)
|
|
}
|
|
}
|
|
Cycle::Unchanged => Some(current_index),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn setup(
|
|
mut commands: Commands,
|
|
mut settings: ResMut<Settings>,
|
|
prefs: ResMut<var::Preferences>,
|
|
asset_server: Res<AssetServer>,
|
|
) {
|
|
settings.hud_active = prefs.augmented_reality;
|
|
settings.radio_mode = prefs.radio_station;
|
|
settings.set_noise_cancellation_mode(prefs.noise_cancellation_mode);
|
|
settings.third_person = prefs.third_person;
|
|
settings.shadows_sun = prefs.shadows_sun;
|
|
settings.ar_avatar = prefs.avatar;
|
|
|
|
// Setup Race
|
|
let mut entitycmd = commands.spawn((
|
|
RaceTarget,
|
|
actor::OrbitsJupiter,
|
|
bevy::pbr::NotShadowCaster,
|
|
bevy::pbr::NotShadowReceiver,
|
|
Position::default(),
|
|
actor::WantsToLookAt(cmd::ID_SPECIAL_PLAYERCAM.to_string()),
|
|
LinearVelocity::default(),
|
|
SpatialBundle {
|
|
transform: Transform::from_scale(Vec3::splat(RACE_TARGET_RADIUS as f32)),
|
|
visibility: Visibility::Hidden,
|
|
..default()
|
|
},
|
|
));
|
|
load_asset("marker_race", &mut entitycmd, &*asset_server);
|
|
}
|
|
|
|
pub fn handle_game_event(
|
|
mut settings: ResMut<Settings>,
|
|
mut er_game: EventReader<GameEvent>,
|
|
mut ew_conv: EventWriter<chat::StartConversationEvent>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
mut ew_updateoverlays: EventWriter<hud::UpdateOverlayVisibility>,
|
|
mut ew_updatemenu: EventWriter<menu::UpdateMenuEvent>,
|
|
mut ew_togglemusic: EventWriter<audio::ToggleMusicEvent>,
|
|
mut q_window: Query<&mut Window, With<PrimaryWindow>>,
|
|
mut q_light: Query<&mut DirectionalLight>,
|
|
mut q_flashlight: Query<(&mut Visibility, &mut SpotLight), With<actor::PlayersFlashLight>>,
|
|
mut mapcam: ResMut<camera::MapCam>,
|
|
mut log: ResMut<hud::Log>,
|
|
opt: Res<var::CommandLineOptions>,
|
|
mut prefs: ResMut<var::Preferences>,
|
|
) {
|
|
for event in er_game.read() {
|
|
match event {
|
|
GameEvent::SetAR(turn) => {
|
|
settings.hud_active = turn.to_bool(settings.hud_active);
|
|
ew_togglemusic.send(audio::ToggleMusicEvent());
|
|
ew_updateoverlays.send(hud::UpdateOverlayVisibility);
|
|
prefs.augmented_reality = settings.hud_active;
|
|
prefs.save();
|
|
}
|
|
GameEvent::SetMusic(cycle) => {
|
|
match cycle.to_index(settings.radio_mode, &settings.radio_modes) {
|
|
Some(mode) => {
|
|
settings.radio_mode = mode;
|
|
}
|
|
None => {}
|
|
}
|
|
ew_togglemusic.send(audio::ToggleMusicEvent());
|
|
prefs.radio_station = settings.radio_mode;
|
|
prefs.save();
|
|
}
|
|
GameEvent::SetSound(cycle) => {
|
|
match cycle.to_index(
|
|
settings.noise_cancellation_mode,
|
|
&settings.noise_cancellation_modes,
|
|
) {
|
|
Some(mode) => {
|
|
settings.set_noise_cancellation_mode(mode);
|
|
}
|
|
None => {}
|
|
}
|
|
ew_togglemusic.send(audio::ToggleMusicEvent());
|
|
prefs.noise_cancellation_mode = settings.noise_cancellation_mode;
|
|
prefs.save();
|
|
}
|
|
GameEvent::SetMap(turn) => {
|
|
settings.map_active = turn.to_bool(settings.map_active);
|
|
if settings.map_active {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Woosh));
|
|
}
|
|
*mapcam = camera::MapCam::default();
|
|
ew_updateoverlays.send(hud::UpdateOverlayVisibility);
|
|
}
|
|
GameEvent::SetFullscreen(turn) => {
|
|
for mut window in &mut q_window {
|
|
let current_state = window.mode != WindowMode::Windowed;
|
|
prefs.fullscreen_on = turn.to_bool(current_state);
|
|
window.mode = match prefs.fullscreen_on {
|
|
true => opt.window_mode_fullscreen,
|
|
false => WindowMode::Windowed,
|
|
};
|
|
prefs.save();
|
|
}
|
|
}
|
|
GameEvent::SetMenu(turn) => {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Click));
|
|
settings.menu_active = turn.to_bool(settings.menu_active);
|
|
for mut window in &mut q_window {
|
|
window.cursor.grab_mode = if settings.menu_active {
|
|
bevy::window::CursorGrabMode::None
|
|
} else {
|
|
bevy::window::CursorGrabMode::Locked
|
|
};
|
|
window.cursor.visible = settings.menu_active;
|
|
}
|
|
ew_updatemenu.send(menu::UpdateMenuEvent);
|
|
}
|
|
GameEvent::SetThirdPerson(turn) => {
|
|
settings.third_person = turn.to_bool(settings.third_person);
|
|
prefs.third_person = settings.third_person;
|
|
prefs.save();
|
|
}
|
|
GameEvent::SetRotationStabilizer(turn) => {
|
|
settings.rotation_stabilizer_active =
|
|
turn.to_bool(settings.rotation_stabilizer_active);
|
|
}
|
|
GameEvent::SetShadows(turn) => {
|
|
settings.shadows_sun = turn.to_bool(settings.shadows_sun);
|
|
for mut light in &mut q_light {
|
|
light.shadows_enabled = settings.shadows_sun;
|
|
}
|
|
prefs.shadows_sun = settings.shadows_sun;
|
|
prefs.save();
|
|
}
|
|
GameEvent::Achievement(name) => {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Achieve));
|
|
log.add(
|
|
format!("Achievement accomplished: {name}!"),
|
|
"".to_string(),
|
|
hud::LogLevel::Achievement,
|
|
);
|
|
}
|
|
GameEvent::UpdateFlashlight => {
|
|
for (mut visibility, mut spotlight) in &mut q_flashlight {
|
|
spotlight.intensity = actor::FLASHLIGHT_INTENSITY[prefs.flashlight_power];
|
|
*visibility = bool2vis(settings.flashlight_active);
|
|
}
|
|
}
|
|
GameEvent::PhoneCall => {
|
|
let talker = chat::Talker {
|
|
chat_name: "phone".to_string(),
|
|
actor_id: "".to_string(),
|
|
name: Some("Phone".to_string()),
|
|
counts_towards_achievement: false,
|
|
pronoun: None,
|
|
talking_speed: 0.0,
|
|
};
|
|
ew_conv.send(chat::StartConversationEvent { talker: talker });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_player_death(
|
|
mut cmd: Commands,
|
|
mut er_playerdies: EventReader<PlayerDiesEvent>,
|
|
q_scenes: Query<(Entity, &SceneInstance), With<world::DespawnOnPlayerDeath>>,
|
|
q_noscenes: Query<Entity, (With<world::DespawnOnPlayerDeath>, Without<SceneInstance>)>,
|
|
mut scene_spawner: ResMut<SceneSpawner>,
|
|
mut active_asteroids: ResMut<world::ActiveAsteroids>,
|
|
mut ew_effect: EventWriter<visual::SpawnEffectEvent>,
|
|
mut ew_deathscreen: EventWriter<menu::DeathScreenEvent>,
|
|
mut log: ResMut<hud::Log>,
|
|
mut gamevars: ResMut<var::GameVars>,
|
|
mut settings: ResMut<Settings>,
|
|
) {
|
|
for death in er_playerdies.read() {
|
|
if settings.god_mode {
|
|
return;
|
|
}
|
|
settings.reset_player_settings();
|
|
gamevars.reset();
|
|
active_asteroids.0.clear();
|
|
for entity in &q_noscenes {
|
|
cmd.entity(entity).despawn();
|
|
}
|
|
for (entity, sceneinstance) in &q_scenes {
|
|
cmd.entity(entity).despawn();
|
|
scene_spawner.despawn_instance(**sceneinstance);
|
|
}
|
|
log.clear();
|
|
|
|
match death.0 {
|
|
actor::DamageType::Depressurization => {
|
|
settings.death_cause = "Depressurization".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(Color::BLACK),
|
|
duration: 4.0,
|
|
});
|
|
}
|
|
actor::DamageType::Mental => {
|
|
settings.death_cause = "Brain Damage".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(Color::BLACK),
|
|
duration: 4.0,
|
|
});
|
|
}
|
|
actor::DamageType::Asphyxiation => {
|
|
settings.death_cause = "Suffocation".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(Color::BLACK),
|
|
duration: 1.0,
|
|
});
|
|
}
|
|
actor::DamageType::Trauma => {
|
|
settings.death_cause = "Trauma".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(css::MAROON.into()),
|
|
duration: 1.0,
|
|
});
|
|
}
|
|
actor::DamageType::GForce => {
|
|
settings.death_cause = "Trauma from excessive g forces".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(css::MAROON.into()),
|
|
duration: 1.0,
|
|
});
|
|
}
|
|
actor::DamageType::Radiation => {
|
|
settings.death_cause = "Acute radiation poisoning".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(Color::BLACK),
|
|
duration: 4.0,
|
|
});
|
|
}
|
|
actor::DamageType::Unknown => {
|
|
settings.death_cause = "Unknown".to_string();
|
|
ew_effect.send(visual::SpawnEffectEvent {
|
|
class: visual::Effects::FadeIn(css::MAROON.into()),
|
|
duration: 1.0,
|
|
});
|
|
}
|
|
}
|
|
|
|
ew_deathscreen.send(menu::DeathScreenEvent::Show);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn handle_cheats(
|
|
key_input: Res<ButtonInput<KeyCode>>,
|
|
mut q_player: Query<
|
|
(&Transform, &mut Position, &mut LinearVelocity),
|
|
With<actor::PlayerCamera>,
|
|
>,
|
|
mut q_life: Query<(&mut actor::LifeForm, &mut actor::ExperiencesGForce), With<actor::Player>>,
|
|
q_target: Query<
|
|
(&Transform, &Position, Option<&LinearVelocity>),
|
|
(With<hud::IsTargeted>, Without<actor::PlayerCamera>),
|
|
>,
|
|
mut ew_playerdies: EventWriter<PlayerDiesEvent>,
|
|
mut settings: ResMut<Settings>,
|
|
jupiter_pos: Res<JupiterPos>,
|
|
id2pos: Res<Id2Pos>,
|
|
id2v: Res<Id2V>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
) {
|
|
if q_player.is_empty() || q_life.is_empty() {
|
|
return;
|
|
}
|
|
let (trans, mut pos, mut v) = q_player.get_single_mut().unwrap();
|
|
let (mut lifeform, mut gforce) = q_life.get_single_mut().unwrap();
|
|
let boost = if key_input.pressed(KeyCode::ShiftLeft) {
|
|
1e6
|
|
} else {
|
|
1e3
|
|
};
|
|
if key_input.just_pressed(settings.key_cheat_god_mode) {
|
|
settings.god_mode ^= true;
|
|
if settings.god_mode {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Honk));
|
|
} else {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Switch));
|
|
}
|
|
}
|
|
if !settings.god_mode && !settings.dev_mode {
|
|
return;
|
|
}
|
|
|
|
if key_input.just_pressed(settings.key_cheat_stop) {
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
v.0 = nature::orbital_velocity(pos.0 - jupiter_pos.0, nature::JUPITER_MASS);
|
|
}
|
|
if key_input.pressed(settings.key_cheat_speed)
|
|
|| key_input.pressed(settings.key_cheat_speed_backward)
|
|
{
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
let sign = if key_input.pressed(settings.key_cheat_speed) {
|
|
1.0
|
|
} else {
|
|
-1.0
|
|
};
|
|
let dv = DVec3::from(trans.rotation * Vec3::new(0.0, 0.0, sign * boost));
|
|
let current_speed = v.0.length();
|
|
let next_speed = (v.0 + dv).length();
|
|
let avg_speed = (current_speed + next_speed) / 2.0;
|
|
let inv_lorentz = nature::inverse_lorentz_factor(avg_speed.clamp(0.0, nature::C));
|
|
v.0 = v.0 + inv_lorentz * dv;
|
|
}
|
|
if key_input.just_pressed(settings.key_cheat_teleport) {
|
|
if let Ok((transform, target_pos, target_v)) = q_target.get_single() {
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
let offset: DVec3 =
|
|
4.0 * (**pos - **target_pos).normalize() * transform.scale.as_dvec3();
|
|
pos.0 = **target_pos + offset;
|
|
if let Some(target_v) = target_v {
|
|
*v = target_v.clone();
|
|
}
|
|
}
|
|
}
|
|
|
|
if !settings.dev_mode {
|
|
return;
|
|
}
|
|
|
|
if key_input.just_pressed(settings.key_cheat_pizza) {
|
|
if let Some(target) = id2pos.0.get(&CHEAT_WARP_1.to_string()) {
|
|
pos.0 = *target + DVec3::new(-60.0, 0.0, 0.0);
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
}
|
|
if let Some(target) = id2v.0.get(&CHEAT_WARP_1.to_string()) {
|
|
v.0 = *target;
|
|
}
|
|
}
|
|
if key_input.just_pressed(settings.key_cheat_farview1) {
|
|
if let Some(target) = id2pos.0.get(&CHEAT_WARP_2.to_string()) {
|
|
pos.0 = *target + DVec3::new(0.0, -1000.0, 0.0);
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
}
|
|
if let Some(target) = id2v.0.get(&CHEAT_WARP_2.to_string()) {
|
|
v.0 = *target;
|
|
}
|
|
}
|
|
if key_input.just_pressed(settings.key_cheat_farview2) {
|
|
if let Some(target) = id2pos.0.get(&CHEAT_WARP_3.to_string()) {
|
|
pos.0 = *target + DVec3::new(0.0, -1000.0, 0.0);
|
|
gforce.ignore_gforce_seconds = 1.0;
|
|
}
|
|
if let Some(target) = id2v.0.get(&CHEAT_WARP_3.to_string()) {
|
|
v.0 = *target;
|
|
}
|
|
}
|
|
if key_input.pressed(settings.key_cheat_adrenaline_zero) {
|
|
lifeform.adrenaline = 0.0;
|
|
}
|
|
if key_input.pressed(settings.key_cheat_adrenaline_mid) {
|
|
lifeform.adrenaline = 0.5;
|
|
}
|
|
if key_input.pressed(settings.key_cheat_adrenaline_max) {
|
|
lifeform.adrenaline = 1.0;
|
|
}
|
|
if key_input.just_pressed(settings.key_cheat_die) {
|
|
settings.god_mode = false;
|
|
ew_playerdies.send(PlayerDiesEvent(actor::DamageType::Trauma));
|
|
}
|
|
}
|
|
|
|
fn update_id2pos(
|
|
mut id2pos: ResMut<Id2Pos>,
|
|
mut jupiterpos: ResMut<JupiterPos>,
|
|
q_id: Query<(&Position, &actor::Identifier)>,
|
|
) {
|
|
id2pos.0.clear();
|
|
for (pos, id) in &q_id {
|
|
id2pos.0.insert(id.0.clone(), pos.0);
|
|
if id.0 == cmd::ID_JUPITER {
|
|
jupiterpos.0 = pos.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_id2v(mut id2v: ResMut<Id2V>, q_id: Query<(&LinearVelocity, &actor::Identifier)>) {
|
|
id2v.0.clear();
|
|
for (v, id) in &q_id {
|
|
id2v.0.insert(id.0.clone(), v.0);
|
|
}
|
|
}
|
|
|
|
fn debug(
|
|
settings: Res<var::Settings>,
|
|
keyboard_input: Res<ButtonInput<KeyCode>>,
|
|
// mut commands: Commands,
|
|
// mut extended_materials: ResMut<
|
|
// Assets<bevy::pbr::ExtendedMaterial<StandardMaterial, load::AsteroidSurface>>,
|
|
// >,
|
|
mut achievement_tracker: ResMut<var::AchievementTracker>,
|
|
vars: Res<var::GameVars>,
|
|
// materials: Query<(Entity, Option<&Name>, &Handle<Mesh>)>,
|
|
) {
|
|
if settings.dev_mode && keyboard_input.just_pressed(KeyCode::KeyP) {
|
|
|
|
// for (entity, _name, mesh) in &materials {
|
|
// dbg!(mesh);
|
|
// let mut entity = commands.entity(entity);
|
|
// entity.remove::<Handle<StandardMaterial>>();
|
|
// let material = extended_materials.add(load::AsteroidSurface::material());
|
|
// entity.insert(material);
|
|
// }
|
|
}
|
|
if settings.dev_mode && keyboard_input.just_pressed(KeyCode::KeyN) {
|
|
achievement_tracker.achieve_all();
|
|
dbg!(&vars);
|
|
}
|
|
}
|
|
|
|
fn handle_achievement_event(
|
|
mut er_achievement: EventReader<AchievementEvent>,
|
|
mut ew_game: EventWriter<GameEvent>,
|
|
mut tracker: ResMut<var::AchievementTracker>,
|
|
) {
|
|
for event in er_achievement.read() {
|
|
match event {
|
|
AchievementEvent::RepairSuit => {
|
|
if !tracker.repair_suit {
|
|
ew_game.send(GameEvent::Achievement("Repair Your Suit".into()));
|
|
}
|
|
tracker.repair_suit = true;
|
|
}
|
|
AchievementEvent::InJupitersShadow => {
|
|
if !tracker.in_jupiters_shadow {
|
|
ew_game.send(GameEvent::Achievement("Enter Jupiter's Shadow".into()));
|
|
}
|
|
tracker.in_jupiters_shadow = true;
|
|
}
|
|
AchievementEvent::DrinkPizza => {
|
|
if !tracker.drink_a_pizza {
|
|
ew_game.send(GameEvent::Achievement("Enjoy A Pizza".into()));
|
|
}
|
|
tracker.drink_a_pizza = true;
|
|
}
|
|
AchievementEvent::FindEarth => {
|
|
if !tracker.find_earth {
|
|
ew_game.send(GameEvent::Achievement("Find Earth".into()));
|
|
}
|
|
tracker.find_earth = true;
|
|
}
|
|
AchievementEvent::RaceScore => {
|
|
if !tracker.race_score {
|
|
ew_game.send(GameEvent::Achievement(format!("Score {} Points In Time Trial", RACE_SCORE_ACHIEVEMENT)));
|
|
}
|
|
tracker.race_score = true;
|
|
}
|
|
AchievementEvent::RideVehicle(name) => {
|
|
tracker.vehicles_ridden.insert(name.clone());
|
|
let len = tracker.vehicles_ridden.len();
|
|
let total = tracker.all_vehicles.len();
|
|
if !tracker.ride_every_vehicle && len == total {
|
|
tracker.ride_every_vehicle = true;
|
|
ew_game.send(GameEvent::Achievement("Ride Every Vehicle".into()));
|
|
}
|
|
}
|
|
AchievementEvent::TalkTo(name) => {
|
|
tracker.people_talked_to.insert(name.clone());
|
|
let len = tracker.people_talked_to.len();
|
|
let total = tracker.all_people.len();
|
|
if !tracker.talk_to_everyone && len == total {
|
|
tracker.talk_to_everyone = true;
|
|
ew_game.send(GameEvent::Achievement("Talk To Everyone".into()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn check_achievements(
|
|
time: Res<Time>,
|
|
q_player: Query<&Position, With<actor::PlayerCamera>>,
|
|
mut q_mirrorlight: Query<&mut Visibility, With<actor::MirrorLight>>,
|
|
id2pos: Res<Id2Pos>,
|
|
mut ew_achievement: EventWriter<AchievementEvent>,
|
|
mut timer: ResMut<AchievementCheckTimer>,
|
|
) {
|
|
if !timer.0.tick(time.delta()).just_finished() {
|
|
return;
|
|
}
|
|
let pos_player = if let Ok(pos) = q_player.get_single() {
|
|
pos
|
|
} else {
|
|
return;
|
|
};
|
|
let pos_sun = if let Some(pos) = id2pos.0.get(cmd::ID_SOL) {
|
|
pos
|
|
} else {
|
|
return;
|
|
};
|
|
let pos_jupiter = if let Some(pos) = id2pos.0.get(cmd::ID_JUPITER) {
|
|
pos
|
|
} else {
|
|
return;
|
|
};
|
|
|
|
let shadowed = in_shadow(
|
|
*pos_sun,
|
|
nature::SOL_RADIUS,
|
|
*pos_jupiter,
|
|
nature::JUPITER_RADIUS,
|
|
**pos_player,
|
|
);
|
|
|
|
if shadowed {
|
|
ew_achievement.send(AchievementEvent::InJupitersShadow);
|
|
for mut mirrorlight_vis in &mut q_mirrorlight {
|
|
*mirrorlight_vis = Visibility::Hidden;
|
|
}
|
|
} else {
|
|
// This is checking for whether the player is shadowed, not the mirror.
|
|
// But in the case where these two are not the same, the player doesn't see
|
|
// the mirror anyway and the mirror light's visibility state is irrelevant.
|
|
for mut mirrorlight_vis in &mut q_mirrorlight {
|
|
*mirrorlight_vis = Visibility::Inherited;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_window_focus(
|
|
mut local_paused: Local<bool>,
|
|
mut settings: ResMut<Settings>,
|
|
mut q_window: Query<&mut Window, With<PrimaryWindow>>,
|
|
mut er_focus: EventReader<bevy::window::WindowFocused>,
|
|
mut physicstime: ResMut<Time<Physics>>,
|
|
) {
|
|
for event in er_focus.read() {
|
|
settings.window_focused = event.focused;
|
|
}
|
|
|
|
let paused = !settings.is_game_running();
|
|
|
|
if paused != *local_paused {
|
|
if paused {
|
|
physicstime.pause();
|
|
} else {
|
|
physicstime.unpause();
|
|
}
|
|
|
|
for mut window in &mut q_window {
|
|
window.cursor.grab_mode = if paused {
|
|
bevy::window::CursorGrabMode::None
|
|
} else {
|
|
bevy::window::CursorGrabMode::Locked
|
|
};
|
|
window.cursor.visible = paused;
|
|
}
|
|
*local_paused = paused;
|
|
}
|
|
}
|
|
|
|
fn handle_race(
|
|
mut commands: Commands,
|
|
time: Res<Time>,
|
|
mut log: ResMut<hud::Log>,
|
|
mut settings: ResMut<Settings>,
|
|
mut race: ResMut<RaceState>,
|
|
mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
|
|
mut ew_achievement: EventWriter<game::AchievementEvent>,
|
|
q_player: Query<(&Position, &LinearVelocity, &Transform), With<PlayerCamera>>,
|
|
mut q_racetarget: Query<
|
|
(Entity, &mut Position, &mut LinearVelocity, &mut Visibility),
|
|
(With<RaceTarget>, Without<PlayerCamera>),
|
|
>,
|
|
) {
|
|
let mut deinitialize = false;
|
|
if !settings.race_active {
|
|
if race.initialized {
|
|
log.warning(format!("Stopped race! Final score: {}", race.score));
|
|
deinitialize = true;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
let (player_pos, player_v, player_trans) = if let Ok(val) = q_player.get_single() {
|
|
val
|
|
} else {
|
|
error!("No player found in handle_race!");
|
|
return;
|
|
};
|
|
let (target_entity, mut target_pos, mut target_v, mut target_vis) =
|
|
if let Ok(val) = q_racetarget.get_single_mut() {
|
|
val
|
|
} else {
|
|
error!("No race target entity found in handle_race!");
|
|
return;
|
|
};
|
|
|
|
if !deinitialize {
|
|
let mut spawn_target = false;
|
|
|
|
if !race.initialized {
|
|
log.warning("Time Trial Race START!".to_string());
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Honk));
|
|
race.score = 0.0;
|
|
race.initialized = true;
|
|
spawn_target = true;
|
|
}
|
|
|
|
if player_pos.distance(target_pos.0) < RACE_TARGET_RADIUS {
|
|
race.score += 1.0;
|
|
spawn_target = true;
|
|
}
|
|
|
|
if spawn_target {
|
|
race.timeout = time.elapsed_seconds_f64() + 5.0;
|
|
if race.score >= RACE_SCORE_ACHIEVEMENT as f64 {
|
|
ew_achievement.send(game::AchievementEvent::RaceScore);
|
|
}
|
|
let difficulty = 2.0 * race.score as f64;
|
|
let mut delta = DVec3::new(0.0, 0.0, 100.0);
|
|
delta = (player_trans.rotation * delta.as_vec3()).as_dvec3();
|
|
delta += DVec3::new(
|
|
(fastrand::f64() - 0.5) * difficulty,
|
|
(fastrand::f64() - 0.5) * difficulty,
|
|
(fastrand::f64() - 0.5) * difficulty,
|
|
);
|
|
*target_pos = Position(player_pos.0 + delta);
|
|
*target_v = *player_v;
|
|
*target_vis = Visibility::Inherited;
|
|
commands.entity(target_entity).insert(RigidBody::Kinematic);
|
|
}
|
|
|
|
if race.timeout <= time.elapsed_seconds_f64() {
|
|
log.warning(format!("GAME OVER! Final score: {}", race.score));
|
|
deinitialize = true;
|
|
}
|
|
}
|
|
|
|
if deinitialize {
|
|
ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::PowerDown));
|
|
race.initialized = false;
|
|
settings.race_active = false;
|
|
*target_vis = Visibility::Hidden;
|
|
commands.entity(target_entity).remove::<RigidBody>();
|
|
}
|
|
}
|