23aa18322c
🤖 Agent: verified by Ludovic's AI agent (contrib gate 20): recipe book settings persist on the server. It passed in this wave's union with main on the Mac mini: the selected parity harnesses (332/332, then 122/122 on the final union), clippy -D warnings and the tests, and lan_e2e with the host on its server thread and in-frame (18/18 each). Thanks @rdbtCVS!
2190 lines
86 KiB
Rust
2190 lines
86 KiB
Rust
//! Control-socket commands for agents and scripts that play the game: read
|
|
//! the world, the player, the inventory and the open screen as JSON, and act
|
|
//! like a player (walk, look, break, place, use, click buttons). Actions that
|
|
//! take time run as a task advanced every frame and reply when they finish or
|
|
//! time out, so `horizon-ctl break 10 64 3` returns what the block dropped.
|
|
use super::{Game, Screen};
|
|
use horizon_client::{
|
|
Result,
|
|
block_entity_anim::Ticker,
|
|
chunk::{MIN_Y, SECTIONS},
|
|
items::ItemStack,
|
|
mobs::{
|
|
Species,
|
|
render::{PROFESSIONS, VILLAGER_TYPES},
|
|
},
|
|
widgets,
|
|
};
|
|
use horizon_core::geometry::Vec3;
|
|
use horizon_world::registry::BlockStateId;
|
|
use serde_json::{Value, json};
|
|
use std::{
|
|
collections::{BTreeMap, HashMap, HashSet},
|
|
sync::mpsc::Sender,
|
|
time::{Duration, Instant},
|
|
};
|
|
use winit::{
|
|
application::ApplicationHandler,
|
|
dpi::PhysicalPosition,
|
|
event::{DeviceId, ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent},
|
|
event_loop::ActiveEventLoop,
|
|
keyboard::KeyCode,
|
|
};
|
|
|
|
pub(super) const HELP: &[&str] = &[
|
|
"state player, world, screen and crosshair target in one reply",
|
|
"looking-at the block or entity under the crosshair (distance, face)",
|
|
"entities [RADIUS] [TYPE] mobs, dropped items and orbs near the player, nearest first",
|
|
"block X Y Z the block state at a position",
|
|
"blocks X1 Y1 Z1 X2 Y2 Z2 the non-air blocks of a box (at most 32768 blocks)",
|
|
"light X1 Y1 Z1 X2 Y2 Z2 the stored sky and block light of a box (at most 32768 blocks)",
|
|
"find-block BLOCK [RADIUS] the nearest loaded blocks of a kind (default radius 32)",
|
|
"inventory hotbar, main inventory, armor, offhand and carried stack",
|
|
"screen the open screen or menu, its slots and its buttons",
|
|
"messages [N] recent chat and system messages, title and action bar",
|
|
"move DIR SECONDS [--sprint] [--sneak] [--jump] walk forward|back|left|right",
|
|
"jump jump once",
|
|
"goto X Y Z [--near R] [--sprint] [--direct] [--timeout S] walk to a position along a path",
|
|
"look-at X Y Z | look-at block X Y Z [FACE] | look-at entity ID [--over S]",
|
|
"turn DYAW DPITCH --over S rotate the view with mouse motion spread over S seconds",
|
|
"mouse-move DX DY relative mouse motion, turned like a player's mouse",
|
|
"attack [ID] swing at the target (after looking at entity ID)",
|
|
"break X Y Z [--timeout S] mine a block until it breaks; reports drops and pickups",
|
|
"place X Y Z [--item ITEM] place the held (or given) item at a position",
|
|
"interact X Y Z [FACE] right-click a block (open a door, chest, crafting table...)",
|
|
"use-item [--hold S] right-click with the held item (eat, drink, throw, draw a bow)",
|
|
"select SLOT|ITEM select a hotbar slot (1-9) or the hotbar slot holding ITEM",
|
|
"drop [all] drop one of the held item (all: the stack)",
|
|
"open-inventory open the inventory screen",
|
|
"click-button LABEL click a button of the open screen or menu by its label",
|
|
"click-at X Y [right] click at GUI pixel X Y of the window",
|
|
"drag-at [right] X Y X Y... press at the first GUI point, move through the others, release",
|
|
"scroll-at X Y STEPS turn the wheel at GUI pixel X Y (positive scrolls up)",
|
|
"command TEXT run a /command",
|
|
"pause open the pause menu",
|
|
"wait TICKS wait for game ticks to pass (held keys stay held)",
|
|
"stop cancel the running action and release every key",
|
|
];
|
|
|
|
/// Keys the agent holds for a task (the game's movement reads these).
|
|
const MOVE_KEYS: [KeyCode; 7] = [
|
|
KeyCode::KeyW,
|
|
KeyCode::KeyS,
|
|
KeyCode::KeyA,
|
|
KeyCode::KeyD,
|
|
KeyCode::Space,
|
|
KeyCode::ShiftLeft,
|
|
KeyCode::ControlLeft,
|
|
];
|
|
|
|
/// Words of a command line: positional values and `--flag [value]` options.
|
|
#[derive(Debug, Default, PartialEq)]
|
|
pub(super) struct Args<'a> {
|
|
pub pos: Vec<&'a str>,
|
|
pub flags: HashMap<&'a str, Option<&'a str>>,
|
|
}
|
|
/// Options that take a value (`--timeout 10` or `--timeout=10`).
|
|
const VALUE_FLAGS: &[&str] = &["timeout", "near", "item", "radius", "hold", "face", "over"];
|
|
|
|
pub(super) fn parse_args<'a>(words: &[&'a str]) -> Args<'a> {
|
|
let mut args = Args::default();
|
|
let mut i = 0;
|
|
while i < words.len() {
|
|
let w = words[i];
|
|
if let Some(flag) = w.strip_prefix("--") {
|
|
if let Some((k, v)) = flag.split_once('=') {
|
|
args.flags.insert(k, Some(v));
|
|
} else if VALUE_FLAGS.contains(&flag) && i + 1 < words.len() {
|
|
args.flags.insert(flag, Some(words[i + 1]));
|
|
i += 1;
|
|
} else {
|
|
args.flags.insert(flag, None);
|
|
}
|
|
} else {
|
|
args.pos.push(w);
|
|
}
|
|
i += 1;
|
|
}
|
|
args
|
|
}
|
|
impl Args<'_> {
|
|
fn has(&self, flag: &str) -> bool {
|
|
self.flags.contains_key(flag)
|
|
}
|
|
fn num(&self, flag: &str, default: f64) -> Result<f64> {
|
|
match self.flags.get(flag) {
|
|
Some(Some(v)) => Ok(v.parse()?),
|
|
Some(None) => Err(format!("--{flag} needs a value").into()),
|
|
None => Ok(default),
|
|
}
|
|
}
|
|
fn get(&self, i: usize, what: &str) -> Result<&str> {
|
|
self.pos
|
|
.get(i)
|
|
.copied()
|
|
.ok_or_else(|| format!("missing {what}").into())
|
|
}
|
|
fn f64(&self, i: usize, what: &str) -> Result<f64> {
|
|
let v = self.get(i, what)?;
|
|
v.parse()
|
|
.map_err(|_| format!("{what} must be a number, not {v}").into())
|
|
}
|
|
fn i32(&self, i: usize, what: &str) -> Result<i32> {
|
|
let v = self.get(i, what)?;
|
|
v.parse()
|
|
.map_err(|_| format!("{what} must be an integer, not {v}").into())
|
|
}
|
|
fn block_pos(&self, from: usize) -> Result<[i32; 3]> {
|
|
Ok([
|
|
self.i32(from, "X")?,
|
|
self.i32(from + 1, "Y")?,
|
|
self.i32(from + 2, "Z")?,
|
|
])
|
|
}
|
|
}
|
|
|
|
fn namespaced(name: &str) -> String {
|
|
if name.contains(':') {
|
|
name.to_owned()
|
|
} else {
|
|
format!("minecraft:{name}")
|
|
}
|
|
}
|
|
|
|
const FACES: [(&str, [i32; 3]); 6] = [
|
|
("down", [0, -1, 0]),
|
|
("up", [0, 1, 0]),
|
|
("north", [0, 0, -1]),
|
|
("south", [0, 0, 1]),
|
|
("west", [-1, 0, 0]),
|
|
("east", [1, 0, 0]),
|
|
];
|
|
fn face_name(face: [i32; 3]) -> &'static str {
|
|
FACES
|
|
.iter()
|
|
.find(|(_, d)| *d == face)
|
|
.map_or("?", |(n, _)| n)
|
|
}
|
|
fn face_dir(name: &str) -> Result<[i32; 3]> {
|
|
FACES
|
|
.iter()
|
|
.find(|(n, _)| *n == name)
|
|
.map(|(_, d)| *d)
|
|
.ok_or_else(|| format!("unknown face {name} (down up north south west east)").into())
|
|
}
|
|
fn add(a: [i32; 3], b: [i32; 3]) -> [i32; 3] {
|
|
[a[0] + b[0], a[1] + b[1], a[2] + b[2]]
|
|
}
|
|
fn dist(a: [f64; 3], b: [f64; 3]) -> f64 {
|
|
((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
|
|
}
|
|
/// Minecraft's yaw and pitch facing from `eye` towards `at` (yaw 0 faces +Z,
|
|
/// 90 faces -X; positive pitch looks down).
|
|
pub(super) fn yaw_pitch(eye: [f64; 3], at: [f64; 3]) -> (f32, f32) {
|
|
let d = [at[0] - eye[0], at[1] - eye[1], at[2] - eye[2]];
|
|
let horizontal = (d[0] * d[0] + d[2] * d[2]).sqrt();
|
|
(
|
|
(-d[0]).atan2(d[2]).to_degrees() as f32,
|
|
(-d[1]).atan2(horizontal).to_degrees() as f32,
|
|
)
|
|
}
|
|
|
|
fn counts(items: impl Iterator<Item = ItemStack>) -> BTreeMap<String, i64> {
|
|
let mut map = BTreeMap::new();
|
|
for s in items {
|
|
*map.entry(s.item.to_string()).or_insert(0) += i64::from(s.count);
|
|
}
|
|
map
|
|
}
|
|
/// Item counts that changed between two inventories (positive: gained).
|
|
fn delta(before: &BTreeMap<String, i64>, after: &BTreeMap<String, i64>) -> BTreeMap<String, i64> {
|
|
let mut out = BTreeMap::new();
|
|
for key in before.keys().chain(after.keys()) {
|
|
let d = after.get(key).copied().unwrap_or(0) - before.get(key).copied().unwrap_or(0);
|
|
if d != 0 {
|
|
out.insert(key.clone(), d);
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// A feet position the A* path walks through.
|
|
type Node = [i32; 3];
|
|
|
|
enum TaskKind {
|
|
/// Hold keys until a deadline.
|
|
Move {
|
|
keys: Vec<KeyCode>,
|
|
until: Instant,
|
|
from: Vec3,
|
|
},
|
|
Wait {
|
|
until_tick: u64,
|
|
},
|
|
Jump {
|
|
release_tick: u64,
|
|
from_y: f64,
|
|
},
|
|
Goto(Box<Goto>),
|
|
Break(Box<Break>),
|
|
/// A right click on a block or a placement: report after a few ticks.
|
|
Click {
|
|
pos: Option<[i32; 3]>,
|
|
before: Option<BlockStateId>,
|
|
inventory: BTreeMap<String, i64>,
|
|
report_tick: u64,
|
|
release: Option<Instant>,
|
|
place: bool,
|
|
},
|
|
Attack {
|
|
id: Option<u32>,
|
|
health: Option<f32>,
|
|
report_tick: u64,
|
|
},
|
|
}
|
|
impl TaskKind {
|
|
/// Whether the keys and buttons are released when the task ends. A wait
|
|
/// holds nothing, so what `key w down` pressed stays down through it.
|
|
fn releases_input(&self) -> bool {
|
|
!matches!(self, TaskKind::Wait { .. })
|
|
}
|
|
}
|
|
struct Goto {
|
|
target: [f64; 3],
|
|
near: f64,
|
|
sprint: bool,
|
|
path: Vec<Node>,
|
|
next: usize,
|
|
/// Tick of the last waypoint reached, and how many replans so far.
|
|
progress_tick: u64,
|
|
replans: u32,
|
|
jump_until: u64,
|
|
warning: Option<String>,
|
|
}
|
|
struct Break {
|
|
pos: [i32; 3],
|
|
before: BlockStateId,
|
|
items_before: HashSet<u32>,
|
|
inventory: BTreeMap<String, i64>,
|
|
started_tick: u64,
|
|
/// Set once the block changed: collect drops until this tick.
|
|
collect_until: Option<u64>,
|
|
broke_tick: u64,
|
|
drops: BTreeMap<u32, ItemStack>,
|
|
}
|
|
struct Task {
|
|
kind: TaskKind,
|
|
reply: Sender<String>,
|
|
deadline: Instant,
|
|
name: &'static str,
|
|
}
|
|
|
|
/// Mouse motion an agent feeds over frames (`mouse-move`, `turn --over`,
|
|
/// `look-at --over`): eased, through `MouseHandler`'s accumulated movement.
|
|
struct Glide {
|
|
/// The whole motion, in mouse units, and how much has been fed.
|
|
total: (f64, f64),
|
|
fed: (f64, f64),
|
|
started: Instant,
|
|
over: Duration,
|
|
/// The frame count when motion was last fed: the reply waits for the
|
|
/// frame that turns the view with it.
|
|
fed_frame: u64,
|
|
deadline: Instant,
|
|
reply: Sender<String>,
|
|
/// What `look-at` aimed at, reported once the turn is done.
|
|
aim: Option<&'static str>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct Agent {
|
|
task: Option<Task>,
|
|
glide: Option<Glide>,
|
|
/// Control-fixture barrier: hold simulation and packet handling, not transport threads.
|
|
pub hold_server: bool,
|
|
}
|
|
|
|
pub(super) enum Handled {
|
|
Reply(Value),
|
|
/// The reply comes later, from the task.
|
|
Deferred,
|
|
/// Not an agent command.
|
|
No,
|
|
}
|
|
|
|
impl Game<'_> {
|
|
pub(super) fn state_string(&self, state: BlockStateId) -> String {
|
|
let Some(s) = self.pack.assets.registry.state(state) else {
|
|
return "?".into();
|
|
};
|
|
if s.properties.is_empty() {
|
|
return s.name.clone();
|
|
}
|
|
let props: Vec<String> = s
|
|
.properties
|
|
.iter()
|
|
.map(|(k, v)| format!("{k}={v}"))
|
|
.collect();
|
|
format!("{}[{}]", s.name, props.join(","))
|
|
}
|
|
fn block_json(&self, pos: [i32; 3]) -> Value {
|
|
let state = self.world.block(pos[0], pos[1], pos[2]);
|
|
let mut v = json!({
|
|
"pos": pos,
|
|
"block": &*self.res.facts().get(state).name,
|
|
"state": self.state_string(state),
|
|
"loaded": self.world.chunks.contains_key(&(pos[0] >> 4, pos[2] >> 4)),
|
|
});
|
|
// How far a chest's or a shulker box's lid is open, 0..1, as drawn.
|
|
match self.be_anims.ticker(state.0) {
|
|
Some(Ticker::Lid) => v["lid"] = json!(self.chest_lid(pos, 1.0)),
|
|
Some(Ticker::Shulker { .. }) => v["lid"] = json!(self.block_anim(pos, 1.0).shulker.0),
|
|
_ => {}
|
|
}
|
|
// The lines of a sign, as this client has them.
|
|
if let Some(horizon_client::containers::BlockEntity::Sign(sign)) =
|
|
self.world.block_entities.get(&(pos[0], pos[1], pos[2]))
|
|
{
|
|
v["sign"] = json!({ "front": sign.front.lines, "back": sign.back.lines });
|
|
}
|
|
v
|
|
}
|
|
pub(super) fn stack_value(&self, s: &ItemStack) -> Value {
|
|
let mut v = json!({ "item": &*s.item, "count": s.count });
|
|
if s.damage > 0 {
|
|
v["damage"] = json!(s.damage);
|
|
}
|
|
if let Some(c) = horizon_client::item_data::encode_components(s) {
|
|
v["components"] = json!(horizon_client::snbt::to_snbt(&c));
|
|
}
|
|
v
|
|
}
|
|
fn slot_value(&self, slot: usize, s: &Option<ItemStack>) -> Value {
|
|
match s {
|
|
Some(s) => {
|
|
let mut v = self.stack_value(s);
|
|
v["slot"] = json!(slot);
|
|
v
|
|
}
|
|
None => json!({ "slot": slot, "item": null }),
|
|
}
|
|
}
|
|
fn need_world(&self) -> Result<()> {
|
|
if self.title.is_some() {
|
|
return Err("no world open (title screen); use: open WORLD [SEED] [creative]".into());
|
|
}
|
|
Ok(())
|
|
}
|
|
fn playing(&self) -> Result<()> {
|
|
if self.title.is_some() {
|
|
return Err("no world open (title screen); use: open WORLD [SEED] [creative]".into());
|
|
}
|
|
if self.player.is_none() {
|
|
return Err("the player has not spawned yet; try wait-ready".into());
|
|
}
|
|
if self.screen != Screen::Playing || self.book.is_some() || self.sign_edit.is_some() {
|
|
return Err(format!(
|
|
"the {} screen is open; close it first (close, or click-button)",
|
|
self.screen_label()
|
|
)
|
|
.into());
|
|
}
|
|
Ok(())
|
|
}
|
|
pub(super) fn screen_label(&self) -> &'static str {
|
|
if self.dialog_open() {
|
|
return "dialog";
|
|
}
|
|
if self.title.is_some() {
|
|
return "title";
|
|
}
|
|
if self.book.is_some() {
|
|
return "book";
|
|
}
|
|
if self.sign_edit.is_some() {
|
|
return "sign";
|
|
}
|
|
match self.screen {
|
|
Screen::Playing => "playing",
|
|
Screen::GameModeSwitcher => "gamemode-switcher",
|
|
Screen::Paused => "paused",
|
|
Screen::Options => "options",
|
|
Screen::Inventory if self.station.is_some() => "station",
|
|
Screen::Inventory if self.container.is_some() => "container",
|
|
Screen::Inventory => "inventory",
|
|
Screen::Creative => "creative",
|
|
Screen::Dead => "dead",
|
|
Screen::Chat => "chat",
|
|
Screen::Stats => "stats",
|
|
Screen::Advancements => "advancements",
|
|
Screen::WorldOptions => "world-options",
|
|
Screen::Friends => "friends",
|
|
Screen::ServerLinks => "server-links",
|
|
Screen::ConfirmLink => "confirm-link",
|
|
Screen::DialogWarning => "dialog-warning",
|
|
Screen::CommandBlock => "command-block",
|
|
Screen::Win => "win",
|
|
Screen::Mod => "mod",
|
|
}
|
|
}
|
|
pub(super) fn inventory_counts(&self) -> BTreeMap<String, i64> {
|
|
counts(
|
|
self.inventory
|
|
.iter()
|
|
.chain(self.armor.iter())
|
|
.chain(std::iter::once(&self.offhand))
|
|
.chain(std::iter::once(&self.carried))
|
|
.flatten()
|
|
.cloned(),
|
|
)
|
|
}
|
|
|
|
/// The block or entity under the crosshair.
|
|
fn looking_at(&self) -> Value {
|
|
let Some(eye) = self.eye_position() else {
|
|
return Value::Null;
|
|
};
|
|
let block = self.pick().map(|hit| {
|
|
let mut v = self.block_json(hit.pos);
|
|
v["face"] = json!(face_name(hit.face));
|
|
v["point"] = json!(hit.point);
|
|
v["distance"] = json!(dist(eye, hit.point));
|
|
v
|
|
});
|
|
let entity = self.mob_hit().map(|(i, d)| {
|
|
let m = &self.mobs[i];
|
|
json!({ "id": m.id, "type": m.kind.id, "health": m.health, "distance": d,
|
|
"pos": [m.position.x, m.position.y, m.position.z] })
|
|
});
|
|
let kind = match (&block, &entity) {
|
|
(Some(b), Some(e)) if e["distance"].as_f64() <= b["distance"].as_f64() => "entity",
|
|
(_, Some(_)) if block.is_none() => "entity",
|
|
(Some(_), _) => "block",
|
|
_ => "none",
|
|
};
|
|
json!({ "kind": kind, "block": block, "entity": entity })
|
|
}
|
|
|
|
fn state_value(&self) -> Value {
|
|
let player = self.player.as_ref().map(|p| {
|
|
json!({
|
|
"position": [p.position.x, p.position.y, p.position.z],
|
|
"block_pos": [p.position.x.floor() as i32, p.position.y.floor() as i32, p.position.z.floor() as i32],
|
|
"eye": self.eye_position(),
|
|
"yaw": self.yaw,
|
|
"pitch": self.pitch,
|
|
"velocity": [p.velocity.x, p.velocity.y, p.velocity.z],
|
|
"on_ground": p.ground.on_ground,
|
|
"flying": p.flying,
|
|
"fall_flying": p.fall_flying,
|
|
"sneaking": self.keys.contains(&KeyCode::ShiftLeft),
|
|
"sprinting": p.sprinting,
|
|
"fov_modifier": self.view.fov_modifier,
|
|
"health": p.health.health(),
|
|
"absorption": p.health.absorption(),
|
|
// The hurt animation's ticks left (the camera's hurt tilt).
|
|
"hurt_time": p.health.hurt_animation_time,
|
|
// LivingEntity.deathTime while dead (the camera's death roll).
|
|
"death_time": self.death_time(),
|
|
"air": p.air,
|
|
"food": p.health.food.food,
|
|
"saturation": p.health.food.saturation,
|
|
"shield_cooldown": self.shield_cooldown,
|
|
"xp": { "level": self.experience.level, "progress": self.experience.progress, "total": self.experience.total },
|
|
"effects": self.potions.effects.list.iter().map(|e| json!({ "id": e.id, "duration_ticks": e.duration, "amplifier": e.amplifier })).collect::<Vec<_>>(),
|
|
})
|
|
});
|
|
json!({
|
|
"dialog": self.dialog_status(),
|
|
"screen": self.screen_label(),
|
|
"menu": self.title.as_ref().map(|_| self.title_value()),
|
|
"world": (self.title.is_none()).then(|| match &self.integrated {
|
|
Some(server) => server.world_name.clone(),
|
|
None => self.level.name.clone(),
|
|
}),
|
|
"dimension": self.dim.id(),
|
|
"gamemode": format!("{:?}", self.mode).to_lowercase(),
|
|
// The bed (its head) the player sleeps in.
|
|
"sleeping": self.sleeping,
|
|
// The item in use: its slot and for how many ticks.
|
|
"using": self.using.map(|(slot, ticks)| json!({ "slot": slot, "ticks": ticks })),
|
|
// The block being dug: how far along, after how many ticks.
|
|
"mining": self.mining.as_ref().map(|m| json!({ "pos": m.pos, "progress": m.progress, "ticks": m.ticks })),
|
|
// The arm swings started (LivingEntity.swing).
|
|
"swings": self.swings_started,
|
|
"time": { "day_time": self.world.day_time, "day": self.world.day_time.div_euclid(24000), "time_of_day": self.world.day_time.rem_euclid(24000) },
|
|
"weather": { "raining": self.world.weather.raining, "thundering": self.world.weather.thundering },
|
|
"paused": self.pause,
|
|
// Mouse movement turns the camera (`apply_mouse_look`): the real
|
|
// pointer is grabbed, or an agent's `mouse-move` stands in for it.
|
|
"pointer_grabbed": self.captured || self.agent_pointer,
|
|
"player": player,
|
|
"selected": self.selected + 1,
|
|
"held": self.held().map(|s| self.stack_value(s)),
|
|
"looking_at": self.looking_at(),
|
|
"busy": self.agent.task.as_ref().map(|t| t.name),
|
|
"ticks": self.ticks,
|
|
})
|
|
}
|
|
|
|
fn title_value(&self) -> Value {
|
|
use horizon_client::title::Mode;
|
|
let Some(title) = &self.title else {
|
|
return Value::Null;
|
|
};
|
|
let worlds = || {
|
|
title
|
|
.recent_worlds()
|
|
.iter()
|
|
.map(|w| json!({ "folder": w.folder, "name": w.name, "creative": w.creative }))
|
|
.collect::<Vec<_>>()
|
|
};
|
|
match &title.mode {
|
|
Mode::Main => json!({ "mode": "main", "worlds": worlds() }),
|
|
Mode::Select {
|
|
worlds: list,
|
|
selected,
|
|
} => json!({
|
|
"mode": "select-world",
|
|
"worlds": list.iter().map(|w| json!({ "folder": w.folder, "name": w.name, "creative": w.creative })).collect::<Vec<_>>(),
|
|
"selected": selected,
|
|
}),
|
|
Mode::Create {
|
|
name,
|
|
seed,
|
|
creative,
|
|
focus,
|
|
options,
|
|
} => json!({
|
|
"mode": "create-world",
|
|
"tab": (["game", "world", "more"][options.tab.min(2)]),
|
|
"fields": { "name": name, "seed": seed },
|
|
"focus": match focus { 0 => "name", 1 => "seed", _ => "none" },
|
|
"creative": creative,
|
|
"hardcore": options.hardcore,
|
|
"difficulty": horizon_client::title::DIFFICULTIES[options.difficulty()],
|
|
"allow_commands": options.commands(*creative),
|
|
"superflat": options.flat,
|
|
"generate_structures": options.structures,
|
|
"bonus_chest": options.bonus_chest(),
|
|
}),
|
|
Mode::Edit {
|
|
world,
|
|
name,
|
|
focused,
|
|
} => {
|
|
json!({ "mode": "edit-world", "folder": world.folder, "fields": { "name": name }, "focus": if *focused { "name" } else { "none" } })
|
|
}
|
|
Mode::Backup { world, .. } => {
|
|
json!({ "mode": "creating-backup", "folder": world.folder })
|
|
}
|
|
Mode::Delete { world } => {
|
|
json!({ "mode": "delete-world", "folder": world.folder, "name": world.name })
|
|
}
|
|
Mode::Error { message, .. } => {
|
|
json!({ "mode": "world-operation-error", "message": message })
|
|
}
|
|
Mode::Multiplayer(horizon_client::multiplayer::Screen::Disconnected {
|
|
reason, ..
|
|
}) => {
|
|
json!({ "mode": "multiplayer", "disconnected": reason })
|
|
}
|
|
Mode::Multiplayer(_) => json!({ "mode": "multiplayer" }),
|
|
}
|
|
}
|
|
|
|
fn entities_value(&self, radius: f64, kind: Option<&str>) -> Value {
|
|
let Some(p) = &self.player else {
|
|
return json!({ "entities": [] });
|
|
};
|
|
let me = [p.position.x, p.position.y, p.position.z];
|
|
let want = kind.map(namespaced);
|
|
let mut list: Vec<(f64, Value)> = Vec::new();
|
|
let mut push = |pos: [f64; 3], ty: &str, v: Value| {
|
|
let d = dist(me, pos);
|
|
if d <= radius && want.as_deref().is_none_or(|w| w == ty) {
|
|
let mut v = v;
|
|
v["type"] = json!(ty);
|
|
v["pos"] = json!(pos);
|
|
v["distance"] = json!(d);
|
|
list.push((d, v));
|
|
}
|
|
};
|
|
for m in self.mobs.iter().filter(|m| m.alive()) {
|
|
let mut v = json!({ "id": m.id, "kind": "mob", "health": m.health, "baby": m.is_baby(), "hurt_time": m.hurt_time });
|
|
// VillagerData as this game knows it: on a client, what the
|
|
// server's synched data says.
|
|
if matches!(m.species(), Species::Villager | Species::ZombieVillager) {
|
|
v["villager"] = json!({
|
|
"type": VILLAGER_TYPES[m.extra.variant as usize % VILLAGER_TYPES.len()],
|
|
"profession": PROFESSIONS[m.extra.variant2 as usize % PROFESSIONS.len()],
|
|
"level": m.extra.variant3,
|
|
});
|
|
}
|
|
push(
|
|
[m.position.x, m.position.y, m.position.z],
|
|
m.kind.id.as_ref(),
|
|
v,
|
|
);
|
|
}
|
|
for item in &self.dropped {
|
|
push(
|
|
[item.position.x, item.position.y, item.position.z],
|
|
"minecraft:item",
|
|
json!({ "id": item.id, "kind": "item", "item": self.stack_value(&item.stack) }),
|
|
);
|
|
}
|
|
for orb in &self.orbs {
|
|
push(
|
|
[orb.position.x, orb.position.y, orb.position.z],
|
|
"minecraft:experience_orb",
|
|
json!({ "kind": "orb", "value": orb.value }),
|
|
);
|
|
}
|
|
list.sort_by(|a, b| a.0.total_cmp(&b.0));
|
|
json!({ "entities": list.into_iter().map(|(_, v)| v).collect::<Vec<_>>() })
|
|
}
|
|
|
|
fn inventory_value(&self) -> Value {
|
|
let armor = ["head", "chest", "legs", "feet"];
|
|
json!({
|
|
"selected": self.selected + 1,
|
|
"held": self.held().map(|s| self.stack_value(s)),
|
|
"hotbar": (0..9).map(|i| self.slot_value(i, &self.inventory[i])).collect::<Vec<_>>(),
|
|
"main": (9..36).map(|i| self.slot_value(i, &self.inventory[i])).collect::<Vec<_>>(),
|
|
"armor": armor.iter().enumerate().map(|(i, name)| {
|
|
let mut v = self.slot_value(500 + i, &self.armor[i]);
|
|
v["part"] = json!(name);
|
|
v
|
|
}).collect::<Vec<_>>(),
|
|
"offhand": self.slot_value(504, &self.offhand),
|
|
"carried": self.carried.as_ref().map(|s| self.stack_value(s)),
|
|
"counts": self.inventory_counts(),
|
|
})
|
|
}
|
|
|
|
fn screen_value(&mut self) -> Value {
|
|
let buttons: Vec<Value> = widgets::last()
|
|
.iter()
|
|
.map(|w| json!({ "label": w.label, "enabled": w.enabled, "x": w.x, "y": w.y, "w": w.w, "h": w.h }))
|
|
.collect();
|
|
let mut v = json!({
|
|
"screen": self.screen_label(),
|
|
"buttons": buttons,
|
|
});
|
|
if let Some(chat) = &self.ui.chat_screen {
|
|
v["chat_input"] = json!(chat.input.value);
|
|
v["chat_suggestions"] = json!(chat.suggestions_visible());
|
|
}
|
|
if self.title.is_some() {
|
|
v["menu"] = self.title_value();
|
|
}
|
|
if self.screen == Screen::Inventory && self.title.is_none() {
|
|
let mut slots = Vec::new();
|
|
for i in self.slots() {
|
|
let stack = if i == 200 {
|
|
self.craft_result()
|
|
} else {
|
|
self.slot_mut(i).clone()
|
|
};
|
|
slots.push(self.slot_value(i, &stack));
|
|
}
|
|
v["slots"] = json!(slots);
|
|
v["carried"] = json!(self.carried.as_ref().map(|s| self.stack_value(s)));
|
|
v["craft_size"] = json!(self.craft_size);
|
|
v["station"] = json!(self.station.as_ref().map(|s| format!("{:?}", s.kind)));
|
|
v["container"] = json!(self.container);
|
|
// The title a server gave the menu, span by span as it is drawn.
|
|
if let Some(title) = self.remote_menu_title() {
|
|
let spans = title.spans.iter().map(|s| {
|
|
json!({
|
|
"text": s.text,
|
|
"color": s.style.color.map(|c| format!("#{c:06X}")),
|
|
"bold": s.style.is_bold(),
|
|
"italic": s.style.is_italic(),
|
|
})
|
|
});
|
|
v["title"] = json!(spans.collect::<Vec<_>>());
|
|
}
|
|
// The recipe book's buttons (GUI pixels): the book button, then
|
|
// the recipe buttons of the page, page arrows, filter and tabs.
|
|
let book = self.recipe_book_targets();
|
|
if !book.is_empty() {
|
|
let (open, filtering) = self.recipe_book_flags().unwrap_or_default();
|
|
v["recipe_book"] = json!({
|
|
"targets": book.iter().map(|t| t.rect).collect::<Vec<_>>(),
|
|
"known": self.recipe_book_known(),
|
|
"open": open,
|
|
"filtering": filtering,
|
|
});
|
|
}
|
|
v["slot_ids"] = json!(
|
|
"0-8 hotbar, 9-35 inventory, 100+ crafting grid (row-major), 200 crafting result, 300+ container, 500-503 armor, 504 offhand, 600+ station"
|
|
);
|
|
}
|
|
v
|
|
}
|
|
|
|
fn messages_value(&self, n: usize) -> Value {
|
|
let titles = &self.titles;
|
|
json!({
|
|
"chat": self.remote_chat(n).unwrap_or_else(|| self.ui.chat.recent_lines(n)),
|
|
"order": "newest first",
|
|
// The chat lines as drawn: colours, click and hover events.
|
|
"styled": self.ui.chat.recent_components(n),
|
|
"title": (titles.time > 0).then(|| titles.title.as_ref().map(|t| t.plain())).flatten(),
|
|
"subtitle": (titles.time > 0).then(|| titles.subtitle.as_ref().map(|t| t.plain())).flatten(),
|
|
"actionbar": (titles.overlay_time > 0).then(|| titles.overlay.as_ref().map(|t| t.plain())).flatten(),
|
|
})
|
|
}
|
|
|
|
/// Whether a block stops movement, for the path finder.
|
|
fn blocks_motion(&self, pos: [i32; 3]) -> bool {
|
|
let f = self
|
|
.res
|
|
.facts()
|
|
.get(self.world.block(pos[0], pos[1], pos[2]));
|
|
f.full_collision || f.legacy_solid
|
|
}
|
|
fn walkable(&self, n: Node) -> bool {
|
|
let below = self.world.block(n[0], n[1] - 1, n[2]);
|
|
let lava = |p: [i32; 3]| {
|
|
&*self
|
|
.res
|
|
.facts()
|
|
.get(self.world.block(p[0], p[1], p[2]))
|
|
.name
|
|
== "minecraft:lava"
|
|
};
|
|
self.world.chunks.contains_key(&(n[0] >> 4, n[2] >> 4))
|
|
&& (self.blocks_motion([n[0], n[1] - 1, n[2]])
|
|
|| self.res.facts().get(below).fluid != horizon_client::blocks::Fluid::None)
|
|
&& !self.blocks_motion(n)
|
|
&& !self.blocks_motion([n[0], n[1] + 1, n[2]])
|
|
&& !lava(n)
|
|
&& !lava([n[0], n[1] - 1, n[2]])
|
|
}
|
|
/// A* over standable feet positions: steps up one block, drops up to three.
|
|
fn find_path(&self, from: Node, goal: [f64; 3], near: f64) -> Option<Vec<Node>> {
|
|
use std::{cmp::Reverse, collections::BinaryHeap};
|
|
let reached = |n: Node| {
|
|
let c = [
|
|
f64::from(n[0]) + 0.5,
|
|
f64::from(n[1]),
|
|
f64::from(n[2]) + 0.5,
|
|
];
|
|
((c[0] - goal[0]).powi(2) + (c[2] - goal[2]).powi(2)).sqrt() <= near.max(0.5)
|
|
&& (c[1] - goal[1]).abs() <= near.max(1.0) + 0.5
|
|
};
|
|
let h = |n: Node| {
|
|
((f64::from(n[0]) + 0.5 - goal[0]).abs()
|
|
+ (f64::from(n[1]) - goal[1]).abs()
|
|
+ (f64::from(n[2]) + 0.5 - goal[2]).abs())
|
|
* 10.0
|
|
};
|
|
let mut open = BinaryHeap::new();
|
|
let mut cost: HashMap<Node, u32> = HashMap::new();
|
|
let mut came: HashMap<Node, Node> = HashMap::new();
|
|
cost.insert(from, 0);
|
|
open.push(Reverse((h(from) as u32, from)));
|
|
let mut expanded = 0;
|
|
while let Some(Reverse((_, n))) = open.pop() {
|
|
if reached(n) {
|
|
let mut path = vec![n];
|
|
let mut at = n;
|
|
while let Some(&p) = came.get(&at) {
|
|
path.push(p);
|
|
at = p;
|
|
}
|
|
path.reverse();
|
|
return Some(path);
|
|
}
|
|
expanded += 1;
|
|
if expanded > 30_000 {
|
|
return None;
|
|
}
|
|
let base = cost[&n];
|
|
for d in [[1, 0], [-1, 0], [0, 1], [0, -1]] {
|
|
for dy in [0, 1, -1, -2, -3] {
|
|
let m = [n[0] + d[0], n[1] + dy, n[2] + d[1]];
|
|
// A step up needs head room above the start; a drop needs
|
|
// the column in front clear down to the landing.
|
|
let clear = match dy {
|
|
1 => !self.blocks_motion([n[0], n[1] + 2, n[2]]),
|
|
d if d < 0 => {
|
|
(m[1]..=n[1] + 1).all(|y| !self.blocks_motion([m[0], y, m[2]]))
|
|
}
|
|
_ => true,
|
|
};
|
|
if !clear || !self.walkable(m) {
|
|
continue;
|
|
}
|
|
let water = self
|
|
.res
|
|
.facts()
|
|
.get(self.world.block(m[0], m[1], m[2]))
|
|
.fluid
|
|
!= horizon_client::blocks::Fluid::None;
|
|
let step = 10 + if dy != 0 { 5 } else { 0 } + if water { 30 } else { 0 };
|
|
let c = base + step;
|
|
if cost.get(&m).is_none_or(|&old| c < old) {
|
|
cost.insert(m, c);
|
|
came.insert(m, n);
|
|
open.push(Reverse((c + h(m) as u32, m)));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Point the view at `at` from the eye.
|
|
fn face_point(&mut self, at: [f64; 3]) -> Result<()> {
|
|
let eye = self.eye_position().ok_or("no player")?;
|
|
let (yaw, pitch) = yaw_pitch(eye, at);
|
|
self.yaw = yaw;
|
|
self.pitch = pitch.clamp(-90.0, 90.0);
|
|
Ok(())
|
|
}
|
|
/// Aim at a face of `pos` the crosshair can reach; the face hit.
|
|
fn aim_block(&mut self, pos: [i32; 3], face: Option<[i32; 3]>) -> Result<[i32; 3]> {
|
|
let eye = self.eye_position().ok_or("no player")?;
|
|
let centre = pos.map(|v| f64::from(v) + 0.5);
|
|
let mut faces: Vec<[i32; 3]> = match face {
|
|
Some(f) => vec![f],
|
|
None => FACES.iter().map(|(_, d)| *d).collect(),
|
|
};
|
|
// Faces turned towards the eye first, nearest first.
|
|
faces.sort_by(|a, b| {
|
|
let point = |f: &[i32; 3]| [0, 1, 2].map(|i| centre[i] + f64::from(f[i]) * 0.45);
|
|
dist(eye, point(a)).total_cmp(&dist(eye, point(b)))
|
|
});
|
|
for f in faces {
|
|
for inset in [0.45, 0.3, 0.0] {
|
|
let point = [0, 1, 2].map(|i| centre[i] + f64::from(f[i]) * inset);
|
|
let (yaw, pitch) = yaw_pitch(eye, point);
|
|
let dir = super::view_vector(yaw, pitch);
|
|
if let Some(hit) = self.clip_ray(eye, dir, self.reach())
|
|
&& hit.pos == pos
|
|
&& (face.is_none() || hit.face == f)
|
|
{
|
|
self.yaw = yaw;
|
|
self.pitch = pitch;
|
|
return Ok(hit.face);
|
|
}
|
|
}
|
|
}
|
|
let d = dist(eye, centre);
|
|
if d > self.reach() + 0.9 {
|
|
return Err(format!(
|
|
"block {pos:?} is {d:.1} blocks away, out of reach ({:.1}); goto it first",
|
|
self.reach()
|
|
)
|
|
.into());
|
|
}
|
|
Err(format!("no face of block {pos:?} is visible from here").into())
|
|
}
|
|
|
|
/// A left or right click, as the mouse would.
|
|
fn agent_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
|
|
self.play_mouse(button, pressed)
|
|
}
|
|
fn release_agent_keys(&mut self) {
|
|
for k in MOVE_KEYS {
|
|
self.keys.remove(&k);
|
|
}
|
|
if self.left {
|
|
let _ = self.agent_mouse(MouseButton::Left, false);
|
|
}
|
|
if self.right {
|
|
let _ = self.agent_mouse(MouseButton::Right, false);
|
|
}
|
|
}
|
|
|
|
/// Synthesize the pointer moving to GUI pixel (x, y) and a click there.
|
|
pub(super) fn synth_click(
|
|
&mut self,
|
|
event_loop: &ActiveEventLoop,
|
|
x: f32,
|
|
y: f32,
|
|
button: MouseButton,
|
|
) -> Result<()> {
|
|
self.synth_drag(event_loop, &[(x, y)], button)
|
|
}
|
|
/// The window events of a press at the first GUI point, moves through
|
|
/// the others and a release at the last (one point is a click).
|
|
fn synth_drag(
|
|
&mut self,
|
|
event_loop: &ActiveEventLoop,
|
|
points: &[(f32, f32)],
|
|
button: MouseButton,
|
|
) -> Result<()> {
|
|
let id = self.window.as_ref().ok_or("no window yet")?.id();
|
|
let scale = self
|
|
.renderer
|
|
.as_ref()
|
|
.map(|r| horizon_client::hud::HudBatch::new([r.config.width, r.config.height]).scale)
|
|
.ok_or("no renderer yet")?;
|
|
let device_id = DeviceId::dummy();
|
|
for (i, &(x, y)) in points.iter().enumerate() {
|
|
let position = PhysicalPosition::new(f64::from(x * scale), f64::from(y * scale));
|
|
self.window_event(
|
|
event_loop,
|
|
id,
|
|
WindowEvent::CursorMoved {
|
|
device_id,
|
|
position,
|
|
},
|
|
);
|
|
if i == 0 {
|
|
self.window_event(
|
|
event_loop,
|
|
id,
|
|
WindowEvent::MouseInput {
|
|
device_id,
|
|
state: ElementState::Pressed,
|
|
button,
|
|
},
|
|
);
|
|
}
|
|
}
|
|
self.window_event(
|
|
event_loop,
|
|
id,
|
|
WindowEvent::MouseInput {
|
|
device_id,
|
|
state: ElementState::Released,
|
|
button,
|
|
},
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
fn start_task(
|
|
&mut self,
|
|
name: &'static str,
|
|
kind: TaskKind,
|
|
reply: &Sender<String>,
|
|
timeout: f64,
|
|
) -> Result<Handled> {
|
|
self.agent.task = Some(Task {
|
|
kind,
|
|
reply: reply.clone(),
|
|
deadline: Instant::now() + Duration::from_secs_f64(timeout.clamp(0.05, 3600.0)),
|
|
name,
|
|
});
|
|
Ok(Handled::Deferred)
|
|
}
|
|
|
|
/// Agent commands; `Handled::No` when `words[0]` is not one of them.
|
|
pub(super) fn agent_command(
|
|
&mut self,
|
|
words: &[&str],
|
|
line: &str,
|
|
reply: &Sender<String>,
|
|
event_loop: &ActiveEventLoop,
|
|
) -> Result<Handled> {
|
|
let name = words[0];
|
|
let a = parse_args(&words[1..]);
|
|
let ok = |v: Value| Ok(Handled::Reply(v));
|
|
let blocking = matches!(
|
|
name,
|
|
"move"
|
|
| "jump"
|
|
| "goto"
|
|
| "break"
|
|
| "place"
|
|
| "interact"
|
|
| "use-item"
|
|
| "attack"
|
|
| "wait"
|
|
);
|
|
if blocking && let Some(task) = &self.agent.task {
|
|
return Err(format!("busy with {}; wait for it or send stop", task.name).into());
|
|
}
|
|
match name {
|
|
"state" => ok(self.state_value()),
|
|
"looking-at" | "target" => {
|
|
self.need_world()?;
|
|
ok(self.looking_at())
|
|
}
|
|
"entities" => {
|
|
self.need_world()?;
|
|
let radius = a.pos.first().map_or(Ok(32.0), |r| r.parse::<f64>())?;
|
|
ok(self.entities_value(radius, a.pos.get(1).copied()))
|
|
}
|
|
"block" => {
|
|
self.need_world()?;
|
|
ok(self.block_json(a.block_pos(0)?))
|
|
}
|
|
"blocks" => {
|
|
self.need_world()?;
|
|
let (p, q) = (a.block_pos(0)?, a.block_pos(3)?);
|
|
let lo = [0, 1, 2].map(|i| p[i].min(q[i]));
|
|
let hi = [0, 1, 2].map(|i| p[i].max(q[i]));
|
|
let volume: i64 = (0..3).map(|i| i64::from(hi[i] - lo[i] + 1)).product();
|
|
if volume > 32768 {
|
|
return Err(format!("{volume} blocks; at most 32768 per request").into());
|
|
}
|
|
let mut list = Vec::new();
|
|
let mut census: BTreeMap<String, u32> = BTreeMap::new();
|
|
for y in lo[1]..=hi[1] {
|
|
for z in lo[2]..=hi[2] {
|
|
for x in lo[0]..=hi[0] {
|
|
let state = self.world.block(x, y, z);
|
|
if self.res.facts().is_air(state) {
|
|
continue;
|
|
}
|
|
let name = self.res.facts().get(state).name.to_string();
|
|
*census.entry(name).or_insert(0) += 1;
|
|
list.push(json!([x, y, z, self.state_string(state)]));
|
|
}
|
|
}
|
|
}
|
|
ok(json!({ "from": lo, "to": hi, "counts": census, "blocks": list }))
|
|
}
|
|
"light" => {
|
|
self.need_world()?;
|
|
let (p, q) = (a.block_pos(0)?, a.block_pos(3)?);
|
|
let lo = [0, 1, 2].map(|i| p[i].min(q[i]));
|
|
let hi = [0, 1, 2].map(|i| p[i].max(q[i]));
|
|
let volume: i64 = (0..3).map(|i| i64::from(hi[i] - lo[i] + 1)).product();
|
|
if volume > 32768 {
|
|
return Err(format!("{volume} blocks; at most 32768 per request").into());
|
|
}
|
|
// One hex digit per block, x fastest, then z, then y; `.`
|
|
// outside the loaded chunks.
|
|
let (mut sky, mut block) = (String::new(), String::new());
|
|
for y in lo[1]..=hi[1] {
|
|
for z in lo[2]..=hi[2] {
|
|
for x in lo[0]..=hi[0] {
|
|
let packed = self
|
|
.world
|
|
.chunks
|
|
.get(&(x >> 4, z >> 4))
|
|
.filter(|_| (MIN_Y..MIN_Y + SECTIONS as i32 * 16).contains(&y))
|
|
.map(|c| c.light(x & 15, y, z & 15));
|
|
let digit = |v: u8| char::from_digit(u32::from(v), 16).unwrap_or('.');
|
|
sky.push(packed.map_or('.', |v| digit(v >> 4)));
|
|
block.push(packed.map_or('.', |v| digit(v & 15)));
|
|
}
|
|
}
|
|
}
|
|
ok(json!({ "from": lo, "to": hi, "sky": sky, "block": block }))
|
|
}
|
|
"find-block" => {
|
|
self.need_world()?;
|
|
let want = namespaced(a.get(0, "BLOCK")?);
|
|
let radius = a
|
|
.pos
|
|
.get(1)
|
|
.map_or(Ok(32), |r| r.parse::<i32>())?
|
|
.clamp(1, 64);
|
|
let eye = self.eye_position().ok_or("no player")?;
|
|
let c = eye.map(|v| v.floor() as i32);
|
|
let mut found = Vec::new();
|
|
for y in (c[1] - radius).max(-64)..=(c[1] + radius).min(319) {
|
|
for z in c[2] - radius..=c[2] + radius {
|
|
for x in c[0] - radius..=c[0] + radius {
|
|
let state = self.world.block(x, y, z);
|
|
if *self.res.facts().get(state).name == *want {
|
|
let d = dist(eye, [x, y, z].map(|v| f64::from(v) + 0.5));
|
|
found.push((d, [x, y, z]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
found.sort_by(|a, b| a.0.total_cmp(&b.0));
|
|
let total = found.len();
|
|
ok(json!({
|
|
"block": want,
|
|
"count": total,
|
|
"nearest": found.iter().take(16).map(|(d, p)| json!({ "pos": p, "distance": d })).collect::<Vec<_>>(),
|
|
}))
|
|
}
|
|
"inventory" => {
|
|
self.need_world()?;
|
|
ok(self.inventory_value())
|
|
}
|
|
"screen" => ok(self.screen_value()),
|
|
"messages" => {
|
|
let n = a.pos.first().map_or(Ok(20), |n| n.parse::<usize>())?;
|
|
ok(self.messages_value(n))
|
|
}
|
|
"move" => {
|
|
self.playing()?;
|
|
let key = match a.get(0, "DIR")? {
|
|
"forward" | "w" => KeyCode::KeyW,
|
|
"back" | "backward" | "s" => KeyCode::KeyS,
|
|
"left" | "a" => KeyCode::KeyA,
|
|
"right" | "d" => KeyCode::KeyD,
|
|
other => {
|
|
return Err(
|
|
format!("DIR is forward, back, left or right, not {other}").into()
|
|
);
|
|
}
|
|
};
|
|
let seconds = a.f64(1, "SECONDS")?.clamp(0.0, 600.0);
|
|
let mut keys = vec![key];
|
|
if a.has("sprint") {
|
|
keys.push(KeyCode::ControlLeft);
|
|
}
|
|
if a.has("sneak") {
|
|
keys.push(KeyCode::ShiftLeft);
|
|
}
|
|
if a.has("jump") {
|
|
keys.push(KeyCode::Space);
|
|
}
|
|
for &k in &keys {
|
|
self.keys.insert(k);
|
|
}
|
|
let from = self.player.as_ref().map_or(Vec3::ZERO, |p| p.position);
|
|
let until = Instant::now() + Duration::from_secs_f64(seconds);
|
|
self.start_task(
|
|
"move",
|
|
TaskKind::Move { keys, until, from },
|
|
reply,
|
|
seconds + 5.0,
|
|
)
|
|
}
|
|
"jump" => {
|
|
self.playing()?;
|
|
self.keys.insert(KeyCode::Space);
|
|
let from_y = self.player.as_ref().map_or(0.0, |p| p.position.y);
|
|
let release_tick = self.ticks + 3;
|
|
self.start_task(
|
|
"jump",
|
|
TaskKind::Jump {
|
|
release_tick,
|
|
from_y,
|
|
},
|
|
reply,
|
|
5.0,
|
|
)
|
|
}
|
|
"goto" => {
|
|
self.playing()?;
|
|
let target = [a.f64(0, "X")?, a.f64(1, "Y")?, a.f64(2, "Z")?];
|
|
let near = a.num("near", 0.6)?.max(0.3);
|
|
let timeout = a.num("timeout", 60.0)?;
|
|
let p = self.player.as_ref().ok_or("no player")?.position;
|
|
let from = [p.x.floor() as i32, p.y.round() as i32, p.z.floor() as i32];
|
|
let (path, warning) = match self.find_path(from, target, near) {
|
|
Some(path) => (path, None),
|
|
None if a.has("direct") => (
|
|
Vec::new(),
|
|
Some("no path found through loaded terrain; walking straight".to_owned()),
|
|
),
|
|
None => {
|
|
return Err(format!(
|
|
"no walking path to {target:?} through loaded terrain (climbs of more than one block, drops of more than three, lava and unloaded chunks are avoided); pick a nearer or lower spot, raise --near, or use --direct to walk straight at it"
|
|
)
|
|
.into());
|
|
}
|
|
};
|
|
let goto = Goto {
|
|
target,
|
|
near,
|
|
sprint: a.has("sprint"),
|
|
path,
|
|
next: 1,
|
|
progress_tick: self.ticks,
|
|
replans: 0,
|
|
jump_until: 0,
|
|
warning,
|
|
};
|
|
self.start_task("goto", TaskKind::Goto(Box::new(goto)), reply, timeout)
|
|
}
|
|
"mouse-move" => {
|
|
self.turning()?;
|
|
let motion = (a.f64(0, "DX")?, a.f64(1, "DY")?);
|
|
self.start_glide(motion, 0.0, None, reply)
|
|
}
|
|
"turn" if a.has("over") => {
|
|
self.turning()?;
|
|
let (dyaw, dpitch) = (a.f64(0, "DYAW")?, a.f64(1, "DPITCH")?);
|
|
let motion =
|
|
horizon_client::mouse::motion_for_turn(dyaw, dpitch, self.look_options());
|
|
self.start_glide(motion, a.num("over", 0.0)?, None, reply)
|
|
}
|
|
"look-at" => {
|
|
self.need_world()?;
|
|
let over = a.has("over").then(|| a.num("over", 0.0)).transpose()?;
|
|
if over.is_some() {
|
|
self.turning()?;
|
|
}
|
|
let before = (self.yaw, self.pitch);
|
|
let (aim, value) = match a.pos.first().copied() {
|
|
Some("block") => {
|
|
let pos = a.block_pos(1)?;
|
|
let face = a.pos.get(4).map(|f| face_dir(f)).transpose()?;
|
|
let hit = self.aim_block(pos, face)?;
|
|
(
|
|
"block",
|
|
json!({ "ok": true, "yaw": self.yaw, "pitch": self.pitch, "face": face_name(hit) }),
|
|
)
|
|
}
|
|
Some("entity") => {
|
|
let id: u32 = a.get(1, "ID")?.parse()?;
|
|
let m = self
|
|
.mobs
|
|
.iter()
|
|
.find(|m| m.id == id)
|
|
.ok_or_else(|| format!("no entity {id}"))?;
|
|
let c = m.center();
|
|
self.face_point(c)?;
|
|
(
|
|
"entity",
|
|
json!({ "ok": true, "yaw": self.yaw, "pitch": self.pitch, "target": self.looking_at() }),
|
|
)
|
|
}
|
|
_ => {
|
|
let at = [a.f64(0, "X")?, a.f64(1, "Y")?, a.f64(2, "Z")?];
|
|
self.face_point(at)?;
|
|
(
|
|
"point",
|
|
json!({ "ok": true, "yaw": self.yaw, "pitch": self.pitch }),
|
|
)
|
|
}
|
|
};
|
|
let Some(over) = over else {
|
|
return ok(value);
|
|
};
|
|
// Turn there with the mouse instead: the shorter way round.
|
|
let target = (self.yaw, self.pitch);
|
|
(self.yaw, self.pitch) = before;
|
|
let dyaw = f64::from(target.0 - before.0 + 180.0).rem_euclid(360.0) - 180.0;
|
|
let dpitch = f64::from(target.1 - before.1);
|
|
let motion =
|
|
horizon_client::mouse::motion_for_turn(dyaw, dpitch, self.look_options());
|
|
self.start_glide(motion, over, Some(aim), reply)
|
|
}
|
|
"attack" => {
|
|
self.playing()?;
|
|
let id = a.pos.first().map(|i| i.parse::<u32>()).transpose()?;
|
|
if let Some(id) = id {
|
|
let m = self
|
|
.mobs
|
|
.iter()
|
|
.find(|m| m.id == id)
|
|
.ok_or_else(|| format!("no entity {id}"))?;
|
|
let c = m.center();
|
|
self.face_point(c)?;
|
|
}
|
|
let target = self
|
|
.mob_hit()
|
|
.map(|(i, _)| (self.mobs[i].id, self.mobs[i].health));
|
|
if id.is_some() && target.map(|t| t.0) != id {
|
|
return Err("that entity is out of reach or hidden; get closer".into());
|
|
}
|
|
self.agent_mouse(MouseButton::Left, true)?;
|
|
self.agent_mouse(MouseButton::Left, false)?;
|
|
let report_tick = self.ticks + 4;
|
|
self.start_task(
|
|
"attack",
|
|
TaskKind::Attack {
|
|
id: target.map(|t| t.0),
|
|
health: target.map(|t| t.1),
|
|
report_tick,
|
|
},
|
|
reply,
|
|
5.0,
|
|
)
|
|
}
|
|
"break" => {
|
|
self.playing()?;
|
|
let pos = a.block_pos(0)?;
|
|
let before = self.world.block(pos[0], pos[1], pos[2]);
|
|
if self.res.facts().is_air(before) {
|
|
return Err(format!("there is no block at {pos:?}").into());
|
|
}
|
|
self.aim_block(pos, None)?;
|
|
let timeout = a.num("timeout", 30.0)?;
|
|
let task = Break {
|
|
pos,
|
|
before,
|
|
items_before: self.dropped.iter().map(|i| i.id).collect(),
|
|
inventory: self.inventory_counts(),
|
|
started_tick: self.ticks,
|
|
collect_until: None,
|
|
broke_tick: 0,
|
|
drops: BTreeMap::new(),
|
|
};
|
|
self.agent_mouse(MouseButton::Left, true)?;
|
|
self.start_task("break", TaskKind::Break(Box::new(task)), reply, timeout)
|
|
}
|
|
"place" => {
|
|
self.playing()?;
|
|
let pos = a.block_pos(0)?;
|
|
if let Some(Some(item)) = a.flags.get("item") {
|
|
self.select_item(&namespaced(item))?;
|
|
}
|
|
let held = self
|
|
.held()
|
|
.ok_or("nothing in hand to place; select an item")?;
|
|
let held = held.item.clone();
|
|
let before = self.world.block(pos[0], pos[1], pos[2]);
|
|
if !self.res.facts().get(before).replaceable && !self.res.facts().is_air(before) {
|
|
return Err(format!(
|
|
"{pos:?} holds {}; break it first",
|
|
self.res.facts().get(before).name
|
|
)
|
|
.into());
|
|
}
|
|
// A replaceable block there (grass, snow) is clicked itself, as
|
|
// a player would; otherwise the face of a neighbour touching it.
|
|
let mut aimed = !self.res.facts().is_air(before)
|
|
&& !self.res.facts().get(before).outline.is_empty()
|
|
&& self.aim_block(pos, None).is_ok();
|
|
for (_, d) in FACES.iter().filter(|_| !aimed) {
|
|
let d = *d;
|
|
let support = add(pos, d);
|
|
let state = self.world.block(support[0], support[1], support[2]);
|
|
let f = self.res.facts().get(state);
|
|
if self.res.facts().is_air(state)
|
|
|| f.replaceable
|
|
|| f.fluid != horizon_client::blocks::Fluid::None && !f.waterlogged
|
|
{
|
|
continue;
|
|
}
|
|
let face = d.map(|v| -v);
|
|
if self.aim_block(support, Some(face)).is_ok() {
|
|
aimed = true;
|
|
break;
|
|
}
|
|
}
|
|
if !aimed {
|
|
return Err(format!(
|
|
"no visible face to place {held} against at {pos:?}; it needs a solid neighbour in reach"
|
|
)
|
|
.into());
|
|
}
|
|
let inventory = self.inventory_counts();
|
|
self.agent_mouse(MouseButton::Right, true)?;
|
|
self.agent_mouse(MouseButton::Right, false)?;
|
|
let report_tick = self.ticks + 2;
|
|
self.start_task(
|
|
"place",
|
|
TaskKind::Click {
|
|
pos: Some(pos),
|
|
before: Some(before),
|
|
inventory,
|
|
report_tick,
|
|
release: None,
|
|
place: true,
|
|
},
|
|
reply,
|
|
5.0,
|
|
)
|
|
}
|
|
"interact" | "use-item" => {
|
|
self.playing()?;
|
|
let hold = a.num("hold", 0.0)?;
|
|
let pos = if name == "interact" {
|
|
let pos = a.block_pos(0)?;
|
|
let face = a.pos.get(3).map(|f| face_dir(f)).transpose()?;
|
|
self.aim_block(pos, face)?;
|
|
Some(pos)
|
|
} else {
|
|
None
|
|
};
|
|
let before = pos.map(|p| self.world.block(p[0], p[1], p[2]));
|
|
let inventory = self.inventory_counts();
|
|
self.agent_mouse(MouseButton::Right, true)?;
|
|
let release = if hold > 0.0 {
|
|
Some(Instant::now() + Duration::from_secs_f64(hold))
|
|
} else {
|
|
self.agent_mouse(MouseButton::Right, false)?;
|
|
None
|
|
};
|
|
let report_tick = self.ticks + 2;
|
|
self.start_task(
|
|
if name == "interact" {
|
|
"interact"
|
|
} else {
|
|
"use-item"
|
|
},
|
|
TaskKind::Click {
|
|
pos,
|
|
before,
|
|
inventory,
|
|
report_tick,
|
|
release,
|
|
place: false,
|
|
},
|
|
reply,
|
|
hold + 5.0,
|
|
)
|
|
}
|
|
"select" => {
|
|
self.need_world()?;
|
|
let what = a.get(0, "SLOT or ITEM")?;
|
|
match what.parse::<usize>() {
|
|
Ok(n) if (1..=9).contains(&n) => self.selected = n - 1,
|
|
Ok(_) => return Err("hotbar slots are 1..9".into()),
|
|
Err(_) => self.select_item(&namespaced(what))?,
|
|
}
|
|
ok(
|
|
json!({ "ok": true, "selected": self.selected + 1, "held": self.held().map(|s| self.stack_value(s)) }),
|
|
)
|
|
}
|
|
"drop" => {
|
|
self.playing()?;
|
|
let all = a.pos.first() == Some(&"all");
|
|
let before = self.held().map(|s| self.stack_value(s));
|
|
self.drop_held(all);
|
|
ok(
|
|
json!({ "ok": true, "dropped_from": before, "held": self.held().map(|s| self.stack_value(s)) }),
|
|
)
|
|
}
|
|
"open-inventory" => {
|
|
self.playing()?;
|
|
self.key_pressed(KeyCode::KeyE)?;
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"click-button" => {
|
|
let label = line
|
|
.trim_start()
|
|
.strip_prefix("click-button")
|
|
.unwrap_or("")
|
|
.trim()
|
|
.trim_matches('"');
|
|
if label.is_empty() {
|
|
return Err("click-button LABEL".into());
|
|
}
|
|
let w = widgets::find(&widgets::last(), label)?;
|
|
if !w.enabled {
|
|
return Err(format!("button {:?} is disabled", w.label).into());
|
|
}
|
|
self.synth_click(
|
|
event_loop,
|
|
w.x + w.w / 2.0,
|
|
w.y + w.h / 2.0,
|
|
MouseButton::Left,
|
|
)?;
|
|
ok(json!({ "ok": true, "clicked": w.label, "screen": self.screen_label() }))
|
|
}
|
|
"drag-at" => {
|
|
let right = a.pos.first() == Some(&"right");
|
|
let numbers = &a.pos[usize::from(right)..];
|
|
let points = numbers
|
|
.chunks(2)
|
|
.map(|c| match c {
|
|
[x, y] => Ok((x.parse::<f32>()?, y.parse::<f32>()?)),
|
|
_ => Err("drag-at needs X Y pairs".into()),
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
if points.is_empty() {
|
|
return Err("drag-at needs X Y pairs".into());
|
|
}
|
|
let button = if right {
|
|
MouseButton::Right
|
|
} else {
|
|
MouseButton::Left
|
|
};
|
|
self.synth_drag(event_loop, &points, button)?;
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"scroll-at" => {
|
|
let (x, y) = (a.f64(0, "X")? as f32, a.f64(1, "Y")? as f32);
|
|
let steps = a.f64(2, "STEPS")? as f32;
|
|
let id = self.window.as_ref().ok_or("no window yet")?.id();
|
|
let scale = self
|
|
.renderer
|
|
.as_ref()
|
|
.map(|r| {
|
|
horizon_client::hud::HudBatch::new([r.config.width, r.config.height]).scale
|
|
})
|
|
.ok_or("no renderer yet")?;
|
|
let device_id = DeviceId::dummy();
|
|
let position = PhysicalPosition::new(f64::from(x * scale), f64::from(y * scale));
|
|
self.window_event(
|
|
event_loop,
|
|
id,
|
|
WindowEvent::CursorMoved {
|
|
device_id,
|
|
position,
|
|
},
|
|
);
|
|
for _ in 0..steps.abs() as u32 {
|
|
self.window_event(
|
|
event_loop,
|
|
id,
|
|
WindowEvent::MouseWheel {
|
|
device_id,
|
|
delta: MouseScrollDelta::LineDelta(0.0, steps.signum()),
|
|
phase: TouchPhase::Moved,
|
|
},
|
|
);
|
|
}
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"click-at" => {
|
|
let (x, y) = (a.f64(0, "X")? as f32, a.f64(1, "Y")? as f32);
|
|
let button = if a.pos.get(2) == Some(&"right") {
|
|
MouseButton::Right
|
|
} else {
|
|
MouseButton::Left
|
|
};
|
|
self.synth_click(event_loop, x, y, button)?;
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"type" if self.title.is_some() => {
|
|
// type [--field name|seed] [--replace] TEXT on the title screens.
|
|
let mut text = line
|
|
.trim_start()
|
|
.strip_prefix("type")
|
|
.unwrap_or("")
|
|
.strip_prefix(' ')
|
|
.unwrap_or("");
|
|
let mut field = None;
|
|
let mut replace = false;
|
|
loop {
|
|
if let Some(rest) = text.strip_prefix("--replace") {
|
|
replace = true;
|
|
text = rest.trim_start();
|
|
} else if let Some(rest) = text.strip_prefix("--field") {
|
|
let rest = rest.trim_start();
|
|
let (name, rest) = rest.split_once(' ').unwrap_or((rest, ""));
|
|
field = Some(name.to_owned());
|
|
text = rest;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
let title = self.title.as_mut().ok_or("no title screen")?;
|
|
if let Some(field) = &field {
|
|
match &mut title.mode {
|
|
horizon_client::title::Mode::Create { focus, options, .. } => {
|
|
// Each box is on its own tab.
|
|
*focus = match field.as_str() {
|
|
"name" => {
|
|
options.tab = 0;
|
|
0
|
|
}
|
|
"seed" => {
|
|
options.tab = 1;
|
|
1
|
|
}
|
|
other => {
|
|
return Err(format!(
|
|
"the create-world fields are name and seed, not {other}"
|
|
)
|
|
.into());
|
|
}
|
|
}
|
|
}
|
|
horizon_client::title::Mode::Edit { focused, .. } if field == "name" => {
|
|
*focused = true
|
|
}
|
|
_ => {
|
|
return Err(
|
|
"--field works on the create-world or edit-world screen".into()
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if replace {
|
|
for _ in 0..64 {
|
|
title.backspace();
|
|
}
|
|
}
|
|
if text == "\\b" {
|
|
title.backspace();
|
|
} else {
|
|
title.type_text(text);
|
|
}
|
|
ok(json!({ "ok": true, "menu": self.title_value() }))
|
|
}
|
|
"command" => {
|
|
self.need_world()?;
|
|
let text = line
|
|
.trim_start()
|
|
.strip_prefix("command")
|
|
.unwrap_or("")
|
|
.trim()
|
|
.trim_start_matches('/');
|
|
if text.is_empty() {
|
|
return Err("command TEXT".into());
|
|
}
|
|
let command = format!("/{text}");
|
|
// Single player's console is its server thread's.
|
|
if let Some(server) = &self.integrated {
|
|
let chat = server
|
|
.call(move |g| g.owner_console_command(&command))
|
|
.ok_or("the integrated server stopped")?;
|
|
return ok(json!({ "ok": true, "chat": chat }));
|
|
}
|
|
if self.remote.is_some() {
|
|
self.send_chat(&command);
|
|
return ok(json!({ "ok": true }));
|
|
}
|
|
self.as_console(|g| g.handle_chat_input(&command));
|
|
ok(json!({ "ok": true, "chat": self.ui.chat.recent_lines(5) }))
|
|
}
|
|
"respawn" if self.remote.is_none() => {
|
|
if self.screen != Screen::Dead {
|
|
return Err("respawn needs the death screen".into());
|
|
}
|
|
let key = if self.level.hardcore {
|
|
"deathScreen.spectate"
|
|
} else {
|
|
"deathScreen.respawn"
|
|
};
|
|
let label = horizon_client::text::Text::translate(key, &[]).plain();
|
|
let w = widgets::find(&widgets::last(), &label)?;
|
|
if !w.enabled {
|
|
// DeathScreen enables its buttons after 20 ticks.
|
|
return Err(
|
|
"the Respawn button is not active yet; try again in a second (wait 20)"
|
|
.into(),
|
|
);
|
|
}
|
|
self.synth_click(
|
|
event_loop,
|
|
w.x + w.w / 2.0,
|
|
w.y + w.h / 2.0,
|
|
MouseButton::Left,
|
|
)?;
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"pause" => {
|
|
self.playing()?;
|
|
self.key_pressed(KeyCode::Escape)?;
|
|
ok(json!({ "ok": true, "screen": self.screen_label() }))
|
|
}
|
|
"wait" => {
|
|
self.need_world()?;
|
|
let ticks: u64 = a.get(0, "TICKS")?.parse()?;
|
|
let until_tick = self.ticks + ticks;
|
|
let timeout = ticks as f64 / 20.0 * 4.0 + 10.0;
|
|
self.start_task("wait", TaskKind::Wait { until_tick }, reply, timeout)
|
|
}
|
|
"stop" => {
|
|
let cancelled = self.agent.task.take().map(|t| {
|
|
let _ = t.reply.send(
|
|
json!({ "error": "cancelled by stop", "cancelled": true }).to_string(),
|
|
);
|
|
t.name
|
|
});
|
|
let turning = self.agent.glide.take().map(|g| {
|
|
let _ = g.reply.send(
|
|
json!({ "error": "cancelled by stop", "cancelled": true }).to_string(),
|
|
);
|
|
"turn"
|
|
});
|
|
let cancelled = cancelled.or(turning);
|
|
self.release_agent_keys();
|
|
ok(json!({ "ok": true, "cancelled": cancelled }))
|
|
}
|
|
_ => Ok(Handled::No),
|
|
}
|
|
}
|
|
|
|
/// Select the hotbar slot holding `item`.
|
|
fn select_item(&mut self, item: &str) -> Result<()> {
|
|
if let Some(i) =
|
|
(0..9).find(|&i| self.inventory[i].as_ref().is_some_and(|s| &*s.item == item))
|
|
{
|
|
self.selected = i;
|
|
return Ok(());
|
|
}
|
|
if self.inventory.iter().flatten().any(|s| &*s.item == item) {
|
|
return Err(format!(
|
|
"{item} is in the main inventory, not the hotbar; move it with open-inventory and click-slot"
|
|
)
|
|
.into());
|
|
}
|
|
Err(format!("no {item} in the inventory").into())
|
|
}
|
|
|
|
/// Mouse motion turns the view only in the world with no screen open
|
|
/// (`MouseHandler` turns the player while the mouse is grabbed).
|
|
fn turning(&self) -> Result<()> {
|
|
self.playing()?;
|
|
if self.agent.glide.is_some() {
|
|
return Err("already turning; wait for it or send stop".into());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn start_glide(
|
|
&mut self,
|
|
total: (f64, f64),
|
|
over: f64,
|
|
aim: Option<&'static str>,
|
|
reply: &Sender<String>,
|
|
) -> Result<Handled> {
|
|
if !over.is_finite() || !(0.0..=60.0).contains(&over) {
|
|
return Err("--over takes 0 to 60 seconds".into());
|
|
}
|
|
if !(total.0.is_finite() && total.1.is_finite()) {
|
|
return Err("the motion must be finite".into());
|
|
}
|
|
let now = Instant::now();
|
|
let over = Duration::from_secs_f64(over);
|
|
self.agent.glide = Some(Glide {
|
|
total,
|
|
fed: (0.0, 0.0),
|
|
started: now,
|
|
over,
|
|
fed_frame: self.frames,
|
|
deadline: now + over + Duration::from_secs(10),
|
|
reply: reply.clone(),
|
|
aim,
|
|
});
|
|
self.advance_glide();
|
|
Ok(Handled::Deferred)
|
|
}
|
|
|
|
/// Feed the motion due by now (eased over the glide's time); reply once
|
|
/// all of it has been turned by a frame.
|
|
fn advance_glide(&mut self) {
|
|
let Some(mut g) = self.agent.glide.take() else {
|
|
return;
|
|
};
|
|
let done = |game: &Self, extra: Value| {
|
|
let mut v = json!({
|
|
"ok": true,
|
|
"yaw": game.yaw,
|
|
"pitch": game.pitch,
|
|
"motion": [g.total.0, g.total.1],
|
|
});
|
|
if let (Value::Object(m), Value::Object(e)) = (&mut v, extra) {
|
|
m.extend(e);
|
|
}
|
|
v
|
|
};
|
|
if let Err(e) = self.playing() {
|
|
let _ = g.reply.send(
|
|
json!({ "error": format!("stopped turning: {e}"), "yaw": self.yaw, "pitch": self.pitch })
|
|
.to_string(),
|
|
);
|
|
return;
|
|
}
|
|
let now = Instant::now();
|
|
let t = if g.over.is_zero() {
|
|
1.0
|
|
} else {
|
|
now.duration_since(g.started).as_secs_f64() / g.over.as_secs_f64()
|
|
};
|
|
let f = horizon_client::mouse::ease_in_out(t);
|
|
let due = (g.total.0 * f, g.total.1 * f);
|
|
let step = (due.0 - g.fed.0, due.1 - g.fed.1);
|
|
if step != (0.0, 0.0) {
|
|
self.mouse.add_motion(step.0, step.1);
|
|
self.agent_pointer = true;
|
|
g.fed = due;
|
|
g.fed_frame = self.frames;
|
|
}
|
|
if t >= 1.0 && self.frames > g.fed_frame {
|
|
let extra = match g.aim {
|
|
Some("block") | Some("entity") => json!({ "target": self.looking_at() }),
|
|
_ => json!({}),
|
|
};
|
|
let _ = g.reply.send(done(self, extra).to_string());
|
|
return;
|
|
}
|
|
if now >= g.deadline {
|
|
let _ = g.reply.send(
|
|
json!({ "error": "no frame was drawn to turn the view", "yaw": self.yaw, "pitch": self.pitch })
|
|
.to_string(),
|
|
);
|
|
return;
|
|
}
|
|
self.agent.glide = Some(g);
|
|
}
|
|
|
|
/// Advance the running agent task; reply when it ends.
|
|
pub(super) fn advance_agent(&mut self) {
|
|
self.advance_glide();
|
|
let Some(mut task) = self.agent.task.take() else {
|
|
return;
|
|
};
|
|
let timed_out = Instant::now() >= task.deadline;
|
|
let result = self.step_task(&mut task.kind, timed_out);
|
|
match result {
|
|
Some(value) => {
|
|
if task.kind.releases_input() {
|
|
self.release_agent_keys();
|
|
}
|
|
let _ = task.reply.send(value.to_string());
|
|
}
|
|
None => self.agent.task = Some(task),
|
|
}
|
|
}
|
|
|
|
fn position(&self) -> [f64; 3] {
|
|
self.player
|
|
.as_ref()
|
|
.map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z])
|
|
}
|
|
|
|
/// One frame of a task: Some(reply) when it is over.
|
|
fn step_task(&mut self, kind: &mut TaskKind, timed_out: bool) -> Option<Value> {
|
|
// Leaving the world (death, a screen, the title) ends movement tasks.
|
|
let interrupted = if self.title.is_some() || self.player.is_none() {
|
|
Some("the world closed")
|
|
} else if self.screen == Screen::Dead {
|
|
Some("the player died")
|
|
} else {
|
|
None
|
|
};
|
|
match kind {
|
|
TaskKind::Move { keys, until, from } => {
|
|
if let Some(why) = interrupted {
|
|
return Some(json!({ "error": why, "position": self.position() }));
|
|
}
|
|
for &k in keys.iter() {
|
|
self.keys.insert(k);
|
|
}
|
|
if Instant::now() < *until && !timed_out {
|
|
return None;
|
|
}
|
|
let to = self.position();
|
|
Some(
|
|
json!({ "ok": true, "from": [from.x, from.y, from.z], "position": to,
|
|
"moved": dist([from.x, from.y, from.z], to) }),
|
|
)
|
|
}
|
|
TaskKind::Wait { until_tick } => {
|
|
if self.ticks >= *until_tick {
|
|
Some(json!({ "ok": true, "ticks": self.ticks }))
|
|
} else if timed_out {
|
|
Some(
|
|
json!({ "error": "game ticks are not advancing (paused?)", "ticks": self.ticks }),
|
|
)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
TaskKind::Jump {
|
|
release_tick,
|
|
from_y,
|
|
} => {
|
|
if self.ticks >= *release_tick || timed_out {
|
|
self.keys.remove(&KeyCode::Space);
|
|
let on_ground = self.player.as_ref().is_some_and(|p| p.ground.on_ground);
|
|
if on_ground || timed_out {
|
|
return Some(
|
|
json!({ "ok": true, "from_y": from_y, "position": self.position() }),
|
|
);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
TaskKind::Goto(goto) => {
|
|
if let Some(why) = interrupted {
|
|
return Some(json!({ "error": why, "position": self.position() }));
|
|
}
|
|
if self.screen != Screen::Playing {
|
|
return Some(
|
|
json!({ "error": format!("the {} screen opened", self.screen_label()), "position": self.position() }),
|
|
);
|
|
}
|
|
self.step_goto(goto, timed_out)
|
|
}
|
|
TaskKind::Break(b) => self.step_break(b, timed_out, interrupted),
|
|
TaskKind::Click {
|
|
pos,
|
|
before,
|
|
inventory,
|
|
report_tick,
|
|
release,
|
|
place,
|
|
} => {
|
|
if let Some(at) = release {
|
|
if Instant::now() < *at && !timed_out && interrupted.is_none() {
|
|
return None;
|
|
}
|
|
let _ = self.agent_mouse(MouseButton::Right, false);
|
|
*release = None;
|
|
*report_tick = self.ticks + 2;
|
|
}
|
|
if self.ticks < *report_tick && !timed_out {
|
|
return None;
|
|
}
|
|
let changed = match (*pos, *before) {
|
|
(Some(p), Some(b)) => self.world.block(p[0], p[1], p[2]) != b,
|
|
_ => false,
|
|
};
|
|
// A client of a server (single player's server thread, a LAN
|
|
// guest) sees the block once the server's answer comes.
|
|
if *place
|
|
&& !changed
|
|
&& self.remote.is_some()
|
|
&& self.ticks < *report_tick + 20
|
|
&& !timed_out
|
|
{
|
|
return None;
|
|
}
|
|
let after = pos.map(|p| self.block_json(p));
|
|
let used = delta(inventory, &self.inventory_counts());
|
|
let mut v = json!({
|
|
"ok": !*place || changed,
|
|
"block_before": before.map(|b| self.state_string(b)),
|
|
"block": after,
|
|
"changed": changed,
|
|
"inventory_change": used,
|
|
"screen": self.screen_label(),
|
|
});
|
|
if *place && !changed {
|
|
v["error"] = json!(
|
|
"the block did not change (blocked by an entity, or the item cannot be placed)"
|
|
);
|
|
}
|
|
Some(v)
|
|
}
|
|
TaskKind::Attack {
|
|
id,
|
|
health,
|
|
report_tick,
|
|
} => {
|
|
if self.ticks < *report_tick && !timed_out {
|
|
return None;
|
|
}
|
|
let now = id.and_then(|id| self.mobs.iter().find(|m| m.id == id));
|
|
Some(json!({
|
|
"ok": true,
|
|
"target": id,
|
|
"health_before": health,
|
|
"health": now.map(|m| m.health),
|
|
"alive": now.is_some_and(|m| m.alive()),
|
|
"hit": id.is_some(),
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn step_goto(&mut self, g: &mut Goto, timed_out: bool) -> Option<Value> {
|
|
let p = self.position();
|
|
let on_ground = self.player.as_ref().is_some_and(|p| p.ground.on_ground);
|
|
let horizontal =
|
|
|a: [f64; 3], b: [f64; 3]| ((a[0] - b[0]).powi(2) + (a[2] - b[2]).powi(2)).sqrt();
|
|
let arrived = horizontal(p, g.target) <= g.near
|
|
&& (p[1] - g.target[1]).abs() <= g.near.max(1.0) + 1.0;
|
|
if arrived {
|
|
return Some(
|
|
json!({ "ok": true, "arrived": true, "position": p, "target": g.target,
|
|
"distance": dist(p, g.target), "warning": g.warning }),
|
|
);
|
|
}
|
|
if timed_out {
|
|
return Some(
|
|
json!({ "error": "timed out before arriving", "arrived": false, "position": p,
|
|
"target": g.target, "distance": dist(p, g.target), "warning": g.warning }),
|
|
);
|
|
}
|
|
// The next waypoint: path nodes, then the target itself.
|
|
let mut aim = g.target;
|
|
while g.next < g.path.len() {
|
|
let n = g.path[g.next];
|
|
let c = [
|
|
f64::from(n[0]) + 0.5,
|
|
f64::from(n[1]),
|
|
f64::from(n[2]) + 0.5,
|
|
];
|
|
let last = g.next + 1 == g.path.len();
|
|
if horizontal(p, c) < if last { 0.3 } else { 0.45 } && (p[1] - c[1]).abs() < 1.1 {
|
|
g.next += 1;
|
|
g.progress_tick = self.ticks;
|
|
continue;
|
|
}
|
|
aim = c;
|
|
break;
|
|
}
|
|
// Stuck: jump, then replan from here.
|
|
let stalled = self.ticks.saturating_sub(g.progress_tick);
|
|
if stalled > 60 && on_ground {
|
|
g.jump_until = self.ticks + 4;
|
|
}
|
|
if stalled > 120 {
|
|
g.replans += 1;
|
|
if g.replans > 3 {
|
|
return Some(
|
|
json!({ "error": "stuck: cannot make progress", "arrived": false, "position": p,
|
|
"target": g.target, "distance": dist(p, g.target) }),
|
|
);
|
|
}
|
|
let from = [
|
|
p[0].floor() as i32,
|
|
p[1].round() as i32,
|
|
p[2].floor() as i32,
|
|
];
|
|
if let Some(path) = self.find_path(from, g.target, g.near) {
|
|
g.path = path;
|
|
g.next = 1;
|
|
}
|
|
g.progress_tick = self.ticks;
|
|
}
|
|
let d = [aim[0] - p[0], aim[2] - p[2]];
|
|
if d[0].abs() + d[1].abs() > 1e-3 {
|
|
self.yaw = (-d[0]).atan2(d[1]).to_degrees() as f32;
|
|
}
|
|
self.keys.insert(KeyCode::KeyW);
|
|
if g.sprint {
|
|
self.keys.insert(KeyCode::ControlLeft);
|
|
}
|
|
// Step up onto the next block, or out of water.
|
|
let in_water = {
|
|
let b = p.map(|v| v.floor() as i32);
|
|
self.res
|
|
.facts()
|
|
.get(self.world.block(b[0], b[1], b[2]))
|
|
.fluid
|
|
!= horizon_client::blocks::Fluid::None
|
|
};
|
|
if aim[1] > p[1] + 0.5 && horizontal(p, aim) < 1.6 && on_ground {
|
|
g.jump_until = self.ticks + 4;
|
|
}
|
|
if self.ticks < g.jump_until || in_water {
|
|
self.keys.insert(KeyCode::Space);
|
|
} else {
|
|
self.keys.remove(&KeyCode::Space);
|
|
}
|
|
None
|
|
}
|
|
|
|
fn step_break(
|
|
&mut self,
|
|
b: &mut Break,
|
|
timed_out: bool,
|
|
interrupted: Option<&str>,
|
|
) -> Option<Value> {
|
|
let state = self.world.block(b.pos[0], b.pos[1], b.pos[2]);
|
|
if b.collect_until.is_none() {
|
|
if let Some(why) = interrupted {
|
|
return Some(json!({ "error": why, "pos": b.pos }));
|
|
}
|
|
if state != b.before {
|
|
// Broken: collect what drops for a moment.
|
|
let _ = self.agent_mouse(MouseButton::Left, false);
|
|
b.broke_tick = self.ticks;
|
|
b.collect_until = Some(self.ticks + 20);
|
|
} else if timed_out {
|
|
let _ = self.agent_mouse(MouseButton::Left, false);
|
|
return Some(
|
|
json!({ "error": "timed out before the block broke", "pos": b.pos,
|
|
"block": self.state_string(state), "ticks": self.ticks - b.started_tick }),
|
|
);
|
|
} else if self.screen != Screen::Playing {
|
|
return Some(
|
|
json!({ "error": format!("the {} screen opened", self.screen_label()), "pos": b.pos }),
|
|
);
|
|
} else {
|
|
// Keep the crosshair on the block (the player may drift).
|
|
if self.pick().is_none_or(|h| h.pos != b.pos)
|
|
&& let Err(e) = self.aim_block(b.pos, None)
|
|
{
|
|
let _ = self.agent_mouse(MouseButton::Left, false);
|
|
return Some(json!({ "error": e.to_string(), "pos": b.pos }));
|
|
}
|
|
if !self.left {
|
|
let _ = self.agent_mouse(MouseButton::Left, true);
|
|
}
|
|
return None;
|
|
}
|
|
}
|
|
// New item entities near the block are its drops.
|
|
let centre = b.pos.map(|v| f64::from(v) + 0.5);
|
|
for item in &self.dropped {
|
|
if !b.items_before.contains(&item.id)
|
|
&& dist(centre, [item.position.x, item.position.y, item.position.z]) < 3.0
|
|
{
|
|
b.drops.insert(item.id, item.stack.clone());
|
|
}
|
|
}
|
|
let remaining = b
|
|
.drops
|
|
.keys()
|
|
.filter(|id| self.dropped.iter().any(|i| i.id == **id))
|
|
.count();
|
|
let until = b.collect_until.unwrap_or(0);
|
|
if (self.ticks < until && (remaining > 0 || self.ticks < b.broke_tick + 3)) && !timed_out {
|
|
return None;
|
|
}
|
|
Some(json!({
|
|
"ok": true,
|
|
"pos": b.pos,
|
|
"block_before": self.state_string(b.before),
|
|
"block": self.state_string(state),
|
|
"ticks": b.broke_tick - b.started_tick,
|
|
"drops": counts(b.drops.values().cloned()),
|
|
"picked_up": delta(&b.inventory, &self.inventory_counts()),
|
|
"items_left_on_ground": remaining,
|
|
"on_ground": self.dropped.iter().filter(|i| b.drops.contains_key(&i.id)).map(|i| json!({
|
|
"id": i.id, "item": &*i.stack.item, "count": i.stack.count,
|
|
"pos": [i.position.x, i.position.y, i.position.z],
|
|
})).collect::<Vec<_>>(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn only_wait_keeps_held_input() {
|
|
assert!(!TaskKind::Wait { until_tick: 40 }.releases_input());
|
|
let jump = TaskKind::Jump {
|
|
release_tick: 4,
|
|
from_y: 64.0,
|
|
};
|
|
assert!(jump.releases_input());
|
|
}
|
|
|
|
#[test]
|
|
fn parses_flags_and_values() {
|
|
let a = parse_args(&["1", "2", "--near", "3", "--sprint", "--timeout=9", "-4"]);
|
|
assert_eq!(a.pos, ["1", "2", "-4"]);
|
|
assert_eq!(a.flags["near"], Some("3"));
|
|
assert_eq!(a.flags["sprint"], None);
|
|
assert_eq!(a.flags["timeout"], Some("9"));
|
|
assert_eq!(a.num("near", 0.0).unwrap(), 3.0);
|
|
assert_eq!(a.num("missing", 7.0).unwrap(), 7.0);
|
|
assert!(a.f64(5, "X").is_err());
|
|
assert_eq!(a.block_pos(0).ok(), Some([1, 2, -4]));
|
|
assert!(a.block_pos(1).is_err());
|
|
assert_eq!(
|
|
parse_args(&["-1", "64", "2"]).block_pos(0).unwrap(),
|
|
[-1, 64, 2]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn yaw_and_pitch_follow_minecraft() {
|
|
let (yaw, pitch) = yaw_pitch([0.0; 3], [0.0, 0.0, 1.0]);
|
|
assert!(yaw.abs() < 1e-4 && pitch.abs() < 1e-4);
|
|
let (yaw, _) = yaw_pitch([0.0; 3], [-1.0, 0.0, 0.0]);
|
|
assert!((yaw - 90.0).abs() < 1e-4);
|
|
let (_, pitch) = yaw_pitch([0.0; 3], [0.0, -1.0, 0.0]);
|
|
assert!((pitch - 90.0).abs() < 1e-4);
|
|
}
|
|
|
|
#[test]
|
|
fn faces_round_trip() {
|
|
for (name, dir) in FACES {
|
|
assert_eq!(face_dir(name).unwrap(), dir);
|
|
assert_eq!(face_name(dir), name);
|
|
}
|
|
assert!(face_dir("sideways").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn inventory_delta() {
|
|
let before = BTreeMap::from([("a".to_owned(), 2), ("b".to_owned(), 1)]);
|
|
let after = BTreeMap::from([("a".to_owned(), 5), ("c".to_owned(), 1)]);
|
|
let d = delta(&before, &after);
|
|
assert_eq!(
|
|
d,
|
|
BTreeMap::from([
|
|
("a".to_owned(), 3),
|
|
("b".to_owned(), -1),
|
|
("c".to_owned(), 1)
|
|
])
|
|
);
|
|
}
|
|
}
|