diff --git a/common/arch/sdl/event.cpp b/common/arch/sdl/event.cpp
index 2c4155604..57e146fe3 100644
--- a/common/arch/sdl/event.cpp
+++ b/common/arch/sdl/event.cpp
@@ -103,7 +103,7 @@ window_event_result event_poll()
 	// Send the idle event if there were no other events (or they were ignored)
 	if (state.highest_result == window_event_result::ignored)
 	{
-		const d_event ievent{EVENT_IDLE};
+		const d_event ievent{event_type::idle};
 		state.highest_result = std::max(event_send(ievent), state.highest_result);
 	}
 	else
@@ -170,8 +170,7 @@ void event_poll_state::process_event_batch(const ranges::subrange<const SDL_Even
 			case SDL_JOYBALLMOTION:
 				continue;
 			case SDL_QUIT: {
-				d_event qevent = { EVENT_QUIT };
-				result = call_default_handler(qevent);
+				result = call_default_handler(d_event{event_type::quit});
 				break;
 			}
 			default:
@@ -245,7 +244,7 @@ window_event_result event_process(void)
 	if ((highest_result == window_event_result::deleted) || (window_get_front() != wind))
 		return highest_result;
 
-	const d_event event{EVENT_WINDOW_DRAW};	// then draw all visible windows
+	const d_event event{event_type::window_draw};	// then draw all visible windows
 	for (wind = window_get_first(); wind != nullptr;)
 	{
 		if (wind->is_visible())
diff --git a/common/arch/sdl/joy.cpp b/common/arch/sdl/joy.cpp
index c4aa87355..233c70497 100644
--- a/common/arch/sdl/joy.cpp
+++ b/common/arch/sdl/joy.cpp
@@ -197,10 +197,10 @@ window_event_result joy_button_handler(const SDL_JoyButtonEvent *const jbe)
 	Joystick.button_state[button] = jbe->state;
 
 	const d_event_joystickbutton event{
-		(jbe->type == SDL_JOYBUTTONDOWN) ? EVENT_JOYSTICK_BUTTON_DOWN : EVENT_JOYSTICK_BUTTON_UP,
+		(jbe->type == SDL_JOYBUTTONDOWN) ? event_type::joystick_button_down : event_type::joystick_button_up,
 		button
 	};
-	con_printf(CON_DEBUG, "Sending event %s, button %d", (jbe->type == SDL_JOYBUTTONDOWN) ? "EVENT_JOYSTICK_BUTTON_DOWN" : "EVENT_JOYSTICK_JOYSTICK_UP", event.button);
+	con_printf(CON_DEBUG, "Sending event %s, button %d", (jbe->type == SDL_JOYBUTTONDOWN) ? "event_type::joystick_button_down" : "EVENT_JOYSTICK_JOYSTICK_UP", event.button);
 	return event_send(event);
 }
 #endif
@@ -236,14 +236,14 @@ window_event_result joy_hat_handler(const SDL_JoyHatEvent *const jhe)
 			// Same state as before
 			continue;
 		saved_button_state = current_button_state;
-		const d_event_joystickbutton event{current_button_state ? EVENT_JOYSTICK_BUTTON_DOWN : EVENT_JOYSTICK_BUTTON_UP, hat + i};
+		const d_event_joystickbutton event{current_button_state ? event_type::joystick_button_down : event_type::joystick_button_up, hat + i};
 		if (current_button_state) //last_state up, current state down
 		{
-			con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_BUTTON_DOWN, button %d", event.button);
+			con_printf(CON_DEBUG, "Sending event event_type::joystick_button_down, button %d", event.button);
 		}
 		else	//last_state down, current state up
 		{
-			con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_BUTTON_UP, button %d", event.button);
+			con_printf(CON_DEBUG, "Sending event event_type::joystick_button_up, button %d", event.button);
 		}
 		highest_result = std::max(event_send(event), highest_result);
 	}
@@ -258,9 +258,9 @@ namespace {
 
 static window_event_result send_axis_button_event(unsigned button, event_type e)
 {
-	Joystick.button_state[button] = (e == EVENT_JOYSTICK_BUTTON_UP) ? 0 : 1;
+	Joystick.button_state[button] = (e == event_type::joystick_button_up) ? 0 : 1;
 	const d_event_joystickbutton event{ e, button };
-	con_printf(CON_DEBUG, "Sending event %s, button %d", (e == EVENT_JOYSTICK_BUTTON_UP) ? "EVENT_JOYSTICK_BUTTON_UP" : "EVENT_JOYSTICK_BUTTON_DOWN", event.button);
+	con_printf(CON_DEBUG, "Sending event %s, button %d", (e == event_type::joystick_button_up) ? "event_type::joystick_button_up" : "event_type::joystick_button_down", event.button);
 	return event_send(event);
 }
 
@@ -283,16 +283,16 @@ window_event_result joy_axisbutton_handler(const SDL_JoyAxisEvent *const jae)
 	if (prev_value <= 0 && new_value >= 0) // positive pressed
 	{
 		if (prev_value < 0) // Do previous direction release first if the case
-			highest_result = std::max(send_axis_button_event(button + 1, EVENT_JOYSTICK_BUTTON_UP), highest_result);
+			highest_result = std::max(send_axis_button_event(button + 1, event_type::joystick_button_up), highest_result);
 		if (new_value > 0)
-			highest_result = std::max(send_axis_button_event(button, EVENT_JOYSTICK_BUTTON_DOWN), highest_result);
+			highest_result = std::max(send_axis_button_event(button, event_type::joystick_button_down), highest_result);
 	}
 	else if (prev_value >= 0 && new_value <= 0) // negative pressed
 	{
 		if (prev_value > 0) // Do previous direction release first if the case
-			highest_result = std::max(send_axis_button_event(button, EVENT_JOYSTICK_BUTTON_UP), highest_result);
+			highest_result = std::max(send_axis_button_event(button, event_type::joystick_button_up), highest_result);
 		if (new_value < 0)
-			highest_result = std::max(send_axis_button_event(button + 1, EVENT_JOYSTICK_BUTTON_DOWN), highest_result);
+			highest_result = std::max(send_axis_button_event(button + 1, event_type::joystick_button_down), highest_result);
 	}
 
 	return highest_result;
@@ -308,10 +308,10 @@ window_event_result joy_axis_handler(const SDL_JoyAxisEvent *const jae)
 	if (axis_value == jae->value/256)
 		return window_event_result::ignored;
 
-	d_event_joystick_moved event{EVENT_JOYSTICK_MOVED};
+	d_event_joystick_moved event{event_type::joystick_moved};
 	event.value = axis_value = jae->value/256;
 	event.axis = axis;
-	con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_MOVED, axis: %d, value: %d",event.axis, event.value);
+	con_printf(CON_DEBUG, "Sending event event_type::joystick_moved, axis: %d, value: %d",event.axis, event.value);
 
 	return event_send(event);
 }
@@ -455,7 +455,7 @@ void joy_close()
 const d_event_joystick_axis_value &event_joystick_get_axis(const d_event &event)
 {
 	auto &e = static_cast<const d_event_joystick_moved &>(event);
-	Assert(e.type == EVENT_JOYSTICK_MOVED);
+	assert(e.type == event_type::joystick_moved);
 	return e;
 }
 #endif
@@ -479,7 +479,7 @@ void joy_flush()
 int event_joystick_get_button(const d_event &event)
 {
 	auto &e = static_cast<const d_event_joystickbutton &>(event);
-	Assert(e.type == EVENT_JOYSTICK_BUTTON_DOWN || e.type == EVENT_JOYSTICK_BUTTON_UP);
+	assert(e.type == event_type::joystick_button_down || e.type == event_type::joystick_button_up);
 	return e.button;
 }
 #endif
@@ -496,7 +496,7 @@ int apply_deadzone(int value, int deadzone)
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
 bool joy_translate_menu_key(const d_event &event) {
-	if (event.type != EVENT_JOYSTICK_BUTTON_DOWN)
+	if (event.type != event_type::joystick_button_down)
 		return false;
 	auto &e = static_cast<const d_event_joystickbutton &>(event);
 	assert(e.button < joy_key_map.size());
diff --git a/common/arch/sdl/key.cpp b/common/arch/sdl/key.cpp
index b78ac343f..6c4137cf1 100644
--- a/common/arch/sdl/key.cpp
+++ b/common/arch/sdl/key.cpp
@@ -535,9 +535,9 @@ window_event_result key_handler(const SDL_KeyboardEvent *const kevent)
 
 		// We allowed the key to be added to the queue for now,
 		// because there are still input loops without associated windows
-		const d_event_keycommand event{key_state ? EVENT_KEY_COMMAND : EVENT_KEY_RELEASE, keycode};
+		const d_event_keycommand event{key_state ? event_type::key_command : event_type::key_release, keycode};
 		con_printf(CON_DEBUG, "Sending event %s: %s %s %s %s %s %s",
-				(key_state)                  ? "EVENT_KEY_COMMAND": "EVENT_KEY_RELEASE",
+				(key_state)                  ? "event_type::key_command": "event_type::key_release",
 				(keycode & KEY_METAED)	? "META" : "",
 				(keycode & KEY_DEBUGGED)	? "DEBUG" : "",
 				(keycode & KEY_CTRLED)	? "CTRL" : "",
@@ -597,14 +597,13 @@ void key_flush()
 }
 
 void event_keycommand_send(unsigned key) {
-	const d_event_keycommand event{EVENT_KEY_COMMAND, key};
-	event_send(event);
+	event_send(d_event_keycommand{event_type::key_command, key});
 }
 
 int event_key_get(const d_event &event)
 {
 	auto &e = static_cast<const d_event_keycommand &>(event);
-	Assert(e.type == EVENT_KEY_COMMAND || e.type == EVENT_KEY_RELEASE);
+	assert(e.type == event_type::key_command || e.type == event_type::key_release);
 	return e.keycode;
 }
 
diff --git a/common/arch/sdl/mouse.cpp b/common/arch/sdl/mouse.cpp
index 03d7b7a12..be115d67e 100644
--- a/common/arch/sdl/mouse.cpp
+++ b/common/arch/sdl/mouse.cpp
@@ -80,13 +80,12 @@ static window_event_result maybe_send_z_move(const mbtn button)
 	}
 	else
 		return window_event_result::ignored;
-	const d_event_mouse_moved event{EVENT_MOUSE_MOVED, 0, 0, dz};
-	return event_send(event);
+	return event_send(d_event_mouse_moved{event_type::mouse_moved, 0, 0, dz});
 }
 
 static window_event_result send_singleclick(const bool pressed, const mbtn button)
 {
-	const d_event_mousebutton event{pressed ? EVENT_MOUSE_BUTTON_DOWN : EVENT_MOUSE_BUTTON_UP, button};
+	const d_event_mousebutton event{pressed ? event_type::mouse_button_down : event_type::mouse_button_up, button};
 	con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_BUTTON_%s, button %d, coords %d,%d,%d",
 			   pressed ? "DOWN" : "UP", underlying_value(event.button), Mouse.x, Mouse.y, Mouse.z);
 	return event_send(event);
@@ -99,8 +98,8 @@ static window_event_result maybe_send_doubleclick(const fix64 now, const mbtn bu
 	when = now;
 	if (now > then + F1_0/5)
 		return window_event_result::ignored;
-	const d_event_mousebutton event{EVENT_MOUSE_DOUBLE_CLICKED, button};
-	con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_DOUBLE_CLICKED, button %d, coords %d,%d", underlying_value(button), Mouse.x, Mouse.y);
+	const d_event_mousebutton event{event_type::mouse_double_clicked, button};
+	con_printf(CON_DEBUG, "Sending event event_type::mouse_double_clicked, button %d, coords %d,%d", underlying_value(button), Mouse.x, Mouse.y);
 	return event_send(event);
 }
 
@@ -163,9 +162,9 @@ window_event_result mouse_motion_handler(const SDL_MouseMotionEvent *const mme)
 	Mouse.y += mme->yrel;
 	
 	// z handled in mouse_button_handler
-	const d_event_mouse_moved event{EVENT_MOUSE_MOVED, mme->xrel, mme->yrel, 0};
+	const d_event_mouse_moved event{event_type::mouse_moved, mme->xrel, mme->yrel, 0};
 	
-	//con_printf(CON_DEBUG, "Sending event EVENT_MOUSE_MOVED, relative motion %d,%d,%d",
+	//con_printf(CON_DEBUG, "Sending event event_type::mouse_moved, relative motion %d,%d,%d",
 	//		   event.dx, event.dy, event.dz);
 	return event_send(event);
 }
@@ -178,12 +177,14 @@ void mouse_flush()	// clears all mice events...
 }
 
 //========================================================================
-void mouse_get_pos( int *x, int *y, int *z )
+std::tuple<int, int, int> mouse_get_pos()
 {
 	//event_poll();		// Have to assume this is called in event_process, because event_poll can cause a window to close (depending on what the user does)
-	*x=Mouse.x;
-	*y=Mouse.y;
-	*z=Mouse.z;
+	return {
+		Mouse.x,
+		Mouse.y,
+		Mouse.z,
+	};
 }
 
 window_event_result mouse_in_window(window *wind)
@@ -193,14 +194,22 @@ window_event_result mouse_in_window(window *wind)
 			(static_cast<unsigned>(Mouse.y) - canv.cv_bitmap.bm_y <= canv.cv_bitmap.bm_h) ? window_event_result::handled : window_event_result::ignored;
 }
 
-void mouse_get_delta( int *dx, int *dy, int *dz )
+#if 0
+std::tuple<int, int, int> mouse_get_delta()
 {
-	*dz = Mouse.delta_z;
+	const int dz{Mouse.delta_z};
+	int dx{}, dy{};
 	Mouse.delta_x = 0;
 	Mouse.delta_y = 0;
 	Mouse.delta_z = 0;
-	SDL_GetRelativeMouseState(dx, dy);
+	SDL_GetRelativeMouseState(&dx, &dy);
+	return {
+		dx,
+		dy,
+		dz,
+	};
 }
+#endif
 
 namespace {
 
diff --git a/common/arch/sdl/window.cpp b/common/arch/sdl/window.cpp
index 61908a579..ebe96a62c 100644
--- a/common/arch/sdl/window.cpp
+++ b/common/arch/sdl/window.cpp
@@ -20,6 +20,7 @@
 #include "console.h"
 #include "dxxerror.h"
 #include "event.h"
+#include "d_underlying_value.h"
 
 namespace dcx {
 
@@ -43,9 +44,9 @@ void window::send_creation_events()
 		FrontWindow->next = this;
 	FrontWindow = this;
 	if (prev_front)
-		prev_front->send_event(d_event{EVENT_WINDOW_DEACTIVATED});
+		prev_front->send_event(d_event{event_type::window_deactivated});
 	this->send_event(d_create_event{});
-	this->send_event(d_event{EVENT_WINDOW_ACTIVATED});
+	this->send_event(d_event{event_type::window_activated});
 }
 
 window::~window()
@@ -69,14 +70,14 @@ mixin_trackable_window::~mixin_trackable_window()
 int window_close(window *wind)
 {
 	if (wind == window_get_front())
-		wind->send_event(d_event{EVENT_WINDOW_DEACTIVATED});	// Deactivate first
+		wind->send_event(d_event{event_type::window_deactivated});	// Deactivate first
 
-	const auto result = wind->send_event(d_event{EVENT_WINDOW_CLOSE});
+	const auto result = wind->send_event(d_event{event_type::window_close});
 	if (result == window_event_result::handled)
 	{
 		// User 'handled' the event, cancelling close
 		if (wind == window_get_front())
-			wind->send_event(d_event{EVENT_WINDOW_ACTIVATED});
+			wind->send_event(d_event{event_type::window_activated});
 		return 0;
 	}
 
@@ -86,7 +87,7 @@ int window_close(window *wind)
 		delete wind;
 
 	if (const auto prev = window_get_front())
-		prev->send_event(d_event{EVENT_WINDOW_ACTIVATED});
+		prev->send_event(d_event{event_type::window_activated});
 
 	return 1;
 }
@@ -127,8 +128,8 @@ void window_select(window &wind)
 	if (wind.is_visible())
 	{
 		if (prev)
-			prev->send_event(d_event{EVENT_WINDOW_DEACTIVATED});
-		wind.send_event(d_event{EVENT_WINDOW_ACTIVATED});
+			prev->send_event(d_event{event_type::window_deactivated});
+		wind.send_event(d_event{event_type::window_activated});
 	}
 }
 
@@ -141,10 +142,10 @@ window *window::set_visible(uint8_t visible)
 		return wind;
 	
 	if (prev)
-		prev->send_event(d_event{EVENT_WINDOW_DEACTIVATED});
+		prev->send_event(d_event{event_type::window_deactivated});
 
 	if (wind)
-		wind->send_event(d_event{EVENT_WINDOW_ACTIVATED});
+		wind->send_event(d_event{event_type::window_activated});
 	return wind;
 }
 
@@ -155,7 +156,7 @@ window_event_result window::send_event(const d_event &event
 									)
 {
 #if DXX_HAVE_CXX_BUILTIN_FILE_LINE
-	con_printf(CON_DEBUG, "%s:%u: sending event %i to window of dimensions %dx%d", file, line, event.type, w_canv.cv_bitmap.bm_w, w_canv.cv_bitmap.bm_h);
+	con_printf(CON_DEBUG, "%s:%u: sending event %i to window of dimensions %dx%d", file, line, underlying_value(event.type), w_canv.cv_bitmap.bm_w, w_canv.cv_bitmap.bm_h);
 #endif
 	const auto r = event_handler(event);
 	if (r == window_event_result::close)
diff --git a/common/arch/win32/messagebox.cpp b/common/arch/win32/messagebox.cpp
index de231a2b5..d49d0000f 100644
--- a/common/arch/win32/messagebox.cpp
+++ b/common/arch/win32/messagebox.cpp
@@ -23,7 +23,7 @@ static void display_win32_alert(const char *message, int error)
 {
 	// Handle Descent's windows properly
 	if (const auto wind = window_get_front())
-		wind->send_event(d_event{EVENT_WINDOW_DEACTIVATED});
+		wind->send_event(d_event{event_type::window_deactivated});
 
 	int fullscreen = (grd_curscreen && gr_check_fullscreen());
 	if (fullscreen)
@@ -32,8 +32,7 @@ static void display_win32_alert(const char *message, int error)
 	MessageBox(NULL, message, error?"Sorry, a critical error has occurred.":"Attention!", error?MB_OK|MB_ICONERROR:MB_OK|MB_ICONWARNING);
 
 	if (const auto wind = window_get_front())
-		wind->send_event(d_event{EVENT_WINDOW_ACTIVATED});
-	
+		wind->send_event(d_event{event_type::window_activated});
 	if (!error && fullscreen)
 		gr_toggle_fullscreen();
 }
diff --git a/common/editor/func.cpp b/common/editor/func.cpp
index cba19d442..a85967f9c 100644
--- a/common/editor/func.cpp
+++ b/common/editor/func.cpp
@@ -34,73 +34,11 @@ namespace dcx {
 
 #define MAX_PARAMS 10
 
-static const FUNCTION * func_table = NULL;
-static int func_size = 0;
-static int initialized = 0;
 static int func_params[MAX_PARAMS];
 
-void func_init( const FUNCTION * funtable, int size )
-{
-	if (!initialized)
-	{
-		initialized = 1;
-		func_table = funtable;
-		func_size = size;
-		atexit( func_close );
-	}
-}
-
-
-void func_close()
-{
-	if (initialized)
-	{
-		initialized = 0;
-		func_table = NULL;
-		func_size = 0;
-	}
-}
-
-int (*func_get( char * name, int * numparams ))(void)
-{
-	for (int i=0; i<func_size; i++ )
-		if (!d_stricmp( name, func_table[i].name ))
-		{
-			*numparams = func_table[i].nparams;
-			return func_table[i].cfunction;
-		}
-
-	return NULL;
-}
-
-int func_get_index( char * name )
-{
-	for (int i=0; i<func_size; i++ )
-		if (!d_stricmp( name, func_table[i].name ))
-		{
-			return i;
-		}
-
-	return -1;
-}
-
-
-int (*func_nget( int func_number, int * numparams, const char **name ))(void)
-{
-	if (func_number < func_size )
-	{
-		*name = func_table[func_number].name;
-		*numparams = func_table[func_number].nparams;
-		return func_table[func_number].cfunction;
-	}
-
-	return NULL;
-}
-
 int func_get_param( int n )
 {
 	return func_params[n];
 }
 
-
 }
diff --git a/common/include/editor/kfuncs.h b/common/include/editor/kfuncs.h
deleted file mode 100644
index 8d9ef50aa..000000000
--- a/common/include/editor/kfuncs.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Portions of this file are copyright Rebirth contributors and licensed as
- * described in COPYING.txt.
- * Portions of this file are copyright Parallax Software and licensed
- * according to the Parallax license below.
- * See COPYING.txt for license details.
-
-THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
-SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
-END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
-ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
-IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
-SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
-FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
-CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
-AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
-COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
-*/
-
-/*
- *
- * Header for kfuncs.c
- *
- */
-
-#ifndef _KFUNCS_H
-#define _KFUNCS_H
-
-#ifdef __cplusplus
-#include "dsx-ns.h"
-
-#ifdef dsx
-namespace dsx {
-void init_med_functions(void);
-}
-#endif
-
-#endif
-
-#endif
diff --git a/common/include/event.h b/common/include/event.h
index 737387b16..b3fd68103 100644
--- a/common/include/event.h
+++ b/common/include/event.h
@@ -19,48 +19,48 @@
 #ifdef __cplusplus
 namespace dcx {
 
-enum event_type : unsigned
+enum class event_type : uint8_t
 {
-	EVENT_IDLE = 0,
-	EVENT_QUIT,
+	idle = 0,
+	quit,
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-	EVENT_JOYSTICK_BUTTON_DOWN,
-	EVENT_JOYSTICK_BUTTON_UP,
+	joystick_button_down,
+	joystick_button_up,
 #endif
 #if DXX_MAX_AXES_PER_JOYSTICK
-	EVENT_JOYSTICK_MOVED,
+	joystick_moved,
 #endif
 
-	EVENT_MOUSE_BUTTON_DOWN,
-	EVENT_MOUSE_BUTTON_UP,
-	EVENT_MOUSE_DOUBLE_CLICKED,
-	EVENT_MOUSE_MOVED,
+	mouse_button_down,
+	mouse_button_up,
+	mouse_double_clicked,
+	mouse_moved,
 
-	EVENT_KEY_COMMAND,
-	EVENT_KEY_RELEASE,
+	key_command,
+	key_release,
 
-	EVENT_WINDOW_CREATED,
+	window_created,
 #if SDL_MAJOR_VERSION == 2
-	EVENT_WINDOW_RESIZE,
+	window_resize,
 #endif
-	EVENT_WINDOW_ACTIVATED,
-	EVENT_WINDOW_DEACTIVATED,
-	EVENT_WINDOW_DRAW,
-	EVENT_WINDOW_CLOSE,
-
-	EVENT_NEWMENU_DRAW,					// draw after the newmenu stuff is drawn (e.g. savegame previews)
-	EVENT_NEWMENU_CHANGED,				// an item had its value/text changed
-	EVENT_NEWMENU_SELECTED,				// user chose something - pressed enter/clicked on it
-
-	EVENT_LOOP_BEGIN_LOOP,
-	EVENT_LOOP_END_LOOP,
-
-	EVENT_UI_DIALOG_DRAW,				// draw after the dialog stuff is drawn (e.g. spinning robots)
-	EVENT_UI_GADGET_PRESSED,				// user 'pressed' a gadget
-	EVENT_UI_LISTBOX_MOVED,
-	EVENT_UI_LISTBOX_SELECTED,
-	EVENT_UI_USERBOX_DRAGGED
+	window_activated,
+	window_deactivated,
+	window_draw,
+	window_close,
+
+	newmenu_draw,					// draw after the newmenu stuff is drawn (e.g. savegame previews)
+	newmenu_changed,				// an item had its value/text changed
+	newmenu_selected,				// user chose something - pressed enter/clicked on it
+
+	loop_begin_loop,
+	loop_end_loop,
+
+	ui_dialog_draw,				// draw after the dialog stuff is drawn (e.g. spinning robots)
+	ui_gadget_pressed,				// user 'pressed' a gadget
+	ui_listbox_moved,
+	ui_listbox_selected,
+	ui_userbox_dragged
 };
 
 enum class window_event_result : uint8_t
@@ -87,7 +87,7 @@ struct d_event
 struct d_create_event : d_event
 {
 	constexpr d_create_event() :
-		d_event{EVENT_WINDOW_CREATED}
+		d_event{event_type::window_created}
 	{
 	}
 };
@@ -96,7 +96,7 @@ struct d_change_event : d_event
 {
 	const int citem;
 	constexpr d_change_event(const int c) :
-		d_event{EVENT_NEWMENU_CHANGED}, citem(c)
+		d_event{event_type::newmenu_changed}, citem{c}
 	{
 	}
 };
@@ -105,7 +105,7 @@ struct d_select_event : d_event
 {
 	int citem;
 	d_select_event(const int c) :
-		d_event{EVENT_NEWMENU_SELECTED}, citem(c)
+		d_event{event_type::newmenu_selected}, citem{c}
 	{
 	}
 };
@@ -116,7 +116,7 @@ struct d_window_size_event : d_event
 	Sint32 width;
 	Sint32 height;
 	d_window_size_event(const Sint32 w, const Sint32 h) :
-		d_event{EVENT_WINDOW_RESIZE}, width(w), height(h)
+		d_event{event_type::window_resize}, width{w}, height{h}
 	{
 	}
 };
@@ -125,7 +125,7 @@ struct d_window_size_event : d_event
 struct d_event_begin_loop : d_event
 {
 	d_event_begin_loop() :
-		d_event{EVENT_LOOP_BEGIN_LOOP}
+		d_event{event_type::loop_begin_loop}
 	{
 	}
 };
@@ -133,7 +133,7 @@ struct d_event_begin_loop : d_event
 struct d_event_end_loop : d_event
 {
 	d_event_end_loop() :
-		d_event{EVENT_LOOP_END_LOOP}
+		d_event{event_type::loop_end_loop}
 	{
 	}
 };
diff --git a/common/include/func.h b/common/include/func.h
index 56aed5429..4ab8db1c9 100644
--- a/common/include/func.h
+++ b/common/include/func.h
@@ -19,21 +19,22 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 
 #pragma once
 
-#ifdef __cplusplus
+#include "dsx-ns.h"
+#include <cstddef>
 
 namespace dcx {
-typedef struct {
+
+struct FUNCTION
+{
+	using callable = int(*)(void);
 	const char *  name;
 	int     nparams;
-	int  (*cfunction)(void);
-} FUNCTION;
+	callable cfunction;
+};
 
-void func_init( const FUNCTION * funtable, int size );
-void func_close();
-int (*func_get( char * name, int * numparams ))(void);
-int (*func_nget( int func_number, int * numparams, const char **name ))(void);
 int func_get_param( int n );
-int func_get_index( char * name );
-}
+FUNCTION::callable func_get(const char *name, int *numparams);
+FUNCTION::callable func_nget(std::size_t func_number, int *numparams, const char **name);
+int func_get_index(const char *name);
 
-#endif
+}
diff --git a/common/include/fwd-event.h b/common/include/fwd-event.h
index a99877548..118fc0653 100644
--- a/common/include/fwd-event.h
+++ b/common/include/fwd-event.h
@@ -16,7 +16,7 @@ struct d_event;
 struct d_change_event;
 struct d_select_event;
 
-enum event_type : unsigned;
+enum class event_type : uint8_t;
 enum class window_event_result : uint8_t;
 
 // Sends input events to event handlers
diff --git a/common/include/gr.h b/common/include/gr.h
index e6ea601d3..8bad2129b 100644
--- a/common/include/gr.h
+++ b/common/include/gr.h
@@ -98,7 +98,7 @@ struct grs_bitmap : prohibit_void_ptr<grs_bitmap>
 	short   bm_rowsize; // unsigned char offset to next row
 	std::array<fix, 3> avg_color_rgb; // same as above but real rgb value to be used to textured objects that should emit light
 	union {
-		const color_palette_index *bm_data;     // ptr to pixel data...
+		const color_palette_index *bm_data{};     // ptr to pixel data...
 	                                //   Linear = *parent+(rowsize*y+x)
 	                                //   ModeX = *parent+(rowsize*y+x/4)
 	                                //   SVGA = *parent+(rowsize*y+x)
@@ -106,9 +106,9 @@ struct grs_bitmap : prohibit_void_ptr<grs_bitmap>
 	};
 	const color_palette_index *get_bitmap_data() const { return bm_data; }
 	color_palette_index *get_bitmap_data() { return bm_mdata; }
-	struct grs_bitmap  *bm_parent;
+	struct grs_bitmap  *bm_parent{};
 #if DXX_USE_OGL
-	struct ogl_texture *gltexture;
+	struct ogl_texture *gltexture{};
 #else
 	uint8_t avg_color;  //  Average color of all pixels in texture map.
 #endif /* def OGL */
diff --git a/common/include/key.h b/common/include/key.h
index a5a2f17e5..87e249c89 100644
--- a/common/include/key.h
+++ b/common/include/key.h
@@ -62,7 +62,7 @@ extern std::array<unsigned char, KEY_BUFFER_SIZE> unicode_frame_buffer;
 
 extern void key_flush();    // Clears the 256 char buffer
 extern void event_keycommand_send(unsigned key); // synthesize a key command event from a keycode
-extern int event_key_get(const d_event &event);	// Get the keycode from the EVENT_KEY_COMMAND event
+int event_key_get(const d_event &event);	// Get the keycode from the event_type::key_command event
 extern int event_key_get_raw(const d_event &event);	// same as above but without mod states
 unsigned char key_ascii();
 
