//! Key mappings (Options.keyMappings): vanilla names, categories and //! defaults, `key_:key.keyboard.x` persistence, display names, and the //! translation of rebound physical keys back to the default keys the game //! logic listens for. use std::collections::BTreeMap; use winit::{event::MouseButton, keyboard::KeyCode}; /// (name, default key, category) in Options.keyMappings order. pub const MAPPINGS: &[(&str, &str, &str)] = &[ ("key.attack", "key.mouse.left", "gameplay"), ("key.use", "key.mouse.right", "gameplay"), ("key.forward", "key.keyboard.w", "movement"), ("key.left", "key.keyboard.a", "movement"), ("key.back", "key.keyboard.s", "movement"), ("key.right", "key.keyboard.d", "movement"), ("key.jump", "key.keyboard.space", "movement"), ("key.sneak", "key.keyboard.left.shift", "movement"), ("key.sprint", "key.keyboard.left.control", "movement"), ("key.drop", "key.keyboard.q", "inventory"), ("key.inventory", "key.keyboard.e", "inventory"), ("key.chat", "key.keyboard.t", "multiplayer"), ("key.playerlist", "key.keyboard.tab", "multiplayer"), ("key.pickItem", "key.mouse.middle", "gameplay"), ("key.command", "key.keyboard.slash", "multiplayer"), ("key.friends", "key.keyboard.o", "multiplayer"), ("key.socialInteractions", "key.keyboard.p", "multiplayer"), ("key.toggleGui", "key.keyboard.f1", "misc"), ( "key.toggleSpectatorShaderEffects", "key.keyboard.f4", "misc", ), ("key.screenshot", "key.keyboard.f2", "misc"), ("key.togglePerspective", "key.keyboard.f5", "misc"), ("key.smoothCamera", "key.keyboard.unknown", "misc"), ("key.fullscreen", "key.keyboard.f11", "misc"), ("key.spectatorOutlines", "key.keyboard.unknown", "spectator"), ("key.spectatorHotbar", "key.mouse.middle", "spectator"), ("key.swapOffhand", "key.keyboard.f", "inventory"), ("key.saveToolbarActivator", "key.keyboard.c", "creative"), ("key.loadToolbarActivator", "key.keyboard.x", "creative"), ("key.advancements", "key.keyboard.l", "misc"), ("key.quickActions", "key.keyboard.g", "misc"), ("key.debug.overlay", "key.keyboard.f3", "debug"), ("key.debug.modifier", "key.keyboard.f3", "debug"), ("key.hotbar.1", "key.keyboard.1", "inventory"), ("key.hotbar.2", "key.keyboard.2", "inventory"), ("key.hotbar.3", "key.keyboard.3", "inventory"), ("key.hotbar.4", "key.keyboard.4", "inventory"), ("key.hotbar.5", "key.keyboard.5", "inventory"), ("key.hotbar.6", "key.keyboard.6", "inventory"), ("key.hotbar.7", "key.keyboard.7", "inventory"), ("key.hotbar.8", "key.keyboard.8", "inventory"), ("key.hotbar.9", "key.keyboard.9", "inventory"), ("key.debug.reloadChunk", "key.keyboard.a", "debug"), ("key.debug.showHitboxes", "key.keyboard.b", "debug"), ("key.debug.clearChat", "key.keyboard.d", "debug"), ("key.debug.crash", "key.keyboard.c", "debug"), ("key.debug.showChunkBorders", "key.keyboard.g", "debug"), ("key.debug.showAdvancedTooltips", "key.keyboard.h", "debug"), ("key.debug.copyRecreateCommand", "key.keyboard.i", "debug"), ("key.debug.spectate", "key.keyboard.n", "debug"), ("key.debug.switchGameMode", "key.keyboard.f4", "debug"), ("key.debug.debugOptions", "key.keyboard.f6", "debug"), ("key.debug.focusPause", "key.keyboard.p", "debug"), ("key.debug.dumpDynamicTextures", "key.keyboard.s", "debug"), ("key.debug.reloadResourcePacks", "key.keyboard.t", "debug"), ("key.debug.profiling", "key.keyboard.l", "debug"), ("key.debug.copyLocation", "key.keyboard.c", "debug"), ("key.debug.dumpVersion", "key.keyboard.v", "debug"), ("key.debug.profilingChart", "key.keyboard.1", "debug"), ("key.debug.fpsCharts", "key.keyboard.2", "debug"), ("key.debug.networkCharts", "key.keyboard.3", "debug"), ("key.debug.lightmapTexture", "key.keyboard.4", "debug"), ("key.debug.improvedTransparency", "key.keyboard.x", "debug"), ]; /// Mappings Options builds as `ToggleKeyMapping` (hold or toggle by option). pub fn is_toggle(name: &str) -> bool { matches!(name, "key.sneak" | "key.sprint" | "key.use" | "key.attack") } /// KeyMapping.Category sort order. pub const CATEGORIES: [&str; 8] = [ "movement", "misc", "multiplayer", "gameplay", "inventory", "creative", "spectator", "debug", ]; /// InputConstants key names <-> winit physical keys. const KEYS: &[(&str, KeyCode)] = &[ ("key.keyboard.a", KeyCode::KeyA), ("key.keyboard.b", KeyCode::KeyB), ("key.keyboard.c", KeyCode::KeyC), ("key.keyboard.d", KeyCode::KeyD), ("key.keyboard.e", KeyCode::KeyE), ("key.keyboard.f", KeyCode::KeyF), ("key.keyboard.g", KeyCode::KeyG), ("key.keyboard.h", KeyCode::KeyH), ("key.keyboard.i", KeyCode::KeyI), ("key.keyboard.j", KeyCode::KeyJ), ("key.keyboard.k", KeyCode::KeyK), ("key.keyboard.l", KeyCode::KeyL), ("key.keyboard.m", KeyCode::KeyM), ("key.keyboard.n", KeyCode::KeyN), ("key.keyboard.o", KeyCode::KeyO), ("key.keyboard.p", KeyCode::KeyP), ("key.keyboard.q", KeyCode::KeyQ), ("key.keyboard.r", KeyCode::KeyR), ("key.keyboard.s", KeyCode::KeyS), ("key.keyboard.t", KeyCode::KeyT), ("key.keyboard.u", KeyCode::KeyU), ("key.keyboard.v", KeyCode::KeyV), ("key.keyboard.w", KeyCode::KeyW), ("key.keyboard.x", KeyCode::KeyX), ("key.keyboard.y", KeyCode::KeyY), ("key.keyboard.z", KeyCode::KeyZ), ("key.keyboard.1", KeyCode::Digit1), ("key.keyboard.2", KeyCode::Digit2), ("key.keyboard.3", KeyCode::Digit3), ("key.keyboard.4", KeyCode::Digit4), ("key.keyboard.5", KeyCode::Digit5), ("key.keyboard.6", KeyCode::Digit6), ("key.keyboard.7", KeyCode::Digit7), ("key.keyboard.8", KeyCode::Digit8), ("key.keyboard.9", KeyCode::Digit9), ("key.keyboard.0", KeyCode::Digit0), ("key.keyboard.enter", KeyCode::Enter), ("key.keyboard.escape", KeyCode::Escape), ("key.keyboard.backspace", KeyCode::Backspace), ("key.keyboard.tab", KeyCode::Tab), ("key.keyboard.space", KeyCode::Space), ("key.keyboard.minus", KeyCode::Minus), ("key.keyboard.equal", KeyCode::Equal), ("key.keyboard.left.bracket", KeyCode::BracketLeft), ("key.keyboard.right.bracket", KeyCode::BracketRight), ("key.keyboard.backslash", KeyCode::Backslash), ("key.keyboard.semicolon", KeyCode::Semicolon), ("key.keyboard.apostrophe", KeyCode::Quote), ("key.keyboard.grave.accent", KeyCode::Backquote), ("key.keyboard.comma", KeyCode::Comma), ("key.keyboard.period", KeyCode::Period), ("key.keyboard.slash", KeyCode::Slash), ("key.keyboard.caps.lock", KeyCode::CapsLock), ("key.keyboard.f1", KeyCode::F1), ("key.keyboard.f2", KeyCode::F2), ("key.keyboard.f3", KeyCode::F3), ("key.keyboard.f4", KeyCode::F4), ("key.keyboard.f5", KeyCode::F5), ("key.keyboard.f6", KeyCode::F6), ("key.keyboard.f7", KeyCode::F7), ("key.keyboard.f8", KeyCode::F8), ("key.keyboard.f9", KeyCode::F9), ("key.keyboard.f10", KeyCode::F10), ("key.keyboard.f11", KeyCode::F11), ("key.keyboard.f12", KeyCode::F12), ("key.keyboard.print.screen", KeyCode::PrintScreen), ("key.keyboard.scroll.lock", KeyCode::ScrollLock), ("key.keyboard.pause", KeyCode::Pause), ("key.keyboard.insert", KeyCode::Insert), ("key.keyboard.home", KeyCode::Home), ("key.keyboard.page.up", KeyCode::PageUp), ("key.keyboard.delete", KeyCode::Delete), ("key.keyboard.end", KeyCode::End), ("key.keyboard.page.down", KeyCode::PageDown), ("key.keyboard.right", KeyCode::ArrowRight), ("key.keyboard.left", KeyCode::ArrowLeft), ("key.keyboard.down", KeyCode::ArrowDown), ("key.keyboard.up", KeyCode::ArrowUp), ("key.keyboard.num.lock", KeyCode::NumLock), ("key.keyboard.keypad.divide", KeyCode::NumpadDivide), ("key.keyboard.keypad.multiply", KeyCode::NumpadMultiply), ("key.keyboard.keypad.subtract", KeyCode::NumpadSubtract), ("key.keyboard.keypad.add", KeyCode::NumpadAdd), ("key.keyboard.keypad.enter", KeyCode::NumpadEnter), ("key.keyboard.keypad.1", KeyCode::Numpad1), ("key.keyboard.keypad.2", KeyCode::Numpad2), ("key.keyboard.keypad.3", KeyCode::Numpad3), ("key.keyboard.keypad.4", KeyCode::Numpad4), ("key.keyboard.keypad.5", KeyCode::Numpad5), ("key.keyboard.keypad.6", KeyCode::Numpad6), ("key.keyboard.keypad.7", KeyCode::Numpad7), ("key.keyboard.keypad.8", KeyCode::Numpad8), ("key.keyboard.keypad.9", KeyCode::Numpad9), ("key.keyboard.keypad.0", KeyCode::Numpad0), ("key.keyboard.keypad.period", KeyCode::NumpadDecimal), ("key.keyboard.keypad.equal", KeyCode::NumpadEqual), ("key.keyboard.menu", KeyCode::ContextMenu), ("key.keyboard.left.control", KeyCode::ControlLeft), ("key.keyboard.left.shift", KeyCode::ShiftLeft), ("key.keyboard.left.alt", KeyCode::AltLeft), ("key.keyboard.left.win", KeyCode::SuperLeft), ("key.keyboard.right.control", KeyCode::ControlRight), ("key.keyboard.right.shift", KeyCode::ShiftRight), ("key.keyboard.right.alt", KeyCode::AltRight), ("key.keyboard.right.win", KeyCode::SuperRight), ]; pub fn key_code(name: &str) -> Option { KEYS.iter().find(|(n, _)| *n == name).map(|(_, k)| *k) } pub fn key_name(code: KeyCode) -> Option<&'static str> { KEYS.iter().find(|(_, k)| *k == code).map(|(n, _)| *n) } pub fn mouse_name(button: MouseButton) -> String { match button { MouseButton::Left => "key.mouse.left".into(), MouseButton::Right => "key.mouse.right".into(), MouseButton::Middle => "key.mouse.middle".into(), MouseButton::Back => "key.mouse.4".into(), MouseButton::Forward => "key.mouse.5".into(), MouseButton::Other(n) => format!("key.mouse.{}", n + 1), } } pub fn mouse_button(name: &str) -> Option { Some(match name { "key.mouse.left" => MouseButton::Left, "key.mouse.right" => MouseButton::Right, "key.mouse.middle" => MouseButton::Middle, "key.mouse.4" => MouseButton::Back, "key.mouse.5" => MouseButton::Forward, _ => return None, }) } pub use horizon_client_core::key_display::display_name; /// Current bindings by mapping name. #[derive(Clone, Debug, PartialEq, Eq)] pub struct KeyBinds { keys: BTreeMap<&'static str, String>, } impl Default for KeyBinds { fn default() -> Self { Self { keys: MAPPINGS .iter() .map(|(n, d, _)| (*n, (*d).to_owned())) .collect(), } } } /// Each default key once, in order: two mappings that share a default key /// (Advancements and the debug profiler both on L) are one press of it, not /// two (the second would close the screen the first opened). Vanilla clicks /// both mappings, but the profiler one only acts with F3 held. fn distinct(keys: Vec) -> Vec { let mut out = Vec::with_capacity(keys.len()); for k in keys { if !out.contains(&k) { out.push(k); } } out } impl KeyBinds { pub fn get(&self, name: &str) -> &str { self.keys .get(name) .map_or("key.keyboard.unknown", String::as_str) } pub fn default_of(name: &str) -> &'static str { MAPPINGS .iter() .find(|m| m.0 == name) .map_or("key.keyboard.unknown", |m| m.1) } pub fn is_default(&self, name: &str) -> bool { self.get(name) == Self::default_of(name) } pub fn set(&mut self, name: &str, key: &str) { if let Some((n, _, _)) = MAPPINGS.iter().find(|m| m.0 == name) { self.keys.insert(n, key.to_owned()); } } pub fn saved(&self) -> Vec<(&'static str, String)> { MAPPINGS .iter() .map(|(n, _, _)| (*n, self.get(n).to_owned())) .collect() } pub fn reset_all(&mut self) { *self = Self::default(); } /// Mappings sharing `name`'s key (KeyMapping.same), for conflict marks. pub fn conflicts(&self, name: &str) -> Vec<&'static str> { let key = self.get(name); if key == "key.keyboard.unknown" { return Vec::new(); } MAPPINGS .iter() .filter(|(n, _, _)| { *n != name && self.get(n) == key && (!self.is_default(n) || !self.is_default(name)) }) .map(|(n, _, _)| *n) .collect() } /// The mapping a physical input triggers (first in list order). pub fn mapping_for(&self, key: &str) -> Option<&'static str> { self.mappings_for(key).next() } /// Every mapping a physical input triggers, in list order: like /// `KeyMapping.set`/`click`, one key drives all the mappings bound to it. pub fn mappings_for<'a>(&'a self, key: &'a str) -> impl Iterator + 'a { MAPPINGS .iter() .map(|m| m.0) .filter(move |n| self.get(n) == key) } /// Translate a physical key into the default key of the mapping it is /// bound to, so game code written against vanilla defaults follows the /// player's bindings. `None` means the key now does nothing; mouse /// mappings bound to keys come back as `Err(button)`. The first of /// [`KeyBinds::translate_all`]. pub fn translate(&self, key: KeyCode) -> Option> { self.translate_all(key).into_iter().next() } /// The default keys of every mapping `key` is bound to (empty when it /// now does nothing), so a key bound to two mappings (forward and /// sprint) drives both, as `KeyMapping.set` does. pub fn translate_all(&self, key: KeyCode) -> Vec> { let Some(name) = key_name(key) else { return vec![Ok(key)]; }; let bound: Vec<_> = self .mappings_for(name) .filter_map(|mapping| { let default = Self::default_of(mapping); match key_code(default) { Some(code) => Some(Ok(code)), None => mouse_button(default).map(Err), } }) .collect(); if !bound.is_empty() { return distinct(bound); } // An unbound key whose default meaning was moved elsewhere is inert. if MAPPINGS .iter() .any(|(n, d, _)| *d == name && !self.is_default(n)) { return Vec::new(); } vec![Ok(key)] } /// Translate a mouse button the same way (keys bound to mouse buttons). pub fn translate_mouse(&self, button: MouseButton) -> Option> { self.translate_mouse_all(button).into_iter().next() } /// [`KeyBinds::translate_all`] for a mouse button. pub fn translate_mouse_all(&self, button: MouseButton) -> Vec> { let name = mouse_name(button); let bound: Vec<_> = self .mappings_for(&name) .filter_map(|mapping| { let default = Self::default_of(mapping); match mouse_button(default) { Some(b) => Some(Err(b)), None => key_code(default).map(Ok), } }) .collect(); if !bound.is_empty() { return distinct(bound); } if MAPPINGS .iter() .any(|(n, d, _)| *d == name && !self.is_default(n)) { return Vec::new(); } vec![Err(button)] } /// `AbstractContainerScreen.checkHotbarMouseClicked`: off hand, then hotbar. pub fn container_mouse_key(&self, button: MouseButton, creative: bool) -> Option { let name = mouse_name(button); if matches!(button, MouseButton::Left | MouseButton::Right) || (creative && self.get("key.pickItem") == name) { return None; } std::iter::once("key.swapOffhand") .chain( MAPPINGS .iter() .map(|m| m.0) .filter(|n| n.starts_with("key.hotbar.")), ) .find(|mapping| self.get(mapping) == name) .and_then(|mapping| key_code(Self::default_of(mapping))) } } #[cfg(test)] mod tests { use super::*; #[test] fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() { for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] { for (mapping, default, _) in MAPPINGS.iter().filter(|m| m.0.starts_with("key.hotbar.")) { let mut keys = KeyBinds::default(); keys.set(mapping, &mouse_name(button)); assert_eq!(keys.container_mouse_key(button, false), key_code(default)); assert_eq!( keys.container_mouse_key(button, true), if button == MouseButton::Middle { None } else { key_code(default) } ); } } let mut keys = KeyBinds::default(); keys.set("key.hotbar.1", "key.mouse.4"); keys.set("key.swapOffhand", "key.mouse.4"); assert_eq!( keys.container_mouse_key(MouseButton::Back, false), Some(KeyCode::KeyF) ); keys.set("key.hotbar.2", "key.mouse.left"); assert_eq!(keys.container_mouse_key(MouseButton::Left, false), None); assert_eq!(keys.container_mouse_key(MouseButton::Right, false), None); assert_eq!(keys.container_mouse_key(MouseButton::Forward, false), None); } #[test] fn rebinding_translates_to_defaults() { let mut k = KeyBinds::default(); assert_eq!(k.translate(KeyCode::KeyW), Some(Ok(KeyCode::KeyW))); // Forward on the up arrow, inventory on W. k.set("key.forward", "key.keyboard.up"); k.set("key.inventory", "key.keyboard.w"); assert_eq!(k.translate(KeyCode::ArrowUp), Some(Ok(KeyCode::KeyW))); assert_eq!(k.translate(KeyCode::KeyW), Some(Ok(KeyCode::KeyE))); // E's default meaning moved and nothing else uses it. assert_eq!(k.translate(KeyCode::KeyE), None); // Attack on a key. k.set("key.attack", "key.keyboard.r"); assert_eq!(k.translate(KeyCode::KeyR), Some(Err(MouseButton::Left))); assert_eq!(k.translate_mouse(MouseButton::Left), None); assert_eq!(k.translate(KeyCode::Escape), Some(Ok(KeyCode::Escape))); assert!(k.conflicts("key.forward").is_empty()); k.set("key.jump", "key.keyboard.up"); assert_eq!(k.conflicts("key.forward"), ["key.jump"]); } #[test] fn display_names() { assert_eq!(display_name("key.keyboard.w").plain(), "W"); assert_eq!(display_name("key.keyboard.slash").plain(), "/"); } }