more keyboard scancode mappings

start menu looks more identical now

Author: FolkertVanVerseveld

game/src/engine.cpp

@@ -569,19 +569,16 @@ bool Engine::is_hosting() {
 }
 
 void Engine::set_background(io::DrsId id) {
+	if (id == (io::DrsId)0)
+		return;
+
 	assert(assets.get());
 	Assets &a = *assets.get();
 
 	const gfx::ImageRef &r = a.at(id);
 	SetBackground(r, vbo);
 }
 
-void Engine::set_background(MenuState s) {
-	const MenuInfo &mi = GetMenuInfo(s);
-	if (mi.border_col != (io::DrsId)0)
-		set_background(mi.border_col);
-}
-
 ImVec2 Engine::tilepos(float x, float y, float left, float top, int h) {
 	float x0 = left + tw / 2 * y + tw / 2 * x;
 	float y0 = top  - th / 2 * y + th / 2 * x - th / 2 * h;
@@ -629,8 +626,11 @@ void Engine::cam_reset() {
 
 void Engine::goto_menu(MenuState state) {
 	menu_state = state;
-	keyctl.clear();
-	set_background(menu_state);
+
+	const MenuInfo &mi = GetMenuInfo(state);
+	keyctl.clear(mi.keyboard_mode);
+	set_background(mi.border_col);
+
 	sdl->window.set_clipping(false);
 
 	switch (menu_state) {
@@ -775,7 +775,7 @@ void Engine::start_multiplayer_game() {
 	show_timeline = false;
 	show_diplomacy = false;
 	multiplayer_ready = false;
-	keyctl.clear();
+	keyctl.clear(KeyboardMode::gameplay);
 
 	cam_reset();
 }
@@ -1116,6 +1116,9 @@ void Engine::key_tapped(SDL &sdl, GameKey k) {
 
 	// menu specific
 	switch (menu_state) {
+	case MenuState::start:
+		mainMenu.key_tapped(k);
+		break;
 	case MenuState::singleplayer_game:
 	case MenuState::multiplayer_game:
 		kbp_game(k);
@@ -1131,7 +1134,7 @@ void Engine::kbp_down(GameKey k) {
 		return;
 
 	if (menu_state == MenuState::start)
-		mainMenu.kbp_down(k);
+		mainMenu.key_down(k, keyctl, sfx);
 }
 
 void Engine::eventloop(SDL &sdl, gfx::GLprogram &prog, GLuint vao) {
@@ -1181,7 +1184,7 @@ void Engine::eventloop(SDL &sdl, gfx::GLprogram &prog, GLuint vao) {
 
 				if (menu_state == MenuState::start) {
 					if (event.button.button = SDL_BUTTON_LEFT)
-						mainMenu.mouse_up(event.button.x, event.button.y, menu_state);
+						mainMenu.mouse_up(event.button.x, event.button.y);
 				}
 				break;
 			default:

game/src/engine.hpp

@@ -228,7 +228,6 @@ class Engine final {
 	void goto_multiplayer_menu();
 	void start_multiplayer_game();
 
-	void set_background(MenuState);
 	void set_background(io::DrsId);
 
 	void draw_background_border();

game/src/engine/keyboard_mode.hpp

@@ -0,0 +1,15 @@
+#ifndef AOE_KEYBOARD_MODE_HPP
+#define AOE_KEYBOARD_MODE_HPP 1
+
+namespace aoe {
+
+enum KeyboardMode {
+	configure, // change settings
+	fullscreen_menu,
+	gameplay,
+	other, // gameplay, scenario editor, etc.
+};
+
+}
+
+#endif

game/src/engine/keyctl.cpp

@@ -1,10 +1,35 @@
 #include "keyctl.hpp"
 
+#include <algorithm> // fill
+
 namespace aoe {
 
 KeyboardController keyctl;
 
-KeyboardController::KeyboardController() : state((size_t)GameKey::max, false), state_tapped(state.size(), false), keys() {
+/*
+https://discourse.libsdl.org/t/scancode-vs-keycode/32860/5
+
+the author of SDL says about key-/scancodes:
+
+SDL is trying to support essentially 3 different types of keyboard input:
+
+SDL scancodes are used for games that require position independent key input, e.g. an FPS that uses WASD for movement should use scancodes because the position is important (i.e. the key position shouldn't change on a French AZERTY keyboard, etc.)
+SDL keycodes are used for games that use symbolic key input, e.g. `I' for inventory, `B' for bag, etc. This is useful for MMOs and other games where the label on the key is important for understanding what the action is. Typically shift or control modifiers on those keys do something related to the original function and aren't related to another letter that might be mapped there (e.g. Shift-B closes all bags, etc.)
+SDL text input is used for games that have a text field for chat, or character names, etc.
+Games don't always follow these usage patterns, but this is the way it was originally designed.
+*/
+
+enum class KeyType {
+	scan, // position independent
+	key , // symbolic key
+	text, // input fields
+};
+
+KeyboardController::KeyboardController()
+	: state((size_t)GameKey::max, false), state_tapped(state.size(), false)
+	, scan_keys()
+	, keys(), mode(KeyboardMode::fullscreen_menu)
+{
 	// NOTE in theory, you can have multiple keys mapped to the same GameKey, but this can lead to unreliable results with key down state.
 	keys[SDLK_UP] = GameKey::ui_prev;
 	keys[SDLK_DOWN] = GameKey::ui_next;
@@ -27,17 +52,35 @@ KeyboardController::KeyboardController() : state((size_t)GameKey::max, false), s
 	keys['t'] = keys['T'] = GameKey::train_melee1;
 	keys['.'] = GameKey::focus_idle_villager;
 	keys[' '] = GameKey::focus_entity;
+
+	scan_keys[SDL_SCANCODE_UP] = GameKey::ui_prev;
+	scan_keys[SDL_SCANCODE_DOWN] = GameKey::ui_next;
+	scan_keys[SDL_SCANCODE_SPACE] = GameKey::ui_select;
+	scan_keys[SDL_SCANCODE_GRAVE] = GameKey::toggle_debug_window;
+	scan_keys[SDL_SCANCODE_F1] = GameKey::open_help;
+	scan_keys[SDL_SCANCODE_F11] = GameKey::toggle_fullscreen;
 }
 
-void KeyboardController::clear() {
-	state.clear();
-	state_tapped.clear();
-	size_t end = (size_t)GameKey::max;
-	state.resize(end, false);
-	state_tapped.resize(end, false);
+void KeyboardController::clear(KeyboardMode mode) {
+	this->mode = mode;
+	std::fill(state.begin(), state.end(), false);
+	std::fill(state_tapped.begin(), state_tapped.end(), false);
 }
 
 GameKey KeyboardController::down(const SDL_KeyboardEvent &e) {
+	if (mode == KeyboardMode::fullscreen_menu) {
+		auto it = scan_keys.find(e.keysym.scancode);
+
+		if (it == scan_keys.end())
+			return GameKey::max;
+
+		GameKey k = it->second;
+		size_t idx = (size_t)k;
+		state[idx] = true;
+		state_tapped[idx] = false;
+		return k;
+	}
+
 	auto it = keys.find(e.keysym.sym);
 
 	if (it == keys.end())
@@ -52,6 +95,24 @@ GameKey KeyboardController::down(const SDL_KeyboardEvent &e) {
 }
 
 GameKey KeyboardController::up(const SDL_KeyboardEvent &e) {
+	if (mode == KeyboardMode::fullscreen_menu) {
+		auto it = scan_keys.find(e.keysym.scancode);
+
+		if (it == scan_keys.end())
+			return GameKey::max;
+
+		GameKey k = it->second;
+		size_t idx = (size_t)k;
+
+		if (!state[idx]) {
+			state[idx] = false;
+			return GameKey::max;
+		}
+		state_tapped[idx] = true;
+		state[idx] = false;
+		return k;
+	}
+
 	auto it = keys.find(e.keysym.sym);
 
 	if (it == keys.end())
@@ -60,6 +121,10 @@ GameKey KeyboardController::up(const SDL_KeyboardEvent &e) {
 	GameKey k = it->second;
 	size_t idx = (size_t)k;
 
+	if (!state[idx]) {
+		state[idx] = false;
+		return GameKey::max;
+	}
 	state[idx] = false;
 	state_tapped[idx] = true;
 	return k;

game/src/engine/keyctl.hpp

@@ -2,16 +2,20 @@
 #define AOE_KEYCTL_HPP 1
 
 #include <map>
+#include <set>
 #include <vector>
 
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_keyboard.h>
 
+#include "keyboard_mode.hpp"
+
 namespace aoe {
 
 enum class GameKey {
 	ui_prev,
 	ui_next,
+	ui_select,
 	// gameplay
 	key_left,
 	key_right,
@@ -37,19 +41,15 @@ enum class GameKey {
 	max,
 };
 
-enum KeyboardMode {
-	configure, // change settings
-	fullscreen_menu,
-	other, // gameplay, scenario editor, etc.
-};
-
 class KeyboardController final {
 	std::vector<bool> state, state_tapped;
+	std::map<SDL_Scancode, GameKey> scan_keys;
 	std::map<SDL_Keycode, GameKey> keys;
+	KeyboardMode mode;
 public:
 	KeyboardController();
 
-	void clear();
+	void clear(KeyboardMode mode);
 
 	GameKey down(const SDL_KeyboardEvent&);
 	GameKey up(const SDL_KeyboardEvent&);

game/src/engine/menu.cpp

@@ -6,19 +6,19 @@ namespace aoe {
 using namespace io;
 
 const MenuInfo menu_info[] = {
-	{ false, DrsId::bkg_main_menu }, // init
-	{ true, DrsId::bkg_main_menu }, // start
-	{ true, DrsId::bkg_singleplayer },
-	{ true, DrsId::bkg_singleplayer },
-	{ false, (DrsId)0 }, // sp game
-	{ true, DrsId::bkg_multiplayer },
-	{ true, DrsId::bkg_multiplayer },
-	{ false, (DrsId)0 }, // mp game
-	{ false, (DrsId)0 }, // mp settings
-	{ true, DrsId::bkg_defeat },
-	{ true, DrsId::bkg_victory },
-	{ true, DrsId::bkg_editor_menu }, // edit menu
-	{ false, (DrsId)0 }, // edit scn
+	{ false, KeyboardMode::configure, DrsId::bkg_main_menu }, // init
+	{ true, KeyboardMode::fullscreen_menu, DrsId::bkg_main_menu }, // start
+	{ true, KeyboardMode::other, DrsId::bkg_singleplayer },
+	{ true, KeyboardMode::other, DrsId::bkg_singleplayer },
+	{ false, KeyboardMode::other, (DrsId)0 }, // sp game
+	{ true, KeyboardMode::other, DrsId::bkg_multiplayer },
+	{ true, KeyboardMode::other, DrsId::bkg_multiplayer },
+	{ false, KeyboardMode::other, (DrsId)0 }, // mp game
+	{ false, KeyboardMode::other, (DrsId)0 }, // mp settings
+	{ true, KeyboardMode::other, DrsId::bkg_defeat },
+	{ true, KeyboardMode::other, DrsId::bkg_victory },
+	{ true, KeyboardMode::other, DrsId::bkg_editor_menu }, // edit menu
+	{ false, KeyboardMode::other, (DrsId)0 }, // edit scn
 };
 
 const MenuInfo &GetMenuInfo(MenuState state) {

game/src/engine/menu.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../legacy/legacy.hpp"
+#include "keyboard_mode.hpp"
 
 namespace aoe {
 
@@ -23,6 +24,7 @@ enum class MenuState {
 
 struct MenuInfo final {
 	bool draw_border;
+	KeyboardMode keyboard_mode;
 	io::DrsId border_col;
 };
 

game/src/ui.cpp

@@ -1051,7 +1051,7 @@ MenuButton mainMenuButtons[] = {
 
 static void DrawMainMenu(Frame &f, Audio &sfx, Assets &ass);
 
-FullscreenMenu mainMenu((unsigned)MenuState::start, mainMenuButtons, ARRAY_SIZE(mainMenuButtons), DrawMainMenu);
+FullscreenMenu mainMenu(MenuState::start, mainMenuButtons, ARRAY_SIZE(mainMenuButtons), DrawMainMenu);
 
 static void DrawMainMenu(Frame &f, Audio &sfx, Assets &ass)
 {

game/src/ui/fullscreenmenu.cpp

@@ -11,9 +11,9 @@ void FullscreenMenu::reshape(ImGuiViewport *vp) {
 		buttons[i].reshape(vp);
 }
 
-FullscreenMenu::FullscreenMenu(unsigned menuState, MenuButton *buttons, unsigned buttonCount,
+FullscreenMenu::FullscreenMenu(MenuState menuState, MenuButton *buttons, unsigned buttonCount,
 	void (*fn)(Frame &, Audio &, Assets &))
-	: menuState(menuState), buttons(buttons), buttonCount(buttonCount), selected(0), draw(fn)
+	: menuState(menuState), buttons(buttons), buttonCount(buttonCount), activated(false), selected(0), draw(fn)
 {
 	assert(buttonCount);
 	buttons[selected].state |= (unsigned)MenuButtonState::selected;
@@ -30,7 +30,7 @@ static inline bool PointInMenuButton(const MenuButton *btn, int mx, int my)
 
 void FullscreenMenu::mouse_down(int mx, int my, Audio &sfx) {
 	unsigned mask = (unsigned)MenuButtonState::active | (unsigned)MenuButtonState::selected;
-	bool activated = false;
+	activated = false;
 
 	for (unsigned i = 0; i < buttonCount; ++i) {
 		MenuButton *btn = &buttons[i];
@@ -44,27 +44,48 @@ void FullscreenMenu::mouse_down(int mx, int my, Audio &sfx) {
 			btn->state &= ~mask;
 		}
 	}
+
+	if (!activated)
+		buttons[selected].state |= (unsigned)MenuButtonState::selected;
 }
 
-void FullscreenMenu::mouse_up(int mx, int my, MenuState state) {
-	if (selected >= buttonCount)
+void FullscreenMenu::mouse_up(int mx, int my) {
+	if (!activated || selected >= buttonCount)
 		return;
 
 	MenuButton *btn = &buttons[selected];
 	unsigned mselected = (unsigned)MenuButtonState::selected;
 	unsigned mactive = (unsigned)MenuButtonState::active;
 
+	activated = false;
+
 	if (PointInMenuButton(btn, mx, my)) {
 		btn->state = (btn->state | mselected) & ~mactive;
-		MenuButtonActivate(state, selected);
+		MenuButtonActivate(menuState, selected);
 	} else {
 		btn->state &= ~mactive;
 	}
 }
 
-void FullscreenMenu::kbp_down(GameKey key) {
+void FullscreenMenu::key_tapped(GameKey key) {
+	if (key == GameKey::ui_select) {
+		buttons[selected].state &= ~(unsigned)MenuButtonState::active;
+		MenuButtonActivate(menuState, selected);
+	}
+}
+
+void FullscreenMenu::key_down(GameKey key, KeyboardController &keyctl, Audio &sfx) {
 	unsigned old = selected;
 
+	if (keyctl.is_down(GameKey::ui_select)) {
+		// only do this if we just selected
+		if (key == GameKey::ui_select) {
+			buttons[selected].state |= (unsigned)MenuButtonState::active;
+			sfx.play_sfx(SfxId::ui_click);
+		}
+		return;
+	}
+
 	if (key == GameKey::ui_prev)
 		dec(selected);
 	else if (key == GameKey::ui_next)