diff --git a/common/include/maths.h b/common/include/maths.h
index 41130dbba..f2a96dd11 100644
--- a/common/include/maths.h
+++ b/common/include/maths.h
@@ -56,7 +56,7 @@ static constexpr int f2i(const fix &f)
 //Convert fix to float and float to fix
 static constexpr float f2fl(const fix &f)
 {
-	return static_cast<float>(f) / static_cast<float>(65536.0);
+	return static_cast<float>(f) / 65536.0f;
 }
 
 static constexpr double f2db(const fix &f)
diff --git a/common/include/mouse.h b/common/include/mouse.h
index fa98027ab..fb16e2f9d 100644
--- a/common/include/mouse.h
+++ b/common/include/mouse.h
@@ -12,10 +12,10 @@
 
 #pragma once
 
+#include <array>
+#include <tuple>
 #include "pstypes.h"
 #include "maths.h"
-
-#ifdef __cplusplus
 #include <SDL_version.h>
 #include <cassert>
 #include "event.h"
@@ -56,9 +56,13 @@ enum class mbtn : uint8_t
 extern void mouse_flush();	// clears all mice events...
 extern void mouse_init(void);
 extern void mouse_close(void);
-extern void mouse_get_pos( int *x, int *y, int *z );
+[[nodiscard]]
+std::tuple<int /* x */, int /* y */, int /* z */> mouse_get_pos();
 window_event_result mouse_in_window(class window *wind);
-extern void mouse_get_delta( int *dx, int *dy, int *dz );
+#if 0
+[[nodiscard]]
+std::tuple<int /* x */, int /* y */, int /* z */> mouse_get_delta();
+#endif
 void mouse_enable_cursor();
 void mouse_disable_cursor();
 window_event_result mouse_button_handler(const SDL_MouseButtonEvent *mbe);
@@ -92,19 +96,20 @@ class d_event_mouse_moved : public d_event
 static inline mbtn event_mouse_get_button(const d_event &event)
 {
 	auto &e = static_cast<const d_event_mousebutton &>(event);
-	assert(e.type == EVENT_MOUSE_BUTTON_DOWN || e.type == EVENT_MOUSE_BUTTON_UP);
+	assert(e.type == event_type::mouse_button_down || e.type == event_type::mouse_button_up);
 	return e.button;
 }
 
-static inline void event_mouse_get_delta(const d_event &event, int *dx, int *dy, int *dz)
+[[nodiscard]]
+static inline std::array<int, 3> event_mouse_get_delta(const d_event &event)
 {
 	auto &e = static_cast<const d_event_mouse_moved &>(event);
-	assert(e.type == EVENT_MOUSE_MOVED);
-	*dx = e.dx;
-	*dy = e.dy;
-	*dz = e.dz;
+	assert(e.type == event_type::mouse_moved);
+	return {{
+		e.dx,
+		e.dy,
+		e.dz,
+	}};
 }
 
 }
-
-#endif
diff --git a/common/include/ntstring.h b/common/include/ntstring.h
index ac049e9e8..fee0d8ec8 100644
--- a/common/include/ntstring.h
+++ b/common/include/ntstring.h
@@ -41,12 +41,12 @@ class ntstring :
 	template <typename I>
 		std::size_t copy_if(I &&i)
 		{
-			return copy_if(static_cast<std::size_t>(0), static_cast<I &&>(i));
+			return copy_if(std::size_t{0}, static_cast<I &&>(i));
 		}
 	template <typename I>
 		std::size_t copy_if(I &&i, std::size_t N)
 		{
-			return copy_if(static_cast<std::size_t>(0), static_cast<I &&>(i), N);
+			return copy_if(std::size_t{0}, static_cast<I &&>(i), N);
 		}
 	template <typename I>
 		std::size_t copy_if(std::size_t out_offset, I &&i)
diff --git a/common/include/rle.h b/common/include/rle.h
index 2cffd8f8e..4de8a6ac8 100644
--- a/common/include/rle.h
+++ b/common/include/rle.h
@@ -189,71 +189,69 @@ class bm_rle_expand : bm_rle_src_stride
 		end_src_bm(end(src))
 	{
 	}
-	template <typename T>
-		/* Decode one row of the bitmap, then return control to the
-		 * caller.  If the return value is `again`, then the caller
-		 * should perform any per-row processing, then call step()
-		 * again.  If the return value is not `again`, then the
-		 * destination buffer is undefined and the caller should not
-		 * access it or call step().
-		 *
-		 * `const T &` to ensure that t is only modified by the caller
-		 * and that the caller does not accidentally provide an
-		 * implementation of `get_begin_dbits` that moves the
-		 * destination pointer.
+	/* Decode one row of the bitmap, then return control to the
+	 * caller.  If the return value is `again`, then the caller
+	 * should perform any per-row processing, then call step()
+	 * again.  If the return value is not `again`, then the
+	 * destination buffer is undefined and the caller should not
+	 * access it or call step().
+	 *
+	 * Use `const auto &` to ensure that t is only modified by the caller
+	 * and that the caller does not accidentally provide an
+	 * implementation of `get_begin_dbits` that moves the
+	 * destination pointer.
+	 */
+	step_result step(const auto &t)
+	{
+		/* Poison the memory first, so that it is undefined even if
+		 * the source is exhausted.
 		 */
-		step_result step(const T &t)
-		{
-			/* Poison the memory first, so that it is undefined even if
-			 * the source is exhausted.
-			 */
-			const auto b = t.get_begin_dbits();
-			const auto e = t.get_end_dbits();
-			DXX_MAKE_MEM_UNDEFINED(std::span(b, e));
-			/* Check for source exhaustion, so that empty bitmaps are
-			 * not read at all.  This allows callers to treat
-			 * src_exhausted as a definitive end-of-record with no data
-			 * available.
-			 */
-			if (ptr_src_bit_lengths == end_src_bit_lengths)
-				return src_exhausted;
-			return step_internal(b, e);
-		}
-	template <typename T>
-		/* Decode until source or destination is exhausted.  The
-		 * destination position is updated automatically as each row is
-		 * decoded.  There is no opportunity for callers to perform
-		 * per-row processing.  Callers should call step() directly if
-		 * per-row processing is required.
-		 *
-		 * `T &&` since some callers may not care about the state of `t`
-		 * afterward; `T &&` lets them pass an anonymous temporary.
+		const auto b = t.get_begin_dbits();
+		const auto e = t.get_end_dbits();
+		DXX_MAKE_MEM_UNDEFINED(std::span(b, e));
+		/* Check for source exhaustion, so that empty bitmaps are
+		 * not read at all.  This allows callers to treat
+		 * src_exhausted as a definitive end-of-record with no data
+		 * available.
 		 */
-		bool loop(const unsigned bm_w, T &&t)
+		if (ptr_src_bit_lengths == end_src_bit_lengths)
+			return src_exhausted;
+		return step_internal(b, e);
+	}
+	/* Decode until source or destination is exhausted.  The
+	 * destination position is updated automatically as each row is
+	 * decoded.  There is no opportunity for callers to perform
+	 * per-row processing.  Callers should call step() directly if
+	 * per-row processing is required.
+	 *
+	 * Use `auto &&` since some callers may not care about the state of `t`
+	 * afterward; `auto &&` lets them pass an anonymous temporary.
+	 */
+	bool loop(const unsigned bm_w, auto &&t)
+	{
+		for (;;)
 		{
-			for (;;)
+			switch (step(t))
 			{
-				switch (step(t))
-				{
-					case again:
-						/* Step succeeded.  Notify `t` to update its
-						 * dbits position, then loop around.
-						 */
-						t.consume_dbits(bm_w);
-						break;
-					case src_exhausted:
-						/* Success: source buffer exhausted and no error
-						 * conditions detected.
-						 */
-						return true;
-					case dst_exhausted:
-						/* Failure: destination buffer too small to hold
-						 * expanded source.
-						 */
-						return false;
-				}
+				case again:
+					/* Step succeeded.  Notify `t` to update its
+					 * dbits position, then loop around.
+					 */
+					t.consume_dbits(bm_w);
+					break;
+				case src_exhausted:
+					/* Success: source buffer exhausted and no error
+					 * conditions detected.
+					 */
+					return true;
+				case dst_exhausted:
+					/* Failure: destination buffer too small to hold
+					 * expanded source.
+					 */
+					return false;
 			}
 		}
+	}
 private:
 	step_result step_internal(uint8_t *begin_dbits, uint8_t *end_dbits);
 };
diff --git a/common/include/serial.h b/common/include/serial.h
index 90e714fb1..3b72f8a51 100644
--- a/common/include/serial.h
+++ b/common/include/serial.h
@@ -24,6 +24,9 @@
 
 namespace serial {
 
+template <std::size_t Expected, std::size_t Actual>
+concept check_equal_value = (Expected == Actual);
+
 template <typename... Args>
 class message;
 
@@ -327,8 +330,11 @@ static inline detail::sign_extend_type<extended_signed_type, wrapped_type> sign_
 #define DEFINE_SERIAL_MUTABLE_UDT_TO_MESSAGE(TYPE, NAME, MEMBERLIST)	\
 	_DEFINE_SERIAL_UDT_TO_MESSAGE(TYPE, NAME, MEMBERLIST)
 
+template <std::size_t Expected, typename T>
+concept check_serial_udt_maximum_message_size = check_equal_value<Expected, T::maximum_size.value>;
+
 #define ASSERT_SERIAL_UDT_MESSAGE_SIZE(T, SIZE)	\
-	assert_equal(serial::class_type<T>::maximum_size, SIZE, "sizeof(" #T ") is not " #SIZE)
+	static_assert(serial::check_serial_udt_maximum_message_size<SIZE, serial::class_type<T>>)
 
 template <typename M1, typename T1, typename base_type = std::is_same<typename std::remove_cv<typename std::remove_reference<M1>::type>::type, T1>>
 struct udt_message_compatible_same_type : base_type
@@ -390,8 +396,8 @@ union unaligned_storage
 		typename std::conditional<N == 1, uint8_t, uint16_t>,
 		typename std::conditional<N == 4, uint32_t, uint64_t>>::type::type i;
 	uint8_t u[N];
-	assert_equal(sizeof(i), N, "sizeof(i) is not N");
-	assert_equal(sizeof(a), sizeof(u), "sizeof(T) is not N");
+	static_assert(check_equal_value<N, sizeof(i)>);
+	static_assert(check_equal_value<sizeof(u), sizeof(a)>);
 };
 
 template <typename T, typename = void>
@@ -512,16 +518,19 @@ static constexpr T bswap(const T u)
 	 */
 }
 
-assert_equal(bswap(static_cast<uint8_t>(1)), 1, "");
+template <typename T, T Expected, T input>
+concept check_bswap = check_equal_value<Expected, bswap(input)>;
+
+static_assert(check_bswap<uint8_t, 1, 1>);
 
-assert_equal(bswap(static_cast<uint16_t>(0x12)), 0x1200, "");
-assert_equal(bswap(static_cast<uint16_t>(0x92)), 0x9200, "");
-assert_equal(bswap(static_cast<uint16_t>(0x9200)), 0x92, "");
-assert_equal(bswap(static_cast<uint16_t>(0x102)), 0x201, "");
+static_assert(check_bswap<uint16_t, 0x1200, 0x12>);
+static_assert(check_bswap<uint16_t, 0x9200, 0x92>);
+static_assert(check_bswap<uint16_t, 0x92, 0x9200>);
+static_assert(check_bswap<uint16_t, 0x201, 0x102>);
 
-assert_equal(bswap(static_cast<uint32_t>(0x102)), 0x2010000, "");
+static_assert(check_bswap<uint32_t, 0x2010000, 0x102>);
 
-assert_equal(bswap(static_cast<uint64_t>(0x102)), 0x201000000000000ull, "");
+static_assert(check_bswap<uint64_t, 0x201000000000000ull, 0x102>);
 
 namespace reader {
 
diff --git a/common/include/ui.h b/common/include/ui.h
index 807d0cb02..f7ac0f78f 100644
--- a/common/include/ui.h
+++ b/common/include/ui.h
@@ -247,9 +247,9 @@ struct UI_DIALOG : window
 	virtual window_event_result callback_handler(const d_event &) = 0;
 };
 
-#define B1_JUST_PRESSED     (event.type == EVENT_MOUSE_BUTTON_DOWN && event_mouse_get_button(event) == mbtn::left)
-#define B1_JUST_RELEASED    (event.type == EVENT_MOUSE_BUTTON_UP && event_mouse_get_button(event) == mbtn::left)
-#define B1_DOUBLE_CLICKED   (event.type == EVENT_MOUSE_DOUBLE_CLICKED && event_mouse_get_button(event) == mbtn::left)
+#define B1_JUST_PRESSED     (event.type == event_type::mouse_button_down && event_mouse_get_button(event) == mbtn::left)
+#define B1_JUST_RELEASED    (event.type == event_type::mouse_button_up && event_mouse_get_button(event) == mbtn::left)
+#define B1_DOUBLE_CLICKED   (event.type == event_type::mouse_double_clicked && event_mouse_get_button(event) == mbtn::left)
 
 extern grs_font_ptr ui_small_font;
 
@@ -275,7 +275,7 @@ int ui_messagebox( short xc, short yc, const char * text, const ui_messagebox_ti
 void ui_dialog_set_current_canvas(UI_DIALOG &dlg);
 void ui_close_dialog(UI_DIALOG &dlg);
 
-#define GADGET_PRESSED(g) (event.type == EVENT_UI_GADGET_PRESSED && &ui_event_get_gadget(event) == g)
+#define GADGET_PRESSED(g) (event.type == event_type::ui_gadget_pressed && &ui_event_get_gadget(event) == g)
 
 void ui_gadget_add(UI_DIALOG &dlg, short x1, short y1, short x2, short y2, UI_GADGET &);
 
diff --git a/common/include/valptridx.h b/common/include/valptridx.h
index d3e255895..c8fe9c57f 100644
--- a/common/include/valptridx.h
+++ b/common/include/valptridx.h
@@ -271,7 +271,7 @@ template <typename managed_type>
 class valptridx<managed_type>::partial_policy::require_valid
 {
 public:
-	static constexpr bool allow_nullptr = false;
+	static constexpr bool allow_nullptr{false};
 	[[nodiscard]]
 	static constexpr std::false_type check_allowed_invalid_index(index_type) { return {}; }
 	[[nodiscard]]
@@ -285,7 +285,7 @@ template <typename managed_type>
 class valptridx<managed_type>::partial_policy::allow_invalid
 {
 public:
-	static constexpr bool allow_nullptr = true;
+	static constexpr bool allow_nullptr{true};
 	[[nodiscard]]
 	static constexpr bool check_allowed_invalid_index(index_type i)
 	{
@@ -298,12 +298,6 @@ class valptridx<managed_type>::partial_policy::allow_invalid
 	}
 };
 
-template <typename managed_type>
-constexpr bool valptridx<managed_type>::partial_policy::require_valid::allow_nullptr;
-
-template <typename managed_type>
-constexpr bool valptridx<managed_type>::partial_policy::allow_invalid::allow_nullptr;
-
 template <typename managed_type>
 template <template <typename> class policy>
 class valptridx<managed_type>::partial_policy::apply_cv_policy
@@ -371,14 +365,20 @@ class valptridx<managed_type>::idx :
 	 * If moving from require_valid to anything, no check is needed.
 	 */
 	template <typename rpolicy>
-		requires(policy::allow_nullptr || !rpolicy::allow_nullptr)
-		idx(const idx<rpolicy> &rhs) :
+		idx(const idx<rpolicy> &rhs)
+		requires(
+			allow_nullptr || !rhs.allow_nullptr
+		)
+		:
 			m_idx(rhs.get_unchecked_index())
 	{
 	}
 	template <typename rpolicy>
-		requires(!(policy::allow_nullptr || !rpolicy::allow_nullptr))
-		idx(const idx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :
+		idx(const idx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS)
+		requires(
+			!(allow_nullptr || !rhs.allow_nullptr)
+		)
+		:
 		/* If moving from allow_invalid to require_valid, check range.
 		 */
 			m_idx(check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS rhs.get_unchecked_index(), nullptr))
@@ -392,7 +392,7 @@ class valptridx<managed_type>::idx :
 		 * right hand side must be saved and checked for validity before
 		 * being used to initialize a require_valid type.
 		 */
-		static_assert(policy::allow_nullptr || !rpolicy::allow_nullptr, "cannot move from allow_invalid to require_valid");
+		static_assert(allow_nullptr || !rhs.allow_nullptr, "cannot move from allow_invalid to require_valid");
 	}
 	idx(index_type i DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :
 		m_idx(check_allowed_invalid_index(i) ? i : check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, nullptr))
@@ -407,7 +407,16 @@ class valptridx<managed_type>::idx :
 		idx(const magic_constant<v> &, const allow_none_construction *) :
 			m_idx(v)
 	{
+		/* Prevent using `allow_none_construction` when the type permits
+		 * use of an invalid index.  `allow_none_construction` is intended
+		 * to override the validity requirement on types that require a
+		 * valid index, for the limited purpose of constructing a sentinel.
+		 */
 		static_assert(!allow_nullptr, "allow_none_construction used where nullptr was already legal");
+		/* Prevent using `allow_none_construction` with a valid index.
+		 * Valid indexes should not use the `allow_none_construction`
+		 * override.
+		 */
 		static_assert(static_cast<std::size_t>(v) >= array_size, "allow_none_construction used with valid index");
 	}
 	idx(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a, const allow_end_construction *) :
@@ -427,6 +436,10 @@ class valptridx<managed_type>::idx :
 		constexpr idx(const magic_constant<v> &) :
 			m_idx(v)
 	{
+		/* If the policy requires a valid index (indicated by
+		 * `allow_nullptr == false`), then require that the magic index be
+		 * valid.
+		 */
 		static_assert(allow_nullptr || static_cast<std::size_t>(v) < array_size, "invalid magic index not allowed for this policy");
 	}
 	template <typename rpolicy>
@@ -510,47 +523,59 @@ class valptridx<managed_type>::ptr :
 		return *get_nonnull_pointer(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VA());
 	}
 
-	ptr(std::nullptr_t) :
+	ptr(std::nullptr_t)
+		requires(allow_nullptr)	// This constructor always stores nullptr, so require a policy with `allow_nullptr == true`.
+		:
 		m_ptr(nullptr)
 	{
-		static_assert(allow_nullptr, "nullptr construction not allowed for this policy");
 	}
 	template <integral_type v>
+		requires(
+			static_cast<std::size_t>(v) >= array_size	// Require that the index be invalid, since a valid index should compute a non-nullptr here, but with no array, no pointer can be computed.
+		)
 		ptr(const magic_constant<v> &) :
-			m_ptr(nullptr)
+			ptr(nullptr)
 	{
-		static_assert(static_cast<std::size_t>(v) >= array_size, "valid magic index requires an array");
-		if constexpr (!allow_nullptr)
-			static_assert(static_cast<std::size_t>(v) < array_size, "invalid magic index not allowed for this policy");
 	}
 	template <integral_type v>
+		requires(
+			static_cast<std::size_t>(v) < array_size	// valid magic index required when using array
+		)
 		ptr(const magic_constant<v> &, array_managed_type &a) :
 			m_ptr(&a[v])
 	{
-		static_assert(static_cast<std::size_t>(v) < array_size, "valid magic index required when using array");
 	}
 	template <typename rpolicy>
-		requires(policy::allow_nullptr || !rpolicy::allow_nullptr)
-		ptr(const ptr<rpolicy> &rhs) :
+		ptr(const ptr<rpolicy> &rhs)
+		requires(
+			allow_nullptr || !rhs.allow_nullptr
+		)
+		:
 			m_ptr(rhs.get_unchecked_pointer())
 	{
 	}
 	template <typename rpolicy>
-		requires(!(policy::allow_nullptr || !rpolicy::allow_nullptr))
-		ptr(const ptr<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :
+		ptr(const ptr<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS)
+		requires(
+			!(allow_nullptr || !rhs.allow_nullptr)
+		)
+		:
 			m_ptr(rhs.get_unchecked_pointer())
 	{
 		check_null_pointer_conversion<null_pointer_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS m_ptr);
 	}
 	template <typename rpolicy>
-		ptr(ptr<rpolicy> &&rhs) :
+		ptr(ptr<rpolicy> &&rhs)
+		requires(
+			allow_nullptr || !rhs.allow_nullptr	// cannot move from allow_invalid to require_valid
+		)
+		:
 			m_ptr(rhs.get_unchecked_pointer())
 	{
 		/* Prevent move from allow_invalid into require_valid.  The
 		 * right hand side must be saved and checked for validity before
 		 * being used to initialize a require_valid type.
 		 */
-		static_assert(policy::allow_nullptr || !rpolicy::allow_nullptr, "cannot move from allow_invalid to require_valid");
 	}
 	ptr(index_type i) = delete;
 	ptr(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_DEFN_VARS index_type i, array_managed_type &a) :
@@ -670,16 +695,22 @@ class valptridx<managed_type>::ptr :
 		-- m_ptr;
 		return *this;
 	}
-	ptr(const allow_none_construction *) :
+	ptr(const allow_none_construction *)
+		requires(
+			!allow_nullptr	// allow_none_construction is only needed where nullptr is not already legal
+		)
+		:
 		m_ptr(nullptr)
 	{
-		static_assert(!allow_nullptr, "allow_none_construction used where nullptr was already legal");
 	}
 	template <typename rpolicy>
-		ptr(ptr<rpolicy> &&rhs, const typename containing_type::rebind_policy *) :
+		ptr(ptr<rpolicy> &&rhs, const typename containing_type::rebind_policy *)
+		requires(
+			allow_nullptr || !rhs.allow_nullptr	// cannot rebind from allow_invalid to require_valid
+		)
+		:
 			m_ptr(const_cast<managed_type *>(rhs.get_unchecked_pointer()))
 	{
-		static_assert(allow_nullptr || !rpolicy::allow_nullptr, "cannot rebind from allow_invalid to require_valid");
 	}
 };
 
@@ -719,6 +750,7 @@ class valptridx<managed_type>::ptridx :
 	using index_type = typename vidx_type::index_type;
 	using typename vidx_type::integral_type;
 	using typename vptr_type::pointer_type;
+	using vptr_type::allow_nullptr;
 	using vidx_type::operator==;
 	using vptr_type::operator==;
 	ptridx(const ptridx &) = default;
@@ -732,15 +764,21 @@ class valptridx<managed_type>::ptridx :
 	 */
 	ptridx(pointer_type p) = delete;
 	template <typename rpolicy>
-		requires(policy::allow_nullptr || !rpolicy::allow_nullptr)
-		ptridx(const ptridx<rpolicy> &rhs) :
+		ptridx(const ptridx<rpolicy> &rhs)
+		requires(
+			allow_nullptr || !rhs.allow_nullptr
+		)
+		:
 			vptr_type(static_cast<const typename ptridx<rpolicy>::vptr_type &>(rhs)),
 			vidx_type(static_cast<const typename ptridx<rpolicy>::vidx_type &>(rhs))
 	{
 	}
 	template <typename rpolicy>
-		requires(!(policy::allow_nullptr || !rpolicy::allow_nullptr))
-		ptridx(const ptridx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) :
+		ptridx(const ptridx<rpolicy> &rhs DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS)
+		requires(
+			!(allow_nullptr || !rhs.allow_nullptr)
+		)
+		:
 			vptr_type(static_cast<const typename ptridx<rpolicy>::vptr_type &>(rhs) DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_PASS_VARS),
 			vidx_type(static_cast<const typename ptridx<rpolicy>::vidx_type &>(rhs) DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_PASS_VARS)
 	{
@@ -807,7 +845,7 @@ class valptridx<managed_type>::ptridx :
 	}
 	ptridx absolute_sibling(const index_type i DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_L_DECL_VARS) const
 	{
-		static_assert(!policy::allow_nullptr, "absolute_sibling not allowed with invalid ptridx");
+		static_assert(!allow_nullptr, "absolute_sibling not allowed with invalid ptridx");
 		ptridx r(*this);
 		r.m_ptr += check_index_range<index_range_error_type<array_managed_type>>(DXX_VALPTRIDX_REPORT_STANDARD_LEADER_COMMA_R_PASS_VARS i, nullptr) - this->m_idx;
 		r.m_idx = i;
diff --git a/common/main/aistruct.h b/common/main/aistruct.h
index cb93145c8..641f83864 100644
--- a/common/main/aistruct.h
+++ b/common/main/aistruct.h
@@ -231,7 +231,7 @@ struct ai_local : public prohibit_void_ptr<ai_local>
 
 struct ai_static : public prohibit_void_ptr<ai_static>
 {
-	ai_behavior behavior = static_cast<ai_behavior>(0);               //
+	ai_behavior behavior{};               //
 	robot_gun_number CURRENT_GUN;
 	ai_static_state CURRENT_STATE;
 	ai_static_state GOAL_STATE;
diff --git a/common/main/d_enumerate.h b/common/main/d_enumerate.h
index b67f662f1..fba2e0806 100644
--- a/common/main/d_enumerate.h
+++ b/common/main/d_enumerate.h
@@ -68,20 +68,21 @@ class enumerated_sentinel
 	}
 };
 
-template <typename range_index_type, typename range_iterator_type, typename sentinel_type, typename adjust_iterator_dereference_type>
+template <typename range_index_type, typename range_iterator_type, typename sentinel_type>
 class enumerated_iterator
 {
+	using adjust_iterator_dereference_type = d_enumerate::detail::adjust_iterator_dereference_type<range_index_type, typename std::remove_cv<decltype(*std::declval<range_iterator_type>())>::type>;
 	range_iterator_type m_iter;
 	range_index_type m_idx;
 public:
 	using index_type = range_index_type;
-	using iterator_category = std::forward_iterator_tag;
+	using iterator_category = typename std::iterator_traits<range_iterator_type>::iterator_category;
 	using value_type = typename adjust_iterator_dereference_type::value_type;
 	using difference_type = std::ptrdiff_t;
 	using pointer = value_type *;
 	using reference = value_type &;
-	constexpr enumerated_iterator(range_iterator_type &&iter, const index_type idx) :
-		m_iter(std::move(iter)), m_idx(idx)
+	constexpr enumerated_iterator(range_iterator_type &&iter, index_type idx) :
+		m_iter{std::move(iter)}, m_idx{std::move(idx)}
 	{
 	}
 	value_type operator*() const
@@ -109,10 +110,27 @@ class enumerated_iterator
 	}
 	enumerated_iterator operator++(int)
 	{
-		auto result = *this;
+		auto result{*this};
 		++ * this;
 		return result;
 	}
