mirror of
https://github.com/vladtrc/iw4L
synced 2026-10-27 18:52:15 -04:00
vtroc7
831 lines
30 KiB
Rust
831 lines
30 KiB
Rust
use bevy::prelude::*;
|
|
use net::{
|
|
ClientActionInbox, LocalPresentClient, LookState, PresentedSnapshot, look_angles_from_degrees,
|
|
};
|
|
use sim::{ClientAction, ClientLifecycle, MatchPhase, SpawnPick};
|
|
use ui::UiLayer;
|
|
|
|
use crate::feature_dispatch::DebugPosOverlay;
|
|
use crate::{
|
|
ConsoleCommand, ConsoleDispatch, ConsoleLine, ConsoleRegistry, ConsoleSettings, ConsoleState,
|
|
plugin::WaitMovePose,
|
|
};
|
|
|
|
#[derive(Component)]
|
|
pub(crate) struct ShowposHud;
|
|
|
|
pub(crate) fn spawn_showpos_hud(commands: &mut Commands, font: Handle<Font>) {
|
|
commands.spawn((
|
|
ShowposHud,
|
|
UiLayer::Overlay,
|
|
Visibility::Hidden,
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
left: px(12),
|
|
top: px(12),
|
|
padding: UiRect::all(px(6)),
|
|
..default()
|
|
},
|
|
BackgroundColor(Color::srgba(0.02, 0.03, 0.04, 0.72)),
|
|
GlobalZIndex(19_000),
|
|
Text::new(""),
|
|
TextFont {
|
|
font: font.into(),
|
|
font_size: FontSize::Px(14.0),
|
|
..default()
|
|
},
|
|
TextColor(Color::srgb(0.95, 0.85, 0.40)),
|
|
));
|
|
}
|
|
|
|
pub(crate) fn register_debug_move_commands(registry: &mut ConsoleRegistry) {
|
|
if registry.resolve("showpos").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("showpos")
|
|
.alias("debug_pos")
|
|
.usage("showpos [on|off] — origin overlay (bare also prints once)"),
|
|
);
|
|
}
|
|
if registry.resolve("move").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("move")
|
|
.alias("tp")
|
|
.usage("move <x> <y> <z> [yaw] [pitch] — write player origin (needs cheats)"),
|
|
);
|
|
}
|
|
if registry.resolve("god").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("god").usage("god — toggle invincibility (needs cheats)"),
|
|
);
|
|
}
|
|
if registry.resolve("kill").is_none() {
|
|
registry
|
|
.register(crate::CommandSpec::new("kill").usage(
|
|
"kill — ForceDeath the local player (needs cheats; invented, not COMMANDS)",
|
|
));
|
|
}
|
|
if registry.resolve("force_spawn").is_none() {
|
|
registry.register(crate::CommandSpec::new("force_spawn").usage(
|
|
"force_spawn [random <seed> | at <x> <y> <z> [yaw]] — respawn from any state through spawn resolution (needs cheats)",
|
|
));
|
|
}
|
|
if registry.resolve("damage").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("damage").usage(
|
|
"damage [amount] — subtract Alive health (default 40; needs cheats; invented)",
|
|
),
|
|
);
|
|
}
|
|
if registry.resolve("look").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("look")
|
|
.usage("look <yaw> <pitch> — write LookState + authority angles (needs cheats)"),
|
|
);
|
|
}
|
|
if registry.resolve("name").is_none() {
|
|
registry.register(
|
|
crate::CommandSpec::new("name")
|
|
.usage("name [string] — write clientState.name[16] for the local client"),
|
|
);
|
|
}
|
|
if registry.resolve("nudge").is_none() {
|
|
registry.register(crate::CommandSpec::new("nudge").usage(
|
|
"nudge <dx> <dy> <dz> — authority-only origin shift, no teleport bit (needs cheats)",
|
|
));
|
|
}
|
|
if registry.resolve("force_match_start").is_none() {
|
|
registry.register(crate::CommandSpec::new("force_match_start").usage(
|
|
"force_match_start — skip waitForPlayers and matchStartTimer (needs cheats; invented)",
|
|
));
|
|
}
|
|
}
|
|
|
|
pub(crate) fn route_debug_move_commands(
|
|
mut events: MessageReader<ConsoleCommand>,
|
|
mut console: ResMut<ConsoleState>,
|
|
settings: Res<ConsoleSettings>,
|
|
mut line: ResMut<ConsoleLine>,
|
|
mut debug_pos: ResMut<DebugPosOverlay>,
|
|
presented: Res<PresentedSnapshot>,
|
|
local: Res<LocalPresentClient>,
|
|
mut authority: Option<ResMut<net::AuthorityWorld>>,
|
|
mut inbox: Option<ResMut<ClientActionInbox>>,
|
|
mut seq: ResMut<net::ActionRequestIds>,
|
|
mut look: ResMut<LookState>,
|
|
mut dispatch: ResMut<ConsoleDispatch>,
|
|
) {
|
|
let capacity = settings.log_capacity;
|
|
let echo = |msg: String, console: &mut ConsoleState, line: &mut ConsoleLine| {
|
|
diag::info!(Console, "{msg}");
|
|
line.0 = msg.clone();
|
|
console.echo(msg, capacity);
|
|
};
|
|
|
|
for cmd in events.read() {
|
|
match cmd.name.as_str() {
|
|
"showpos" | "debug_pos" => match cmd.args.first().map(String::as_str) {
|
|
None => {
|
|
debug_pos.0 = true;
|
|
echo(format_showpos(&presented, local.0), &mut console, &mut line);
|
|
}
|
|
Some("on") | Some("1") => {
|
|
debug_pos.0 = true;
|
|
echo("showpos on".into(), &mut console, &mut line);
|
|
}
|
|
Some("off") | Some("0") => {
|
|
debug_pos.0 = false;
|
|
echo("showpos off".into(), &mut console, &mut line);
|
|
}
|
|
Some(other) => echo(
|
|
format!("usage: showpos [on|off] (got `{other}`)"),
|
|
&mut console,
|
|
&mut line,
|
|
),
|
|
},
|
|
"move" | "tp" => match parse_move(&cmd.args, &presented, local.0) {
|
|
Err(msg) => echo(msg, &mut console, &mut line),
|
|
Ok((origin, angles)) => {
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"move: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("move: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"move: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(
|
|
local.0,
|
|
ClientAction::Move {
|
|
request_id,
|
|
origin,
|
|
angles,
|
|
},
|
|
) {
|
|
echo(format!("move: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
|
|
look.angles = look_angles_from_degrees(angles);
|
|
arm_wait_move(
|
|
&mut dispatch,
|
|
cmd.background,
|
|
local.0,
|
|
origin,
|
|
angles,
|
|
"move",
|
|
);
|
|
echo(
|
|
format!(
|
|
"move: queued ({:.1} {:.1} {:.1}) yaw={:.0} pitch={:.0} request_id={request_id}{}",
|
|
origin[0],
|
|
origin[1],
|
|
origin[2],
|
|
angles[1],
|
|
angles[0],
|
|
if cmd.background {
|
|
" (async)"
|
|
} else {
|
|
" (sync until presented pose)"
|
|
}
|
|
),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
},
|
|
"look" => match parse_look(&cmd.args, &presented, local.0) {
|
|
Err(msg) => echo(msg, &mut console, &mut line),
|
|
Ok((origin, angles)) => {
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"look: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("look: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"look: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(
|
|
local.0,
|
|
ClientAction::Move {
|
|
request_id,
|
|
origin,
|
|
angles,
|
|
},
|
|
) {
|
|
echo(format!("look: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
look.angles = look_angles_from_degrees(angles);
|
|
arm_wait_move(
|
|
&mut dispatch,
|
|
cmd.background,
|
|
local.0,
|
|
origin,
|
|
angles,
|
|
"look",
|
|
);
|
|
echo(
|
|
format!(
|
|
"look: queued yaw={:.0} pitch={:.0} request_id={request_id}{}",
|
|
angles[1],
|
|
angles[0],
|
|
if cmd.background {
|
|
" (async)"
|
|
} else {
|
|
" (sync until presented pose)"
|
|
}
|
|
),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
},
|
|
"god" => {
|
|
if !cmd.args.is_empty() {
|
|
echo("usage: god".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("god: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"god: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo("god: no action inbox".into(), &mut console, &mut line);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(local.0, ClientAction::ToggleGod { request_id }) {
|
|
echo(format!("god: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
echo(
|
|
format!("god: queued toggle request_id={request_id}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
"kill" => {
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"kill: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("kill: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"kill: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(local.0, ClientAction::ForceDeath { request_id }) {
|
|
echo(format!("kill: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
echo(
|
|
format!("kill: queued ForceDeath request_id={request_id}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
"force_spawn" => {
|
|
let pick = match parse_force_spawn(&cmd.args) {
|
|
Ok(pick) => pick,
|
|
Err(error) => {
|
|
echo(format!("force_spawn: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
};
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo(
|
|
"force_spawn: cheats are off".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"force_spawn: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) =
|
|
inbox.push(local.0, ClientAction::ForceSpawn { request_id, pick })
|
|
{
|
|
echo(format!("force_spawn: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
if !cmd.background {
|
|
let life = authority
|
|
.as_ref()
|
|
.and_then(|a| a.0.client_meta(local.0))
|
|
.map(|m| m.life_sequence)
|
|
.unwrap_or_default();
|
|
dispatch.wait_alive = Some((local.0, life));
|
|
dispatch.wait_alive_elapsed = 0.0;
|
|
}
|
|
echo(
|
|
format!("force_spawn: queued {pick:?} request_id={request_id}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
"damage" => {
|
|
let amount = match cmd.args.first() {
|
|
None => Ok(40),
|
|
Some(raw) => raw
|
|
.parse::<i32>()
|
|
.map_err(|_| format!("usage: damage [amount] (got `{raw}`)")),
|
|
};
|
|
let amount = match amount {
|
|
Ok(n) if n > 0 => n,
|
|
Ok(_) => {
|
|
echo("damage: amount must be > 0".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
Err(msg) => {
|
|
echo(msg, &mut console, &mut line);
|
|
continue;
|
|
}
|
|
};
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"damage: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("damage: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"damage: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) =
|
|
inbox.push(local.0, ClientAction::DebugDamage { request_id, amount })
|
|
{
|
|
echo(format!("damage: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
echo(
|
|
format!("damage: queued {amount} request_id={request_id}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
"nudge" => {
|
|
if cmd.args.len() != 3 {
|
|
echo(
|
|
"usage: nudge <dx> <dy> <dz>".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if !alive(&presented, local.0) {
|
|
echo(
|
|
"nudge: not Alive — spawn a class first".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo("nudge: cheats are off".into(), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
let parse = |s: &str| {
|
|
s.parse::<f32>()
|
|
.ok()
|
|
.filter(|v| v.is_finite())
|
|
.ok_or_else(|| format!("nudge: not a finite number `{s}`"))
|
|
};
|
|
let delta = match (
|
|
parse(&cmd.args[0]),
|
|
parse(&cmd.args[1]),
|
|
parse(&cmd.args[2]),
|
|
) {
|
|
(Ok(x), Ok(y), Ok(z)) => [x, y, z],
|
|
(Err(msg), _, _) | (_, Err(msg), _) | (_, _, Err(msg)) => {
|
|
echo(msg, &mut console, &mut line);
|
|
continue;
|
|
}
|
|
};
|
|
let Some(authority) = authority.as_deref_mut() else {
|
|
echo(
|
|
"nudge: no authority world (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
authority.0.gate_nudge_origin(local.0, delta);
|
|
echo(
|
|
format!(
|
|
"nudge: authority origin += ({:.1} {:.1} {:.1})",
|
|
delta[0], delta[1], delta[2]
|
|
),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
"name" => match cmd.args.as_slice() {
|
|
[] => {
|
|
let shown = presented
|
|
.snapshot()
|
|
.and_then(|s| s.meta.for_client(local.0))
|
|
.and_then(|m| entity_iw4::client_state_name(&m.name).map(str::to_owned));
|
|
match shown {
|
|
Some(n) => echo(format!("name is \"{n}\""), &mut console, &mut line),
|
|
None => echo("name is \"\"".into(), &mut console, &mut line),
|
|
}
|
|
}
|
|
[raw] => {
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"name: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let packed = entity_iw4::pack_client_state_name(raw);
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(
|
|
local.0,
|
|
ClientAction::SetName {
|
|
request_id,
|
|
name: packed,
|
|
},
|
|
) {
|
|
echo(format!("name: {error}"), &mut console, &mut line);
|
|
continue;
|
|
}
|
|
echo(
|
|
format!("name: queued `{raw}` request_id={request_id}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
_ => echo("usage: name [string]".into(), &mut console, &mut line),
|
|
},
|
|
"force_match_start" => {
|
|
if authority.as_ref().is_some_and(|a| !a.0.cheats_enabled()) {
|
|
echo(
|
|
"force_match_start: cheats are off".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
let Some(world) = authority.as_ref() else {
|
|
echo(
|
|
"force_match_start: no authority world (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
match world.0.phase() {
|
|
MatchPhase::Playing => {
|
|
echo(
|
|
"force_match_start: already playing".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
MatchPhase::Warmup => {}
|
|
other => {
|
|
echo(
|
|
format!("force_match_start: match is not in warmup (phase={other:?})"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
let Some(inbox) = inbox.as_deref_mut() else {
|
|
echo(
|
|
"force_match_start: no action inbox (not a listen host)".into(),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
};
|
|
let request_id = seq.allocate();
|
|
if let Err(error) = inbox.push(
|
|
local.0,
|
|
ClientAction::SetMatchPhase {
|
|
request_id,
|
|
phase: MatchPhase::Playing,
|
|
},
|
|
) {
|
|
echo(
|
|
format!("force_match_start: {error}"),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
continue;
|
|
}
|
|
if !cmd.background {
|
|
dispatch.wait_playing = true;
|
|
dispatch.wait_playing_elapsed = 0.0;
|
|
echo(
|
|
format!(
|
|
"force_match_start: queued SetMatchPhase Playing request_id={request_id} (sync until Playing)"
|
|
),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
} else {
|
|
echo(
|
|
format!(
|
|
"force_match_start &: queued SetMatchPhase Playing request_id={request_id} (async)"
|
|
),
|
|
&mut console,
|
|
&mut line,
|
|
);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn update_showpos_overlay(
|
|
debug_pos: Res<DebugPosOverlay>,
|
|
presented: Res<PresentedSnapshot>,
|
|
local: Res<LocalPresentClient>,
|
|
clock: Res<net::AuthorityClock>,
|
|
time: Res<Time>,
|
|
actions: Res<net::ClientActionInput>,
|
|
mut line: ResMut<ConsoleLine>,
|
|
mut hud: Query<(&mut Text, &mut Visibility), With<ShowposHud>>,
|
|
) {
|
|
if !debug_pos.0 {
|
|
for (_, mut vis) in &mut hud {
|
|
*vis = Visibility::Hidden;
|
|
}
|
|
return;
|
|
}
|
|
let text = format_showpos_live(&presented, local.0, clock.tick, &time, &actions);
|
|
line.0 = text.clone();
|
|
for (mut hud_text, mut vis) in &mut hud {
|
|
*vis = Visibility::Visible;
|
|
**hud_text = text.clone();
|
|
}
|
|
}
|
|
|
|
fn alive(presented: &PresentedSnapshot, id: sim::ClientId) -> bool {
|
|
presented
|
|
.snapshot()
|
|
.and_then(|s| s.meta.for_client(id))
|
|
.is_some_and(|m| m.lifecycle == ClientLifecycle::Alive)
|
|
}
|
|
|
|
fn format_showpos(presented: &PresentedSnapshot, id: sim::ClientId) -> String {
|
|
match presented.alive_player(id) {
|
|
Some(ps) => {
|
|
let eye_z = ps.origin[2] + ps.view_height_current;
|
|
format!(
|
|
"showpos origin={:.1} {:.1} {:.1} eye={:.1} {:.1} {:.1} yaw={:.0} pitch={:.0}",
|
|
ps.origin[0],
|
|
ps.origin[1],
|
|
ps.origin[2],
|
|
ps.origin[0],
|
|
ps.origin[1],
|
|
eye_z,
|
|
ps.viewangles[1],
|
|
ps.viewangles[0]
|
|
)
|
|
}
|
|
None => "showpos: not Alive".into(),
|
|
}
|
|
}
|
|
|
|
fn format_showpos_live(
|
|
presented: &PresentedSnapshot,
|
|
id: sim::ClientId,
|
|
tick: u32,
|
|
time: &Time,
|
|
actions: &net::ClientActionInput,
|
|
) -> String {
|
|
let life = presented
|
|
.snapshot()
|
|
.and_then(|s| s.meta.for_client(id))
|
|
.map(|m| format!("{:?}", m.lifecycle))
|
|
.unwrap_or_else(|| "—".into());
|
|
let (origin, eye, yaw, pitch, vz, ground) = match presented.alive_player(id) {
|
|
Some(ps) => {
|
|
let eye_z = ps.origin[2] + ps.view_height_current;
|
|
(
|
|
format!(
|
|
"{:.0} {:.0} {:.0}",
|
|
ps.origin[0], ps.origin[1], ps.origin[2]
|
|
),
|
|
format!("{:.0} {:.0} {:.0}", ps.origin[0], ps.origin[1], eye_z),
|
|
ps.viewangles[1],
|
|
ps.viewangles[0],
|
|
ps.velocity[2],
|
|
ps.ground_entity_num,
|
|
)
|
|
}
|
|
None => ("—".into(), "—".into(), 0.0, 0.0, 0.0, -1),
|
|
};
|
|
let fps = if time.delta_secs() > 0.0 {
|
|
1.0 / time.delta_secs()
|
|
} else {
|
|
0.0
|
|
};
|
|
let mut held_names = Vec::new();
|
|
actions.client.kb.visit_active_names(|n| held_names.push(n));
|
|
let held = if held_names.is_empty() {
|
|
"—".into()
|
|
} else {
|
|
held_names.join(",")
|
|
};
|
|
format!(
|
|
"showpos tick={tick} life={life} origin={origin} eye={eye} yaw={yaw:.0} pitch={pitch:.0} vz={vz:.0} ground={ground} held=[{held}] fps={fps:.0}"
|
|
)
|
|
}
|
|
|
|
fn parse_move(
|
|
args: &[String],
|
|
presented: &PresentedSnapshot,
|
|
id: sim::ClientId,
|
|
) -> Result<([f32; 3], [f32; 3]), String> {
|
|
if args.len() < 3 || args.len() > 5 {
|
|
return Err("usage: move <x> <y> <z> [yaw] [pitch]".into());
|
|
}
|
|
let parse = |s: &str| {
|
|
s.parse::<f32>()
|
|
.ok()
|
|
.filter(|v| v.is_finite())
|
|
.ok_or_else(|| format!("move: not a finite number `{s}`"))
|
|
};
|
|
let origin = [parse(&args[0])?, parse(&args[1])?, parse(&args[2])?];
|
|
let current = presented
|
|
.alive_player(id)
|
|
.map(|ps| ps.viewangles)
|
|
.unwrap_or([0.0, 0.0, 0.0]);
|
|
let mut angles = current;
|
|
if args.len() >= 4 {
|
|
angles[1] = parse(&args[3])?;
|
|
}
|
|
if args.len() == 5 {
|
|
angles[0] = parse(&args[4])?;
|
|
}
|
|
Ok((origin, angles))
|
|
}
|
|
|
|
fn parse_look(
|
|
args: &[String],
|
|
presented: &PresentedSnapshot,
|
|
id: sim::ClientId,
|
|
) -> Result<([f32; 3], [f32; 3]), String> {
|
|
if args.len() != 2 {
|
|
return Err("usage: look <yaw> <pitch>".into());
|
|
}
|
|
let parse = |s: &str| {
|
|
s.parse::<f32>()
|
|
.ok()
|
|
.filter(|v| v.is_finite())
|
|
.ok_or_else(|| format!("look: not a finite number `{s}`"))
|
|
};
|
|
let Some(ps) = presented.alive_player(id) else {
|
|
return Err("look: not Alive — spawn a class first".into());
|
|
};
|
|
let mut angles = ps.viewangles;
|
|
angles[1] = parse(&args[0])?;
|
|
angles[0] = parse(&args[1])?;
|
|
Ok((ps.origin, angles))
|
|
}
|
|
|
|
fn arm_wait_move(
|
|
dispatch: &mut ConsoleDispatch,
|
|
background: bool,
|
|
client: sim::ClientId,
|
|
origin: [f32; 3],
|
|
angles: [f32; 3],
|
|
verb: &str,
|
|
) {
|
|
if background {
|
|
diag::info!(Console, "{verb} &: async — FIFO not blocked");
|
|
return;
|
|
}
|
|
dispatch.wait_move = Some(WaitMovePose {
|
|
client,
|
|
origin,
|
|
angles,
|
|
});
|
|
dispatch.wait_move_elapsed = 0.0;
|
|
}
|
|
|
|
pub(crate) fn presented_matches_move(presented: &PresentedSnapshot, pose: WaitMovePose) -> bool {
|
|
let Some(ps) = presented.alive_player(pose.client) else {
|
|
return false;
|
|
};
|
|
pose_matches_move(ps.origin, ps.viewangles, pose.origin, pose.angles)
|
|
}
|
|
|
|
fn pose_matches_move(
|
|
have_origin: [f32; 3],
|
|
have_angles: [f32; 3],
|
|
want_origin: [f32; 3],
|
|
want_angles: [f32; 3],
|
|
) -> bool {
|
|
(have_origin[0] - want_origin[0]).abs() < 1.0
|
|
&& (have_origin[1] - want_origin[1]).abs() < 1.0
|
|
&& angle_abs_delta(have_angles[0], want_angles[0]) < 0.5
|
|
&& angle_abs_delta(have_angles[1], want_angles[1]) < 0.5
|
|
}
|
|
|
|
fn angle_abs_delta(a: f32, b: f32) -> f32 {
|
|
let mut d = (a - b) % 360.0;
|
|
if d > 180.0 {
|
|
d -= 360.0;
|
|
} else if d < -180.0 {
|
|
d += 360.0;
|
|
}
|
|
d.abs()
|
|
}
|
|
|
|
fn parse_force_spawn(args: &[String]) -> Result<SpawnPick, String> {
|
|
const USAGE: &str = "usage: force_spawn [random <seed> | at <x> <y> <z> [yaw]]";
|
|
let num = |raw: &String| {
|
|
raw.parse::<f32>()
|
|
.map_err(|_| format!("{USAGE} (got `{raw}`)"))
|
|
};
|
|
match args.first().map(String::as_str) {
|
|
None => Ok(SpawnPick::Seeded(0)),
|
|
Some("random") => {
|
|
let [_, seed] = args else {
|
|
return Err(USAGE.into());
|
|
};
|
|
seed.parse::<u64>()
|
|
.map(SpawnPick::Seeded)
|
|
.map_err(|_| format!("{USAGE} (got `{seed}`)"))
|
|
}
|
|
Some("at") if matches!(args.len(), 4 | 5) => Ok(SpawnPick::At {
|
|
origin: [num(&args[1])?, num(&args[2])?, num(&args[3])?],
|
|
yaw: args.get(4).map(num).transpose()?.unwrap_or(0.0),
|
|
}),
|
|
Some(_) => Err(USAGE.into()),
|
|
}
|
|
}
|