+	enumerated_iterator &operator--()
+		requires(std::bidirectional_iterator<range_iterator_type>)
+	{
+		-- m_iter;
+		if constexpr (std::is_enum<index_type>::value)
+			m_idx = static_cast<index_type>(static_cast<typename std::underlying_type<index_type>::type>(m_idx) - 1u);
+		else
+			-- m_idx;
+		return *this;
+	}
+	enumerated_iterator operator--(int)
+		requires(std::bidirectional_iterator<range_iterator_type>)
+	{
+		auto result{*this};
+		-- * this;
+		return result;
+	}
 	constexpr bool operator==(const enumerated_sentinel<sentinel_type> &i) const
 	{
 		return m_iter == i.m_sentinel;
@@ -123,14 +141,14 @@ template <typename range_iterator_type, typename range_sentinel_type, typename r
 class enumerate : ranges::subrange<range_iterator_type, range_sentinel_type>
 {
 	using base_type = ranges::subrange<range_iterator_type, range_sentinel_type>;
-	using iterator_dereference_type = decltype(*std::declval<range_iterator_type>());
 	using enumerated_iterator_type = enumerated_iterator<
 		range_index_type,
 		range_iterator_type,
-		range_sentinel_type,
-		d_enumerate::detail::adjust_iterator_dereference_type<range_index_type, typename std::remove_cv<iterator_dereference_type>::type>>;
-	const range_index_type m_idx;
+		range_sentinel_type>;
+	[[no_unique_address]]
+	range_index_type m_idx;
 public:
+	using base_type::size;
 	using index_type = range_index_type;
 	template <typename range_type>
 		/* Block using `enumerate` on an ephemeral range, since the storage
@@ -139,10 +157,9 @@ class enumerate : ranges::subrange<range_iterator_type, range_sentinel_type>
 		 * storage may cease to exist after this constructor returns.
 		 */
 		requires(ranges::borrowed_range<range_type>)
-		enumerate(range_type &&t, const index_type i = index_type{}) :
-			base_type(std::forward<range_type>(t)), m_idx(i)
+		enumerate(range_type &&t, index_type i = index_type{}) :
+			base_type{std::forward<range_type>(t)}, m_idx{std::move(i)}
 	{
-		static_assert(std::is_rvalue_reference<range_type &&>::value || !std::is_rvalue_reference<iterator_dereference_type>::value, "lvalue range must not produce rvalue reference enumerated_value");
 	}
 	enumerated_iterator_type begin() const
 	{
diff --git a/common/main/d_zip.h b/common/main/d_zip.h
index 1029392e6..48dfa1365 100644
--- a/common/main/d_zip.h
+++ b/common/main/d_zip.h
@@ -6,6 +6,7 @@
  */
 #pragma once
 
+#include <cstdint>
 #include <iterator>
 #include <tuple>
 #include <type_traits>
@@ -19,8 +20,7 @@ namespace d_zip {
 
 namespace detail {
 
-template <typename... T>
-void discard_arguments(T &&...)
+void discard_arguments(auto &&...)
 {
 }
 
@@ -34,6 +34,12 @@ void increment_iterator(std::tuple<range_iterator_type...> &iterator, std::index
 	discard_arguments(++(std::get<N>(iterator))...);
 }
 
+template <std::size_t... N, typename... range_iterator_type>
+void decrement_iterator(std::tuple<range_iterator_type...> &iterator, std::index_sequence<N...>)
+{
+	discard_arguments(--(std::get<N>(iterator))...);
+}
+
 template <std::size_t... N, typename... range_iterator_type>
 auto dereference_iterator(const std::tuple<range_iterator_type...> &iterator, std::index_sequence<N...>)
 {
@@ -52,6 +58,15 @@ auto dereference_iterator(const std::tuple<range_iterator_type...> &iterator, st
 		>(*(std::get<N>(iterator))...);
 }
 
+/* This is declared, but never defined.  It is used only for a decltype()
+ * expression.
+ *
+ * Given a tuple of iterator types, return the most-derived iterator_category
+ * that all the iterator types satisfy.
+ */
+template <typename... range_iterator_type>
+typename std::common_type<typename std::iterator_traits<range_iterator_type>::iterator_category...>::type common_iterator_category(std::tuple<range_iterator_type...>);
+
 /* The overloads of get_static_size are declared, but never defined.  They
  * exist only for use in decltype() expressions.
  */
@@ -276,7 +291,7 @@ class zip_iterator : range_iterator_type
 	using value_type = decltype(d_zip::detail::dereference_iterator(std::declval<range_iterator_type>(), index_sequence_type()));
 	using pointer = value_type *;
 	using reference = value_type &;
-	using iterator_category = std::forward_iterator_tag;
+	using iterator_category = decltype(d_zip::detail::common_iterator_category(std::declval<range_iterator_type>()));
 	auto operator*() const
 	{
 		return d_zip::detail::dereference_iterator(*this, index_sequence_type());
@@ -291,14 +306,29 @@ class zip_iterator : range_iterator_type
 	 */
 	zip_iterator operator++(int)
 	{
-		auto result = *this;
-		d_zip::detail::increment_iterator(*this, index_sequence_type());
+		auto result{*this};
+		++ *this;
+		return result;
+	}
+	zip_iterator &operator--()
+		requires(std::derived_from<std::bidirectional_iterator_tag, iterator_category>)
+	{
+		d_zip::detail::decrement_iterator(*this, index_sequence_type());
+		return *this;
+	}
+	zip_iterator operator--(int)
+		requires(std::derived_from<std::bidirectional_iterator_tag, iterator_category>)
+	{
+		auto result{*this};
+		-- *this;
 		return result;
 	}
 	auto operator-(const zip_iterator &i) const
+		requires(std::derived_from<std::random_access_iterator_tag, iterator_category>)
 	{
 		return std::get<0>(static_cast<const range_iterator_type &>(*this)) - std::get<0>(static_cast<const range_iterator_type &>(i));
 	}
+	constexpr bool operator==(const zip_iterator &) const = default;
 	constexpr bool operator==(const range_sentinel_type &i) const
 	{
 		return d_zip::detail::compare_zip_iterators<range_iterator_type>(*this, i, index_sequence_type());
diff --git a/common/main/digi.h b/common/main/digi.h
index 03099cda0..2c8c49197 100644
--- a/common/main/digi.h
+++ b/common/main/digi.h
@@ -67,7 +67,7 @@ enum class sound_sample_rate : uint16_t
 
 struct digi_sound_deleter : std::default_delete<uint8_t[]>
 {
-	game_sound_offset offset = {};
+	game_sound_offset offset{};
 	constexpr digi_sound_deleter() = default;
 	constexpr digi_sound_deleter(const game_sound_offset offset) :
 		offset(offset)
diff --git a/common/main/lighting.h b/common/main/lighting.h
index 1501acd52..8cad087ea 100644
--- a/common/main/lighting.h
+++ b/common/main/lighting.h
@@ -52,8 +52,8 @@ namespace dsx {
 #if defined(DXX_BUILD_DESCENT_II)
 struct d_level_unique_headlight_state
 {
-	unsigned Num_headlights = 0;
-	std::array<const object_base *, 8> Headlights = {};
+	unsigned Num_headlights{};
+	std::array<const object_base *, 8> Headlights{};
 };
 
 struct d_level_unique_light_state :
diff --git a/common/main/menu.h b/common/main/menu.h
index 6382683d8..9f43883a4 100644
--- a/common/main/menu.h
+++ b/common/main/menu.h
@@ -33,8 +33,8 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 
 namespace dcx {
 
-template <typename Rep, std::size_t MaximumValue = std::numeric_limits<Rep>::max()>
-using human_readable_mmss_time = std::array<char, number_to_text_length<MaximumValue / 60> + number_to_text_length<60> + sizeof("ms")>;
+template <typename Rep>
+using human_readable_mmss_time = std::array<char, number_to_text_length<std::numeric_limits<Rep>::max() / 60> + number_to_text_length<60> + sizeof("ms")>;
 
 template <typename Rep, std::size_t S>
 void format_human_readable_time(std::array<char, S> &buf, const std::chrono::duration<Rep, std::chrono::seconds::period> duration);
diff --git a/common/main/nvparse.h b/common/main/nvparse.h
index 9f0a3f25e..71c12267c 100644
--- a/common/main/nvparse.h
+++ b/common/main/nvparse.h
@@ -23,8 +23,9 @@ static inline bool cmp(const char *token, const char *equal, const char (&name)[
 	return &token[N - 1] == equal && !strncmp(token, name, N - 1);
 }
 
-template <typename T>
-static inline std::optional<T> convert_integer(const char *value, int base, auto libc_str_to_integer)
+template <std::integral T>
+[[nodiscard]]
+static inline std::optional<T> convert_integer(const char *const value, int base, auto libc_str_to_integer)
 {
 	char *e;
 	const auto r = libc_str_to_integer(value, &e, base);
@@ -42,22 +43,21 @@ static inline std::optional<T> convert_integer(const char *value, int base, auto
 	return static_cast<T>(r);
 }
 
-template <typename T>
-requires(std::is_signed<T>::value)
+template <std::signed_integral T>
+[[nodiscard]]
 static inline auto convert_integer(const char *value, int base = 10)
 {
 	return convert_integer<T>(value, base, std::strtol);
 }
 
-template <typename T>
-requires(std::is_unsigned<T>::value)
+template <std::unsigned_integral T>
+[[nodiscard]]
 static inline auto convert_integer(const char *value, int base = 10)
 {
 	return convert_integer<T>(value, base, std::strtoul);
 }
 
-template <typename T>
-requires(std::is_integral<T>::value)
+template <std::integral T>
 static inline void convert_integer(T &t, const char *value, int base = 10)
 {
 	if (auto r = convert_integer<T>(value, base))
diff --git a/common/main/object.h b/common/main/object.h
index 80ffcc992..b28700240 100644
--- a/common/main/object.h
+++ b/common/main/object.h
@@ -230,13 +230,13 @@ struct quaternionpos : prohibit_void_ptr<quaternionpos>
 	vms_vector rotvel;
 };
 
-// stuctures for different kinds of simulation
+// structures for different kinds of simulation
 
 struct laser_parent
 {
-	int16_t parent_type = {};        // The type of the parent of this object
-	objnum_t parent_num = {};         // The object's parent's number
-	object_signature_t parent_signature = object_signature_t{0};   // The object's parent's signature...
+	int16_t parent_type{};        // The type of the parent of this object
+	objnum_t parent_num{};         // The object's parent's number
+	object_signature_t parent_signature{};   // The object's parent's signature...
 };
 
 struct laser_info : prohibit_void_ptr<laser_info>, laser_parent
@@ -251,10 +251,10 @@ struct laser_info : prohibit_void_ptr<laser_info>, laser_parent
 	 * hitobj_count == hitobj_values.size(), hitobj_pos wraps around and
 	 * begins erasing the oldest elements first.
 	 */
-	uint8_t hitobj_pos = 0, hitobj_count = 0;
-	std::array<objnum_t, 83> hitobj_values = {};
-	objnum_t track_goal = 0;         // Object this object is tracking.
-	fix multiplier = 0;         // Power if this is a fusion bolt (or other super weapon to be added).
+	uint8_t hitobj_pos{}, hitobj_count{};
+	std::array<objnum_t, 83> hitobj_values{};
+	objnum_t track_goal{};         // Object this object is tracking.
+	fix multiplier{};         // Power if this is a fusion bolt (or other super weapon to be added).
 	uint_fast8_t test_set_hitobj(const vcobjidx_t o);
 	uint_fast8_t test_hitobj(const vcobjidx_t o) const;
 	icobjidx_t get_last_hitobj() const;
diff --git a/common/main/segiter.h b/common/main/segiter.h
index e27cf75fc..1b294928c 100644
--- a/common/main/segiter.h
+++ b/common/main/segiter.h
@@ -36,12 +36,27 @@ class segment_object_range_t
 	const iterator &begin() const { return b; }
 	static sentinel end() { return {}; }
 	static T construct(const unique_segment &s, auto &of, auto &sf)
+		requires(
+			std::convertible_to<decltype(of(s.objects)), const object_base &> &&
+			requires(const object_base o) {
+			/* Require that the supplied `sf` can produce a value whose address
+			 * can be compared to the address of a `const unique_segment &`.
+			 *
+			 * In !NDEBUG builds, this is required as a consequence of the
+			 * assert conditions.  In NDEBUG builds, it would not be checked,
+			 * so an erroneous factory would compile successfully.  Use the
+			 * `requires` clause to catch this error when assertions are not
+			 * enabled.
+			 */
+				&*sf(o.segnum) == &s;
+			}
+		)
 		{
 			if (s.objects == object_none)
 				return T(object_none, static_cast<typename T::allow_none_construction *>(nullptr));
 			auto opi = of(s.objects);
-			const object_base &o = opi;
 #if DXX_SEGITER_DEBUG_OBJECT_LINKAGE
+			const object_base &o = opi;
 			/* Assert that the first object in the segment claims to be
 			 * in the segment that claims to have that object.
 			 */
@@ -51,14 +66,6 @@ class segment_object_range_t
 			 */
 			assert(o.prev == object_none);
 #endif
-			/* Check that the supplied SF can produce `const unique_segment &`.
-			 * In !NDEBUG builds, this would be checked as a side effect of the
-			 * assert conditions.  In NDEBUG builds, it would not be checked.
-			 *
-			 * Wrap the expression in a sizeof to prevent the compiler from
-			 * emitting code to implement the test.
-			 */
-			static_cast<void>(sizeof(&*sf(o.segnum) == &s));
 			return opi;
 		}
 };
diff --git a/common/mem/mem.cpp b/common/mem/mem.cpp
index 1df9c8009..1ba426139 100644
--- a/common/mem/mem.cpp
+++ b/common/mem/mem.cpp
@@ -165,7 +165,7 @@ void *(mem_calloc)( size_t nmemb, size_t size, const char * var, const char * fi
 	if ((nmemb | size) >= threshold) {
 		/* possible overflow condition */
 		if (request / size != nmemb)
-			request = ~static_cast<size_t>(0);
+			request = ~std::size_t{0};
 	}
 	void *ptr = mem_malloc(request, var, filename, line);
 	if (ptr)
diff --git a/common/ui/button.cpp b/common/ui/button.cpp
index e71ec33eb..e341dffbd 100644
--- a/common/ui/button.cpp
+++ b/common/ui/button.cpp
@@ -136,7 +136,7 @@ window_event_result UI_GADGET_BUTTON::event_handler(UI_DIALOG &dlg, const d_even
 	oldposition = position;
 	pressed = 0;
 
-	if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
+	if (event.type == event_type::mouse_button_down || event.type == event_type::mouse_button_up)
 	{
 		const auto OnMe = ui_mouse_on_gadget(*this);
 
@@ -155,7 +155,7 @@ window_event_result UI_GADGET_BUTTON::event_handler(UI_DIALOG &dlg, const d_even
 	}
 
 	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 	{
 		const auto keypress = event_key_get(event);
 		if (keypress == hotkey ||
@@ -166,7 +166,7 @@ window_event_result UI_GADGET_BUTTON::event_handler(UI_DIALOG &dlg, const d_even
 			rval = window_event_result::handled;
 		}
 	}
-	else if (event.type == EVENT_KEY_RELEASE)
+	else if (event.type == event_type::key_release)
 	{
 		const auto keypress = event_key_get(event);
 		position = 0;
@@ -182,7 +182,7 @@ window_event_result UI_GADGET_BUTTON::event_handler(UI_DIALOG &dlg, const d_even
 		}
 	}
 
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_button(dlg, *this);
 
 	if (pressed && user_function )
@@ -192,7 +192,7 @@ window_event_result UI_GADGET_BUTTON::event_handler(UI_DIALOG &dlg, const d_even
 	}
 	else if (pressed)
 	{
-		rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
diff --git a/common/ui/checkbox.cpp b/common/ui/checkbox.cpp
index 5546d59cf..f70195852 100644
--- a/common/ui/checkbox.cpp
+++ b/common/ui/checkbox.cpp
@@ -85,7 +85,7 @@ window_event_result UI_GADGET_CHECKBOX::event_handler(UI_DIALOG &dlg, const d_ev
 	oldposition = position;
 	pressed = 0;
 
-	if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
+	if (event.type == event_type::mouse_button_down || event.type == event_type::mouse_button_up)
 	{
 		const auto OnMe = ui_mouse_on_gadget(*this);
 		
@@ -104,7 +104,7 @@ window_event_result UI_GADGET_CHECKBOX::event_handler(UI_DIALOG &dlg, const d_ev
 	}
 
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 	{
 		const auto key = event_key_get(event);
 		if (dlg.keyboard_focus_gadget == this && (key == KEY_SPACEBAR || key == KEY_ENTER))
@@ -113,7 +113,7 @@ window_event_result UI_GADGET_CHECKBOX::event_handler(UI_DIALOG &dlg, const d_ev
 			return window_event_result::handled;
 		}
 	}
-	else if (event.type == EVENT_KEY_RELEASE)
+	else if (event.type == event_type::key_release)
 	{
 		const auto key = event_key_get(event);
 		position = 0;
@@ -124,13 +124,13 @@ window_event_result UI_GADGET_CHECKBOX::event_handler(UI_DIALOG &dlg, const d_ev
 	if (pressed == 1)
 	{
 		flag ^= 1;
-		auto rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		auto rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 		return rval;
 	}
 
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_checkbox(dlg, *this);
 
 	return window_event_result::ignored;
diff --git a/common/ui/dialog.cpp b/common/ui/dialog.cpp
index cf72951fa..f491d8c9a 100644
--- a/common/ui/dialog.cpp
+++ b/common/ui/dialog.cpp
@@ -65,8 +65,8 @@ static void ui_dialog_draw(UI_DIALOG *dlg)
 // The dialog handler borrows heavily from the newmenu_handler
 window_event_result UI_DIALOG::event_handler(const d_event &event)
 {
-	if (event.type == EVENT_WINDOW_ACTIVATED ||
-		event.type == EVENT_WINDOW_DEACTIVATED)
+	if (event.type == event_type::window_activated ||
+		event.type == event_type::window_deactivated)
 		return window_event_result::ignored;
 	auto rval = callback_handler(event);
 	if (rval != window_event_result::ignored)
@@ -74,24 +74,21 @@ window_event_result UI_DIALOG::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay2(50);
 			[[fallthrough]];
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
-		case EVENT_MOUSE_MOVED:
-		case EVENT_KEY_COMMAND:
-		case EVENT_KEY_RELEASE:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
+		case event_type::mouse_moved:
+		case event_type::key_command:
+		case event_type::key_release:
 			return ui_dialog_do_gadgets(*this, event);
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 		{
 			ui_dialog_draw(this);
 			rval = ui_dialog_do_gadgets(*this, event);
 			if (rval != window_event_result::close)
-			{
-				d_event event2 = { EVENT_UI_DIALOG_DRAW };
-				this->send_event(event2);
-			}
+				this->send_event(d_event{event_type::ui_dialog_draw});
 			return rval;
 		}
 
@@ -152,7 +149,6 @@ void restore_state()
 
 void ui_mega_process()
 {
-	int mx, my, mz;
 	unsigned char k;
 	
 	event_process();
@@ -160,7 +156,8 @@ void ui_mega_process()
 	switch( Record )
 	{
 	case 0:
-		mouse_get_delta( &mx, &my, &mz );
+		{
+			const auto [mx, my, mz] = mouse_get_delta();
 		Mouse.new_dx = mx;
 		Mouse.new_dy = my;
 		Mouse.new_buttons = mouse_get_btns();
@@ -172,6 +169,7 @@ void ui_mega_process()
 
 		break;
 	case 1:
+		{
 
 		if (ui_event_counter==0 )
 		{
@@ -191,7 +189,7 @@ void ui_mega_process()
 			ui_event_counter++;
 		}
 
-		mouse_get_delta( &mx, &my, &mz );
+		const auto [mx, my, mz] = mouse_get_delta();
 		MouseDX = mx;
 		MouseDY = my;
 		MouseButtons = mouse_get_btns();
@@ -289,6 +287,7 @@ void ui_mega_process()
 				Record = 0;
 			}
 		}
+		}
 
 		FrameCount++;
 
diff --git a/common/ui/file.cpp b/common/ui/file.cpp
index a9fecedec..b31d6bbe4 100644
--- a/common/ui/file.cpp
+++ b/common/ui/file.cpp
@@ -126,7 +126,7 @@ window_event_result ui_file_browser::callback_handler(const d_event &event)
 {
 	window_event_result rval = window_event_result::ignored;
 
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		ui_dputs_at(this, 10, 5, message);
 
@@ -151,8 +151,7 @@ window_event_result ui_file_browser::callback_handler(const d_event &event)
 		ui_messagebox( -1, -1, 1, "Sorry, no help is available!", "Ok" );
 		rval = window_event_result::handled;
 	}
-	
-	if (event.type == EVENT_UI_LISTBOX_MOVED)
+	if (event.type == event_type::ui_listbox_moved)
 	{
 		if (&ui_event_get_gadget(event) == listbox1.get() && listbox1->current_item >= 0 && filename_list[listbox1->current_item])
 			ui_inputbox_set_text(user_file.get(), filename_list[listbox1->current_item]);
@@ -162,8 +161,7 @@ window_event_result ui_file_browser::callback_handler(const d_event &event)
 
 		rval = window_event_result::handled;
 	}
-	
-	if (GADGET_PRESSED(button1.get()) || GADGET_PRESSED(user_file.get()) || event.type == EVENT_UI_LISTBOX_SELECTED)
+	if (GADGET_PRESSED(button1.get()) || GADGET_PRESSED(user_file.get()) || event.type == event_type::ui_listbox_selected)
 	{
 		char *p;
 		
diff --git a/common/ui/gadget.cpp b/common/ui/gadget.cpp
index fc46404fc..45767913a 100644
--- a/common/ui/gadget.cpp
+++ b/common/ui/gadget.cpp
@@ -115,9 +115,7 @@ int is_under_another_window( UI_DIALOG * dlg, UI_GADGET * gadget )
 
 int ui_mouse_on_gadget(UI_GADGET &gadget)
 {
-	int x, y, z;
-	
-	mouse_get_pos(&x, &y, &z);
+	const auto [x, y, z] = mouse_get_pos();
 	if (x >= gadget.x1 && x <= gadget.x2 - 1 && y >= gadget.y1 && y <= gadget.y2 - 1)
 	{
 #if 0	// check is no longer required - if it is under another window, that dialog's handler would have returned 1
@@ -142,7 +140,7 @@ window_event_result ui_gadget_send_event(UI_DIALOG &dlg, const event_type type,
 UI_GADGET &ui_event_get_gadget(const d_event &event)
 {
 	auto &e = static_cast<const event_gadget &>(event);
-	Assert(e.type >= EVENT_UI_GADGET_PRESSED);	// Any UI event
+	assert(e.type >= event_type::ui_gadget_pressed);	// Any UI event
 	return e.gadget;
 }
 
@@ -151,7 +149,7 @@ window_event_result ui_dialog_do_gadgets(UI_DIALOG &dlg, const d_event &event)
 	int keypress = 0;
 	UI_GADGET * tmp, * tmp1;
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
 
 	tmp = dlg.gadget;
diff --git a/common/ui/icon.cpp b/common/ui/icon.cpp
index 2301a9b89..c159a24e6 100644
--- a/common/ui/icon.cpp
+++ b/common/ui/icon.cpp
@@ -115,7 +115,7 @@ window_event_result UI_GADGET_ICON::event_handler(UI_DIALOG &dlg, const d_event
 	pressed = 0;
 
 	window_event_result rval = window_event_result::ignored;
-	if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
+	if (event.type == event_type::mouse_button_down || event.type == event_type::mouse_button_up)
 	{
 		const auto OnMe = ui_mouse_on_gadget(*this);
 
@@ -134,7 +134,7 @@ window_event_result UI_GADGET_ICON::event_handler(UI_DIALOG &dlg, const d_event
 	}
 
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 	{
 		const auto key = event_key_get(event);
 		if (key == trap_key)
@@ -143,23 +143,22 @@ window_event_result UI_GADGET_ICON::event_handler(UI_DIALOG &dlg, const d_event
 			rval = window_event_result::handled;
 		}
 	}
-	else if (event.type == EVENT_KEY_RELEASE)
+	else if (event.type == event_type::key_release)
 	{
 		const auto key = event_key_get(event);
 		position = 0;
 		if (key == trap_key)
 			pressed = 1;
 	}
-		
 	if (pressed == 1)
 	{
 		flag = static_cast<int8_t>(user_function());
-		rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
 
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_icon(*this);
 
 	return rval;
diff --git a/common/ui/inputbox.cpp b/common/ui/inputbox.cpp
index bbcdaa000..73873da74 100644
--- a/common/ui/inputbox.cpp
+++ b/common/ui/inputbox.cpp
@@ -93,7 +93,7 @@ std::unique_ptr<UI_GADGET_INPUTBOX> ui_add_gadget_inputbox(UI_DIALOG &dlg, const
 
 window_event_result UI_GADGET_INPUTBOX::event_handler(UI_DIALOG &dlg, const d_event &event)
 {
-	const auto keypress = (event.type == EVENT_KEY_COMMAND)
+	const auto keypress = (event.type == event_type::key_command)
 		? event_key_get(event)
 		: 0u;
 
@@ -139,15 +139,13 @@ window_event_result UI_GADGET_INPUTBOX::event_handler(UI_DIALOG &dlg, const d_ev
 	} else {
 		first_time = 1;
 	}
-	
 	if (pressed)
 	{
-		rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
-		
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_inputbox(dlg, *this);
 
 	return rval;
diff --git a/common/ui/listbox.cpp b/common/ui/listbox.cpp
index 385b98103..c439fe517 100644
--- a/common/ui/listbox.cpp
+++ b/common/ui/listbox.cpp
@@ -143,16 +143,14 @@ std::unique_ptr<UI_GADGET_LISTBOX> ui_add_gadget_listbox(UI_DIALOG &dlg, short x
 window_event_result UI_GADGET_LISTBOX::event_handler(UI_DIALOG &dlg, const d_event &event)
 {
 	int kf;
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 	{
 		ui_draw_listbox(dlg, *this);
 		return window_event_result::ignored;
 	}
-	
-	const auto keypress = (event.type == EVENT_KEY_COMMAND)
+	const auto keypress = (event.type == event_type::key_command)
 		? event_key_get(event)
 		: 0u;
-	
 	selected_item = -1;
 
 	moved = 0;
@@ -280,9 +278,7 @@ window_event_result UI_GADGET_LISTBOX::event_handler(UI_DIALOG &dlg, const d_eve
 	{
 		if (dragging)
 		{
-			int x, y, z;
-			
-			mouse_get_pos(&x, &y, &z);
+			const auto [x, y, z] = mouse_get_pos();
 			const auto mitem = (y < y1)
 				? -1
 				: (y - y1) / textheight;
@@ -349,10 +345,9 @@ window_event_result UI_GADGET_LISTBOX::event_handler(UI_DIALOG &dlg, const d_eve
 		}
 
 	}
-	
 	if (moved || (selected_item > 0))
 	{
-		rval = ui_gadget_send_event(dlg, (selected_item > 0) ? EVENT_UI_LISTBOX_SELECTED : EVENT_UI_LISTBOX_MOVED, *this);
+		rval = ui_gadget_send_event(dlg, (selected_item > 0) ? event_type::ui_listbox_selected : event_type::ui_listbox_moved, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
diff --git a/common/ui/menu.cpp b/common/ui/menu.cpp
index bea3ec3b8..4d90dbed0 100644
--- a/common/ui/menu.cpp
+++ b/common/ui/menu.cpp
@@ -102,9 +102,7 @@ int MenuX( int x, int y, int NumButtons, const char *const text[] )
 	h = grd_curscreen->get_screen_height();
 
 	{
-		int mx, my, mz;
-		
-		mouse_get_pos(&mx, &my, &mz);
+		const auto [mx, my, mz] = mouse_get_pos();
 		if ( x == -1 ) x = mx - width/2;
 		if ( y == -1 ) y = my;
 	}
diff --git a/common/ui/menubar.cpp b/common/ui/menubar.cpp
index 28358ffb3..f6cec1fbb 100644
--- a/common/ui/menubar.cpp
+++ b/common/ui/menubar.cpp
@@ -237,10 +237,7 @@ static int menu_match_keypress(MENU &menu, int keypress)
 
 static int menu_is_mouse_on(const ITEM &item)
 {
-	int x, y, z;
-	
-	mouse_get_pos(&x, &y, &z);
-
+	const auto [x, y, z] = mouse_get_pos();
 	if (x >= item.x &&
 		x < item.x + item.w &&
 		y >= item.y &&
@@ -284,8 +281,7 @@ static int state2_alt_down;
 static window_event_result do_state_0(const d_event &event)
 {
 	int keypress = 0;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
 
 	auto &menubar = *Menu[0];
@@ -367,11 +363,10 @@ static window_event_result do_state_1(const d_event &event)
 {
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
 	auto &menubar = *Menu[0];
-	if ((event.type == EVENT_KEY_RELEASE) && !(event_key_get(event) & KEY_ALTED))
+	if (event.type == event_type::key_release && !(event_key_get(event) & KEY_ALTED))
 	{
 		state = 2;
 		state2_alt_down = 0;
@@ -429,16 +424,15 @@ static window_event_result do_state_2(const d_event &event)
 	int i;
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-		
 	if (keypress & KEY_ALTED)
 	{
  		state2_alt_down = 1;
 		rval = window_event_result::handled;
 	}
 
-	if ((event.type == EVENT_KEY_RELEASE) && !(event_key_get(event) & KEY_ALTED) && state2_alt_down)
+	if (event.type == event_type::key_release && !(event_key_get(event) & KEY_ALTED) && state2_alt_down)
 	{
 		state = 0;
 		menu_hide_all();
@@ -545,10 +539,9 @@ window_event_result menu_window::event_handler(const d_event &event)
 	
 	if (state != 3)
 		return window_event_result::ignored;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	else if (event.type == EVENT_WINDOW_CLOSE)	// quitting
+	else if (event.type == event_type::window_close)	// quitting
 	{
 		state = 0;
 		menu_hide_all();
@@ -659,8 +652,7 @@ window_event_result menu_window::event_handler(const d_event &event)
 			break;
 			}
 	}
-	
-	if (event.type == EVENT_MOUSE_MOVED || B1_JUST_RELEASED)
+	if (event.type == event_type::mouse_moved || B1_JUST_RELEASED)
 	{
 		auto &other_menu = *Menu[CMENU];
 		const auto i = menu_check_mouse_item(other_menu);
@@ -708,24 +700,23 @@ window_event_result menu_window::event_handler(const d_event &event)
 		}
 	}
 
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 	{
 		auto &other_menu = *Menu[CMENU];
 		menu_draw(other_menu);
 		return window_event_result::handled;
 	}
-	
 	return rval;
 }
 
 window_event_result menubar_window::event_handler(const d_event &event)
 {
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 	{
 		menu_draw(menubar);
 		return window_event_result::handled;
 	}
-	else if (event.type == EVENT_WINDOW_CLOSE)
+	else if (event.type == event_type::window_close)
 	{
 		range_for (const auto pi, partial_range(Menu, 1u, num_menus))
 		{
diff --git a/common/ui/message.cpp b/common/ui/message.cpp
index 5816adb38..2e78b7b84 100644
--- a/common/ui/message.cpp
+++ b/common/ui/message.cpp
@@ -63,7 +63,7 @@ struct messagebox : UI_DIALOG
 
 window_event_result messagebox::callback_handler(const d_event &event)
 {
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		const grs_font * temp_font;
 
@@ -144,10 +144,7 @@ int (ui_messagebox)( short xc, short yc, const char * text, const ui_messagebox_
 	height += 2;  // For line in middle
 
 	{
-		int mx, my, mz;
-		
-		mouse_get_pos(&mx, &my, &mz);
-
+		const auto [mx, my, mz] = mouse_get_pos();
 		if ( xc == -1 )
 			xc = mx;
 
diff --git a/common/ui/radio.cpp b/common/ui/radio.cpp
index f77b05ac3..e54f5c0a8 100644
--- a/common/ui/radio.cpp
+++ b/common/ui/radio.cpp
@@ -88,7 +88,7 @@ window_event_result UI_GADGET_RADIO::event_handler(UI_DIALOG &dlg, const d_event
 	pressed = 0;
 
 	window_event_result rval = window_event_result::ignored;
-	if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
+	if (event.type == event_type::mouse_button_down || event.type == event_type::mouse_button_up)
 	{
 		const auto OnMe = ui_mouse_on_gadget(*this);
 
@@ -106,8 +106,7 @@ window_event_result UI_GADGET_RADIO::event_handler(UI_DIALOG &dlg, const d_event
 		}
 	}
 
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 	{
 		const auto key = event_key_get(event);
 		if (dlg.keyboard_focus_gadget == this && (key == KEY_SPACEBAR || key==KEY_ENTER))
@@ -116,7 +115,7 @@ window_event_result UI_GADGET_RADIO::event_handler(UI_DIALOG &dlg, const d_event
 			rval = window_event_result::handled;
 		}
 	}
-	else if (event.type == EVENT_KEY_RELEASE)
+	else if (event.type == event_type::key_release)
 	{
 		const auto key = event_key_get(event);
 		position = 0;
@@ -141,12 +140,12 @@ window_event_result UI_GADGET_RADIO::event_handler(UI_DIALOG &dlg, const d_event
 			tmp = tmp->next;
 		}
 		flag = 1;
-		rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
 
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_radio(dlg, *this);
 
 	return rval;
diff --git a/common/ui/scroll.cpp b/common/ui/scroll.cpp
index 00052431a..66a9ba2eb 100644
--- a/common/ui/scroll.cpp
+++ b/common/ui/scroll.cpp
@@ -97,10 +97,8 @@ std::unique_ptr<UI_GADGET_SCROLLBAR> ui_add_gadget_scrollbar(UI_DIALOG &dlg, sho
 
 window_event_result UI_GADGET_SCROLLBAR::event_handler(UI_DIALOG &dlg, const d_event &event)
 {
-	int x, y, z;
 	window_event_result rval = window_event_result::ignored;
-		
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 	{
 		ui_draw_scrollbar(dlg, *this);
 		return window_event_result::ignored;
@@ -121,10 +119,9 @@ window_event_result UI_GADGET_SCROLLBAR::event_handler(UI_DIALOG &dlg, const d_e
 	moved = 0;
 
 
-	if (keyfocus && event.type == EVENT_KEY_COMMAND)
+	if (keyfocus && event.type == event_type::key_command)
 	{
 		int key;
-		
 		key = event_key_get(event);
 
 		if (key & KEY_UP)
@@ -138,12 +135,10 @@ window_event_result UI_GADGET_SCROLLBAR::event_handler(UI_DIALOG &dlg, const d_e
 			rval = window_event_result::handled;
 		}
 	}
-	else if (keyfocus && event.type == EVENT_KEY_RELEASE)
+	else if (keyfocus && event.type == event_type::key_release)
 	{
 		int key;
-		
 		key = event_key_get(event);
-		
 		if (key & KEY_UP)
 		{
 			up_button->position = 0;
@@ -195,7 +190,7 @@ window_event_result UI_GADGET_SCROLLBAR::event_handler(UI_DIALOG &dlg, const d_e
 	//    listbox->dragging = 1;
 
 
-	mouse_get_pos(&x, &y, &z);
+	const auto [x, y, z] = mouse_get_pos();
 
 	const auto OnSlider = y >= fake_position + y1 &&
 		y < fake_position + y1 + fake_size &&
@@ -275,7 +270,7 @@ window_event_result UI_GADGET_SCROLLBAR::event_handler(UI_DIALOG &dlg, const d_e
 		moved = 1;
 	if (moved)
 	{
-		rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, *this);
+		rval = ui_gadget_send_event(dlg, event_type::ui_gadget_pressed, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
diff --git a/common/ui/userbox.cpp b/common/ui/userbox.cpp
index 84863f191..76b2df4f9 100644
--- a/common/ui/userbox.cpp
+++ b/common/ui/userbox.cpp
@@ -74,17 +74,14 @@ std::unique_ptr<UI_GADGET_USERBOX> ui_add_gadget_userbox(UI_DIALOG &dlg, short x
 
 window_event_result UI_GADGET_USERBOX::event_handler(UI_DIALOG &dlg, const d_event &event)
 {
-	int x, y, z;
 	window_event_result rval = window_event_result::ignored;
-	
-	if (event.type == EVENT_WINDOW_DRAW)
+	if (event.type == event_type::window_draw)
 		ui_draw_userbox(dlg, *this);
 
-	const auto keypress = (event.type == EVENT_KEY_COMMAND)
+	const auto keypress = (event.type == event_type::key_command)
 		? event_key_get(event)
 		: 0u;
-		
-	mouse_get_pos(&x, &y, &z);
+	const auto [x, y, z] = mouse_get_pos();
 	const auto OnMe = ui_mouse_on_gadget(*this);
 
 	const auto olddrag  = b1_held_down;
@@ -113,7 +110,7 @@ window_event_result UI_GADGET_USERBOX::event_handler(UI_DIALOG &dlg, const d_eve
 			rval = window_event_result::handled;
 		}
 
-		if ( (event.type == EVENT_MOUSE_MOVED) && b1_held_down )
+		if (event.type == event_type::mouse_moved && b1_held_down)
 		{
 			b1_dragging = 1;
 			b1_drag_x2 = x - x1;
@@ -146,10 +143,9 @@ window_event_result UI_GADGET_USERBOX::event_handler(UI_DIALOG &dlg, const d_eve
 		this->keypress = keypress;
 		rval = window_event_result::handled;
 	}
-	
 	if (b1_clicked || b1_dragging)
 	{
-		rval = ui_gadget_send_event(dlg, b1_clicked ? EVENT_UI_GADGET_PRESSED : EVENT_UI_USERBOX_DRAGGED, *this);
+		rval = ui_gadget_send_event(dlg, b1_clicked ? event_type::ui_gadget_pressed : event_type::ui_userbox_dragged, *this);
 		if (rval == window_event_result::ignored)
 			rval = window_event_result::handled;
 	}
diff --git a/common/unittest/enumerate.cpp b/common/unittest/enumerate.cpp
index 340744667..86ac53fbe 100644
--- a/common/unittest/enumerate.cpp
+++ b/common/unittest/enumerate.cpp
@@ -63,13 +63,10 @@ BOOST_AUTO_TEST_CASE(enumerate_starting_value)
  * static_assert can produce a better error message than letting it fail
  * at runtime.
  */
-template <typename Expected, typename enumerate_type, typename index_type = typename enumerate_type::index_type>
-struct assert_index_type
-{
-	static_assert(std::is_same<Expected, index_type>::value);
-};
+template <typename Expected, typename enumerate_type>
+concept assert_index_type = std::same_as<Expected, typename enumerate_type::index_type>;
 
-template struct assert_index_type<std::size_t, decltype(enumerate(std::declval<std::array<int, 1> &>()))>;
+static_assert(assert_index_type<std::size_t, decltype(enumerate(std::declval<std::array<int, 1> &>()))>);
 
 template <typename T>
 struct custom_index_type : std::array<int, 1>
@@ -79,4 +76,4 @@ struct custom_index_type : std::array<int, 1>
 };
 enum class e1 : unsigned char;
 
-template struct assert_index_type<e1, decltype(enumerate(std::declval<custom_index_type<e1>&>()))>;
+static_assert(assert_index_type<e1, decltype(enumerate(std::declval<custom_index_type<e1>&>()))>);
diff --git a/common/unittest/partial_range.cpp b/common/unittest/partial_range.cpp
index 93505dda5..666f8c833 100644
--- a/common/unittest/partial_range.cpp
+++ b/common/unittest/partial_range.cpp
@@ -105,13 +105,10 @@ BOOST_AUTO_TEST_CASE(range_slice_reversed_begin_1_end_3)
  * static_assert can produce a better error message than letting it fail
  * at runtime.
  */
-template <typename Expected, typename partial_range_type, typename index_type = typename partial_range_type::index_type>
-struct assert_index_type : std::true_type
-{
-	static_assert(std::is_same<Expected, index_type>::value);
-};
+template <typename Expected, typename partial_range_type>
+concept assert_index_type = std::same_as<Expected, typename partial_range_type::index_type>;
 
-static_assert(assert_index_type<void, decltype(partial_range(std::declval<std::vector<int>&>(), 0u, 1u))>::value);
+static_assert(assert_index_type<void, decltype(partial_range(std::declval<std::vector<int>&>(), 0u, 1u))>);
 template <typename T>
 struct custom_index_type_only : std::array<int, 1>
 {
@@ -129,6 +126,6 @@ enum class e1 : unsigned char;
 /* The type is `void` because resolving index_type fails since `int *`
  * is not a valid argument type to operator[].
  */
-static_assert(assert_index_type<void, decltype(partial_range(std::declval<custom_index_type_only<int *>&>(), 0u, 1u))>::value);
-static_assert(assert_index_type<std::size_t, decltype(partial_range(std::declval<custom_index_type<std::size_t>&>(), 0u, 1u))>::value);
-static_assert(assert_index_type<e1, decltype(partial_range(std::declval<custom_index_type<e1>&>(), 0u, 1u))>::value);
+static_assert(assert_index_type<void, decltype(partial_range(std::declval<custom_index_type_only<int *>&>(), 0u, 1u))>);
+static_assert(assert_index_type<std::size_t, decltype(partial_range(std::declval<custom_index_type<std::size_t>&>(), 0u, 1u))>);
+static_assert(assert_index_type<e1, decltype(partial_range(std::declval<custom_index_type<e1>&>(), 0u, 1u))>);
diff --git a/common/unittest/serial.cpp b/common/unittest/serial.cpp
index 4bec4eb0a..4d30d8fc8 100644
--- a/common/unittest/serial.cpp
+++ b/common/unittest/serial.cpp
@@ -9,8 +9,14 @@
 static_assert(!serial::is_message<int>::value, "");
 static_assert(serial::is_message<serial::message<int>>::value, "");
 
-assert_equal(serial::detail::size_base<4>::maximum_size, 4, "");
-assert_equal((serial::detail::size_base<4, 2>::minimum_size), 2, "");
+template <std::size_t Expected, typename SizeBase>
+concept check_maximum_size = serial::check_equal_value<Expected, SizeBase::maximum_size.value>;
+
+template <std::size_t Expected, typename SizeBase>
+concept check_minimum_size = serial::check_equal_value<Expected, SizeBase::minimum_size.value>;
+
+static_assert(check_maximum_size<4, serial::detail::size_base<4>>);
+static_assert(check_minimum_size<2, serial::detail::size_base<4, 2>>);
 
 static_assert(!serial::is_cxx_array<int>::value, "");
 static_assert(!serial::is_cxx_array<int[1]>::value, "");
diff --git a/common/unittest/valptridx-range.cpp b/common/unittest/valptridx-range.cpp
index 05d697352..530962d12 100644
--- a/common/unittest/valptridx-range.cpp
+++ b/common/unittest/valptridx-range.cpp
@@ -168,7 +168,7 @@ BOOST_AUTO_TEST_CASE(idx_convert_check)
 	using vo = valptridx<object>;
 	BOOST_CHECK_NO_THROW(
 		DXX_TEST_VALPTRIDX_IGNORE_RETURN(({
-			typename vo::imidx i(static_cast<objnum_t>(0));
+			typename vo::imidx i(objnum_t{0});
 			typename vo::vmidx{i};
 			}))
 	);
diff --git a/common/unittest/xrange.cpp b/common/unittest/xrange.cpp
index bf96ae129..e930b73a9 100644
--- a/common/unittest/xrange.cpp
+++ b/common/unittest/xrange.cpp
@@ -136,10 +136,4 @@ BOOST_AUTO_TEST_CASE(xrange_iter_values)
 	BOOST_TEST(*std::next(r.begin(), 2) == 2);
 }
 
-template <typename T>
-requires(std::ranges::borrowed_range<T>)
-struct check_is_borrowed_range : std::true_type
-{
-};
-
-static_assert(check_is_borrowed_range<decltype(xrange(2u))>::value);
+static_assert(std::ranges::borrowed_range<decltype(xrange(2u))>);
diff --git a/common/unittest/zip.cpp b/common/unittest/zip.cpp
index be5ae8fb7..2ce8b38ef 100644
--- a/common/unittest/zip.cpp
+++ b/common/unittest/zip.cpp
@@ -134,13 +134,10 @@ BOOST_AUTO_TEST_CASE(zip_xrange)
  * static_assert can produce a better error message than letting it fail
  * at runtime.
  */
-template <typename Expected, typename zip_type, typename index_type = typename zip_type::index_type>
-requires(std::is_same<Expected, index_type>::value)
-struct assert_index_type : std::true_type
-{
-};
+template <typename Expected, typename zip_type>
+concept assert_index_type = std::same_as<Expected, typename zip_type::index_type>;
 
-static_assert(assert_index_type<void, decltype(zip(std::declval<std::array<int, 1> &>(), std::declval<std::array<float, 1> &>()))>::value);
+static_assert(assert_index_type<void, decltype(zip(std::declval<std::array<int, 1> &>(), std::declval<std::array<float, 1> &>()))>);
 
 template <typename T>
 struct custom_index_type : std::array<int, 1>
@@ -151,36 +148,19 @@ struct custom_index_type : std::array<int, 1>
 enum class e1 : unsigned char;
 enum class e2 : unsigned char;
 
-static_assert(assert_index_type<e1, decltype(zip(std::declval<custom_index_type<e1>&>(), std::declval<custom_index_type<e1>&>()))>::value);
-static_assert(assert_index_type<void, decltype(zip(std::declval<custom_index_type<e1>&>(), std::declval<custom_index_type<e2>&>()))>::value);
-
-template <typename Expected, typename Actual>
-requires(std::is_same<Expected, Actual>::value)
-using assert_same_type = std::true_type;
+static_assert(assert_index_type<e1, decltype(zip(std::declval<custom_index_type<e1>&>(), std::declval<custom_index_type<e1>&>()))>);
+static_assert(assert_index_type<void, decltype(zip(std::declval<custom_index_type<e1>&>(), std::declval<custom_index_type<e2>&>()))>);
 
-static_assert(assert_same_type<std::nullptr_t, decltype(d_zip::detail::get_static_size(std::declval<int *>()))>::value);
-static_assert(assert_same_type<std::nullptr_t, decltype(d_zip::detail::get_static_size(std::declval<std::vector<int>::iterator>()))>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 5>, decltype(d_zip::detail::get_static_size(std::declval<int (&)[5]>()))>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 6>, decltype(d_zip::detail::get_static_size(std::declval<std::array<int, 6> &>()))>::value);
-
-template <typename T>
-requires(std::ranges::range<T>)
-struct check_is_range : std::true_type
-{
-};
-
-template <typename T>
-requires(std::ranges::borrowed_range<T>)
-struct check_is_borrowed_range : std::true_type
-{
-};
+static_assert(std::same_as<std::nullptr_t, decltype(d_zip::detail::get_static_size(std::declval<int *>()))>);
+static_assert(std::same_as<std::nullptr_t, decltype(d_zip::detail::get_static_size(std::declval<std::vector<int>::iterator>()))>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 5>, decltype(d_zip::detail::get_static_size(std::declval<int (&)[5]>()))>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 6>, decltype(d_zip::detail::get_static_size(std::declval<std::array<int, 6> &>()))>);
 
-static_assert(check_is_borrowed_range<decltype(zip(std::declval<int (&)[1]>()))>::value);
+static_assert(std::ranges::borrowed_range<decltype(zip(std::declval<int (&)[1]>()))>);
 
 struct difference_range
 {
 	struct iterator {
-		int *operator *() const;
 		iterator &operator++();
 		iterator operator++(int);
 		constexpr auto operator<=>(const iterator &) const = default;
@@ -189,6 +169,7 @@ struct difference_range
 		using pointer = value_type *;
 		using reference = value_type &;
 		using iterator_category = std::forward_iterator_tag;
+		reference operator *() const;
 		difference_type operator-(const iterator &) const;
 	};
 	struct index_type {};
@@ -196,12 +177,13 @@ struct difference_range
 	iterator end();
 };
 
-static_assert(check_is_range<decltype(std::declval<difference_range &>())>::value);
-static_assert(check_is_borrowed_range<decltype(std::declval<difference_range &>())>::value);
-static_assert(assert_same_type<difference_range::iterator::difference_type, decltype(zip(std::declval<difference_range &>()).begin())::difference_type>::value);
+static_assert(std::ranges::range<difference_range &>);
+static_assert(std::ranges::input_range<difference_range &>);
+static_assert(std::ranges::borrowed_range<difference_range &>);
+static_assert(std::same_as<difference_range::iterator::difference_type, decltype(zip(std::declval<difference_range &>()).begin())::difference_type>);
 
-static_assert(assert_same_type<std::nullptr_t, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t>>::type>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 1>, d_zip::detail::minimum_static_size<std::tuple<std::integral_constant<std::size_t, 1>, std::nullptr_t>>::type>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 1>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 1>>>::type>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 2>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 2>, std::integral_constant<std::size_t, 3>>>::type>::value);
-static_assert(assert_same_type<std::integral_constant<std::size_t, 2>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 3>, std::nullptr_t, std::integral_constant<std::size_t, 2>>>::type>::value);
+static_assert(std::same_as<std::nullptr_t, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t>>::type>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 1>, d_zip::detail::minimum_static_size<std::tuple<std::integral_constant<std::size_t, 1>, std::nullptr_t>>::type>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 1>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 1>>>::type>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 2>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 2>, std::integral_constant<std::size_t, 3>>>::type>);
+static_assert(std::same_as<std::integral_constant<std::size_t, 2>, d_zip::detail::minimum_static_size<std::tuple<std::nullptr_t, std::integral_constant<std::size_t, 3>, std::nullptr_t, std::integral_constant<std::size_t, 2>>>::type>);
diff --git a/contrib/dxx-rebirth.xcodeproj/project.pbxproj b/contrib/dxx-rebirth.xcodeproj/project.pbxproj
index 5adce5f1c..50d1b5669 100644
--- a/contrib/dxx-rebirth.xcodeproj/project.pbxproj
+++ b/contrib/dxx-rebirth.xcodeproj/project.pbxproj
@@ -302,7 +302,6 @@
 		14F8A9741A2D6320003AA93A /* eswitch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = eswitch.h; sourceTree = "<group>"; };
 		14F8A9751A2D6320003AA93A /* info.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = info.h; sourceTree = "<group>"; };
 		14F8A9761A2D6320003AA93A /* kdefs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kdefs.h; sourceTree = "<group>"; };
-		14F8A9771A2D6320003AA93A /* kfuncs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kfuncs.h; sourceTree = "<group>"; };
 		14F8A9781A2D6320003AA93A /* macro.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macro.h; sourceTree = "<group>"; };
 		14F8A9791A2D6320003AA93A /* meddraw.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = meddraw.h; sourceTree = "<group>"; };
 		14F8A97A1A2D6320003AA93A /* medlisp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = medlisp.h; sourceTree = "<group>"; };
@@ -904,7 +903,6 @@
 				14F8A9741A2D6320003AA93A /* eswitch.h */,
 				14F8A9751A2D6320003AA93A /* info.h */,
 				14F8A9761A2D6320003AA93A /* kdefs.h */,
-				14F8A9771A2D6320003AA93A /* kfuncs.h */,
 				14F8A9781A2D6320003AA93A /* macro.h */,
 				14F8A9791A2D6320003AA93A /* meddraw.h */,
 				14F8A97A1A2D6320003AA93A /* medlisp.h */,
diff --git a/d1x-rebirth/editor/ehostage.cpp b/d1x-rebirth/editor/ehostage.cpp
index ab3d7936c..f141467bc 100644
--- a/d1x-rebirth/editor/ehostage.cpp
+++ b/d1x-rebirth/editor/ehostage.cpp
@@ -138,16 +138,16 @@ window_event_result hostage_dialog::callback_handler(const d_event &event)
 {
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			return hostage_dialog_created(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MainWindow = nullptr;
 			return window_event_result::ignored;
 		default:
 			break;
 	}
 	int keypress = 0;
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
 
 	Assert(MainWindow != NULL);
diff --git a/d2x-rebirth/main/escort.cpp b/d2x-rebirth/main/escort.cpp
index 1783634c5..711a3f6c8 100644
--- a/d2x-rebirth/main/escort.cpp
+++ b/d2x-rebirth/main/escort.cpp
@@ -151,7 +151,7 @@ window_event_result rename_guidebot_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 				uint8_t changed = 0;
 				if (PlayerCfg.GuidebotName != guidebot_name_buffer)
@@ -453,7 +453,7 @@ __attribute_nonnull()
 static void buddy_message_force_str(const char *str)
 {
 	auto &BuddyState = LevelUniqueObjectState.BuddyState;
-	BuddyState.Last_buddy_message_time = GameTime64;
+	BuddyState.Last_buddy_message_time = {GameTime64};
 	HUD_init_message(HM_DEFAULT, "%c%c%s:%c%c %s", CC_COLOR, BM_XRGB(28, 0, 0), static_cast<const char *>(PlayerCfg.GuidebotName), CC_COLOR, BM_XRGB(0, 31, 0), str);
 }
 
@@ -1183,7 +1183,7 @@ static void do_buddy_dude_stuff(const vmobjptridx_t buddy_objp)
 		{
 			if ((objp->type == OBJ_ROBOT) && !Robot_info[get_robot_id(objp)].companion)
 				if (maybe_buddy_fire_mega(objp, buddy_objp)) {
-					BuddyState.Buddy_last_missile_time = GameTime64;
+					BuddyState.Buddy_last_missile_time = {GameTime64};
 					return;
 				}
 		}
@@ -1193,7 +1193,7 @@ static void do_buddy_dude_stuff(const vmobjptridx_t buddy_objp)
 		{
 			if ((objp->type == OBJ_ROBOT) && !Robot_info[get_robot_id(objp)].companion)
 				if (maybe_buddy_fire_smart(objp, buddy_objp)) {
-					BuddyState.Buddy_last_missile_time = GameTime64;
+					BuddyState.Buddy_last_missile_time = {GameTime64};
 					return;
 				}
 		}
@@ -1232,7 +1232,7 @@ void do_escort_frame(const vmobjptridx_t objp, const robot_info &robptr, const o
 	auto &player_info = plrobj.ctype.player_info;
 	if (player_is_visible(player_visibility))
 	{
-		BuddyState.Buddy_last_seen_player = GameTime64;
+		BuddyState.Buddy_last_seen_player = {GameTime64};
 		if (player_info.powerup_flags & PLAYER_FLAGS_HEADLIGHT_ON)	//	DAMN! MK, stupid bug, fixed 12/08/95, changed PLAYER_FLAGS_HEADLIGHT to PLAYER_FLAGS_HEADLIGHT_ON
 		{
 			const auto energy = player_info.energy;
@@ -1282,7 +1282,7 @@ void do_escort_frame(const vmobjptridx_t objp, const robot_info &robptr, const o
 			return;
 		if (player_is_visible(player_visibility))
 			if (BuddyState.Escort_last_path_created + F1_0*3 < GameTime64) {
-				BuddyState.Escort_last_path_created = GameTime64;
+				BuddyState.Escort_last_path_created = {GameTime64};
 				create_n_segment_path(objp, robptr, 10 + d_rand() * 16, plrobj.segnum);
 			}
 
@@ -1293,20 +1293,20 @@ void do_escort_frame(const vmobjptridx_t objp, const robot_info &robptr, const o
 	if (BuddyState.Escort_last_path_created + (BuddyState.Escort_special_goal != ESCORT_GOAL_SCRAM ? (F1_0 * 5) : (F1_0 * 15)) < GameTime64)
 	{
 		BuddyState.Escort_goal_object = ESCORT_GOAL_UNSPECIFIED;
-		BuddyState.Escort_last_path_created = GameTime64;
+		BuddyState.Escort_last_path_created = {GameTime64};
 	}
 
 	const player *guidebot_controller_player;
 	if (BuddyState.Escort_special_goal != ESCORT_GOAL_SCRAM && (guidebot_controller_player = time_to_visit_player(LevelUniqueObjectState, objp)))
 	{
 		unsigned max_len;
-		BuddyState.Buddy_last_player_path_created = GameTime64;
+		BuddyState.Buddy_last_player_path_created = {GameTime64};
 		ailp->mode = ai_mode::AIM_GOTO_PLAYER;
 		if (!player_is_visible(player_visibility))
 		{
 			if (BuddyState.Last_come_back_message_time + F1_0 < GameTime64)
 			{
-				BuddyState.Last_come_back_message_time = GameTime64;
+				BuddyState.Last_come_back_message_time = {GameTime64};
 				auto &local_player = *Players.vcptr(Player_num);
 				if (guidebot_controller_player == &local_player)
 					buddy_message_str("Coming back to get you.");
@@ -1940,21 +1940,18 @@ window_event_result escort_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			break;
-			
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			return event_key_command(event);
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay2(50);
 			break;
-			
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			show_escort_menu();
 			break;
-			
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			return window_event_result::ignored;	// continue closing
 		default:
 			return window_event_result::ignored;
diff --git a/d2x-rebirth/main/movie.cpp b/d2x-rebirth/main/movie.cpp
index 24f3db516..974fa9bd3 100644
--- a/d2x-rebirth/main/movie.cpp
+++ b/d2x-rebirth/main/movie.cpp
@@ -246,20 +246,20 @@ window_event_result movie_pause_window::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_MOUSE_BUTTON_DOWN:
+		case event_type::mouse_button_down:
 			if (event_mouse_get_button(event) != mbtn::left)
 				return window_event_result::ignored;
 			[[fallthrough]];
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			if (const auto result = call_default_handler(event); result == window_event_result::ignored)
 				return window_event_result::close;
 			else
 				return result;
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay(F1_0 / 4);
 			break;
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 		{
 			const char *msg = TXT_PAUSE;
 			int y;
@@ -287,16 +287,16 @@ window_event_result movie::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			paused = 0;
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			paused = 1;
 			MVE_rmHoldMovie();
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			{
 				const auto key = event_key_get(event);
 
@@ -318,7 +318,7 @@ window_event_result movie::event_handler(const d_event &event)
 			break;
 			}
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			{
 				const auto f = frame_num;
 			if (!paused)
@@ -340,7 +340,7 @@ window_event_result movie::event_handler(const d_event &event)
 
 			break;
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
@@ -644,11 +644,13 @@ std::unique_ptr<BuiltinMovies> init_movies()
 {
 	if (GameArg.SysNoMovies)
 		return nullptr;
+	return std::make_unique<BuiltinMovies>();
+}
 
-	auto r = std::make_unique<BuiltinMovies>();
-	for (auto &&[f, m] : zip(movielib_files, r->movies))
+BuiltinMovies::BuiltinMovies()
+{
+	for (auto &&[f, m] : zip(movielib_files, movies))
 		init_movie(&f[0], 1, m);
-	return r;
 }
 
 LoadedMovie::~LoadedMovie()
diff --git a/d2x-rebirth/main/movie.h b/d2x-rebirth/main/movie.h
index 0f966dd7f..76cf954e7 100644
--- a/d2x-rebirth/main/movie.h
+++ b/d2x-rebirth/main/movie.h
@@ -82,6 +82,7 @@ struct LoadedMovieWithResolution : LoadedMovie
 struct BuiltinMovies
 {
 	std::array<LoadedMovie, 3> movies;
+	BuiltinMovies();
 };
 
 // find and initialize the movie libraries
diff --git a/similar/arch/sdl/gr.cpp b/similar/arch/sdl/gr.cpp
index 3d0c996cd..ec879ea15 100644
--- a/similar/arch/sdl/gr.cpp
+++ b/similar/arch/sdl/gr.cpp
@@ -263,7 +263,7 @@ void gr_palette_load( palette_array_t &pal )
 		return; // Display is not palettised
 
 	range_for (const int i, xrange(64u))
-		gamma[i] = static_cast<int>((pow((static_cast<double>(14)/static_cast<double>(32)), 1.0)*i) + 0.5);
+		gamma[i] = static_cast<int>((pow((14.0 / 32.0), 1.0) * i) + 0.5);
 
 	std::array<SDL_Color, 256> colors{};
 	for (int i = 0, j = 0; j < 256; j++)
diff --git a/similar/editor/centers.cpp b/similar/editor/centers.cpp
index 6cb6af6b7..4ebf09b21 100644
--- a/similar/editor/centers.cpp
+++ b/similar/editor/centers.cpp
@@ -146,9 +146,9 @@ window_event_result centers_dialog::callback_handler(const d_event &event)
 	auto &RobotCenters = LevelSharedRobotcenterState.RobotCenters;
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			return centers_dialog_created(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MainWindow = NULL;
 			return window_event_result::ignored;
 		default:
@@ -160,9 +160,8 @@ window_event_result centers_dialog::callback_handler(const d_event &event)
 
 	Assert(MainWindow != NULL);
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	
 	//------------------------------------------------------------
 	// Call the ui code..
 	//------------------------------------------------------------
@@ -221,15 +220,12 @@ window_event_result centers_dialog::callback_handler(const d_event &event)
 			rval = window_event_result::handled;
 		}
 	}
-	
 	//------------------------------------------------------------
 	// If anything changes in the ui system, redraw all the text that
 	// identifies this wall.
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
-//		int	i;
-	
 		ui_dprintf_at(this, 12, 6, "Seg: %3hu", static_cast<segnum_t>(Cursegp));
 	}
 
diff --git a/similar/editor/eswitch.cpp b/similar/editor/eswitch.cpp
index fd34212d3..a4c53c461 100644
--- a/similar/editor/eswitch.cpp
+++ b/similar/editor/eswitch.cpp
@@ -377,9 +377,9 @@ window_event_result trigger_dialog::callback_handler(const d_event &event)
 {
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			return trigger_dialog_created(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MainWindow = NULL;
 			return window_event_result::ignored;
 		default:
@@ -397,10 +397,8 @@ window_event_result trigger_dialog::callback_handler(const d_event &event)
 	// Call the ui code..
 	//------------------------------------------------------------
 	ui_button_any_drawn = 0;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	
 	//------------------------------------------------------------
 	// If we change walls, we need to reset the ui code for all
 	// of the checkboxes that control the wall flags.  
@@ -478,7 +476,7 @@ window_event_result trigger_dialog::callback_handler(const d_event &event)
 	//------------------------------------------------------------
 	// Draw the wall in the little 64x64 box
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		gr_set_current_canvas( wallViewBox->canvas );
 		auto &canvas = *grd_curcanv;
@@ -508,7 +506,7 @@ window_event_result trigger_dialog::callback_handler(const d_event &event)
 	// If anything changes in the ui system, redraw all the text that
 	// identifies this robot.
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		if (markedseg.s.sides[Markedside].wall_num != wall_none)
 		{
diff --git a/similar/editor/info.cpp b/similar/editor/info.cpp
index 62bb836bb..2a6e865aa 100644
--- a/similar/editor/info.cpp
+++ b/similar/editor/info.cpp
@@ -288,7 +288,7 @@ window_event_result info_dialog_window::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 		{
 			gr_set_current_canvas(w_canv);
 			auto &canvas = *grd_curcanv;
@@ -315,10 +315,9 @@ window_event_result info_dialog_window::event_handler(const d_event &event)
 			grd_curcanv = save_canvas;
 			return window_event_result::handled;
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			Pad_info = NULL;
 			break;
-			
 		default:
 			break;
 	}
diff --git a/similar/editor/kfuncs.cpp b/similar/editor/kfuncs.cpp
index 185799cf6..a75b2a4c2 100644
--- a/similar/editor/kfuncs.cpp
+++ b/similar/editor/kfuncs.cpp
@@ -26,6 +26,7 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #include <stdlib.h>
 #include "inferno.h"
 #include "func.h"
+#include "d_enumerate.h"
 #include "editor/kdefs.h"
 #include "editor/editor.h"
 #include "dxxerror.h"
@@ -37,7 +38,6 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #include "editor/medmisc.h"
 #include "editor/texpage.h"
 #include "editor/ehostage.h"
-#include "kfuncs.h"
 #include "dsx-ns.h"
 
 namespace dsx {
@@ -377,13 +377,43 @@ const FUNCTION med_functions[] = {
 
 // In gamesavec
 {	"rename-level",							0, get_level_name },
+};
 
-// The terminating marker
-{   NULL, 0, NULL } };
+}
+
+namespace dcx {	/* This should be dsx, but UI code in common needs to see these accessors */
+
+FUNCTION::callable func_get(const char *name, int *numparams)
+{
+	for (auto &&f : med_functions)
+		if (!d_stricmp(name, f.name))
+		{
+			*numparams = f.nparams;
+			return f.cfunction;
+		}
+	return NULL;
+}
+
+int func_get_index(const char *name)
+{
+	for (auto &&[i, f] : enumerate(med_functions))
+		if (!d_stricmp(name, f.name))
+		{
+			return i;
+		}
+	return -1;
+}
 
-void init_med_functions()
+FUNCTION::callable func_nget(std::size_t func_number, int *numparams, const char **name)
 {
-	func_init(med_functions, (sizeof(med_functions)/sizeof(FUNCTION))-1 );
+	if (func_number < std::size(med_functions))
+	{
+		auto &f = med_functions[func_number];
+		*name = f.name;
+		*numparams = f.nparams;
+		return f.cfunction;
+	}
+	return NULL;
 }
 
 }
diff --git a/similar/editor/med.cpp b/similar/editor/med.cpp
index df46ab294..7eae47380 100644
--- a/similar/editor/med.cpp
+++ b/similar/editor/med.cpp
@@ -54,7 +54,6 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #include "kconfig.h"
 #include "mouse.h"
 #include "dxxerror.h"
-#include "kfuncs.h"
 #ifdef INCLUDE_XLISP
 #include "medlisp.h"
 #endif
@@ -371,8 +370,6 @@ void init_editor()
 		return;
 	}
 
-	init_med_functions();	// Must be called before medlisp_init
-
 	for (auto &&[idx, value] : enumerate(pads))
 		if (!ui_pad_read(idx, value))
 		{
@@ -1029,26 +1026,24 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
 
-	if (event.type == EVENT_WINDOW_CREATED)
+	if (event.type == event_type::window_created)
 		return window_event_result::ignored;
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	else if (event.type == EVENT_WINDOW_CLOSE)
+	else if (event.type == event_type::window_close)
 	{
 		EditorWindow = NULL;
 		close_editor();
 		return window_event_result::ignored;
 	}
-	
 	// Update the windows
 
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		// Draw status box
 		gr_set_default_canvas();
 		gr_rect(*grd_curcanv, STATUS_X,STATUS_Y,STATUS_X+STATUS_W-1,STATUS_Y+STATUS_H-1, CGREY);
-		
 		medlisp_update_screen();
 		calc_frame_time();
 		texpage_do(event);
@@ -1060,28 +1055,27 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 		set_editor_time_of_day();
 		return window_event_result::handled;
 	}
-	
 	if ((selected_gadget == GameViewBox.get() && !render_3d_in_big_window) ||
 		(selected_gadget == LargeViewBox.get() && render_3d_in_big_window))
 		switch (event.type)
 		{
-			case EVENT_MOUSE_BUTTON_UP:
-			case EVENT_MOUSE_BUTTON_DOWN:
+			case event_type::mouse_button_up:
+			case event_type::mouse_button_down:
 				break;
-			case EVENT_MOUSE_MOVED:
+			case event_type::mouse_moved:
 				if (!keyd_pressed[ KEY_LCTRL ] && !keyd_pressed[ KEY_RCTRL ])
 					break;
 				[[fallthrough]];
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-			case EVENT_JOYSTICK_BUTTON_UP:
-			case EVENT_JOYSTICK_BUTTON_DOWN:
+			case event_type::joystick_button_up:
+			case event_type::joystick_button_down:
 #endif
 #if DXX_MAX_AXES_PER_JOYSTICK
-			case EVENT_JOYSTICK_MOVED:
+			case event_type::joystick_moved:
 #endif
-			case EVENT_KEY_COMMAND:
-			case EVENT_KEY_RELEASE:
-			case EVENT_IDLE:
+			case event_type::key_command:
+			case event_type::key_release:
+			case event_type::idle:
 				kconfig_read_controls(Controls, event, 1);
 
 				if (slew_frame(0))
@@ -1097,10 +1091,10 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 					rval = window_event_result::handled;
 				}
 				break;
-			case EVENT_LOOP_BEGIN_LOOP:
+			case event_type::loop_begin_loop:
 				kconfig_begin_loop(Controls);
 				break;
-			case EVENT_LOOP_END_LOOP:
+			case event_type::loop_end_loop:
 				kconfig_end_loop(Controls, FrameTime);
 				break;
 
@@ -1109,7 +1103,7 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 		}
 
 	//do non-essential stuff in idle event
-	if (event.type == EVENT_IDLE)
+	if (event.type == event_type::idle)
 	{
 		check_wall_validity();
 
@@ -1261,7 +1255,7 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 		Update_flags |= UF_ED_STATE_CHANGED | UF_VIEWPOINT_MOVED;
 	}
 
-	if (event.type == EVENT_UI_USERBOX_DRAGGED && &ui_event_get_gadget(event) == GameViewBox.get())
+	if (event.type == event_type::ui_userbox_dragged && &ui_event_get_gadget(event) == GameViewBox.get())
 	{
 		int	x, y;
 		x = GameViewBox->b1_drag_x2;
@@ -1336,11 +1330,9 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 	}
 
 	// Allow specification of LargeView using mouse
-	if (event.type == EVENT_MOUSE_MOVED && (keyd_pressed[ KEY_LCTRL ] || keyd_pressed[ KEY_RCTRL ]))
+	if (event.type == event_type::mouse_moved && (keyd_pressed[ KEY_LCTRL ] || keyd_pressed[ KEY_RCTRL ]))
 	{
-		int dx, dy, dz;
-
-		event_mouse_get_delta(event, &dx, &dy, &dz);
+		const auto [dx, dy, dz] = event_mouse_get_delta(event);
 		if ((dx != 0) && (dy != 0))
 		{
 			vms_matrix	MouseRotMat;
@@ -1353,11 +1345,9 @@ window_event_result editor_dialog::callback_handler(const d_event &event)
 		}
 	}
 
-	if (event.type == EVENT_MOUSE_MOVED)
+	if (event.type == event_type::mouse_moved)
 	{
-		int dx, dy, dz;
-
-		event_mouse_get_delta(event, &dx, &dy, &dz);
+		const auto [dx, dy, dz] = event_mouse_get_delta(event);
 		if (dz != 0)
 		{
 			current_view->ev_dist += dz*10000;
diff --git a/similar/editor/medrobot.cpp b/similar/editor/medrobot.cpp
index 2517fd4c5..ccc501e9c 100644
--- a/similar/editor/medrobot.cpp
+++ b/similar/editor/medrobot.cpp
@@ -83,7 +83,7 @@ struct robot_dialog : UI_DIALOG
 	std::unique_ptr<UI_GADGET_BUTTON> quitButton, prev_powerup_type, next_powerup_type, prev_powerup_id, next_powerup_id, prev_powerup_count, next_powerup_count, prev_robot_type, next_robot_type, next_segment, prev_object, next_object, delete_object, new_object, set_path;
 	std::array<std::unique_ptr<UI_GADGET_RADIO>, 6> initialMode;			//	Number of boxes, AI modes
 	fix64 time;
-	vms_angvec angles = {}, goody_angles = {};
+	vms_angvec angles{}, goody_angles{};
 	int old_object;
 	virtual window_event_result callback_handler(const d_event &) override;
 };
@@ -578,9 +578,9 @@ window_event_result robot_dialog::callback_handler(const d_event &event)
 	auto &vmobjptridx = Objects.vmptridx;
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			return robot_dialog_created(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MainWindow = NULL;
 			return window_event_result::ignored;
 		default:
@@ -591,10 +591,8 @@ window_event_result robot_dialog::callback_handler(const d_event &event)
 	int	first_object_index;
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-		
 	Assert(MainWindow != NULL);
 
 	first_object_index = Cur_object_index;
@@ -665,7 +663,7 @@ window_event_result robot_dialog::callback_handler(const d_event &event)
 	//------------------------------------------------------------
 	// Redraw the object in the little 64x64 box
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		// A simple frame time counter for spinning the objects...
 		Temp = timer_query();
@@ -855,7 +853,7 @@ window_event_result object_dialog::callback_handler(const d_event &event)
 	auto &vmobjptr = Objects.vmptr;
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MattWindow = NULL;
 			return window_event_result::ignored;
 		default:
@@ -864,23 +862,20 @@ window_event_result object_dialog::callback_handler(const d_event &event)
 	const auto &&obj = vmobjptr(Cur_object_index);
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	
 	//------------------------------------------------------------
 	// Call the ui code..
 	//------------------------------------------------------------
 	ui_button_any_drawn = 0;
 
 
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		ui_dputs_at(this, 10, 132, "&X:");
 		ui_dputs_at(this, 10, 162, "&Y:");
 		ui_dputs_at(this, 10, 192, "&Z:");
 	}
-	
 	if (GADGET_PRESSED(quitButton.get()) || keypress == KEY_ESC)
 	{
 		if (initialMode[0]->flag)
diff --git a/similar/editor/medwall.cpp b/similar/editor/medwall.cpp
index 3507ab6e8..b465f8e92 100644
--- a/similar/editor/medwall.cpp
+++ b/similar/editor/medwall.cpp
@@ -485,9 +485,9 @@ window_event_result wall_dialog::callback_handler(const d_event &event)
 {
 	switch(event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			return wall_dialog_created(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			MainWindow = nullptr;
 			return window_event_result::ignored;
 		default:
@@ -497,10 +497,8 @@ window_event_result wall_dialog::callback_handler(const d_event &event)
 	fix64 Temp;
 	int keypress = 0;
 	window_event_result rval = window_event_result::ignored;
-	
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 		keypress = event_key_get(event);
-	
 	Assert(MainWindow != NULL);
 
 	//------------------------------------------------------------
@@ -593,7 +591,7 @@ window_event_result wall_dialog::callback_handler(const d_event &event)
 	//------------------------------------------------------------
 	// Draw the wall in the little 64x64 box
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		// A simple frame time counter for animating the walls...
 		Temp = timer_query();
@@ -638,7 +636,7 @@ window_event_result wall_dialog::callback_handler(const d_event &event)
 	// If anything changes in the ui system, redraw all the text that
 	// identifies this wall.
 	//------------------------------------------------------------
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		if (const auto wp = w.get_unchecked_pointer())
 		{
diff --git a/similar/editor/objpage.cpp b/similar/editor/objpage.cpp
index 53147cdfb..f2e88ed77 100644
--- a/similar/editor/objpage.cpp
+++ b/similar/editor/objpage.cpp
@@ -364,7 +364,7 @@ void objpage_close()
 
 int objpage_do(const d_event &event)
 {
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		for (int i=0;  i<OBJS_PER_PAGE; i++ )
 		{
diff --git a/similar/editor/texpage.cpp b/similar/editor/texpage.cpp
index 68839084a..794813a9f 100644
--- a/similar/editor/texpage.cpp
+++ b/similar/editor/texpage.cpp
@@ -227,18 +227,15 @@ static std::array<replacement, MAX_REPLACEMENTS> Replacement_list;
 
 int texpage_do(const d_event &event)
 {
-	if (event.type == EVENT_UI_DIALOG_DRAW)
+	if (event.type == event_type::ui_dialog_draw)
 	{
 		gr_set_current_canvas( TmapnameCanvas );
 		gr_set_curfont(*grd_curcanv, *ui_small_font.get());
 		gr_set_fontcolor(*grd_curcanv, CBLACK, CWHITE);
-		
 		texpage_redraw();
-		
 		// Don't reset the current tmap every time we go back to the editor.
 		//	CurrentTexture = TexturePage*TMAPS_PER_PAGE;
 		texpage_show_current();
-		
 		return 1;
 	}
 
diff --git a/similar/main/ai.cpp b/similar/main/ai.cpp
index d41c95e2f..2d91519bf 100644
--- a/similar/main/ai.cpp
+++ b/similar/main/ai.cpp
@@ -635,9 +635,9 @@ void init_ai_object(const d_robot_info_array &Robot_info, const vmobjptridx_t ob
 		 */
 		aip->CURRENT_GUN = robot_gun_number::_0;
 	aip->CURRENT_STATE = AIS_REST;
-	ailp->time_player_seen = GameTime64;
-	ailp->next_misc_sound_time = GameTime64;
-	ailp->time_player_sound_attacked = GameTime64;
+	ailp->time_player_seen = {GameTime64};
+	ailp->next_misc_sound_time = {GameTime64};
+	ailp->time_player_sound_attacked = {GameTime64};
 
 	aip->hide_segment = hide_segment;
 	ailp->goal_segment = hide_segment;
@@ -1769,7 +1769,7 @@ static void compute_vis_and_vec(const d_robot_info_array &Robot_info, const vmob
 			const unsigned cloak_index = (objp) % MAX_AI_CLOAK_INFO;
 			const fix delta_time = GameTime64 - Ai_cloak_info[cloak_index].last_time;
 			if (delta_time > F1_0*2) {
-				Ai_cloak_info[cloak_index].last_time = GameTime64;
+				Ai_cloak_info[cloak_index].last_time = {GameTime64};
 				vm_vec_scale_add2(Ai_cloak_info[cloak_index].last_position, make_random_vector(), 8 * delta_time);
 			}
 
@@ -1810,14 +1810,14 @@ static void compute_vis_and_vec(const d_robot_info_array &Robot_info, const vmob
 					if (ailp.time_player_seen + F1_0/2 < GameTime64)
 					{
 						digi_link_sound_to_object(robptr.see_sound, objp, 0, Robot_sound_volume, sound_stack::allow_stacking);
-						ailp.time_player_sound_attacked = GameTime64;
+						ailp.time_player_sound_attacked = {GameTime64};
 						ailp.next_misc_sound_time = GameTime64 + F1_0 + d_rand()*4;
 					}
 				}
 				else if (ailp.time_player_sound_attacked + F1_0/4 < GameTime64)
 				{
 					digi_link_sound_to_object(robptr.attack_sound, objp, 0, Robot_sound_volume, sound_stack::allow_stacking);
-					ailp.time_player_sound_attacked = GameTime64;
+					ailp.time_player_sound_attacked = {GameTime64};
 				}
 			} 
 
@@ -1839,7 +1839,7 @@ static void compute_vis_and_vec(const d_robot_info_array &Robot_info, const vmob
 
 		if (player_is_visible(player_visibility.visibility))
 		{
-			ailp.time_player_seen = GameTime64;
+			ailp.time_player_seen = {GameTime64};
 		}
 	player_visibility.initialized = 1;
 }
@@ -2182,7 +2182,7 @@ static imobjptridx_t create_gated_robot(const d_robot_info_array &Robot_info, co
 	digi_link_sound_to_pos(Vclip[vclip_index::morphing_robot].sound_num, segp, sidenum_t::WLEFT, object_pos, 0, F1_0);
 	morph_start(LevelUniqueMorphObjectState, LevelSharedPolygonModelState, objp);
 
-	BossUniqueState.Last_gate_time = GameTime64;
+	BossUniqueState.Last_gate_time = {GameTime64};
 	++LevelUniqueObjectState.accumulated_robots;
 	++GameUniqueState.accumulated_robots;
 
@@ -2411,7 +2411,7 @@ static void teleport_boss(const d_robot_info_array &Robot_info, const d_vclip_ar
 	compute_segment_center(vcvertptr, objp->pos, rand_segp);
 	obj_relink(vmobjptr, vmsegptr, objp, rand_segp);
 
-	BossUniqueState.Last_teleport_time = GameTime64;
+	BossUniqueState.Last_teleport_time = {GameTime64};
 
 	//	make boss point right at player
 	const auto boss_dir = vm_vec_sub(target_pos, objp->pos);
@@ -2438,7 +2438,7 @@ void start_boss_death_sequence(d_level_unique_boss_state &BossUniqueState, const
 	if (robptr.boss_flag != boss_robot_id::None)
 	{
 		BossUniqueState.Boss_dying = 1;
-		BossUniqueState.Boss_dying_start_time = GameTime64;
+		BossUniqueState.Boss_dying_start_time = {GameTime64};
 	}
 
 }
@@ -2469,7 +2469,7 @@ static void do_boss_dying_frame(const d_robot_info_array &Robot_info, const vmob
 
 	if (BossUniqueState.Boss_dying_start_time + BOSS_DEATH_DURATION < GameTime64 || GameTime64+(F1_0*2) < BossUniqueState.Boss_dying_start_time)
 	{
-		BossUniqueState.Boss_dying_start_time = GameTime64; // make sure following only happens one time!
+		BossUniqueState.Boss_dying_start_time = {GameTime64}; // make sure following only happens one time!
 		do_controlcen_destroyed_stuff(object_none);
 		explode_object(LevelUniqueObjectState, Robot_info, LevelSharedSegmentState, LevelUniqueSegmentState, objp, F1_0/4);
 		digi_link_sound_to_object2(SOUND_BADASS_EXPLOSION, objp, 0, F2_0, sound_stack::allow_stacking, vm_distance{F1_0*512});
@@ -2525,7 +2525,7 @@ imobjptridx_t boss_spew_robot(const d_robot_info_array &Robot_info, const object
 void start_robot_death_sequence(object &obj)
 {
 	auto &ai_info = obj.ctype.ai_info;
-	ai_info.dying_start_time = GameTime64;
+	ai_info.dying_start_time = {GameTime64};
 	ai_info.dying_sound_playing = 0;
 	ai_info.SKIP_AI_COUNT = 0;
 }
@@ -2577,7 +2577,7 @@ static void do_boss_dying_frame(const d_robot_info_array &Robot_info, const vmob
 
 	if (rval)
 	{
-		BossUniqueState.Boss_dying_start_time = GameTime64; // make sure following only happens one time!
+		BossUniqueState.Boss_dying_start_time = {GameTime64}; // make sure following only happens one time!
 		do_controlcen_destroyed_stuff(object_none);
 		explode_object(LevelUniqueObjectState, Robot_info, LevelSharedSegmentState, LevelUniqueSegmentState, objp, F1_0/4);
 		digi_link_sound_to_object2(SOUND_BADASS_EXPLOSION, objp, 0, F2_0, sound_stack::allow_stacking, vm_distance{F1_0*512});
@@ -2594,7 +2594,7 @@ static int do_any_robot_dying_frame(const d_robot_info_array &Robot_info, const
 		rval = do_robot_dying_frame(objp, objp->ctype.ai_info.dying_start_time, min(death_roll/2+1,6)*F1_0, &objp->ctype.ai_info.dying_sound_playing, Robot_info[get_robot_id(objp)].deathroll_sound, death_roll*F1_0/8, death_roll*F1_0/2);
 
 		if (rval) {
-			objp->ctype.ai_info.dying_start_time = GameTime64; // make sure following only happens one time!
+			objp->ctype.ai_info.dying_start_time = {GameTime64}; // make sure following only happens one time!
 			explode_object(LevelUniqueObjectState, Robot_info, LevelSharedSegmentState, LevelUniqueSegmentState, objp, F1_0/4);
 			digi_link_sound_to_object2(SOUND_BADASS_EXPLOSION, objp, 0, F2_0, sound_stack::allow_stacking, vm_distance{F1_0*512});
 			if (Current_level_num < 0)
@@ -2694,7 +2694,7 @@ static void do_d1_boss_stuff(const d_robot_info_array &Robot_info, fvmsegptridx
 				if (ai_multiplayer_awareness(objp, 95))
 				{
 					BossUniqueState.Boss_hit_this_frame = 0;
-					BossUniqueState.Boss_cloak_start_time = GameTime64;
+					BossUniqueState.Boss_cloak_start_time = {GameTime64};
 					objp->ctype.ai_info.CLOAKED = 1;
 					if (Game_mode & GM_MULTI)
 						multi_send_boss_cloak(objp);
@@ -2778,7 +2778,7 @@ static void do_d2_boss_stuff(fvmsegptridx &vmsegptridx, const vmobjptridx_t objp
 	if (!BossUniqueState.Boss_dying && Boss_teleports[boss_index]) {
 		const auto Boss_cloak_start_time = BossUniqueState.Boss_cloak_start_time;
 		if (objp->ctype.ai_info.CLOAKED == 1) {
-			BossUniqueState.Boss_hit_time = GameTime64;	//	Keep the cloak:teleport process going.
+			BossUniqueState.Boss_hit_time = {GameTime64};	//	Keep the cloak:teleport process going.
 			if (GameTime64 - Boss_cloak_start_time > Boss_cloak_duration / 3 &&
 				(Boss_cloak_start_time + Boss_cloak_duration) - GameTime64 > Boss_cloak_duration / 3 &&
 				GameTime64 - BossUniqueState.Last_teleport_time > LevelSharedBossState.Boss_teleport_interval)
@@ -2795,7 +2795,7 @@ static void do_d2_boss_stuff(fvmsegptridx &vmsegptridx, const vmobjptridx_t objp
 		} else if (GameTime64 - (Boss_cloak_start_time + Boss_cloak_duration) > LevelSharedBossState.Boss_cloak_interval ||
 				GameTime64 - (Boss_cloak_start_time + Boss_cloak_duration) < -Boss_cloak_duration) {
 			if (ai_multiplayer_awareness(objp, 95)) {
-				BossUniqueState.Boss_cloak_start_time = GameTime64;
+				BossUniqueState.Boss_cloak_start_time = {GameTime64};
 				objp->ctype.ai_info.CLOAKED = 1;
 				if (Game_mode & GM_MULTI)
 					multi_send_boss_cloak(objp);
@@ -4463,7 +4463,7 @@ void do_ai_frame(const d_level_shared_robot_info_state &LevelSharedRobotInfoStat
 void ai_do_cloak_stuff(void)
 {
 	range_for (auto &i, Ai_cloak_info) {
-		i.last_time = GameTime64;
+		i.last_time = {GameTime64};
 #if defined(DXX_BUILD_DESCENT_II)
 		i.last_segment = ConsoleObject->segnum;
 #endif
@@ -4665,7 +4665,7 @@ static void state_ai_local_to_ai_local_rw(const ai_local *ail, ai_local_rw *ail_
 	ail_rw->next_action_time           = ail->next_action_time;
 	ail_rw->next_fire                  = ail->next_fire;
 	ail_rw->player_awareness_time      = ail->player_awareness_time;
-	const auto gametime = GameTime64;
+	const auto gametime{GameTime64};
 	ail_rw->time_player_seen = build_savegametime_from_gametime(gametime, ail->time_player_seen);
 	ail_rw->time_player_sound_attacked = build_savegametime_from_gametime(gametime, ail->time_player_sound_attacked);
 	ail_rw->next_misc_sound_time = build_savegametime_from_gametime(gametime, ail->next_misc_sound_time);
@@ -4741,7 +4741,7 @@ int ai_save_state(PHYSFS_File *fp)
 		state_ai_cloak_info_to_ai_cloak_info_rw(&i, &aic_rw);
 		PHYSFS_write(fp, &aic_rw, sizeof(aic_rw), 1);
 	}
-	const auto gametime = GameTime64;
+	const auto gametime{GameTime64};
 	{
 		const auto Boss_cloak_start_time = BossUniqueState.Boss_cloak_start_time;
 		tmptime32 = build_savegametime_from_gametime(gametime, Boss_cloak_start_time);
diff --git a/similar/main/aipath.cpp b/similar/main/aipath.cpp
index f7ad4689b..72687c0a4 100644
--- a/similar/main/aipath.cpp
+++ b/similar/main/aipath.cpp
@@ -652,7 +652,7 @@ void create_path_to_segment(const vmobjptridx_t objp, const robot_info &robptr,
 	ai_static *const aip = &obj.ctype.ai_info;
 	ai_local *const ailp = &obj.ctype.ai_info.ail;
 
-	ailp->time_player_seen = GameTime64;			//	Prevent from resetting path quickly.
+	ailp->time_player_seen = {GameTime64};			//	Prevent from resetting path quickly.
 	ailp->goal_segment = goal_segment;
 
 	segnum_t			start_seg;
@@ -720,7 +720,7 @@ void create_path_to_segment(const vmobjptridx_t objp, const robot_info &robptr,
 	ai_static	*aip = &objp->ctype.ai_info;
 	ai_local		*ailp = &objp->ctype.ai_info.ail;
 
-	ailp->time_player_seen = GameTime64;			//	Prevent from resetting path quickly.
+	ailp->time_player_seen = {GameTime64};			//	Prevent from resetting path quickly.
 	ailp->goal_segment = goalseg;
 
 	segnum_t			start_seg, end_seg;
@@ -764,7 +764,7 @@ void create_path_to_station(const vmobjptridx_t objp, const robot_info &robptr,
 	if (max_length == -1)
 		max_length = MAX_DEPTH_TO_SEARCH_FOR_PLAYER;
 
-	ailp->time_player_seen = GameTime64;			//	Prevent from resetting path quickly.
+	ailp->time_player_seen = {GameTime64};			//	Prevent from resetting path quickly.
 
 	segnum_t			start_seg, end_seg;
 	start_seg = obj.segnum;
diff --git a/similar/main/automap.cpp b/similar/main/automap.cpp
index 3d2eb0d99..8f14ae28a 100644
--- a/similar/main/automap.cpp
+++ b/similar/main/automap.cpp
@@ -297,7 +297,7 @@ window_event_result marker_delete_are_you_sure_menu::event_handler(const d_event
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			const auto citem = static_cast<const d_select_event &>(event).citem;
 			if (citem == 0)
@@ -1135,53 +1135,51 @@ window_event_result automap::event_handler(const d_event &event)
 	auto &vmobjptr = Objects.vmptr;
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(controls);
 			event_toggle_focus(1);
-			key_toggle_repeat(0);
+			key_toggle_repeat(1);
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			event_toggle_focus(0);
 			key_toggle_repeat(1);
 			break;
 
 #if SDL_MAJOR_VERSION == 2
-		case EVENT_WINDOW_RESIZE:
+		case event_type::window_resize:
 			init_automap_subcanvas(automap_view, grd_curscreen->sc_canvas);
 			break;
 #endif
 
-		case EVENT_IDLE:
+		case event_type::idle:
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_UP:
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_up:
+		case event_type::joystick_button_down:
 #endif
 #if DXX_MAX_AXES_PER_JOYSTICK
-		case EVENT_JOYSTICK_MOVED:
+		case event_type::joystick_moved:
 #endif
-		case EVENT_MOUSE_BUTTON_UP:
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_MOVED:
-		case EVENT_KEY_RELEASE:
+		case event_type::mouse_button_up:
+		case event_type::mouse_button_down:
+		case event_type::mouse_moved:
+		case event_type::key_release:
 			return automap_process_input(event, *this);
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 		{
 			window_event_result kret = automap_key_command(event, *this);
 			if (kret == window_event_result::ignored)
 				kret = automap_process_input(event, *this);
 			return kret;
 		}
-			
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			{
 				auto &plrobj = get_local_plrobj();
 				automap_apply_input(*this, plrobj.orient, plrobj.pos);
 			}
 			draw_automap(vcobjptr, *this);
 			break;
-			
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			if (!pause_game)
 				ConsoleObject->mtype.phys_info.flags |= old_wiggle;		// Restore wiggle
 			event_toggle_focus(0);
@@ -1200,16 +1198,15 @@ window_event_result automap::event_handler(const d_event &event)
 			multi_send_msgsend_state(msgsend_state::none);
 			return window_event_result::ignored;	// continue closing
 
-		case EVENT_LOOP_BEGIN_LOOP:
+		case event_type::loop_begin_loop:
 			kconfig_begin_loop(controls);
 			break;
-		case EVENT_LOOP_END_LOOP:
+		case event_type::loop_end_loop:
 			kconfig_end_loop(controls, FrameTime);
 			break;
 
 		default:
 			return window_event_result::ignored;
-			break;
 	}
 	return window_event_result::handled;
 }
diff --git a/similar/main/bm.cpp b/similar/main/bm.cpp
index 0c395186e..b2809b24a 100644
--- a/similar/main/bm.cpp
+++ b/similar/main/bm.cpp
@@ -227,7 +227,7 @@ void properties_read_cmp(d_level_shared_robot_info_state &LevelSharedRobotInfoSt
 	range_for (auto &i, ObjBitmapPtrs)
 	{
 		if (const auto oi = ObjBitmaps.valid_index(PHYSFSX_readShort(fp)))
-			i = *oi;
+			i = {*oi};
 		else
 			i = {};
 	}
@@ -375,7 +375,7 @@ void bm_read_all(d_level_shared_robot_info_state &LevelSharedRobotInfoState, d_v
 	range_for (auto &i, partial_range(ObjBitmapPtrs, N_ObjBitmaps))
 	{
 		if (const auto oi = ObjBitmaps.valid_index(PHYSFSX_readShort(fp)))
-			i = *oi;
+			i = {*oi};
 		else
 			i = {};
 	}
@@ -523,7 +523,7 @@ void bm_read_extra_robots(const char *fname, Mission::descent_version_type type)
 	range_for (auto &i, partial_range(ObjBitmapPtrs, N_D2_OBJBITMAPPTRS.value, N_D2_OBJBITMAPPTRS + t))
 	{
 		if (const auto oi = ObjBitmaps.valid_index(PHYSFSX_readShort(fp)))
-			i = *oi;
+			i = {*oi};
 		else
 			i = {};
 	}
diff --git a/similar/main/cntrlcen.cpp b/similar/main/cntrlcen.cpp
index 1d07f4537..cfc5a2fba 100644
--- a/similar/main/cntrlcen.cpp
+++ b/similar/main/cntrlcen.cpp
@@ -386,7 +386,7 @@ void do_controlcen_frame(const d_robot_info_array &Robot_info, const vmobjptridx
 	{
 		if (LevelUniqueControlCenterState.Last_time_cc_vis_check + F1_0 * 5 < GameTime64 || LevelUniqueControlCenterState.Last_time_cc_vis_check > GameTime64)
 		{
-			LevelUniqueControlCenterState.Last_time_cc_vis_check = GameTime64;
+			LevelUniqueControlCenterState.Last_time_cc_vis_check = {GameTime64};
 			const auto &&[dist_to_player, vec_to_player] = vm_vec_normalize_quick_with_magnitude(vm_vec_sub(ConsoleObject->pos, obj->pos));
 			if (dist_to_player < F1_0*120) {
 				LevelUniqueControlCenterState.Control_center_player_been_seen = player_is_visible_from_object(Robot_info, obj, obj->pos, 0, vec_to_player);
diff --git a/similar/main/collide.cpp b/similar/main/collide.cpp
index 7bba7531a..36d816872 100644
--- a/similar/main/collide.cpp
+++ b/similar/main/collide.cpp
@@ -124,7 +124,7 @@ static int check_collision_delayfunc_exec()
 	static fix64 last_play_time=0;
 	if (last_play_time + (F1_0/3) < GameTime64 || last_play_time > GameTime64)
 	{
-		last_play_time = GameTime64;
+		last_play_time = {GameTime64};
 		last_play_time -= (d_rand()/2); // add some randomness
 		return 1;
 	}
@@ -467,7 +467,7 @@ volatile_wall_result check_volatile_wall(const vmobjptridx_t obj, const unique_s
 		{
 			if (!((GameTime64 > Last_volatile_scrape_time + DESIGNATED_GAME_FRAMETIME) || (GameTime64 < Last_volatile_scrape_time)))
 				return volatile_wall_result::none;
-			Last_volatile_scrape_time = GameTime64;
+			Last_volatile_scrape_time = {GameTime64};
 
 #if defined(DXX_BUILD_DESCENT_II)
 			if (d > 0)
@@ -512,7 +512,7 @@ bool scrape_player_on_wall(const vmobjptridx_t obj, const vmsegptridx_t hitseg,
 	if (type != volatile_wall_result::none)
 	{
 		if ((GameTime64 > Last_volatile_scrape_sound_time + F1_0/4) || (GameTime64 < Last_volatile_scrape_sound_time)) {
-			Last_volatile_scrape_sound_time = GameTime64;
+			Last_volatile_scrape_sound_time = {GameTime64};
 			const auto sound =
 #if defined(DXX_BUILD_DESCENT_II)
 				(type != volatile_wall_result::lava)
@@ -1068,14 +1068,14 @@ static void collide_robot_and_player(const d_robot_info_array &Robot_info, const
 			ai_local		*ailp = &robot->ctype.ai_info.ail;
 			if (ailp->mode == ai_mode::AIM_THIEF_ATTACK)
 			{
-				Last_thief_hit_time = GameTime64;
+				Last_thief_hit_time = {GameTime64};
 				attempt_to_steal_item(robot, robptr, playerobj);
 				steal_attempt = 1;
 			} else if (GameTime64 - Last_thief_hit_time < F1_0*2)
 				return;		//	ZOUNDS!  BRILLIANT!  Thief not collide with player if not stealing!
 								// NO!  VERY DUMB!  makes thief look very stupid if player hits him while cloaked! -AP
 			else
-				Last_thief_hit_time = GameTime64;
+				Last_thief_hit_time = {GameTime64};
 		}
 #endif
 
@@ -1422,7 +1422,7 @@ void do_final_boss_hacks(void)
 	if (!(pl_flags & PLAYER_FLAGS_INVULNERABLE)) {
 		pl_flags |= PLAYER_FLAGS_INVULNERABLE;
 		player_info.FakingInvul = 0;
-		player_info.invulnerable_time = GameTime64;
+		player_info.invulnerable_time = {GameTime64};
 	}
 	if (!(Game_mode & GM_MULTI))
 		buddy_message("Nice job, %s!", static_cast<const char *>(get_local_player().callsign));
@@ -1445,7 +1445,7 @@ int apply_damage_to_robot(const d_robot_info_array &Robot_info, const vmobjptrid
 	auto &Objects = LevelUniqueObjectState.Objects;
 	auto &vmobjptr = Objects.vmptr;
 	if (robptr.boss_flag != boss_robot_id::None)
-		BossUniqueState.Boss_hit_time = GameTime64;
+		BossUniqueState.Boss_hit_time = {GameTime64};
 
 	//	Buddy invulnerable on level 24 so he can give you his important messages.  Bah.
 	//	Also invulnerable if his cheat for firing weapons is in effect.
@@ -1585,7 +1585,7 @@ static boss_weapon_collision_result do_boss_weapon_collision(const d_robot_info_
 						int	sval;
 
 						BuddyState.Buddy_gave_hint_count--;
-						BuddyState.Last_time_buddy_gave_hint = GameTime64;
+						BuddyState.Last_time_buddy_gave_hint = {GameTime64};
 						sval = (d_rand()*4) >> 15;
 						const char *msg;
 						switch (sval) {
@@ -1650,7 +1650,7 @@ static void collide_robot_and_weapon(const d_robot_info_array &Robot_info, const
 	{
 		BossUniqueState.Boss_hit_this_frame = 1;
 #if defined(DXX_BUILD_DESCENT_II)
-		BossUniqueState.Boss_hit_time = GameTime64;
+		BossUniqueState.Boss_hit_time = {GameTime64};
 #endif
 	}
 #if defined(DXX_BUILD_DESCENT_II)
@@ -1853,7 +1853,7 @@ static void collide_player_and_player(const d_robot_info_array &Robot_info, cons
 			: player1)->ctype.player_info.Last_bumped_local_player;
 		if (last_player_bump + (F1_0/Netgame.PacketsPerSec) < GameTime64 || last_player_bump > GameTime64)
 		{
-			last_player_bump = GameTime64;
+			last_player_bump = {GameTime64};
 			damage_flag = 1;
 		}
 	}
@@ -2157,7 +2157,7 @@ void apply_damage_to_player(object &playerobj, const icobjptridx_t killer, const
 #if defined(DXX_BUILD_DESCENT_II)
 			auto &Robot_info = LevelSharedRobotInfoState.Robot_info;
 				if (killer && killer->type == OBJ_ROBOT && robot_is_companion(Robot_info[get_robot_id(killer)]))
-					BuddyState.Buddy_sorry_time = GameTime64;
+					BuddyState.Buddy_sorry_time = {GameTime64};
 #endif
 		}
 	}
diff --git a/similar/main/console.cpp b/similar/main/console.cpp
index 7748cda3d..f543a472e 100644
--- a/similar/main/console.cpp
+++ b/similar/main/console.cpp
@@ -184,7 +184,7 @@ static void con_print_file(const char *const buffer)
 			tm_hour, tm_min, tm_sec;
 #ifdef _WIN32
 #define DXX_LF	"\r\n"
-		SYSTEMTIME st = {};
+		SYSTEMTIME st{};
 		GetLocalTime(&st);
 #if DXX_CONSOLE_TIME_SHOW_YMD
 		tm_year = st.wYear;
@@ -353,20 +353,19 @@ window_event_result console_window::event_handler(const d_event &event)
 {
 	int key;
 	static fix64 last_scroll_time = 0;
-	
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			key_toggle_repeat(1);
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			key_toggle_repeat(0);
 			con_size = 0;
 			con_state = con_state::closed;
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			key = event_key_get(event);
 			switch (key)
 			{
@@ -422,7 +421,7 @@ window_event_result console_window::event_handler(const d_event &event)
 			}
 			return window_event_result::handled;
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			timer_delay2(50);
 			if (con_state == con_state::opening)
 			{
@@ -448,12 +447,11 @@ window_event_result console_window::event_handler(const d_event &event)
 				return window_event_result::close;
 			}
 			break;
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
 	}
-	
 	return window_event_result::ignored;
 }
 
diff --git a/similar/main/credits.cpp b/similar/main/credits.cpp
index e43c8bf8f..b24b5a2a7 100644
--- a/similar/main/credits.cpp
+++ b/similar/main/credits.cpp
@@ -81,13 +81,13 @@ struct credits_window : window
 {
 	RAIIPHYSFS_File file;
 	const uint8_t have_bin_file;
-	std::array<PHYSFSX_gets_line_t<80>, NUM_LINES> buffer = {};
+	std::array<PHYSFSX_gets_line_t<80>, NUM_LINES> buffer{};
 	int buffer_line = 0;
 	int first_line_offset = 0;
 	int extra_inc = 0;
 	int done = 0;
 	int row = 0;
-	grs_main_bitmap backdrop = {};
+	grs_main_bitmap backdrop{};
 	credits_window(grs_canvas &src, int x, int y, int w, int h, RAIIPHYSFS_File f, const uint8_t bin_file) :
 		window(src, x, y, w, h), file(std::move(f)), have_bin_file(bin_file)
 	{
@@ -115,15 +115,15 @@ window_event_result credits_window::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			if ((result = call_default_handler(event)) == window_event_result::ignored)	// if not print screen, debug etc
 			{
 				return window_event_result::close;
 			}
 			return result;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 			if (event_mouse_get_button(event) == mbtn::left || event_mouse_get_button(event) == mbtn::right)
 			{
 				return window_event_result::close;
@@ -131,18 +131,17 @@ window_event_result credits_window::event_handler(const d_event &event)
 			break;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_down:
 			return window_event_result::close;
 #endif
 
-		case EVENT_IDLE:
+		case event_type::idle:
 			if (done > NUM_LINES)
 			{
 				return window_event_result::close;
 			}
 			break;
-			
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			{
 #if defined(DXX_BUILD_DESCENT_I)
 			timer_delay(F1_0/17);
@@ -242,7 +241,7 @@ window_event_result credits_window::event_handler(const d_event &event)
 			break;
 			}
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			songs_set_volume(CGameCfg.MusicVolume);
 			songs_play_song( SONG_TITLE, 1 );
 			break;
diff --git a/similar/main/fireball.cpp b/similar/main/fireball.cpp
index 977d4729e..b1cfd8dbf 100644
--- a/similar/main/fireball.cpp
+++ b/similar/main/fireball.cpp
@@ -1197,14 +1197,7 @@ static bool drop_robot_egg(const d_robot_info_array &Robot_info, const contained
 //				new_pos.y += (d_rand()-16384)*7;
 //				new_pos.z += (d_rand()-16384)*6;
 
-#if defined(DXX_BUILD_DESCENT_I)
-				/* ObjId appears to serve as both a polygon_model_index and as
-				 * a robot index.
-				 */
-				const auto rid = static_cast<robot_id>(ObjId[underlying_value(type)]);
-#elif defined(DXX_BUILD_DESCENT_II)
 				const auto rid = static_cast<robot_id>(id);
-#endif
 				auto &robptr = Robot_info[rid];
 				const auto &&objp = robot_create(Robot_info, rid, segnum, new_pos, &vmd_identity_matrix, Polygon_models[robptr.model_num].rad, ai_behavior::AIB_NORMAL);
 				if (objp == object_none)
diff --git a/similar/main/fuelcen.cpp b/similar/main/fuelcen.cpp
index 52bb91ba6..7ded4d5d5 100644
--- a/similar/main/fuelcen.cpp
+++ b/similar/main/fuelcen.cpp
@@ -569,7 +569,7 @@ constexpr std::integral_constant<unsigned, F1_0 / 4> FUELCEN_SOUND_DELAY{};
 //-------------------------------------------------------------
 fix fuelcen_give_fuel(const shared_segment &segp, fix MaxAmountCanTake)
 {
-	static fix64 last_play_time = 0;
+	static fix64 last_play_time{};
 
 	if (segp.special == segment_special::fuelcen)
 	{
@@ -590,7 +590,7 @@ fix fuelcen_give_fuel(const shared_segment &segp, fix MaxAmountCanTake)
 
 		if (last_play_time + FUELCEN_SOUND_DELAY < GameTime64 || last_play_time > GameTime64)
 		{
-			last_play_time = GameTime64;
+			last_play_time = {GameTime64};
 			multi_digi_play_sample(SOUND_REFUEL_STATION_GIVING_FUEL, F1_0/2);
 		}
 		return amount;
@@ -609,7 +609,7 @@ namespace dcx {
 // use same values as fuel centers
 fix repaircen_give_shields(const shared_segment &segp, const fix MaxAmountCanTake)
 {
-	static fix last_play_time=0;
+	static fix64 last_play_time{};
 
 	if (segp.special == segment_special::repaircen)
 	{
@@ -623,8 +623,8 @@ fix repaircen_give_shields(const shared_segment &segp, const fix MaxAmountCanTak
 		if (last_play_time > GameTime64)
 			last_play_time = 0;
 		if (GameTime64 > last_play_time+FUELCEN_SOUND_DELAY) {
+			last_play_time = {GameTime64};
 			multi_digi_play_sample(SOUND_REFUEL_STATION_GIVING_FUEL, F1_0/2);
-			last_play_time = GameTime64;
 		}
 		return amount;
 	} else {
diff --git a/similar/main/game.cpp b/similar/main/game.cpp
index dd2afeeec..567a1c979 100644
--- a/similar/main/game.cpp
+++ b/similar/main/game.cpp
@@ -1296,8 +1296,8 @@ static void diminish_palette_towards_normal(void)
 		}
 
 		if (Time_flash_last_played + F1_0/8 < GameTime64) {
+			Time_flash_last_played = {GameTime64};
 			digi_play_sample( SOUND_CLOAK_OFF, Flash_effect/4);
-			Time_flash_last_played = GameTime64;
 		}
 
 		Flash_effect -= FrameTime;
@@ -1773,7 +1773,7 @@ window_event_result game_window::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			set_screen_mode(SCREEN_GAME);
 
 			event_toggle_focus(1);
@@ -1792,7 +1792,7 @@ window_event_result game_window::event_handler(const d_event &event)
 			reset_cockpit();
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			if (!(((Game_mode & GM_MULTI) && (Newdemo_state != ND_STATE_PLAYBACK)) && (!Endlevel_sequence)) )
 				stop_time();
 
@@ -1807,21 +1807,21 @@ window_event_result game_window::event_handler(const d_event &event)
 			break;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_UP:
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_up:
+		case event_type::joystick_button_down:
 #endif
 #if DXX_MAX_AXES_PER_JOYSTICK
-		case EVENT_JOYSTICK_MOVED:
-#endif
-		case EVENT_MOUSE_BUTTON_UP:
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_MOVED:
-		case EVENT_KEY_COMMAND:
-		case EVENT_KEY_RELEASE:
-		case EVENT_IDLE:
+		case event_type::joystick_moved:
+#endif
+		case event_type::mouse_button_up:
+		case event_type::mouse_button_down:
+		case event_type::mouse_moved:
+		case event_type::key_command:
+		case event_type::key_release:
+		case event_type::idle:
 			return ReadControls(LevelSharedRobotInfoState, event, Controls);
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			if (!time_paused)
 			{
 				calc_frame_time();
@@ -1838,7 +1838,7 @@ window_event_result game_window::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			digi_stop_digi_sounds();
 
 			if ( (Newdemo_state == ND_STATE_RECORDING) || (Newdemo_state == ND_STATE_PAUSED) )
@@ -1862,10 +1862,10 @@ window_event_result game_window::event_handler(const d_event &event)
 			Game_wind = nullptr;
 			return window_event_result::ignored;
 
-		case EVENT_LOOP_BEGIN_LOOP:
+		case event_type::loop_begin_loop:
 			kconfig_begin_loop(Controls);
 			break;
-		case EVENT_LOOP_END_LOOP:
+		case event_type::loop_end_loop:
 			kconfig_end_loop(Controls, FrameTime);
 			break;
 
diff --git a/similar/main/gamecntl.cpp b/similar/main/gamecntl.cpp
index ba4fab79a..1c2216b3f 100644
--- a/similar/main/gamecntl.cpp
+++ b/similar/main/gamecntl.cpp
@@ -201,8 +201,8 @@ static void transfer_energy_to_shield(object &plrobj)
 		last_play_time = 0;
 
 	if (GameTime64 > last_play_time+CONVERTER_SOUND_DELAY) {
+		last_play_time = {GameTime64};
 		digi_play_sample_once(SOUND_CONVERT_ENERGY, F1_0);
-		last_play_time = GameTime64;
 	}
 }
 #endif
@@ -413,7 +413,7 @@ window_event_result choose_curseg_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 				char *p;
 				const auto s = strtoul(text.data(), &p, 0);
@@ -445,11 +445,11 @@ window_event_result pause_window::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			switch (event_key_get(event))
 			{
 				case 0:
@@ -466,16 +466,16 @@ window_event_result pause_window::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay2(50);
 			break;
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			gr_set_default_canvas();
 			show_boxed_message(*grd_curcanv, msg.data());
 			break;
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			songs_resume();
 			break;
 
@@ -555,7 +555,7 @@ static int HandleDeathInput(const d_event &event, control_info &Controls)
 {
 	const auto input_aborts_death_sequence = [&]() {
 		const auto RespawnMode = PlayerCfg.RespawnMode;
-		if (event.type == EVENT_KEY_COMMAND)
+		if (event.type == event_type::key_command)
 		{
 			const auto key = event_key_get(event);
 			if ((RespawnMode == RespawnPress::Any && !key_isfunc(key) && key != KEY_PAUSE && key) ||
@@ -566,9 +566,9 @@ static int HandleDeathInput(const d_event &event, control_info &Controls)
 		if (RespawnMode == RespawnPress::Any
 			? (
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-				event.type == EVENT_JOYSTICK_BUTTON_UP ||
+				event.type == event_type::joystick_button_up ||
 #endif
-				event.type == EVENT_MOUSE_BUTTON_UP)
+				event.type == event_type::mouse_button_up)
 			: (Controls.state.fire_primary || Controls.state.fire_secondary || Controls.state.fire_flare))
 			return 1;
 		return 0;
@@ -654,11 +654,11 @@ static window_event_result HandleDemoKey(int key)
 			Newdemo_vcr_state = ND_STATE_PAUSED;
 			break;
 		case KEY_LEFT:
-			newdemo_single_frame_time = GameTime64;
+			newdemo_single_frame_time = {GameTime64};
 			Newdemo_vcr_state = ND_STATE_ONEFRAMEBACKWARD;
 			break;
 		case KEY_RIGHT:
-			newdemo_single_frame_time = GameTime64;
+			newdemo_single_frame_time = {GameTime64};
 			Newdemo_vcr_state = ND_STATE_ONEFRAMEFORWARD;
 			break;
 		case KEY_CTRLED + KEY_RIGHT:
@@ -1411,7 +1411,7 @@ static window_event_result HandleTestKey(const d_level_shared_robot_info_state &
 				if (Game_mode & GM_MULTI)
 					multi_send_cloak();
 				ai_do_cloak_stuff();
-				player_info.cloak_time = GameTime64;
+				player_info.cloak_time = {GameTime64};
 			}
 			break;
 		}
@@ -1681,7 +1681,7 @@ window_event_result levelwarp_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			handle_close_event();
 			return window_event_result::ignored;
 		default:
@@ -1843,7 +1843,7 @@ static window_event_result FinalCheats(const d_level_shared_robot_info_state &Le
 		if (have_cloaked)
 		{
 			ai_do_cloak_stuff();
-			player_info.cloak_time = GameTime64;
+			player_info.cloak_time = {GameTime64};
 		}
 	}
 
@@ -2024,7 +2024,7 @@ class cheat_menu_bit_cloak :
 			if (Game_mode & GM_MULTI)
 				multi_send_cloak();
 			ai_do_cloak_stuff();
-			get().cloak_time = GameTime64;
+			get().cloak_time = {GameTime64};
 		}
 		return *this;
 	}
@@ -2087,7 +2087,7 @@ window_event_result wimp_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 				auto &pl_info = plrobj.ctype.player_info;
 				uint8_t plr_laser_level;
@@ -2158,7 +2158,7 @@ window_event_result ReadControls(const d_level_shared_robot_info_state &LevelSha
 	if (Newdemo_state == ND_STATE_PLAYBACK)
 		update_vcr_state();
 
-	if (event.type == EVENT_KEY_COMMAND)
+	if (event.type == event_type::key_command)
 	{
 		key = event_key_get(event);
 #if defined(DXX_BUILD_DESCENT_II)
diff --git a/similar/main/gameseg.cpp b/similar/main/gameseg.cpp
index de8b3304f..e5bb7ac5c 100644
--- a/similar/main/gameseg.cpp
+++ b/similar/main/gameseg.cpp
@@ -819,7 +819,7 @@ static void add_to_fcd_cache(const segnum_t seg0, const segnum_t seg1, const vm_
 void flush_fcd_cache()
 {
 	Fcd_index = 0;
-	Last_fcd_flush_time = GameTime64;
+	Last_fcd_flush_time = {GameTime64};
 
 	for (auto &f : Fcd_cache)
 		f.seg0 = segment_none;
@@ -1119,9 +1119,10 @@ namespace {
 // ------------------------------------------------------------------------------------------
 //	Extract a vector from a segment.  The vector goes from the start face to the end face.
 //	The point on each face is the average of the four points forming the face.
-static void extract_vector_from_segment(fvcvertptr &vcvertptr, const shared_segment &sp, vms_vector &vp, const sidenum_t istart, const sidenum_t iend)
+[[nodiscard]]
+static vms_vector extract_vector_from_segment(fvcvertptr &vcvertptr, const shared_segment &sp, const sidenum_t istart, const sidenum_t iend)
 {
-	vp = {};
+	vms_vector vp{};
 	auto &start = Side_to_verts[istart];
 	auto &end = Side_to_verts[iend];
 	auto &verts = sp.verts;
@@ -1131,16 +1132,15 @@ static void extract_vector_from_segment(fvcvertptr &vcvertptr, const shared_segm
 		vm_vec_add2(vp, vcvertptr(verts[ve]));
 	}
 	vm_vec_scale(vp,F1_0/4);
+	return vp;
 }
 }
 
 //create a matrix that describes the orientation of the given segment
 void extract_orient_from_segment(fvcvertptr &vcvertptr, vms_matrix &m, const shared_segment &seg)
 {
-	vms_vector fvec,uvec;
-
-	extract_vector_from_segment(vcvertptr, seg, fvec, sidenum_t::WFRONT, sidenum_t::WBACK);
-	extract_vector_from_segment(vcvertptr, seg, uvec, sidenum_t::WBOTTOM, sidenum_t::WTOP);
+	const auto fvec{extract_vector_from_segment(vcvertptr, seg, sidenum_t::WFRONT, sidenum_t::WBACK)};
+	const auto uvec{extract_vector_from_segment(vcvertptr, seg, sidenum_t::WBOTTOM, sidenum_t::WTOP)};
 
 	//vector to matrix does normalizations and orthogonalizations
 	vm_vector_2_matrix(m, fvec, &uvec, nullptr);
@@ -1156,7 +1156,7 @@ namespace {
 // to the center of the back face of the segment.
 void extract_forward_vector_from_segment(fvcvertptr &vcvertptr, const shared_segment &sp, vms_vector &vp)
 {
-	extract_vector_from_segment(vcvertptr, sp, vp, sidenum_t::WFRONT, sidenum_t::WBACK);
+	vp = extract_vector_from_segment(vcvertptr, sp, sidenum_t::WFRONT, sidenum_t::WBACK);
 }
 
 // ------------------------------------------------------------------------------------------
@@ -1165,7 +1165,7 @@ void extract_forward_vector_from_segment(fvcvertptr &vcvertptr, const shared_seg
 // to the center of the right face of the segment.
 void extract_right_vector_from_segment(fvcvertptr &vcvertptr, const shared_segment &sp, vms_vector &vp)
 {
-	extract_vector_from_segment(vcvertptr, sp, vp, sidenum_t::WLEFT, sidenum_t::WRIGHT);
+	vp = extract_vector_from_segment(vcvertptr, sp, sidenum_t::WLEFT, sidenum_t::WRIGHT);
 }
 
 // ------------------------------------------------------------------------------------------
@@ -1174,7 +1174,7 @@ void extract_right_vector_from_segment(fvcvertptr &vcvertptr, const shared_segme
 // to the center of the top face of the segment.
 void extract_up_vector_from_segment(fvcvertptr &vcvertptr, const shared_segment &sp, vms_vector &vp)
 {
-	extract_vector_from_segment(vcvertptr, sp, vp, sidenum_t::WBOTTOM, sidenum_t::WTOP);
+	vp = extract_vector_from_segment(vcvertptr, sp, sidenum_t::WBOTTOM, sidenum_t::WTOP);
 }
 
 #if !DXX_USE_EDITOR
diff --git a/similar/main/gameseq.cpp b/similar/main/gameseq.cpp
index bf2326ead..9ea77e2ff 100644
--- a/similar/main/gameseq.cpp
+++ b/similar/main/gameseq.cpp
@@ -782,7 +782,7 @@ void init_player_stats_ship(object &plrobj, const fix GameTime64)
 #endif
 	player_info.mission.hostages_on_board = 0;
 	player_info.homing_object_dist = -F1_0; // Added by RH
-	player_info.Next_flare_fire_time = player_info.Next_laser_fire_time = player_info.Next_missile_fire_time = GameTime64;
+	player_info.Next_flare_fire_time = player_info.Next_laser_fire_time = player_info.Next_missile_fire_time = {GameTime64};
 }
 }
 
diff --git a/similar/main/gauges.cpp b/similar/main/gauges.cpp
index c13766b5e..bc340a4cd 100644
--- a/similar/main/gauges.cpp
+++ b/similar/main/gauges.cpp
@@ -847,13 +847,13 @@ constexpr std::array<dspan, 107> weapon_windows_hires = {{
 
 struct gauge_inset_window
 {
-	fix fade_value = 0;
-	weapon_index old_weapon = {};
-	weapon_box_state box_state = weapon_box_state::set;
+	fix fade_value{};
+	weapon_index old_weapon{};
+	weapon_box_state box_state{weapon_box_state::set};
 #if defined(DXX_BUILD_DESCENT_II)
-	weapon_box_user user = weapon_box_user::weapon;
-	uint8_t overlap_dirty = 0;
-	fix time_static_played = 0;
+	weapon_box_user user{weapon_box_user::weapon};
+	uint8_t overlap_dirty{};
+	fix time_static_played{};
 #endif
 };
 
@@ -1113,8 +1113,8 @@ void play_homing_warning(const player_info &player_info)
 			beep_delay = F1_0/8;
 
 		if (GameTime64 - Last_warning_beep_time > beep_delay/2 || Last_warning_beep_time > GameTime64) {
+			Last_warning_beep_time = {GameTime64};
 			digi_play_sample( SOUND_HOMING_WARNING, F1_0 );
-			Last_warning_beep_time = GameTime64;
 		}
 	}
 }
@@ -1835,7 +1835,7 @@ static void hud_show_cloak_invuln(grs_canvas &canvas, const player_flags player_
 		return;
 	gr_set_fontcolor(canvas, BM_XRGB(0, 31, 0), -1);
 	const auto &&line_spacing = LINE_SPACING(*canvas.cv_font, *GAME_FONT);
-	const auto gametime64 = GameTime64;
+	const auto gametime64{GameTime64};
 	const auto &&fspacx1 = FSPACX(1);
 
 	const auto cloak_invul_timer = show_cloak_invul_timer();
@@ -2217,8 +2217,7 @@ void close_gauges()
 namespace dsx {
 void init_gauges()
 {
-	inset_window[gauge_inset_window_view::primary] = {};
-	inset_window[gauge_inset_window_view::secondary] = {};
+	inset_window = {};
 	old_laser_level	= {};
 }
 }
@@ -3739,7 +3738,7 @@ void draw_hud(const d_robot_info_array &Robot_info, grs_canvas &canvas, const ob
 		if (PlayerCfg.CockpitMode[1] == cockpit_mode_t::status_bar || PlayerCfg.CockpitMode[1] == cockpit_mode_t::full_screen)
 			hud_show_homing_warning(canvas, player_info.homing_object_dist);
 
-		const local_multires_gauge_graphic multires_gauge_graphic = {};
+		const local_multires_gauge_graphic multires_gauge_graphic{};
 		const hud_draw_context_hs_mr hudctx(canvas, grd_curscreen->get_screen_width(), grd_curscreen->get_screen_height(), multires_gauge_graphic);
 		if (PlayerCfg.CockpitMode[1] == cockpit_mode_t::full_screen)
 		{
diff --git a/similar/main/iff.cpp b/similar/main/iff.cpp
index 1e0f6c14b..2fb085e78 100644
--- a/similar/main/iff.cpp
+++ b/similar/main/iff.cpp
@@ -540,15 +540,7 @@ static int iff_parse_bitmap(PHYSFS_File *ifile, grs_bitmap &bm, const bm_mode bi
 	int sig,form_len;
 	long form_type;
 
-	bmheader.raw_data.reset(bm.get_bitmap_data());
-
-	if (bmheader.raw_data) {
-		bmheader.w = bm.bm_w;
-		bmheader.h = bm.bm_h;
-	}//added 05/17/99 Matt Mueller - don't just leave them unitialized
-	else{
 		bmheader.w=bmheader.h=0;
-	}
 
 	sig=get_sig(ifile);
 
@@ -607,7 +599,7 @@ int iff_read_bitmap(const char *const ifilename, grs_bitmap &bm, palette_array_t
 	if (!ifile)
 		return IFF_NO_FILE;
 
-	bm.bm_data = nullptr;
+	assert(bm.bm_data == nullptr);
 	ret = iff_parse_bitmap(ifile, bm, bm_mode::linear, palette, nullptr);
 	return ret;
 }
diff --git a/similar/main/inferno.cpp b/similar/main/inferno.cpp
index dec7c7587..6423f870f 100644
--- a/similar/main/inferno.cpp
+++ b/similar/main/inferno.cpp
@@ -296,14 +296,14 @@ window_event_result standard_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 			// No window selecting
 			// We stay with the current one until it's closed/hidden or another one is made
 			// Not the case for the editor
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			key = event_key_get(event);
 
 			switch (key)
@@ -360,15 +360,15 @@ window_event_result standard_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_WINDOW_DRAW:
-		case EVENT_IDLE:
+		case event_type::window_draw:
+		case event_type::idle:
 			//see if redbook song needs to be restarted
 #if DXX_USE_SDL_REDBOOK_AUDIO
 			RBACheckFinishedHook();
 #endif
 			return window_event_result::handled;
 
-		case EVENT_QUIT:
+		case event_type::quit:
 #if DXX_USE_EDITOR
 			if (!SafetyCheck())
 				return window_event_result::handled;
diff --git a/similar/main/kconfig.cpp b/similar/main/kconfig.cpp
index 73118e40b..fe4f608b8 100644
--- a/similar/main/kconfig.cpp
+++ b/similar/main/kconfig.cpp
@@ -550,7 +550,7 @@ namespace {
 static window_event_result kconfig_mouse(kc_menu &menu, const d_event &event)
 {
 	grs_canvas &save_canvas = *grd_curcanv;
-	int mx, my, mz, x1, y1;
+	int x1, y1;
 	window_event_result rval = window_event_result::ignored;
 
 	gr_set_current_canvas(menu.w_canv);
@@ -560,7 +560,7 @@ static window_event_result kconfig_mouse(kc_menu &menu, const d_event &event)
 	{
 		int item_height;
 		
-		mouse_get_pos(&mx, &my, &mz);
+		const auto [mx, my, mz] = mouse_get_pos();
 		const auto &&fspacx = FSPACX();
 		const auto &&fspacy = FSPACY();
 		const auto nitems = menu.nitems;
@@ -576,11 +576,10 @@ static window_event_result kconfig_mouse(kc_menu &menu, const d_event &event)
 			}
 		}
 	}
-	else if (event.type == EVENT_MOUSE_BUTTON_UP)
+	else if (event.type == event_type::mouse_button_up)
 	{
 		int item_height;
-		
-		mouse_get_pos(&mx, &my, &mz);
+		const auto [mx, my, mz] = mouse_get_pos();
 		item_height = get_item_height(*canvas.cv_font, menu.items[menu.citem], menu.mitems[menu.citem]);
 		const auto &&fspacx = FSPACX();
 		x1 = canvas.cv_bitmap.bm_x + fspacx(menu.items[menu.citem].xinput);
@@ -701,20 +700,18 @@ window_event_result kc_menu::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			break;
-			
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			mouse_state = 0;
 			break;
-			
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
-			if (changing && items[citem].type == kc_type::mouse_button && event.type == EVENT_MOUSE_BUTTON_UP)
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
+			if (changing && items[citem].type == kc_type::mouse_button && event.type == event_type::mouse_button_up)
 			{
 				kc_change_mousebutton(*this, event, mitems[citem]);
-				mouse_state = (event.type == EVENT_MOUSE_BUTTON_DOWN);
+				mouse_state = (event.type == event_type::mouse_button_down);
 				return window_event_result::handled;
 			}
 
@@ -729,25 +726,25 @@ window_event_result kc_menu::event_handler(const d_event &event)
 			else if (event_mouse_get_button(event) != mbtn::left)
 				return window_event_result::ignored;
 
-			mouse_state = (event.type == EVENT_MOUSE_BUTTON_DOWN);
+			mouse_state = (event.type == event_type::mouse_button_down);
 			return kconfig_mouse(*this, event);
 
-		case EVENT_MOUSE_MOVED:
+		case event_type::mouse_moved:
 			if (changing && items[citem].type == kc_type::mouse_axis)
 				kc_change_mouseaxis(*this, event, mitems[citem]);
 			else
-				event_mouse_get_delta(event, &old_maxis[0], &old_maxis[1], &old_maxis[2]);
+				old_maxis = event_mouse_get_delta(event);
 			break;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK || DXX_MAX_HATS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_down:
 			if (changing && items[citem].type == kc_type::joy_button)
 				kc_change_joybutton(*this, event, mitems[citem]);
 			break;
 #endif
 
 #if DXX_MAX_AXES_PER_JOYSTICK
-		case EVENT_JOYSTICK_MOVED:
+		case event_type::joystick_moved:
 			if (changing && items[citem].type == kc_type::joy_axis)
 				kc_change_joyaxis(*this, event, mitems[citem]);
 			else
@@ -760,7 +757,7 @@ window_event_result kc_menu::event_handler(const d_event &event)
 			break;
 #endif
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 		{
 			window_event_result rval = kconfig_key_command(*this, event);
 			if (rval != window_event_result::ignored)
@@ -770,19 +767,17 @@ window_event_result kc_menu::event_handler(const d_event &event)
 			return window_event_result::ignored;
 		}
 
-		case EVENT_IDLE:
+		case event_type::idle:
 			kconfig_mouse(*this, event);
 			break;
-			
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			if (changing)
 				timer_delay(f0_1/10);
 			else
 				timer_delay2(50);
 			kconfig_draw(*this);
 			break;
-			
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			// Update save values...
 			for (auto &&[kcm, setting] : zip(kcm_keyboard, PlayerCfg.KeySettings.Keyboard))
 				setting = kcm.value;
@@ -885,7 +880,7 @@ static void kc_change_key( kc_menu &menu,const d_event &event, kc_mitem &mitem )
 {
 	ubyte keycode = 255;
 
-	Assert(event.type == EVENT_KEY_COMMAND);
+	assert(event.type == event_type::key_command);
 	keycode = event_key_get_raw(event);
 
 	auto e = end(system_keys);
@@ -903,7 +898,7 @@ static void kc_change_joybutton( kc_menu &menu,const d_event &event, kc_mitem &m
 {
 	int button = 255;
 
-	Assert(event.type == EVENT_JOYSTICK_BUTTON_DOWN);
+	assert(event.type == event_type::joystick_button_down);
 	button = event_joystick_get_button(event);
 
 	kc_set_exclusive_binding(menu, mitem, kc_type::joy_button, button);
@@ -933,10 +928,8 @@ static void kc_change_joyaxis( kc_menu &menu,const d_event &event, kc_mitem &mit
 
 static void kc_change_mouseaxis( kc_menu &menu,const d_event &event, kc_mitem &mitem )
 {
-	int dx, dy, dz;
-
-	Assert(event.type == EVENT_MOUSE_MOVED);
-	event_mouse_get_delta( event, &dx, &dy, &dz );
+	assert(event.type == event_type::mouse_moved);
+	const auto [dx, dy, dz] = event_mouse_get_delta(event);
 	uint8_t code;
 	if (abs(dz) > 5)
 		code = 2;
@@ -1116,8 +1109,8 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
-		case EVENT_KEY_RELEASE:
+		case event_type::key_command:
+		case event_type::key_release:
 			{
 				const auto &&key = event_key_get_raw(event);
 				if (key < 255)
@@ -1125,9 +1118,9 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 					for (auto &&[kc, kcm] : zip(kc_keyboard, kcm_keyboard))
 					{
 						if (kcm.value == key)
-							input_button_matched(Controls, kc, event.type == EVENT_KEY_COMMAND);
+							input_button_matched(Controls, kc, event.type == event_type::key_command);
 					}
-			if (!automap_flag && event.type == EVENT_KEY_COMMAND)
+			if (!automap_flag && event.type == event_type::key_command)
 				for (uint_fast32_t i = 0, j = 0; i < 28; i += 3, j++)
 					if (kcm_rebirth[i].value == key)
 					{
@@ -1138,8 +1131,8 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			}
 			break;
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
-		case EVENT_JOYSTICK_BUTTON_UP:
+		case event_type::joystick_button_down:
+		case event_type::joystick_button_up:
 			if (!(PlayerCfg.ControlType & CONTROL_USING_JOYSTICK))
 				break;
 			{
@@ -1149,9 +1142,9 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 					for (auto &&[kc, kcm] : zip(kc_joystick, kcm_joystick))
 					{
 						if (kc.type == kc_type::joy_button && kcm.value == button)
-							input_button_matched(Controls, kc, event.type == EVENT_JOYSTICK_BUTTON_DOWN);
+							input_button_matched(Controls, kc, event.type == event_type::joystick_button_down);
 					}
-			if (!automap_flag && event.type == EVENT_JOYSTICK_BUTTON_DOWN)
+			if (!automap_flag && event.type == event_type::joystick_button_down)
 				for (uint_fast32_t i = 1, j = 0; i < 29; i += 3, j++)
 					if (kcm_rebirth[i].value == button)
 					{
@@ -1162,8 +1155,8 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			break;
 			}
 #endif
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 			if (!(PlayerCfg.ControlType & CONTROL_USING_MOUSE))
 				break;
 			{
@@ -1172,9 +1165,9 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 					for (auto &&[kc, kcm] : zip(kc_mouse, kcm_mouse))
 					{
 						if (kc.type == kc_type::mouse_button && kcm.value == button)
-							input_button_matched(Controls, kc, event.type == EVENT_MOUSE_BUTTON_DOWN);
+							input_button_matched(Controls, kc, event.type == event_type::mouse_button_down);
 					}
-			if (!automap_flag && event.type == EVENT_MOUSE_BUTTON_DOWN)
+			if (!automap_flag && event.type == event_type::mouse_button_down)
 				for (uint_fast32_t i = 2, j = 0; i < 30; i += 3, j++)
 					if (kcm_rebirth[i].value == button)
 					{
@@ -1184,7 +1177,7 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			}
 			break;
 #if DXX_MAX_AXES_PER_JOYSTICK
-		case EVENT_JOYSTICK_MOVED:
+		case event_type::joystick_moved:
 		{
 			int joy_null_value = 0;
 			if (!(PlayerCfg.ControlType & CONTROL_USING_JOYSTICK))
@@ -1214,14 +1207,13 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			break;
 		}
 #endif
-		case EVENT_MOUSE_MOVED:
+		case event_type::mouse_moved:
 		{
 			if (!(PlayerCfg.ControlType & CONTROL_USING_MOUSE))
 				break;
 			if (PlayerCfg.MouseFlightSim)
 			{
-				int ax[3];
-				event_mouse_get_delta( event, &ax[0], &ax[1], &ax[2] );
+				const auto ax{event_mouse_get_delta(event)};
 				for (uint_fast32_t i = 0; i <= 2; i++)
 				{
 					int mouse_null_value = (i==2?16:PlayerCfg.MouseFSDead*8);
@@ -1237,7 +1229,7 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			}
 			else
 			{
-				event_mouse_get_delta( event, &Controls.raw_mouse_axis[0], &Controls.raw_mouse_axis[1], &Controls.raw_mouse_axis[2] );
+				Controls.raw_mouse_axis = event_mouse_get_delta(event);
 				Controls.mouse_axis[0] = (Controls.raw_mouse_axis[0] * frametime) / 8;
 				Controls.mouse_axis[1] = (Controls.raw_mouse_axis[1] * frametime) / 8;
 				Controls.mouse_axis[2] = (Controls.raw_mouse_axis[2] * frametime);
@@ -1245,7 +1237,7 @@ void kconfig_read_controls(control_info &Controls, const d_event &event, int aut
 			}
 			break;
 		}
-		case EVENT_IDLE:
+		case event_type::idle:
 		default:
 			if (!PlayerCfg.MouseFlightSim && mouse_delta_time < timer_query())
 			{
diff --git a/similar/main/kmatrix.cpp b/similar/main/kmatrix.cpp
index fcb6158a4..336666b5d 100644
--- a/similar/main/kmatrix.cpp
+++ b/similar/main/kmatrix.cpp
@@ -326,10 +326,9 @@ window_event_result kmatrix_window::event_handler(const d_event &event)
 {
 	auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;
 	int k = 0;
-	
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			k = event_key_get(event);
 			switch( k )
 			{
@@ -365,8 +364,7 @@ window_event_result kmatrix_window::event_handler(const d_event &event)
 					break;
 			}
 			break;
-			
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			{
 			timer_delay2(50);
 			gr_set_default_canvas();
@@ -427,12 +425,10 @@ window_event_result kmatrix_window::event_handler(const d_event &event)
 			kmatrix_status_msg(*grd_curcanv, playing == kmatrix_status_mode::reactor_countdown_running ? LevelUniqueControlCenterState.Countdown_seconds_left : f2i(end_time - timer_query()), playing);
 			break;
 			}
-			
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			game_flush_inputs(Controls);
 			newmenu_free_background();
 			break;
-			
 		default:
 			break;
 	}
diff --git a/similar/main/laser.cpp b/similar/main/laser.cpp
index bd10a5eaa..612662680 100644
--- a/similar/main/laser.cpp
+++ b/similar/main/laser.cpp
@@ -1921,7 +1921,7 @@ void do_laser_firing_player(object &plrobj)
 			}
 		} else {
 #if defined(DXX_BUILD_DESCENT_II)
-			Next_laser_fire_time = GameTime64;	//	Prevents shots-to-fire from building up.
+			Next_laser_fire_time = {GameTime64};	//	Prevents shots-to-fire from building up.
 #endif
 			break;	//	Couldn't fire weapon, so abort.
 		}
diff --git a/similar/main/menu.cpp b/similar/main/menu.cpp
index 2b97f39ab..c372b32e3 100644
--- a/similar/main/menu.cpp
+++ b/similar/main/menu.cpp
@@ -343,7 +343,7 @@ int hide_menus(void)
 }
 
 // Show all menus, with the front one shown first
-// This makes sure EVENT_WINDOW_ACTIVATED is only sent to that window
+// This makes sure event_type::window_activated is only sent to that window
 void show_menus(void)
 {
 	range_for (auto &i, menus)
@@ -518,9 +518,9 @@ window_event_result pilot_selection_listbox::callback_handler(const d_event &eve
 {
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			return player_menu_keycommand(this, event);
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			if (citem < 0)
@@ -539,7 +539,7 @@ window_event_result pilot_selection_listbox::callback_handler(const d_event &eve
 			return window_event_result::close;
 		}
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			if (read_player_file() != EZERO)
 				return window_event_result::handled;		// abort close!
 
@@ -740,32 +740,32 @@ window_event_result main_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			if (InterfaceUniqueState.PilotName[0u])
 				break;
 			RegisterPlayer();
 			break;
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 #if defined(DXX_BUILD_DESCENT_II)
 			load_palette(MENU_PALETTE, load_palette_use::background, load_palette_change_screen::delayed);		//get correct palette
 #endif
 			keyd_time_when_last_pressed = timer_query();		// .. 20 seconds from now!
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			// Don't allow them to hit ESC in the main menu.
 			if (event_key_get(event)==KEY_ESC)
 				return window_event_result::ignored;
 			break;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 			// Don't allow mousebutton-closing in main menu.
 			if (event_mouse_get_button(event) == mbtn::right)
 				return window_event_result::ignored;
 			break;
 
-		case EVENT_IDLE:
+		case event_type::idle:
 #if defined(DXX_BUILD_DESCENT_I)
 #define DXX_DEMO_KEY_DELAY	45
 #elif defined(DXX_BUILD_DESCENT_II)
@@ -794,11 +794,11 @@ window_event_result main_menu::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_NEWMENU_DRAW:
+		case event_type::newmenu_draw:
 			draw_copyright(parent_canvas, *GAME_FONT);
 			break;
 
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			return dispatch_menu_option(static_cast<main_menu_item_index>(citem));
@@ -895,9 +895,9 @@ window_event_result demo_selection_listbox::callback_handler(const d_event &even
 {
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			return demo_menu_keycommand(this, event);
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			if (citem < 0)
@@ -905,7 +905,7 @@ window_event_result demo_selection_listbox::callback_handler(const d_event &even
 			newdemo_start_playback(item[citem]);
 			return window_event_result::handled;		// stay in demo selector
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
@@ -1076,7 +1076,7 @@ window_event_result options_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			switch (citem)
@@ -1097,7 +1097,7 @@ window_event_result options_menu::event_handler(const d_event &event)
 			return window_event_result::handled;	// stay in menu until escape
 		}
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			write_player_file();
 			break;
 
@@ -1219,7 +1219,7 @@ window_event_result screen_resolution_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			handle_close_event();
 			return window_event_result::ignored;
 		default:
@@ -1347,8 +1347,8 @@ void screen_resolution_menu::apply_resolution(const screen_mode new_mode) const
 		Game_screen_mode = new_mode;
 		if (const auto g = Game_wind) // shortly activate Game_wind so it's canvas will align to new resolution. really minor glitch but whatever
 		{
-			g->send_event(d_event{EVENT_WINDOW_ACTIVATED});
-			g->send_event(d_event{EVENT_WINDOW_DEACTIVATED});
+			g->send_event(d_event{event_type::window_activated});
+			g->send_event(d_event{event_type::window_deactivated});
 		}
 	}
 	game_init_render_sub_buffers(*grd_curcanv, 0, 0, SM_W(Game_screen_mode), SM_H(Game_screen_mode));
@@ -1418,7 +1418,7 @@ window_event_result menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			copy_sensitivity_from_menu_to_cfg(m, copy_sensitivity<opt_label_kb, &player_config::KeyboardSens>());
 			break;
 		default:
@@ -1489,7 +1489,7 @@ window_event_result menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			PlayerCfg.MouseFSDead = m[opt_mfsd_deadzone].value;
 			copy_sensitivity_from_menu_to_cfg(m,
 				copy_sensitivity<opt_label_ms, &player_config::MouseSens>(),
@@ -1556,7 +1556,7 @@ window_event_result menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			copy_sensitivity_from_menu_to_cfg(m,
 				copy_sensitivity<opt_label_js, &player_config::JoystickSens>(),
 				copy_sensitivity<opt_label_jl, &player_config::JoystickLinear>(),
@@ -1673,7 +1673,7 @@ window_event_result input_config_menu::event_handler(const d_event &event)
 	const auto &items = m;
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_CHANGED:
+		case event_type::newmenu_changed:
 		{
 			const auto citem = static_cast<const d_change_event &>(event).citem;
 			MouselookMode mousemode;
@@ -1728,7 +1728,7 @@ window_event_result input_config_menu::event_handler(const d_event &event)
 
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			const auto citem = static_cast<const d_select_event &>(event).citem;
 			if (citem == opt_ic_confkey)
@@ -1833,7 +1833,7 @@ window_event_result reticle_config_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			for (uint_fast32_t i = opt_reticle_classic; i != opt_label_blank_reticle_type; ++i)
 				if (m[i].value)
 				{
@@ -1901,7 +1901,7 @@ window_event_result hud_style_config_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 		{
 			const auto new_mode = m[opt_viewstyle_cockpit].value
 				? cockpit_mode_t::full_cockpit
@@ -1984,7 +1984,7 @@ window_event_result hud_config_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
                         if (citem == opt_hud_reticlemenu)
@@ -1993,7 +1993,7 @@ window_event_result hud_config_menu::event_handler(const d_event &event)
                                 hud_style_config();
 			return window_event_result::handled;		// stay in menu
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			DSX_HUD_MENU_OPTIONS(READ);
 #if defined(DXX_BUILD_DESCENT_II)
 			PlayerCfg.MissileViewEnabled = m[opt_missileview_selfandallies].value
@@ -2084,7 +2084,7 @@ window_event_result graphics_config_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_CHANGED:
+		case event_type::newmenu_changed:
 		{
 			auto &citem = static_cast<const d_change_event &>(event).citem;
 			if (citem == opt_gr_brightness)
@@ -2098,7 +2098,7 @@ window_event_result graphics_config_menu::event_handler(const d_event &event)
 #endif
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			if (citem == opt_gr_screenres)
@@ -2107,7 +2107,7 @@ window_event_result graphics_config_menu::event_handler(const d_event &event)
 				hud_config();
 			return window_event_result::handled;		// stay in menu
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 #if DXX_USE_OGL
 			if (CGameCfg.VSync != m[opt_gr_vsync].value || CGameCfg.Multisample != m[opt_gr_multisample].value)
 			{
@@ -2261,7 +2261,7 @@ window_event_result browser::callback_handler(const d_event &event, window_event
 	switch (event.type)
 	{
 #ifdef _WIN32
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 		{
 			if (event_key_get(event) == KEY_CTRLED + KEY_D)
 			{
@@ -2291,7 +2291,7 @@ window_event_result browser::callback_handler(const d_event &event, window_event
 			break;
 		}
 #endif
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			auto newpath = view_path.path;
@@ -2356,7 +2356,7 @@ window_event_result browser::callback_handler(const d_event &event, window_event
 			}
 			return get_absolute_path(userdata, list[citem]);
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
@@ -2578,7 +2578,7 @@ window_event_result sound_menu::event_handler(const d_event &event)
 	int replay = 0;
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_CHANGED:
+		case event_type::newmenu_changed:
 		{
 			auto &citem = static_cast<const d_change_event &>(event).citem;
 			if (citem == opt_sm_digivol)
@@ -2653,7 +2653,7 @@ window_event_result sound_menu::event_handler(const d_event &event)
 #endif
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 #if DXX_USE_SDLMIXER
 			auto &citem = static_cast<const d_select_event &>(event).citem;
@@ -2683,7 +2683,7 @@ window_event_result sound_menu::event_handler(const d_event &event)
 #endif
 			return window_event_result::handled;	// stay in menu
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 #if DXX_USE_SDLMIXER
 			if (strcmp(old_music.data(), current_music.data()))
 			{
@@ -2780,7 +2780,7 @@ window_event_result gameplay_config_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
                         if (citem == opt_gameplay_reorderprimary_menu)
@@ -2789,7 +2789,7 @@ window_event_result gameplay_config_menu::event_handler(const d_event &event)
                                 ReorderSecondary();
 			return window_event_result::handled;		// stay in menu
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 #if defined(DXX_BUILD_DESCENT_II)
 				uint8_t thief_absent;
@@ -2827,7 +2827,7 @@ window_event_result netgame_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			// stay in multiplayer menu, even after having played a game
@@ -2884,13 +2884,13 @@ window_event_result polygon_models_viewer_window::event_handler(const d_event &e
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 #if defined(DXX_BUILD_DESCENT_II)
 			gr_use_palette_table("groupa.256");
 #endif
 			key_toggle_repeat(1);
 			break;
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			key = event_key_get(event);
 			switch (key)
 			{
@@ -2939,7 +2939,7 @@ window_event_result polygon_models_viewer_window::event_handler(const d_event &e
 					break;
 			}
 			return window_event_result::handled;
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			timer_delay(F1_0/60);
 			{
 				auto &canvas = *grd_curcanv;
@@ -2950,7 +2950,7 @@ window_event_result polygon_models_viewer_window::event_handler(const d_event &e
 				gr_printf(canvas, game_font, FSPACX(1), FSPACY(1), "ESC: leave\nSPACE/BACKSP: next/prev model (%i/%i)\nA/D: rotate y\nW/S: rotate x\nQ/E: rotate z\nR: reset orientation", underlying_value(view_idx), LevelSharedPolygonModelState.N_polygon_models - 1);
 			}
 			break;
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 #if defined(DXX_BUILD_DESCENT_II)
 			load_palette(MENU_PALETTE, load_palette_use::background, load_palette_change_screen::delayed);
 #endif
@@ -2977,13 +2977,13 @@ window_event_result gamebitmaps_viewer_window::event_handler(const d_event &even
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 #if defined(DXX_BUILD_DESCENT_II)
 			gr_use_palette_table("groupa.256");
 #endif
 			key_toggle_repeat(1);
 			break;
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			key = event_key_get(event);
 			switch (key)
 			{
@@ -3002,7 +3002,7 @@ window_event_result gamebitmaps_viewer_window::event_handler(const d_event &even
 					break;
 			}
 			return window_event_result::handled;
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			{
 				const bitmap_index bi{view_idx};
 				grs_bitmap *const bm = &GameBitmaps[bi];
@@ -3021,7 +3021,7 @@ window_event_result gamebitmaps_viewer_window::event_handler(const d_event &even
 				gr_printf(canvas, game_font, FSPACX(1), FSPACY(1), "ESC: leave\nSPACE/BACKSP: next/prev bitmap (%i/%i)", view_idx, Num_bitmap_files-1);
 			}
 			break;
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 #if defined(DXX_BUILD_DESCENT_II)
 			load_palette(MENU_PALETTE, load_palette_use::background, load_palette_change_screen::delayed);
 #endif
@@ -3071,7 +3071,7 @@ window_event_result sandbox_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			switch (citem)
diff --git a/similar/main/mission.cpp b/similar/main/mission.cpp
index d4ba9ce9b..084dc92f3 100644
--- a/similar/main/mission.cpp
+++ b/similar/main/mission.cpp
@@ -139,9 +139,9 @@ struct mission_subdir_stats
 struct mission_name_and_version
 {
 #if defined(DXX_BUILD_DESCENT_II)
-	const Mission::descent_version_type descent_version = {};
+	const Mission::descent_version_type descent_version{};
 #endif
-	char *const name = nullptr;
+	char *const name{};
 	mission_name_and_version() = default;
 	mission_name_and_version(Mission::descent_version_type, char *);
 };
@@ -566,9 +566,8 @@ static int read_mission_file(mission_list_type &mission_list, mission_candidate_
 		{
 			if (istok(temp,"type"))
 			{
-				const auto p = get_value(temp);
 				//get mission type
-				if (p)
+				if (const auto p = get_value(temp))
 					mission->anarchy_only_flag = istok(p, "anarchy") ? Mission::anarchy_only_level::only_anarchy_games : Mission::anarchy_only_level::allow_any_game;
 			}
 		}
@@ -1326,9 +1325,9 @@ window_event_result mission_menu::callback_handler(const d_event &event, window_
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CREATED:
+		case event_type::window_created:
 			break;
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			const auto raw_citem = static_cast<const d_select_event &>(event).citem;
 			auto citem = raw_citem;
@@ -1338,7 +1337,7 @@ window_event_result mission_menu::callback_handler(const d_event &event, window_
 				{
 					/* Clear parent pointer so that the parent window is
 					 * not implicitly closed during handling of
-					 * EVENT_WINDOW_CLOSE.
+					 * event_type::window_close.
 					 */
 					parent = nullptr;
 					return window_event_result::close;
@@ -1375,7 +1374,7 @@ window_event_result mission_menu::callback_handler(const d_event &event, window_
 			}
 			return (*when_selected)();
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			/* If the user dismisses the listbox by pressing ESCAPE,
 			 * do not close the parent listbox.
 			 */
diff --git a/similar/main/multi.cpp b/similar/main/multi.cpp
index 2325ea335..0487caff6 100644
--- a/similar/main/multi.cpp
+++ b/similar/main/multi.cpp
@@ -2105,7 +2105,7 @@ static void multi_do_cloak(fvmobjptr &vmobjptr, const playernum_t pnum)
 	const auto &&objp = vmobjptr(vcplayerptr(pnum)->objnum);
 	auto &player_info = objp->ctype.player_info;
 	player_info.powerup_flags |= PLAYER_FLAGS_CLOAKED;
-	player_info.cloak_time = GameTime64;
+	player_info.cloak_time = {GameTime64};
 	ai_do_cloak_stuff();
 
 	multi_strip_robots(pnum);
diff --git a/similar/main/multibot.cpp b/similar/main/multibot.cpp
index ead3b7216..edd1b6884 100644
--- a/similar/main/multibot.cpp
+++ b/similar/main/multibot.cpp
@@ -142,7 +142,7 @@ int multi_can_move_robot(const vmobjptridx_t objnum, int agitation)
 		}
 		else {
 			robot_agitation[slot_num] = agitation;
-			robot_last_message_time[slot_num] = GameTime64;
+			robot_last_message_time[slot_num] = {GameTime64};
 			return 1;
 		}
 	}
@@ -168,7 +168,7 @@ void multi_check_robot_timeout()
 
 	if (GameTime64 > lastcheck + F1_0 || lastcheck > GameTime64)
 	{
-		lastcheck = GameTime64;
+		lastcheck = {GameTime64};
 		for (i = 0; i < MAX_ROBOTS_CONTROLLED; i++) 
 		{
 			if (robot_controlled[i] != object_none && robot_last_send_time[i] + ROBOT_TIMEOUT < GameTime64)
@@ -322,8 +322,8 @@ int multi_add_controlled_robot(const vmobjptridx_t objnum, int agitation)
 	robot_agitation[i] = agitation;
 	objrobot.ctype.ai_info.REMOTE_OWNER = Player_num;
 	objrobot.ctype.ai_info.REMOTE_SLOT_NUM = i;
-	robot_controlled_time[i] = GameTime64;
-	robot_last_send_time[i] = robot_last_message_time[i] = GameTime64;
+	robot_controlled_time[i] = {GameTime64};
+	robot_last_send_time[i] = robot_last_message_time[i] = {GameTime64};
 	return(1);
 }	
 
@@ -512,7 +512,7 @@ void multi_send_robot_position(object &obj, const multi_send_robot_position_prio
 //	Objects[objnum].phys_info.drag = Robot_info[Objects[objnum].id].drag; // Set drag to normal
 
 	const auto slot = obj.ctype.ai_info.REMOTE_SLOT_NUM;
-	robot_last_send_time[slot] = GameTime64;
+	robot_last_send_time[slot] = {GameTime64};
 	robot_send_pending[slot] = force;
 	return;
 }
@@ -1131,7 +1131,7 @@ void multi_do_boss_teleport(const d_robot_info_array &Robot_info, const d_vclip_
 	auto &vcvertptr = Vertices.vcptr;
 	compute_segment_center(vcvertptr, boss_obj->pos, teleport_segnum);
 	obj_relink(vmobjptr, vmsegptr, boss_obj, teleport_segnum);
-	BossUniqueState.Last_teleport_time = GameTime64;
+	BossUniqueState.Last_teleport_time = {GameTime64};
 
 	const auto boss_dir = vm_vec_sub(vcobjptr(vcplayerptr(pnum)->objnum)->pos, boss_obj->pos);
 	vm_vector_2_matrix(boss_obj->orient, boss_dir, nullptr, nullptr);
@@ -1172,7 +1172,7 @@ void multi_do_boss_cloak(const multiplayer_rspan<multiplayer_command_t::MULTI_BO
 #if defined(DXX_BUILD_DESCENT_II)
 	BossUniqueState.Boss_hit_time = -F1_0*10;
 #endif
-	BossUniqueState.Boss_cloak_start_time = GameTime64;
+	BossUniqueState.Boss_cloak_start_time = {GameTime64};
 	boss_obj->ctype.ai_info.CLOAKED = 1;
 }
 
diff --git a/similar/main/net_udp.cpp b/similar/main/net_udp.cpp
index 97bbd0ef1..54cbf9fa8 100644
--- a/similar/main/net_udp.cpp
+++ b/similar/main/net_udp.cpp
@@ -302,7 +302,7 @@ window_event_result net_udp_select_teams_menu::event_handler(const d_event &even
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 			{
 				const auto citem = static_cast<const d_select_event &>(event).citem;
 				if (citem == idx_item_accept)
@@ -358,7 +358,7 @@ window_event_result net_udp_select_teams_menu::event_handler(const d_event &even
 					-- this->citem;
 			}
 			return window_event_result::handled;
-		case EVENT_NEWMENU_DRAW:
+		case event_type::newmenu_draw:
 			{
 				const auto draw_team_color_box = [&canv = this->w_canv](const newmenu_item &mi, const color_palette_index cpi) {
 					const unsigned height = mi.h - 8;
@@ -1273,7 +1273,7 @@ struct netgame_list_game_menu : netgame_list_game_menu_items, direct_join, newme
 {
 	unsigned num_active_udp_games = 0;
 	uint8_t num_active_udp_changed = 1;
-	std::array<UDP_netgame_info_lite, UDP_MAX_NETGAMES> Active_udp_games = {};
+	std::array<UDP_netgame_info_lite, UDP_MAX_NETGAMES> Active_udp_games{};
 	netgame_list_game_menu(grs_canvas &src) :
 		newmenu(menu_title{"NETGAMES"}, menu_subtitle{nullptr}, menu_filename{nullptr}, tiny_mode_flag::tiny, tab_processing_flag::process, adjusted_citem::create(menus, 0), src)
 	{
@@ -1381,7 +1381,7 @@ window_event_result manual_join_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			if (connecting != direct_join::connect_type::idle && event_key_get(event) == KEY_ESC)
 			{
 				connecting = direct_join::connect_type::idle;
@@ -1389,8 +1389,7 @@ window_event_result manual_join_menu::event_handler(const d_event &event)
 				return window_event_result::handled;
 			}
 			break;
-			
-		case EVENT_IDLE:
+		case event_type::idle:
 			if (connecting != direct_join::connect_type::idle)
 			{
 				if (net_udp_game_connect(this))
@@ -1400,7 +1399,7 @@ window_event_result manual_join_menu::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			int sockres = -1;
 
@@ -1431,12 +1430,10 @@ window_event_result manual_join_menu::event_handler(const d_event &event)
 				return window_event_result::handled;
 			}
 		}
-			
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			if (!Game_wind) // they cancelled
 				net_udp_close();
 			break;
-			
 		default:
 			break;
 	}
@@ -1492,7 +1489,7 @@ window_event_result netgame_list_game_menu::event_handler(const d_event &event)
 	static int NLPage = 0;
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 		{
 			Netgame.protocol.udp.valid = 0;
 			Active_udp_games = {};
@@ -1509,7 +1506,7 @@ window_event_result netgame_list_game_menu::event_handler(const d_event &event)
 				nm_set_item_text(menus[UDP_NETGAMES_PPAGE+4], "\t");
 			break;
 		}
-		case EVENT_IDLE:
+		case event_type::idle:
 			if (connecting != direct_join::connect_type::idle)
 			{
 				if (net_udp_game_connect(this))
@@ -1518,7 +1515,7 @@ window_event_result netgame_list_game_menu::event_handler(const d_event &event)
 					nm_set_item_text(menus[UDP_NETGAMES_PPAGE+4], "\t");
 			}
 			break;
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 		{
 			int key = event_key_get(event);
 			if (key == KEY_PAGEUP)
@@ -1597,7 +1594,7 @@ window_event_result netgame_list_game_menu::event_handler(const d_event &event)
 			}
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			if (((citem+(NLPage*UDP_NETGAMES_PPAGE)) >= 4) && (((citem+(NLPage*UDP_NETGAMES_PPAGE))-3) <= num_active_udp_games))
@@ -1622,7 +1619,7 @@ window_event_result netgame_list_game_menu::event_handler(const d_event &event)
 			}
 			return window_event_result::handled;
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 		{
 			if (!Game_wind)
 			{
@@ -3663,7 +3660,7 @@ static int net_udp_sync_poll( newmenu *,const d_event &event, const unused_newme
 	static fix64 t1 = 0;
 	int rval = 0;
 
-	if (event.type != EVENT_WINDOW_DRAW)
+	if (event.type != event_type::window_draw)
 		return 0;
 	net_udp_listen();
 
@@ -3690,7 +3687,7 @@ static int net_udp_sync_poll( newmenu *,const d_event &event, const unused_newme
 
 static int net_udp_start_poll(newmenu *, const d_event &event, start_poll_menu_items *const items)
 {
-	if (event.type != EVENT_WINDOW_DRAW)
+	if (event.type != event_type::window_draw)
 		return 0;
 	assert(Network_status == network_state::starting);
 
@@ -3868,7 +3865,7 @@ window_event_result netgame_powerups_allowed_menu::event_handler(const d_event &
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 				typename std::underlying_type<netflag_flag>::type AllowedItems = 0;
 				for (auto &&[i, mi] : enumerate(m))
@@ -4159,7 +4156,7 @@ window_event_result grant_powerup_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			read(Netgame.SpawnGrantedItems);
 			break;
 		default:
@@ -4185,7 +4182,7 @@ window_event_result more_game_options_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_CHANGED:
+		case event_type::newmenu_changed:
 		{
 			auto &citem = static_cast<const d_change_event &>(event).citem;
 			auto &menus = m;
@@ -4247,7 +4244,7 @@ window_event_result more_game_options_menu::event_handler(const d_event &event)
 			}
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			if (citem == opt_setpower)
@@ -4258,7 +4255,7 @@ window_event_result more_game_options_menu::event_handler(const d_event &event)
 				break;
 			return window_event_result::handled;
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			read();
 			if (Netgame.PacketsPerSec > MAX_PPS)
 			{
@@ -4312,7 +4309,7 @@ static int net_udp_game_param_handler( newmenu *menu,const d_event &event, param
 	newmenu_item *menus = newmenu_get_items(menu);
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_CHANGED:
+		case event_type::newmenu_changed:
 		{
 			auto &citem = static_cast<const d_change_event &>(event).citem;
 #if defined(DXX_BUILD_DESCENT_I)
@@ -4391,7 +4388,7 @@ static int net_udp_game_param_handler( newmenu *menu,const d_event &event, param
 			Netgame.RefusePlayers=menus[opt->refuse].value;
 			break;
 		}
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 #if defined(DXX_BUILD_DESCENT_I)
@@ -5006,7 +5003,7 @@ static int net_udp_request_poll( newmenu *,const d_event &event, const unused_ne
 	// Polling loop for waiting-for-requests menu
 	int num_ready = 0;
 
-	if (event.type != EVENT_WINDOW_DRAW)
+	if (event.type != event_type::window_draw)
 		return 0;
 	net_udp_listen();
 	net_udp_timeout_check(timer_query());
@@ -6376,7 +6373,7 @@ window_event_result show_game_info_menu::event_handler(const d_event &event)
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 		{
 			auto &citem = static_cast<const d_select_event &>(event).citem;
 			switch (citem)
@@ -6535,7 +6532,7 @@ static int udp_tracker_register()
 	game_info_light light;
 	std::size_t len = 1;
 	const auto light_span = net_udp_prepare_light_game_info(LevelUniqueObjectState.ControlCenterState, Netgame, light.buf);
-	std::array<uint8_t, 2 + sizeof("b=") + sizeof(UDP_REQ_ID) + sizeof("00000.00000.00000.00000,z=") + upid_length<upid::game_info_lite>> pBuf = {};
+	std::array<uint8_t, 2 + sizeof("b=") + sizeof(UDP_REQ_ID) + sizeof("00000.00000.00000.00000,z=") + upid_length<upid::game_info_lite>> pBuf{};
 
 	pBuf[0] = UPID_TRACKER_REGISTER;
 	len += snprintf(reinterpret_cast<char *>(&pBuf[1]), sizeof(pBuf)-1, "b=" UDP_REQ_ID DXX_VERSION_STR ".%hu,z=", MULTI_PROTO_VERSION );
@@ -6547,7 +6544,7 @@ static int udp_tracker_register()
 /* Ask the tracker to send us a list of games */
 static int udp_tracker_reqgames()
 {
-	std::array<uint8_t, 2 + sizeof(UDP_REQ_ID) + sizeof("00000.00000.00000.00000")> pBuf = {};
+	std::array<uint8_t, 2 + sizeof(UDP_REQ_ID) + sizeof("00000.00000.00000.00000")> pBuf{};
 	unsigned len = 1;
 
 	pBuf[0] = UPID_TRACKER_REQGAMES;
@@ -6568,7 +6565,7 @@ static int udp_tracker_process_game(const std::span<const uint8_t> buf, const _s
 		return -1;
 
 	const char *p0 = NULL, *p1 = NULL, *p3 = NULL;
-	char sIP[47] = {};
+	char sIP[47]{};
 	std::array<char, 6> sPort{};
 	uint16_t iPort = 0;
 
diff --git a/similar/main/newdemo.cpp b/similar/main/newdemo.cpp
index a7a7bf8e5..80758bb03 100644
--- a/similar/main/newdemo.cpp
+++ b/similar/main/newdemo.cpp
@@ -1794,7 +1794,7 @@ static int newdemo_read_demo_start(const purpose_type purpose)
 		nd_write_int(underlying_value(Newdemo_game_mode));
 	}
 
-	BossUniqueState.Boss_cloak_start_time = GameTime64;
+	BossUniqueState.Boss_cloak_start_time = {GameTime64};
 #endif
 
 	change_playernum_to((recorded_demo_game_mode >> 16) & 0x7);
diff --git a/similar/main/newmenu.cpp b/similar/main/newmenu.cpp
index 72fe8dfa3..6fcf074cb 100644
--- a/similar/main/newmenu.cpp
+++ b/similar/main/newmenu.cpp
@@ -539,7 +539,7 @@ int newmenu::process_until_closed(newmenu *const menu)
 	// Track to see when the window is freed
 	// Doing this way in case another window is opened on top without its own polling loop
 	// newmenu_do2 and simpler get their own event loop
-	// This is so the caller doesn't have to provide a callback that responds to EVENT_NEWMENU_SELECTED
+	// This is so the caller doesn't have to provide a callback that responds to event_type::newmenu_selected
 	for (const auto exists = menu->track(); *exists;)
 		event_process();
 
@@ -831,7 +831,7 @@ static void check_apply_mouse_scroll(newmenu *const menu, const grs_canvas &canv
 
 static window_event_result newmenu_mouse(const d_event &event, newmenu *menu, const mbtn button)
 {
-	int old_choice, mx=0, my=0, mz=0, x1 = 0, x2, y1, y2, changed = 0;
+	int old_choice, x1 = 0, x2, y1, y2, changed = 0;
 	grs_canvas &menu_canvas = menu->w_canv;
 
 	switch (button)
@@ -843,9 +843,9 @@ static window_event_result newmenu_mouse(const d_event &event, newmenu *menu, co
 			old_choice = menu->citem;
 
 			const auto &&fspacx = FSPACX();
-			if ((event.type == EVENT_MOUSE_BUTTON_DOWN) && !menu->all_text)
+			if (event.type == event_type::mouse_button_down && !menu->all_text)
 			{
-				mouse_get_pos(&mx, &my, &mz);
+				const auto [mx, my, mz] = mouse_get_pos();
 				const int line_spacing = static_cast<int>(LINE_SPACING(*canvas.cv_font, *GAME_FONT));
 				for (int i = menu->scroll_offset; i < menu->max_on_menu + menu->scroll_offset; ++i)
 				{
@@ -883,8 +883,7 @@ static window_event_result newmenu_mouse(const d_event &event, newmenu *menu, co
 			}
 
 			if ( menu->mouse_state ) {
-				mouse_get_pos(&mx, &my, &mz);
-
+				const auto [mx, my, mz] = mouse_get_pos();
 				// check possible scrollbar stuff first
 				const int line_spacing = static_cast<int>(LINE_SPACING(*canvas.cv_font, *GAME_FONT));
 				if (menu->is_scroll_box) {
@@ -956,12 +955,12 @@ static window_event_result newmenu_mouse(const d_event &event, newmenu *menu, co
 				}
 			}
 
-			if (event.type == EVENT_MOUSE_BUTTON_UP &&
+			if (event.type == event_type::mouse_button_up &&
 				!menu->all_text &&
 				menu->citem != -1 &&
 				std::next(menu->items.begin(), menu->citem)->type == nm_type::menu)
 			{
-				mouse_get_pos(&mx, &my, &mz);
+				const auto [mx, my, mz] = mouse_get_pos();
 				const int line_spacing = static_cast<int>(LINE_SPACING(*canvas.cv_font, *GAME_FONT));
 				for (int i = menu->scroll_offset; i < menu->max_on_menu + menu->scroll_offset; ++i)
 				{
@@ -982,7 +981,7 @@ static window_event_result newmenu_mouse(const d_event &event, newmenu *menu, co
 				}
 			}
 
-			if (event.type == EVENT_MOUSE_BUTTON_UP && menu->citem > -1)
+			if (event.type == event_type::mouse_button_up && menu->citem > -1)
 			{
 				auto &citem = *std::next(menu->items.begin(), menu->citem);
 				if (citem.type == nm_type::input_menu && citem.imenu().group == 0)
@@ -1179,7 +1178,7 @@ static window_event_result newmenu_key_command(const d_event &event, newmenu *co
 	}
 
 	if ( menu->citem > -1 )	{
-		// Alerting callback of every keypress for NM_TYPE_INPUT. Alternatively, just respond to EVENT_NEWMENU_SELECTED
+		// Alerting callback of every keypress for NM_TYPE_INPUT. Alternatively, just respond to event_type::newmenu_selected
 		if ((citem.type == nm_type::input || (citem.type == nm_type::input_menu && citem.imenu().group == 1)) && old_choice == menu->citem)
 		{
 			if ( k==KEY_LEFT || k==KEY_BACKSP || k==KEY_PAD4 )	{
@@ -1566,7 +1565,7 @@ static window_event_result newmenu_draw(newmenu *menu)
 
 		gr_string(menu_canvas, cv_font, sx, sy, (scroll_offset + menu->max_displayable < menu->items.size()) ? DOWN_ARROW_MARKER(cv_font, game_font) : "  ");
 	}
-	menu->event_handler(d_event{EVENT_NEWMENU_DRAW});
+	menu->event_handler(d_event{event_type::newmenu_draw});
 	return window_event_result::handled;
 }
 
@@ -1592,35 +1591,35 @@ window_event_result newmenu::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			event_toggle_focus(0);
 			key_toggle_repeat(1);
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			//event_toggle_focus(1);	// No cursor recentering
 			key_toggle_repeat(1);
 			mouse_state = 0;
 			break;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 		{
-			mouse_state = event.type == EVENT_MOUSE_BUTTON_DOWN;
+			mouse_state = event.type == event_type::mouse_button_down;
 			const auto button = event_mouse_get_button(event);
 			return newmenu_mouse(event, this, button);
 		}
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			return newmenu_key_command(event, this);
-		case EVENT_IDLE:
+		case event_type::idle:
 			if (!(Game_mode & GM_MULTI) || !Game_wind || !Game_wind->is_visible())
 				timer_delay2(CGameArg.SysMaxFPS);
 			break;
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			return newmenu_draw(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
@@ -1757,8 +1756,7 @@ static window_event_result listbox_mouse(const d_event &event, listbox *lb, cons
 		{
 			if (lb->mouse_state)
 			{
-				int mx, my, mz;
-				mouse_get_pos(&mx, &my, &mz);
+				const auto [mx, my, mz] = mouse_get_pos();
 				const int x1{lb->box_x};
 				if (mx <= x1)
 					break;
@@ -1787,13 +1785,12 @@ static window_event_result listbox_mouse(const d_event &event, listbox *lb, cons
 					break;
 				lb->citem = idx_absolute_item;
 			}
-			else if (event.type == EVENT_MOUSE_BUTTON_UP)
+			else if (event.type == event_type::mouse_button_up)
 			{
 				if (lb->citem < 0)
 					return window_event_result::ignored;
 
-				int mx, my, mz;
-				mouse_get_pos(&mx, &my, &mz);
+				const auto [mx, my, mz] = mouse_get_pos();
 				const auto h = gr_get_string_size(*MEDIUM3_FONT, lb->item[lb->citem]).height;
 				const int x1{lb->box_x};
 				const int x2 = lb->box_x + lb->box_w;
@@ -2096,7 +2093,7 @@ static window_event_result listbox_draw(listbox *lb)
 		}
 	}
 
-	return lb->callback_handler(d_event{EVENT_NEWMENU_DRAW}, window_event_result::handled);
+	return lb->callback_handler(d_event{event_type::newmenu_draw}, window_event_result::handled);
 }
 
 }
@@ -2113,30 +2110,30 @@ window_event_result listbox::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			event_toggle_focus(0);
 			key_toggle_repeat(1);
 			break;
 
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_deactivated:
 			//event_toggle_focus(1);	// No cursor recentering
 			key_toggle_repeat(0);
 			break;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
-			mouse_state = event.type == EVENT_MOUSE_BUTTON_DOWN;
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
+			mouse_state = event.type == event_type::mouse_button_down;
 			return listbox_mouse(event, this, event_mouse_get_button(event));
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			return listbox_key_command(event, this);
-		case EVENT_IDLE:
+		case event_type::idle:
 			if (!(Game_mode & GM_MULTI && Game_wind))
 				timer_delay2(CGameArg.SysMaxFPS);
 			return window_event_result::ignored;
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			return listbox_draw(this);
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
diff --git a/similar/main/object.cpp b/similar/main/object.cpp
index 593441fb4..a1d8c5616 100644
--- a/similar/main/object.cpp
+++ b/similar/main/object.cpp
@@ -1215,7 +1215,7 @@ imobjptridx_t obj_create(d_level_unique_object_state &LevelUniqueObjectState, co
         {
 		obj->ctype.powerup_info.count = 1;
                 obj->ctype.powerup_info.flags = 0;
-                obj->ctype.powerup_info.creation_time = GameTime64;
+                obj->ctype.powerup_info.creation_time = {GameTime64};
         }
 
 	// Init physics info for this object
@@ -1262,7 +1262,7 @@ imobjptridx_t obj_weapon_create(d_level_unique_object_state &LevelUniqueObjectSt
 	assert(obj.control_source == object::control_type::weapon);
 	if (Weapon_info[id].persistent != weapon_info::persistence_flag::terminate_on_impact)
 		obj.mtype.phys_info.flags |= PF_PERSISTENT;
-	obj.ctype.laser_info.creation_time = GameTime64;
+	obj.ctype.laser_info.creation_time = {GameTime64};
 	obj.ctype.laser_info.clear_hitobj();
 	obj.ctype.laser_info.multiplier = F1_0;
 #if defined(DXX_BUILD_DESCENT_II)
@@ -2086,8 +2086,8 @@ static window_event_result object_move_one(const d_level_shared_robot_info_state
 
 		assert(obj->control_source == object::control_type::weapon);
 		if ((obj->ctype.laser_info.last_afterburner_time + delay < GameTime64) || (obj->ctype.laser_info.last_afterburner_time > GameTime64)) {
+			obj->ctype.laser_info.last_afterburner_time = {GameTime64};
 			drop_afterburner_blobs(obj, 1, i2f(Weapon_info[get_weapon_id(obj)].afterburner_size)/16, lifetime);
-			obj->ctype.laser_info.last_afterburner_time = GameTime64;
 		}
 	}
 
diff --git a/similar/main/powerup.cpp b/similar/main/powerup.cpp
index cbd8215fb..7502052b3 100644
--- a/similar/main/powerup.cpp
+++ b/similar/main/powerup.cpp
@@ -596,7 +596,7 @@ int do_powerup(const vmobjptridx_t obj)
 				HUD_init_message(HM_DEFAULT|HM_REDUNDANT|HM_MAYDUPL, "%s %s!",TXT_ALREADY_ARE,TXT_CLOAKED);
 				break;
 			} else {
-				player_info.cloak_time = GameTime64;	//	Not! changed by awareness events (like player fires laser).
+				player_info.cloak_time = {GameTime64};	//	Not! changed by awareness events (like player fires laser).
 				player_info.powerup_flags |= PLAYER_FLAGS_CLOAKED;
 				ai_do_cloak_stuff();
 				if (Game_mode & GM_MULTI)
@@ -617,7 +617,7 @@ int do_powerup(const vmobjptridx_t obj)
 			}
 				player_info.FakingInvul = 0;
 				pl_flags |= PLAYER_FLAGS_INVULNERABLE;
-				player_info.invulnerable_time = GameTime64;
+				player_info.invulnerable_time = {GameTime64};
 				powerup_basic(7, 14, 21, INVULNERABILITY_SCORE, "%s!",TXT_INVULNERABILITY);
 				used = 1;
 				break;
diff --git a/similar/main/scores.cpp b/similar/main/scores.cpp
index e86475cba..bce0d8b68 100644
--- a/similar/main/scores.cpp
+++ b/similar/main/scores.cpp
@@ -254,7 +254,7 @@ window_event_result request_user_high_score_comment::event_handler(const d_event
 {
 	switch (event.type)
 	{
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			{
 				std::array<char, sizeof(all_scores::cool_saying)> &text1 = *this;
 				strcpy(scores.cool_saying, text1[0] ? text1.data() : "No comment");
@@ -504,11 +504,11 @@ window_event_result scores_menu::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
+		case event_type::window_activated:
 			game_flush_inputs(Controls);
 			break;
 			
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			k = event_key_get(event);
 			switch( k )	{
 				case KEY_CTRLED+KEY_R:		
@@ -533,8 +533,8 @@ window_event_result scores_menu::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
-		case EVENT_MOUSE_BUTTON_UP:
+		case event_type::mouse_button_down:
+		case event_type::mouse_button_up:
 			if (event_mouse_get_button(event) == mbtn::left || event_mouse_get_button(event) == mbtn::right)
 			{
 				return window_event_result::close;
@@ -542,15 +542,15 @@ window_event_result scores_menu::event_handler(const d_event &event)
 			break;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_down:
 			return window_event_result::close;
 #endif
 
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay2(50);
 			break;
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			
 			{
 				auto &canvas = w_canv;
@@ -594,7 +594,7 @@ window_event_result scores_menu::event_handler(const d_event &event)
 			}
 			}
 			break;
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 		default:
 			break;
diff --git a/similar/main/state.cpp b/similar/main/state.cpp
index bc54730d8..e24dbae4e 100644
--- a/similar/main/state.cpp
+++ b/similar/main/state.cpp
@@ -284,10 +284,10 @@ window_event_result savegame_chooser_newmenu::event_handler(const d_event &event
 {
 	switch (event.type)
 	{
-		case EVENT_NEWMENU_DRAW:
+		case event_type::newmenu_draw:
 			draw_handler();
 			return window_event_result::handled;
-		case EVENT_NEWMENU_SELECTED:
+		case event_type::newmenu_selected:
 			{
 				const auto citem = static_cast<const d_select_event &>(event).citem;
 				const auto choice = static_cast<d_game_unique_state::save_slot>(citem - decorative_item_count);
@@ -1858,7 +1858,7 @@ int state_restore_all_sub(const d_level_shared_destructible_light_state &LevelSh
 	static constexpr std::integral_constant<secret_restore, secret_restore::none> secret{};
 #elif defined(DXX_BUILD_DESCENT_II)
 	auto &Robot_info = LevelSharedRobotInfoState.Robot_info;
-	fix64	old_gametime = GameTime64;
+	const auto old_gametime{GameTime64};
 #endif
 
 	#ifndef NDEBUG
@@ -2312,9 +2312,9 @@ int state_restore_all_sub(const d_level_shared_destructible_light_state &LevelSh
 	auto &Next_laser_fire_time = player_info.Next_laser_fire_time;
 	auto &Next_missile_fire_time = player_info.Next_missile_fire_time;
 	player_info.Auto_fire_fusion_cannon_time = 0;
-	player_info.Next_flare_fire_time = GameTime64;
-	Next_laser_fire_time = GameTime64;
-	Next_missile_fire_time = GameTime64;
+	player_info.Next_flare_fire_time = {GameTime64};
+	Next_laser_fire_time = {GameTime64};
+	Next_missile_fire_time = {GameTime64};
 
 	state_game_id = 0;
 
diff --git a/similar/main/text.cpp b/similar/main/text.cpp
index 20f4f01f1..4187d0d39 100644
--- a/similar/main/text.cpp
+++ b/similar/main/text.cpp
@@ -51,19 +51,11 @@ namespace {
 static std::unique_ptr<char[]> text;
 static std::unique_ptr<char[]> overwritten_text;
 
-// rotates a byte left one bit, preserving the bit falling off the right
-static uint8_t encode_rotate_left(const uint8_t v)
+static constexpr uint8_t decode_char(const uint8_t c)
 {
-	return (v >> 7) | (v << 1);
-}
-
-constexpr std::integral_constant<uint8_t, 0xd3> BITMAP_TBL_XOR{};
-
-static uint8_t decode_char(const uint8_t c)
-{
-	const auto c1 = encode_rotate_left(c);
-	const auto c2 = c1 ^ BITMAP_TBL_XOR;
-	return encode_rotate_left(c2);
+	constexpr uint8_t BITMAP_TBL_XOR{0xd3};
+	const uint8_t c2 = std::rotl(c, 1) ^ BITMAP_TBL_XOR;
+	return {std::rotl(c2, 1)};
 }
 
 }
diff --git a/similar/main/titles.cpp b/similar/main/titles.cpp
index 0c8bc123c..8ff856ffa 100644
--- a/similar/main/titles.cpp
+++ b/similar/main/titles.cpp
@@ -129,7 +129,7 @@ window_event_result title_screen::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_MOUSE_BUTTON_DOWN:
+		case event_type::mouse_button_down:
 			if (event_mouse_get_button(event) != mbtn::left)
 				return window_event_result::ignored;
 			else
@@ -138,7 +138,7 @@ window_event_result title_screen::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			if ((result = call_default_handler(event)) == window_event_result::ignored)
 				{
 					return window_event_result::close;
@@ -146,11 +146,11 @@ window_event_result title_screen::event_handler(const d_event &event)
 			return result;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_down:
 				return window_event_result::close;
 #endif
 
-		case EVENT_IDLE:
+		case event_type::idle:
 			timer_delay2(50);
 
 			if (timer_query() > timer)
@@ -159,11 +159,11 @@ window_event_result title_screen::event_handler(const d_event &event)
 			}
 			break;
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 			show_fullscr(w_canv, title_bm);
 			break;
 
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			break;
 
 		default:
@@ -1560,12 +1560,12 @@ window_event_result briefing::event_handler(const d_event &event)
 
 	switch (event.type)
 	{
-		case EVENT_WINDOW_ACTIVATED:
-		case EVENT_WINDOW_DEACTIVATED:
+		case event_type::window_activated:
+		case event_type::window_deactivated:
 			key_flush();
 			break;
 
-		case EVENT_MOUSE_BUTTON_DOWN:
+		case event_type::mouse_button_down:
 			if (event_mouse_get_button(event) == mbtn::left)
 			{
 				if (this->new_screen)
@@ -1587,7 +1587,7 @@ window_event_result briefing::event_handler(const d_event &event)
 			break;
 
 #if DXX_MAX_BUTTONS_PER_JOYSTICK
-		case EVENT_JOYSTICK_BUTTON_DOWN:
+		case event_type::joystick_button_down:
 			// using joy_translate_menu_key doesn't work here for unclear
 			// reasons, so we build a reasonable facsimile right here
 			if (event_joystick_get_button(event) == 1)
@@ -1609,7 +1609,7 @@ window_event_result briefing::event_handler(const d_event &event)
 			return window_event_result::handled;
 #endif
 
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 		{
 			int key = event_key_get(event);
 
@@ -1646,7 +1646,7 @@ window_event_result briefing::event_handler(const d_event &event)
 			break;
 		}
 
-		case EVENT_WINDOW_DRAW:
+		case event_type::window_draw:
 		{
 			auto &canvas = w_canv;
 
@@ -1691,7 +1691,7 @@ window_event_result briefing::event_handler(const d_event &event)
 				gr_string(canvas, game_font, this->text_x, this->text_y, "_");
 			break;
 		}
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			free_briefing_screen(this);
 #if defined(DXX_BUILD_DESCENT_II)
 			this->hum_channel.reset();
diff --git a/similar/main/weapon.cpp b/similar/main/weapon.cpp
index 56516d5c6..93b1c61b2 100644
--- a/similar/main/weapon.cpp
+++ b/similar/main/weapon.cpp
@@ -259,10 +259,10 @@ window_event_result weapon_reorder_menu<cycle_weapon_state>::event_handler(const
 {
 	switch(event.type)
 	{
-		case EVENT_KEY_COMMAND:
+		case event_type::key_command:
 			event_key_command(event);
 			break;
-		case EVENT_WINDOW_CLOSE:
+		case event_type::window_close:
 			for (auto &&[i, mi] : enumerate(menu_items))
 				cycle_weapon_state::get_weapon_by_order_slot(i) = mi.value;
 			break;
@@ -1371,7 +1371,7 @@ void smega_rock_stuff(void)
 		if (*least > i)
 			least = &i;
 	}
-	*least = GameTime64;
+	*least = {GameTime64};
 }
 
 namespace {