Rename all non-ultra functions to snake case

src/include/constants.h

@@ -60,7 +60,7 @@
 #define IS4MB()             (g_Is4Mb == true)
 #define IS8MB()             (g_Is4Mb != true)
 #define LINEHEIGHT          (VERSION == VERSION_JPN_FINAL ? 14 : 11)
-#define MIXCOLOUR(dialog, property) dialog->transitionfrac < 0.0f ? g_MenuColours[dialog->type].property : colourBlend(g_MenuColours[dialog->type2].property, g_MenuColours[dialog->type].property, dialog->colourweight)
+#define MIXCOLOUR(dialog, property) dialog->transitionfrac < 0.0f ? g_MenuColours[dialog->type].property : colour_blend(g_MenuColours[dialog->type2].property, g_MenuColours[dialog->type].property, dialog->colourweight)
 #define MPCHR(index)        ((index) < MAX_PLAYERS ? &g_PlayerConfigsArray[index].base : &g_BotConfigsArray[(index) - MAX_PLAYERS].base)
 #define RANDOMFRAC()        (random() * (1.0f / U32_MAX))
 #define SECSTOTIME240(secs) (secs * 240)

src/include/game/activemenu.h

@@ -4,27 +4,27 @@
 #include "data.h"
 #include "types.h"
 
-void amTick(void);
+void am_tick(void);
 
-void amOpenPickTarget(void);
+void am_open_pick_target(void);
 MenuDialogHandlerResult menudialog000fcd48(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult amPickTargetMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-void amSetAiBuddyTemperament(bool aggressive);
-void amSetAiBuddyStealth(void);
-s32 amGetFirstBuddyIndex(void);
-void amApply(s32 slot);
-void amGetSlotDetails(s32 slot, u32 *flags, char *label);
-void amReset(void);
-s16 amCalculateSlotWidth(void);
-void amChangeScreen(s32 step);
-void amAssignWeaponSlots(void);
-void amOpen(void);
-void amClose(void);
-bool amIsCramped(void);
-void amCalculateSlotPosition(s16 column, s16 row, s16 *x, s16 *y);
-Gfx *amRenderText(Gfx *gdl, char *text, u32 colour, s16 left, s16 top);
-Gfx *amRenderAibotInfo(Gfx *gdl, s32 buddynum);
-Gfx *amRenderSlot(Gfx *gdl, char *text, s16 x, s16 y, s32 mode, s32 flags);
-Gfx *amRender(Gfx *gdl);
+MenuDialogHandlerResult am_pick_target_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+void am_set_ai_buddy_temperament(bool aggressive);
+void am_set_ai_buddy_stealth(void);
+s32 am_get_first_buddy_index(void);
+void am_apply(s32 slot);
+void am_get_slot_details(s32 slot, u32 *flags, char *label);
+void am_reset(void);
+s16 am_calculate_slot_width(void);
+void am_change_screen(s32 step);
+void am_assign_weapon_slots(void);
+void am_open(void);
+void am_close(void);
+bool am_is_cramped(void);
+void am_calculate_slot_position(s16 column, s16 row, s16 *x, s16 *y);
+Gfx *am_render_text(Gfx *gdl, char *text, u32 colour, s16 left, s16 top);
+Gfx *am_render_aibot_info(Gfx *gdl, s32 buddynum);
+Gfx *am_render_slot(Gfx *gdl, char *text, s16 x, s16 y, s32 mode, s32 flags);
+Gfx *am_render(Gfx *gdl);
 
 #endif

src/include/game/bg.h

@@ -4,103 +4,103 @@
 #include "data.h"
 #include "types.h"
 
-void bgUnpausePropsInRoom(u32 roomnum, bool tintedglassonly);
-void bgSetRoomOnscreen(s32 room, s32 draworder, struct screenbox *arg2);
-void bgGetRoomBrightnessRange(s32 roomnum, u8 *min, u8 *max);
-struct drawslot *bgGetRoomDrawSlot(s32 roomnum);
-Gfx *bgRenderXrayData(Gfx *gdl, struct xraydata *xraydata);
-Gfx *bgAddXrayTri(Gfx *gdl, struct xraydata *xraydata, s16 vertices1[3], s16 vertices2[3], s16 vertices3[3], u32 colour1, u32 colour2, u32 colour3);
-void bgChooseXrayVtxColour(bool *inrange, s16 vertex[3], u32 *colour, struct xraydata *xraydata);
-Gfx *bgProcessXrayTri(Gfx *gdl, struct xraydata *xraydata, s16 arg2[3], s16 arg3[3], s16 arg4[3], s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, s32 arg10);
-Gfx *bgRenderGdlInXray(Gfx *gdl, s8 *readgdl, Vtx *vertices, s16 arg3[3]);
-Gfx *bgRenderRoomXrayPass(Gfx *gdl, s32 roomnum, struct roomblock *blocks, bool recurse, s16 arg4[3]);
-Gfx *bgRenderRoomInXray(Gfx *gdl, s32 roomnum);
-Gfx *bgRenderSceneInXray(Gfx *gdl);
-Gfx *bgRenderScene(Gfx *gdl);
-Gfx *bgRenderArtifacts(Gfx *gdl);
-void bgLoadFile(void *memaddr, u32 offset, u32 len);
-s32 bgGetStageIndex(s32 stagenum);
-f32 bgCalculatePortalSurfaceArea(s32 portal);
-u8 bgCalculatePortalAlpha(s32 portal);
+void bg_unpause_props_in_room(u32 roomnum, bool tintedglassonly);
+void bg_set_room_onscreen(s32 room, s32 draworder, struct screenbox *arg2);
+void bg_get_room_brightness_range(s32 roomnum, u8 *min, u8 *max);
+struct drawslot *bg_get_room_draw_slot(s32 roomnum);
+Gfx *bg_render_xray_data(Gfx *gdl, struct xraydata *xraydata);
+Gfx *bg_add_xray_tri(Gfx *gdl, struct xraydata *xraydata, s16 vertices1[3], s16 vertices2[3], s16 vertices3[3], u32 colour1, u32 colour2, u32 colour3);
+void bg_choose_xray_vtx_colour(bool *inrange, s16 vertex[3], u32 *colour, struct xraydata *xraydata);
+Gfx *bg_process_xray_tri(Gfx *gdl, struct xraydata *xraydata, s16 arg2[3], s16 arg3[3], s16 arg4[3], s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, s32 arg10);
+Gfx *bg_render_gdl_in_xray(Gfx *gdl, s8 *readgdl, Vtx *vertices, s16 arg3[3]);
+Gfx *bg_render_room_xray_pass(Gfx *gdl, s32 roomnum, struct roomblock *blocks, bool recurse, s16 arg4[3]);
+Gfx *bg_render_room_in_xray(Gfx *gdl, s32 roomnum);
+Gfx *bg_render_scene_in_xray(Gfx *gdl);
+Gfx *bg_render_scene(Gfx *gdl);
+Gfx *bg_render_artifacts(Gfx *gdl);
+void bg_load_file(void *memaddr, u32 offset, u32 len);
+s32 bg_get_stage_index(s32 stagenum);
+f32 bg_calculate_portal_surface_area(s32 portal);
+u8 bg_calculate_portal_alpha(s32 portal);
 u32 not(u32 arg);
-u32 bgXorBabebabe(u32 value);
-void bgReset(s32 stagenum);
-void bgBuildTables(s32 stagenum);
-void bgStop(void);
-void bgSetStageTranslationThing(f32 arg0);
-f32 bgGetStageTranslationThing(void);
-f32 bgGetScaleBg2Gfx(void);
-void bgSetScaleBg2Gfx(f32 arg0);
-void bgTickCounter(void);
-void bgTick(void);
-Gfx *bgRender(Gfx *gdl);
-Gfx *bgScissorToViewport(Gfx *gdl);
-Gfx *bgScissorWithinViewportF(Gfx *gdl, f32 viewleft, f32 viewtop, f32 viewright, f32 viewbottom);
-Gfx *bgScissorWithinViewport(Gfx *gdl, s32 viewleft, s32 viewtop, s32 viewright, s32 viewbottom);
-void bgClearPortalCameraCache(void);
-bool bgRoomIntersectsScreenBox(s32 room, struct screenbox *arg1);
-bool bg3dPosTo2dPos(struct coord *cornerpos, struct coord *screenpos);
-bool bgGetPortalScreenBbox(s32 portal, struct screenbox *arg1);
-Gfx *bgDrawBoxEdge(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
-bool bgGetBoxIntersection(struct screenbox *a, struct screenbox *b);
-void bgExpandBox(struct screenbox *a, struct screenbox *b);
-void bgCopyBox(struct screenbox *dst, struct screenbox *src);
-bool bgRoomIsOnscreen(s32 room);
-bool bgRoomIsStandby(s32 room);
-bool bgRoomIsOnPlayerScreen(s32 room, u32 playernum);
-bool bgRoomIsOnPlayerStandby(s32 room, u32 aibotindex);
-s32 bgFindPortalByVertices(struct portalvertices *pvertices);
-u32 bgInflate(u8 *src, u8 *dst, u32 len);
-Gfx *bgGetNextGdlInBlock(struct roomblock *block, Gfx *start, Gfx *end);
-Gfx *bgGetNextGdlInLayer(s32 roomnum, Gfx *start, u32 types);
-Vtx *bgFindVerticesForGdl(s32 roomnum, Gfx *gdl);
-void bgLoadRoom(s32 roomnum);
-void bgUnloadRoom(s32 room);
-void bgUnloadAllRooms(void);
-void bgGarbageCollectRooms(s32 bytesneeded, bool desparate);
-void bgTickRooms(void);
-Gfx *bgRenderRoomPass(Gfx *gdl, s32 roomnum, struct roomblock *blocks, bool arg3);
-Gfx *bgRenderRoomOpaque(Gfx *gdl, s32 roomnum);
-Gfx *bgRenderRoomXlu(Gfx *gdl, s32 roomnum);
-s32 bgPopulateVtxBatchType(s32 roomnum, struct vtxbatch *batches, Gfx *gdl, s32 batchindex, Vtx *vertices, s32 arg5);
-void bgFindRoomVtxBatches(s32 roomnum);
-bool bgTestLineIntersectsIntBbox(struct coord *arg0, struct coord *arg1, s32 *arg2, s32 *arg3);
-bool bgTestLineIntersectsBbox(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3);
-bool bgTestHitOnObj(struct coord *arg0, struct coord *arg1, struct coord *arg2, Gfx *gdl, Gfx *gdl2, Vtx *vertices, struct hitthing *hitthing);
-bool bgTestHitOnChr(struct model *model, struct coord *arg1, struct coord *arg2, struct coord *arg3, Gfx *arg4, Gfx *arg5, Vtx *vertices, f32 *arg7, struct hitthing *hitthing);
-bool bgTestHitInVtxBatch(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct vtxbatch *batches, s32 roomnum, struct hitthing *hitthing);
+u32 bg_xor_babebabe(u32 value);
+void bg_reset(s32 stagenum);
+void bg_build_tables(s32 stagenum);
+void bg_stop(void);
+void bg_set_stage_translation_thing(f32 arg0);
+f32 bg_get_stage_translation_thing(void);
+f32 bg_get_scale_bg2gfx(void);
+void bg_set_scale_bg2gfx(f32 arg0);
+void bg_tick_counter(void);
+void bg_tick(void);
+Gfx *bg_render(Gfx *gdl);
+Gfx *bg_scissor_to_viewport(Gfx *gdl);
+Gfx *bg_scissor_within_viewport_f(Gfx *gdl, f32 viewleft, f32 viewtop, f32 viewright, f32 viewbottom);
+Gfx *bg_scissor_within_viewport(Gfx *gdl, s32 viewleft, s32 viewtop, s32 viewright, s32 viewbottom);
+void bg_clear_portal_camera_cache(void);
+bool bg_room_intersects_screen_box(s32 room, struct screenbox *arg1);
+bool bg_3d_pos_to_2d_pos(struct coord *cornerpos, struct coord *screenpos);
+bool bg_get_portal_screen_bbox(s32 portal, struct screenbox *arg1);
+Gfx *bg_draw_box_edge(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
+bool bg_get_box_intersection(struct screenbox *a, struct screenbox *b);
+void bg_expand_box(struct screenbox *a, struct screenbox *b);
+void bg_copy_box(struct screenbox *dst, struct screenbox *src);
+bool bg_room_is_onscreen(s32 room);
+bool bg_room_is_standby(s32 room);
+bool bg_room_is_on_player_screen(s32 room, u32 playernum);
+bool bg_room_is_on_player_standby(s32 room, u32 aibotindex);
+s32 bg_find_portal_by_vertices(struct portalvertices *pvertices);
+u32 bg_inflate(u8 *src, u8 *dst, u32 len);
+Gfx *bg_get_next_gdl_in_block(struct roomblock *block, Gfx *start, Gfx *end);
+Gfx *bg_get_next_gdl_in_layer(s32 roomnum, Gfx *start, u32 types);
+Vtx *bg_find_vertices_for_gdl(s32 roomnum, Gfx *gdl);
+void bg_load_room(s32 roomnum);
+void bg_unload_room(s32 room);
+void bg_unload_all_rooms(void);
+void bg_garbage_collect_rooms(s32 bytesneeded, bool desparate);
+void bg_tick_rooms(void);
+Gfx *bg_render_room_pass(Gfx *gdl, s32 roomnum, struct roomblock *blocks, bool arg3);
+Gfx *bg_render_room_opaque(Gfx *gdl, s32 roomnum);
+Gfx *bg_render_room_xlu(Gfx *gdl, s32 roomnum);
+s32 bg_populate_vtx_batch_type(s32 roomnum, struct vtxbatch *batches, Gfx *gdl, s32 batchindex, Vtx *vertices, s32 arg5);
+void bg_find_room_vtx_batches(s32 roomnum);
+bool bg_test_line_intersects_int_bbox(struct coord *arg0, struct coord *arg1, s32 *arg2, s32 *arg3);
+bool bg_test_line_intersects_bbox(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3);
+bool bg_test_hit_on_obj(struct coord *arg0, struct coord *arg1, struct coord *arg2, Gfx *gdl, Gfx *gdl2, Vtx *vertices, struct hitthing *hitthing);
+bool bg_test_hit_on_chr(struct model *model, struct coord *arg1, struct coord *arg2, struct coord *arg3, Gfx *arg4, Gfx *arg5, Vtx *vertices, f32 *arg7, struct hitthing *hitthing);
+bool bg_test_hit_in_vtx_batch(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct vtxbatch *batches, s32 roomnum, struct hitthing *hitthing);
 s32 bg0f1612e4(struct coord *bbmin, struct coord *bbmax, struct coord *frompos, struct coord *dist, struct coord *arg4, struct coord *arg5);
-bool bgTestHitInRoom(struct coord *frompos, struct coord *topos, s32 roomnum, struct hitthing *hitthing);
-bool bgRoomIsLoaded(s32 room);
-bool bgRoomContainsCoord(struct coord *pos, RoomNum roomnum);
-bool bgTestPosInRoomCheap(struct coord *pos, RoomNum roomnum);
-bool bgTestPosInRoomExpensive(struct coord *pos, RoomNum roomnum);
-bool bgTestPosInRoom(struct coord *pos, RoomNum roomnum);
-void bgFindRoomsByPos(struct coord *pos, RoomNum *inrooms, RoomNum *aboverooms, s32 max, RoomNum *bestroom);
-bool bgCmdPushValue(bool value);
-bool bgCmdPopValue(void);
-bool bgCmdGetNthValueFromEnd(s32 offset);
-struct bgcmd *bgCmdExecuteBranch(struct bgcmd *cmd, bool s2);
-struct bgcmd *bgCmdExecute(struct bgcmd *cmd);
-void bgTickPortalsXray(void);
-void bgAddToSnake(RoomNum fromroomnum, RoomNum roomnum, s16 draworder, struct screenbox *box);
-void bgConsumeSnakeItem(struct bgsnakeitem *arg0);
-bool bgTryConsumeSnake(void);
-void bgChooseRoomsToLoad(void);
-void bgTickPortals(void);
-Gfx *bgRenderSceneAndLoadCandidate(Gfx *gdl);
-s32 bgGetForceOnscreenRooms(RoomNum *rooms, s32 len);
-s32 bgRoomGetNeighbours(s32 room, RoomNum *rooms, s32 len);
-bool bgRoomsAreNeighbours(s32 roomnum1, s32 roomnum2);
-void bgCalculateScreenProperties(void);
-void bgExpandRoomToPortals(s32 roomnum);
-void bgPortalSwapRooms(s32 portal);
-void bgInitPortal(s32 portalnum);
-void bgInitRoom(s32 roomnum);
-void bgSetPortalOpenState(s32 portal, bool open);
-s32 bgFindPortalBetweenPositions(struct coord *pos1, struct coord *pos2);
-bool bgIsBboxOverlapping(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3);
-void bgCalculatePortalBbox(s32 portalnum, struct coord *bbmin, struct coord *bbmax);
-void bgFindEnteredRooms(struct coord *bbmin, struct coord *upper, RoomNum *rooms, s32 maxlen, bool arg4);
+bool bg_test_hit_in_room(struct coord *frompos, struct coord *topos, s32 roomnum, struct hitthing *hitthing);
+bool bg_room_is_loaded(s32 room);
+bool bg_room_contains_coord(struct coord *pos, RoomNum roomnum);
+bool bg_test_pos_in_room_cheap(struct coord *pos, RoomNum roomnum);
+bool bg_test_pos_in_room_expensive(struct coord *pos, RoomNum roomnum);
+bool bg_test_pos_in_room(struct coord *pos, RoomNum roomnum);
+void bg_find_rooms_by_pos(struct coord *pos, RoomNum *inrooms, RoomNum *aboverooms, s32 max, RoomNum *bestroom);
+bool bg_cmd_push_value(bool value);
+bool bg_cmd_pop_value(void);
+bool bg_cmd_get_nth_value_from_end(s32 offset);
+struct bgcmd *bg_cmd_execute_branch(struct bgcmd *cmd, bool s2);
+struct bgcmd *bg_cmd_execute(struct bgcmd *cmd);
+void bg_tick_portals_xray(void);
+void bg_add_to_snake(RoomNum fromroomnum, RoomNum roomnum, s16 draworder, struct screenbox *box);
+void bg_consume_snake_item(struct bgsnakeitem *arg0);
+bool bg_try_consume_snake(void);
+void bg_choose_rooms_to_load(void);
+void bg_tick_portals(void);
+Gfx *bg_render_scene_and_load_candidate(Gfx *gdl);
+s32 bg_get_force_onscreen_rooms(RoomNum *rooms, s32 len);
+s32 bg_room_get_neighbours(s32 room, RoomNum *rooms, s32 len);
+bool bg_rooms_are_neighbours(s32 roomnum1, s32 roomnum2);
+void bg_calculate_screen_properties(void);
+void bg_expand_room_to_portals(s32 roomnum);
+void bg_portal_swap_rooms(s32 portal);
+void bg_init_portal(s32 portalnum);
+void bg_init_room(s32 roomnum);
+void bg_set_portal_open_state(s32 portal, bool open);
+s32 bg_find_portal_between_positions(struct coord *pos1, struct coord *pos2);
+bool bg_is_bbox_overlapping(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3);
+void bg_calculate_portal_bbox(s32 portalnum, struct coord *bbmin, struct coord *bbmax);
+void bg_find_entered_rooms(struct coord *bbmin, struct coord *upper, RoomNum *rooms, s32 maxlen, bool arg4);
 
 #endif

src/include/game/body.h

@@ -4,19 +4,19 @@
 #include "data.h"
 #include "types.h"
 
-void bodiesInit(void);
+void bodies_init(void);
 
-void bodiesReset(s32 stagenum);
+void bodies_reset(s32 stagenum);
 
-u32 bodyGetRace(s32 bodynum);
-bool bodyLoad(s32 bodynum);
+u32 body_get_race(s32 bodynum);
+bool body_load(s32 bodynum);
 struct model *body0f02ce8c(s32 bodynum, s32 headnum, struct modeldef *bodymodeldef, struct modeldef *headmodeldef, bool sunglasses, struct model *model, bool isplayer, u8 varyheight);
 struct model *body0f02d338(s32 bodynum, s32 headnum, struct modeldef *bodymodeldef, struct modeldef *headmodeldef, bool sunglasses, u8 varyheight);
-struct model *bodyAllocateModel(s32 bodynum, s32 headnum, u32 spawnflags);
+struct model *body_allocate_model(s32 bodynum, s32 headnum, u32 spawnflags);
 s32 body0f02d3f8(void);
-s32 bodyChooseHead(s32 bodynum);
-void bodyAllocateChr(s32 stagenum, struct packedchr *packed, s32 cmdindex);
-struct prop *bodyAllocateEyespy(struct pad *pad, RoomNum room);
-void bodyCalculateHeadOffset(struct modeldef *headmodeldef, s32 headnum, s32 bodynum);
+s32 body_choose_head(s32 bodynum);
+void body_allocate_chr(s32 stagenum, struct packedchr *packed, s32 cmdindex);
+struct prop *body_allocate_eyespy(struct pad *pad, RoomNum room);
+void body_calculate_head_offset(struct modeldef *headmodeldef, s32 headnum, s32 bodynum);
 
 #endif

src/include/game/bondbike.h

@@ -4,21 +4,21 @@
 #include "data.h"
 #include "types.h"
 
-void bbikeInit(void);
-void bbikeExit(void);
-void bbikeUpdateVehicleOffset(void);
-void bbikeTryDismountAngle(f32 relativeangle, f32 distance);
-void bbikeHandleActivate(void);
-void bbikeApplyMoveData(struct movedata *data);
+void bbike_init(void);
+void bbike_exit(void);
+void bbike_update_vehicle_offset(void);
+void bbike_try_dismount_angle(f32 relativeangle, f32 distance);
+void bbike_handle_activate(void);
+void bbike_apply_move_data(struct movedata *data);
 void bbike0f0d2b40(struct defaultobj *bike, struct coord *arg1, f32 arg2, struct defaultobj *obstacle);
-s32 bbikeCalculateNewPosition(struct coord *arg0, f32 arg1);
-s32 bbikeCalculateNewPositionWithPush(struct coord *arg0, f32 arg1);
-void bbikeUpdateVertical(struct coord *pos);
+s32 bbike_calculate_new_position(struct coord *arg0, f32 arg1);
+s32 bbike_calculate_new_position_with_push(struct coord *arg0, f32 arg1);
+void bbike_update_vertical(struct coord *pos);
 s32 bbike0f0d3680(struct coord *arg0, struct coord *arg1, struct coord *arg2);
 s32 bbike0f0d36d4(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3, struct coord *arg4);
 s32 bbike0f0d3840(struct coord *arg0, struct coord *arg1, struct coord *arg2);
 s32 bbike0f0d3940(struct coord *arg0, struct coord *arg1, struct coord *arg2);
 void bbike0f0d3c60(struct coord *arg0);
-void bbikeTick(void);
+void bbike_tick(void);
 
 #endif

src/include/game/bondcutscene.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void bcutsceneInit(void);
-void bcutsceneTick(void);
+void bcutscene_init(void);
+void bcutscene_tick(void);
 
 #endif

src/include/game/bondeyespy.h

@@ -4,16 +4,16 @@
 #include "data.h"
 #include "types.h"
 
-f32 eyespyFindGround(RoomNum *floorroom);
-s32 eyespyTryMoveUpwards(f32 yvel);
-s32 eyespyCalculateNewPosition(struct coord *vel);
-bool eyespyCalculateNewPositionWithPush(struct coord *vel);
+f32 eyespy_find_ground(RoomNum *floorroom);
+s32 eyespy_try_move_upwards(f32 yvel);
+s32 eyespy_calculate_new_position(struct coord *vel);
+bool eyespy_calculate_new_position_with_push(struct coord *vel);
 s32 eyespy0f0cf890(struct coord *arg0, struct coord *arg1, struct coord *arg2, struct coord *arg3, struct coord *arg4);
 s32 eyespy0f0cf9f8(struct coord *arg0, struct coord *arg1, struct coord *arg2);
 s32 eyespy0f0cfafc(struct coord *arg0, struct coord *arg1, struct coord *arg2);
 s32 eyespy0f0cfdd0(struct coord *vel, struct coord *arg1, struct coord *arg2);
-void eyespyUpdateVertical(void);
-bool eyespyTryLaunch(void);
-void eyespyProcessInput(bool allowbuttons);
+void eyespy_update_vertical(void);
+bool eyespy_try_launch(void);
+void eyespy_process_input(bool allowbuttons);
 
 #endif

src/include/game/bondgrab.h

@@ -4,27 +4,27 @@
 #include "data.h"
 #include "types.h"
 
-void bgrabInit(void);
-void bgrabExit(void);
+void bgrab_init(void);
+void bgrab_exit(void);
 void bgrab0f0ccbf0(struct coord *delta, f32 angle, struct defaultobj *obj);
-bool bgrabTryMoveUpwards(f32 y);
-s32 bgrabCalculateNewPosition(struct coord *delta, f32 angle, bool arg2);
-bool bgrabCalculateNewPositiontWithPush(struct coord *delta, f32 angle, bool arg2);
+bool bgrab_try_move_upwards(f32 y);
+s32 bgrab_calculate_new_position(struct coord *delta, f32 angle, bool arg2);
+bool bgrab_calculate_new_positiont_with_push(struct coord *delta, f32 angle, bool arg2);
 bool bgrab0f0cdb04(f32 angle, bool arg2);
 bool bgrab0f0cdb68(f32 angle);
 void bgrab0f0cdef0(void);
 bool bgrab0f0cdf64(struct coord *delta, struct coord *arg1, struct coord *arg2);
 s32 bgrab0f0cdfbc(struct coord *delta, struct coord *arg1, struct coord *arg2);
 void bgrab0f0ce0bc(struct coord *arg0);
-void bgrabUpdatePrevPos(void);
+void bgrab_update_prev_pos(void);
 void bgrab0f0ce178(void);
-void bgrabUpdateVertical(void);
-void bgrabHandleActivate(void);
-void bgrabUpdateSpeedSideways(f32 targetspeed, f32 accelspeed, s32 mult);
-void bgrabUpdateSpeedForwards(f32 target, f32 speed);
-void bgrabApplyMoveData(struct movedata *data);
-void bgrabUpdateSpeedTheta(void);
+void bgrab_update_vertical(void);
+void bgrab_handle_activate(void);
+void bgrab_update_speed_sideways(f32 targetspeed, f32 accelspeed, s32 mult);
+void bgrab_update_speed_forwards(f32 target, f32 speed);
+void bgrab_apply_move_data(struct movedata *data);
+void bgrab_update_speed_theta(void);
 void bgrab0f0ce924(void);
-void bgrabTick(void);
+void bgrab_tick(void);
 
 #endif

src/include/game/bondgun.h

@@ -4,184 +4,184 @@
 #include "data.h"
 #include "types.h"
 
-void bgunReset(void);
+void bgun_reset(void);
 
-void bgunStop(void);
+void bgun_stop(void);
 
-void bgunRumble(s32 handnum, s32 weaponnum);
-s32 bgunGetUnequippedReloadIndex(s32 weaponnum);
-void bgunTickUnequippedReload(void);
-bool bgunTestGunVisCommand(struct gunviscmd *cmd, struct hand *hand);
-void bgunSetPartVisible(s16 partnum, bool visible, struct hand *hand, struct modeldef *modeldef);
-void bgunExecuteGunVisCommands(struct hand *hand, struct modeldef *arg1, struct gunviscmd *command);
+void bgun_rumble(s32 handnum, s32 weaponnum);
+s32 bgun_get_unequipped_reload_index(s32 weaponnum);
+void bgun_tick_unequipped_reload(void);
+bool bgun_test_gun_vis_command(struct gunviscmd *cmd, struct hand *hand);
+void bgun_set_part_visible(s16 partnum, bool visible, struct hand *hand, struct modeldef *modeldef);
+void bgun_execute_gun_vis_commands(struct hand *hand, struct modeldef *arg1, struct gunviscmd *command);
 void bgun0f098030(struct hand *hand, struct modeldef *arg1);
 f32 bgun0f09815c(struct hand *hand);
 void bgun0f0981e8(struct hand *hand, struct modeldef *modeldef);
 bool bgun0f098884(struct guncmd *cmd, struct gset *gset);
-void bgunStartAnimation(struct guncmd *cmd, s32 handnum, struct hand *hand);
+void bgun_start_animation(struct guncmd *cmd, s32 handnum, struct hand *hand);
 bool bgun0f098a44(struct hand *hand, s32 time);
-bool bgunIsAnimBusy(struct hand *hand);
-void bgunResetAnim(struct hand *hand);
-void bgunGetWeaponInfo(struct handweaponinfo *info, s32 handnum);
+bool bgun_is_anim_busy(struct hand *hand);
+void bgun_reset_anim(struct hand *hand);
+void bgun_get_weapon_info(struct handweaponinfo *info, s32 handnum);
 s32 bgun0f098ca0(s32 arg0, struct handweaponinfo *info, struct hand *hand);
 void bgun0f098df8(s32 weaponfunc, struct handweaponinfo *info, struct hand *hand, u8 onebullet, u8 checkunequipped);
 void bgun0f098f8c(struct handweaponinfo *info, struct hand *hand);
 bool bgun0f099008(s32 handnum);
 bool bgun0f0990b0(struct weaponfunc *basefunc, struct weapon *weapon);
 bool bgun0f099188(struct hand *hand, s32 gunfunc);
-s32 bgunTickIncIdle(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-void bgunSetArmPitch(struct hand *hand, f32 angle);
-s32 bgunTickIncAutoSwitch(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-bool bgunIsReloading(struct hand *hand);
-s32 bgunTickIncReload(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-s32 bgunTickIncChangeFunc(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+s32 bgun_tick_inc_idle(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+void bgun_set_arm_pitch(struct hand *hand, f32 angle);
+s32 bgun_tick_inc_auto_switch(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+bool bgun_is_reloading(struct hand *hand);
+s32 bgun_tick_inc_reload(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+s32 bgun_tick_inc_change_func(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
 s32 bgun0f09a3f8(struct hand *hand, struct weaponfunc *func);
 void bgun0f09a6f8(struct handweaponinfo *info, s32 handnum, struct hand *hand, struct weaponfunc *func);
-bool bgunTickRecoil(struct hand *hand, struct handweaponinfo *info, s32 handnum, struct weaponfunc_shoot *func);
-bool bgunTickIncAttackingShoot(struct handweaponinfo *info, s32 handnum, struct hand *hand);
-bool bgunTickIncAttackingThrow(s32 handnum, struct hand *hand);
-s32 bgunGetMinClipQty(s32 weaponnum, s32 funcnum);
-bool bgunTickIncAttackingMelee(s32 handnum, struct hand *hand);
-bool bgunTickIncAttackingSpecial(struct hand *hand);
-s32 bgunTickIncAttackEmpty(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-s32 bgunTickIncAttack(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-bool bgunIsReadyToSwitch(s32 handnum);
-bool bgunCanFreeWeapon(s32 handnum);
+bool bgun_tick_recoil(struct hand *hand, struct handweaponinfo *info, s32 handnum, struct weaponfunc_shoot *func);
+bool bgun_tick_inc_attacking_shoot(struct handweaponinfo *info, s32 handnum, struct hand *hand);
+bool bgun_tick_inc_attacking_throw(s32 handnum, struct hand *hand);
+s32 bgun_get_min_clip_qty(s32 weaponnum, s32 funcnum);
+bool bgun_tick_inc_attacking_melee(s32 handnum, struct hand *hand);
+bool bgun_tick_inc_attacking_special(struct hand *hand);
+s32 bgun_tick_inc_attack_empty(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+s32 bgun_tick_inc_attack(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+bool bgun_is_ready_to_switch(s32 handnum);
+bool bgun_can_free_weapon(s32 handnum);
 bool bgun0f09bf44(s32 handnum);
-s32 bgunTickIncChangeGun(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-s32 bgunTickIncState2(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
-s32 bgunTickInc(struct handweaponinfo *info, s32 handnum, s32 lvupdate);
-bool bgunSetState(s32 handnum, s32 state);
-void bgunTickHand(s32 handnum);
-void bgunTickSwitch(void);
-void bgunInitHandAnims(void);
-f32 bgunGetNoiseRadius(s32 handnum);
-void bgunDecreaseNoiseRadius(void);
-void bgunCalculateBlend(s32 hand);
-void bgunUpdateBlend(struct hand *hand, s32 handnum);
+s32 bgun_tick_inc_change_gun(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+s32 bgun_tick_inc_state2(struct handweaponinfo *info, s32 handnum, struct hand *hand, s32 lvupdate);
+s32 bgun_tick_inc(struct handweaponinfo *info, s32 handnum, s32 lvupdate);
+bool bgun_set_state(s32 handnum, s32 state);
+void bgun_tick_hand(s32 handnum);
+void bgun_tick_switch(void);
+void bgun_init_hand_anims(void);
+f32 bgun_get_noise_radius(s32 handnum);
+void bgun_decrease_noise_radius(void);
+void bgun_calculate_blend(s32 hand);
+void bgun_update_blend(struct hand *hand, s32 handnum);
 void bgun0f09d8dc(f32 breathing, f32 arg1, f32 arg2, f32 arg3, f32 arg4);
-bool bgunIsLoaded(void);
-u32 bgunGetGunMemType(void);
-u8 *bgunGetGunMem(void);
-u32 bgunCalculateGunMemCapacity(void);
-void bgunFreeGunMem(void);
-void bgunSetGunMemWeapon(s32 weaponnum);
-void bgunEnterFlux(void);
-bool bgunChangeGunMem(s32 newowner);
-void bgunTickGunLoad(void);
-void bgunTickMasterLoad(void);
-void bgunTickLoad(void);
-bool bgunLoadAll(void);
-struct modeldef *bgunGetCartModeldef(void);
+bool bgun_is_loaded(void);
+u32 bgun_get_gun_mem_type(void);
+u8 *bgun_get_gun_mem(void);
+u32 bgun_calculate_gun_mem_capacity(void);
+void bgun_free_gun_mem(void);
+void bgun_set_gun_mem_weapon(s32 weaponnum);
+void bgun_enter_flux(void);
+bool bgun_change_gun_mem(s32 newowner);
+void bgun_tick_gun_load(void);
+void bgun_tick_master_load(void);
+void bgun_tick_load(void);
+bool bgun_load_all(void);
+struct modeldef *bgun_get_cart_modeldef(void);
 void bgun0f09ebcc(struct defaultobj *obj, struct coord *coord, RoomNum *rooms, Mtxf *matrix1, struct coord *velocity, Mtxf *matrix2, struct prop *prop, struct coord *pos);
 void bgun0f09ed2c(struct defaultobj *obj, struct coord *coord, Mtxf *arg2, struct coord *velocity, Mtxf *arg4);
-struct defaultobj *bgunCreateThrownProjectile2(struct chrdata *chr, struct gset *gset, struct coord *pos, RoomNum *rooms, Mtxf *arg4, struct coord *velocity);
-void bgunCreateThrownProjectile(s32 handnum, struct gset *gset);
-void bgunUpdateHeldRocket(s32 handnum);
-void bgunCreateHeldRocket(s32 handnum, struct weaponfunc_shootprojectile *func);
-void bgunFreeHeldRocket(s32 handnum);
-void bgunCreateFiredProjectile(s32 handnum);
-void bgunSwivel(f32 autoaimx, f32 autoaimy, f32 crossdamp, f32 aimdamp);
-void bgunSwivelWithDamp(f32 screenx, f32 screeny, f32 damp);
-void bgunSwivelWithoutDamp(f32 arg0, f32 arg1);
-void bgunGetCrossPos(f32 *x, f32 *y);
+struct defaultobj *bgun_create_thrown_projectile2(struct chrdata *chr, struct gset *gset, struct coord *pos, RoomNum *rooms, Mtxf *arg4, struct coord *velocity);
+void bgun_create_thrown_projectile(s32 handnum, struct gset *gset);
+void bgun_update_held_rocket(s32 handnum);
+void bgun_create_held_rocket(s32 handnum, struct weaponfunc_shootprojectile *func);
+void bgun_free_held_rocket(s32 handnum);
+void bgun_create_fired_projectile(s32 handnum);
+void bgun_swivel(f32 autoaimx, f32 autoaimy, f32 crossdamp, f32 aimdamp);
+void bgun_swivel_with_damp(f32 screenx, f32 screeny, f32 damp);
+void bgun_swivel_without_damp(f32 arg0, f32 arg1);
+void bgun_get_cross_pos(f32 *x, f32 *y);
 void bgun0f0a0c08(struct coord *arg0, struct coord *arg1);
 void bgun0f0a0c44(s32 handnum, struct coord *arg1, struct coord *arg2);
-void bgunCalculatePlayerShotSpread(struct coord *arg0, struct coord *arg1, s32 handnum, bool dorandom);
-void bgunCalculateBotShotSpread(struct coord *arg0, s32 weaponnum, s32 funcnum, bool arg3, s32 crouchpos, bool dual);
-void bgunSetLastShootInfo(struct coord *pos, struct coord *dir, s32 handnum);
-s32 bgunGetShotsToTake(s32 handnum);
-void bgunFreeWeapon(s32 handnum);
-void bgunTickSwitch2(void);
-void bgunEquipWeapon(s32 weaponnum);
-s32 bgunGetWeaponNum(s32 handnum);
+void bgun_calculate_player_shot_spread(struct coord *arg0, struct coord *arg1, s32 handnum, bool dorandom);
+void bgun_calculate_bot_shot_spread(struct coord *arg0, s32 weaponnum, s32 funcnum, bool arg3, s32 crouchpos, bool dual);
+void bgun_set_last_shoot_info(struct coord *pos, struct coord *dir, s32 handnum);
+s32 bgun_get_shots_to_take(s32 handnum);
+void bgun_free_weapon(s32 handnum);
+void bgun_tick_switch2(void);
+void bgun_equip_weapon(s32 weaponnum);
+s32 bgun_get_weapon_num(s32 handnum);
 bool bgun0f0a1a10(s32 weaponnum);
-s32 bgunGetSwitchToWeapon(s32 handnum);
-void bgunSwitchToPrevious(void);
-void bgunCycleForward(void);
-void bgunCycleBack(void);
-bool bgunHasAmmoForWeapon(s32 weaponnum);
-void bgunAutoSwitchWeapon(void);
-void bgunEquipWeapon2(s32 handnum, s32 weaponnum);
-s32 bgunIsFiring(s32 handnum);
-s32 bgunGetAttackType(s32 handnum);
-char *bgunGetName(s32 weaponnum);
-u16 bgunGetNameId(s32 weaponnum);
-char *bgunGetShortName(s32 arg0);
-void bgunReloadIfPossible(s32 handnum);
-void bgunSetAdjustPos(f32 angle);
-void bgunStartSlide(s32 handnum);
-void bgunUpdateSlide(s32 handnum);
+s32 bgun_get_switch_to_weapon(s32 handnum);
+void bgun_switch_to_previous(void);
+void bgun_cycle_forward(void);
+void bgun_cycle_back(void);
+bool bgun_has_ammo_for_weapon(s32 weaponnum);
+void bgun_auto_switch_weapon(void);
+void bgun_equip_weapon2(s32 handnum, s32 weaponnum);
+s32 bgun_is_firing(s32 handnum);
+s32 bgun_get_attack_type(s32 handnum);
+char *bgun_get_name(s32 weaponnum);
+u16 bgun_get_name_id(s32 weaponnum);
+char *bgun_get_short_name(s32 arg0);
+void bgun_reload_if_possible(s32 handnum);
+void bgun_set_adjust_pos(f32 angle);
+void bgun_start_slide(s32 handnum);
+void bgun_update_slide(s32 handnum);
 f32 bgun0f0a2498(f32 arg0, f32 arg1, f32 arg2, f32 arg3);
 void bgun0f0a24f0(struct coord *arg0, s32 handnum);
 bool bgun0f0a27c8(void);
-void bgunHandlePlayerDead(void);
-bool bgunIsMissionCritical(s32 weaponnum);
-void bgunDisarm(struct prop *attacker);
-void bgunExecuteModelCmdList(s32 *arg0);
-s32 bgunCreateModelCmdList(struct model *model, struct modelnode *node, s32 *ptr);
-void bgunStartDetonateAnimation(s32 playernum);
-void bgunUpdateGangsta(struct hand *hand, s32 handnum, struct coord *arg2, struct weaponfunc *funcdef, Mtxf *arg4, Mtxf *arg5);
-void bgunUpdateSmoke(struct hand *hand, s32 handnum, s32 weaponnum, struct weaponfunc *funcdef);
-void bgunUpdateLasersight(struct hand *hand, struct modeldef *modeldef, s32 handnum, u8 *allocation);
-void bgunUpdateReaper(struct hand *hand, struct modeldef *modeldef);
-void bgunUpdateSniperRifle(struct modeldef *modeldef, u8 *allocation);
-void bgunUpdateDevastator(struct hand *hand, u8 *allocation, struct modeldef *modeldef);
-void bgunUpdateShotgun(struct hand *hand, u8 *allocation, bool *arg2, struct modeldef *modeldef);
-void bgunUpdateLaser(struct hand *hand);
-void bgunUpdateMagnum(struct hand *hand, s32 handnum, struct modeldef *modeldef, Mtxf *mtx);
-void bgunUpdateRocketLauncher(struct hand *hand, s32 handnum, struct weaponfunc_shootprojectile *func);
+void bgun_handle_player_dead(void);
+bool bgun_is_mission_critical(s32 weaponnum);
+void bgun_disarm(struct prop *attacker);
+void bgun_execute_model_cmd_list(s32 *arg0);
+s32 bgun_create_model_cmd_list(struct model *model, struct modelnode *node, s32 *ptr);
+void bgun_start_detonate_animation(s32 playernum);
+void bgun_update_gangsta(struct hand *hand, s32 handnum, struct coord *arg2, struct weaponfunc *funcdef, Mtxf *arg4, Mtxf *arg5);
+void bgun_update_smoke(struct hand *hand, s32 handnum, s32 weaponnum, struct weaponfunc *funcdef);
+void bgun_update_lasersight(struct hand *hand, struct modeldef *modeldef, s32 handnum, u8 *allocation);
+void bgun_update_reaper(struct hand *hand, struct modeldef *modeldef);
+void bgun_update_sniper_rifle(struct modeldef *modeldef, u8 *allocation);
+void bgun_update_devastator(struct hand *hand, u8 *allocation, struct modeldef *modeldef);
+void bgun_update_shotgun(struct hand *hand, u8 *allocation, bool *arg2, struct modeldef *modeldef);
+void bgun_update_laser(struct hand *hand);
+void bgun_update_magnum(struct hand *hand, s32 handnum, struct modeldef *modeldef, Mtxf *mtx);
+void bgun_update_rocket_launcher(struct hand *hand, s32 handnum, struct weaponfunc_shootprojectile *func);
 void bgun0f0a45d0(struct hand *hand, struct modeldef *modeldef, bool isdetonator);
-void bgunTickEject(struct hand *hand, struct modeldef *modeldef, bool isdetonator);
+void bgun_tick_eject(struct hand *hand, struct modeldef *modeldef, bool isdetonator);
 void bgun0f0a4e44(struct hand *hand, struct weapon *weapondef, struct modeldef *modeldef, struct weaponfunc *funcdef, s32 maxburst, u8 *allocation, s32 weaponnum, bool **arg7, s32 mtxindex, Mtxf *arg9, Mtxf *arg10);
-void bgunCreateFx(struct hand *hand, s32 handnum, struct weaponfunc *funcdef, s32 weaponnum, struct modeldef *modeldef, u8 *allocation);
+void bgun_create_fx(struct hand *hand, s32 handnum, struct weaponfunc *funcdef, s32 weaponnum, struct modeldef *modeldef, u8 *allocation);
 void bgun0f0a5550(s32 handnum);
-void bgunTickMaulerCharge(void);
-void bgunTickGameplay2(void);
-s32 bgunAllocateFireslot(void);
-void bgunRender(Gfx **gdl);
-struct sndstate **bgunAllocateAudioHandle(void);
-void bgunPlayPropHitSound(struct gset *gset, struct prop *prop, s32 texturenum);
-void bgunPlayGlassHitSound(struct coord *pos, RoomNum *rooms, s32 texturenum);
-void bgunPlayBgHitSound(struct gset *gset, struct coord *hitpos, s32 texturenum, RoomNum *rooms);
-void bgunSetTriggerOn(s32 handnum, bool on);
-s32 bgunConsiderToggleGunFunction(s32 usedowntime, bool trigpressed, bool fromactivemenu);
+void bgun_tick_mauler_charge(void);
+void bgun_tick_gameplay2(void);
+s32 bgun_allocate_fireslot(void);
+void bgun_render(Gfx **gdl);
+struct sndstate **bgun_allocate_audio_handle(void);
+void bgun_play_prop_hit_sound(struct gset *gset, struct prop *prop, s32 texturenum);
+void bgun_play_glass_hit_sound(struct coord *pos, RoomNum *rooms, s32 texturenum);
+void bgun_play_bg_hit_sound(struct gset *gset, struct coord *hitpos, s32 texturenum, RoomNum *rooms);
+void bgun_set_trigger_on(s32 handnum, bool on);
+s32 bgun_consider_toggle_gun_function(s32 usedowntime, bool trigpressed, bool fromactivemenu);
 void bgun0f0a8c50(void);
-bool bgunIsUsingSecondaryFunction(void);
-void bgunTickGameplay(bool triggeron);
-void bgunSetPassiveMode(bool enable);
-void bgunSetAimType(u32 aimtype);
-void bgunSetAimPos(struct coord *coord);
-void bgunSetHitPos(struct coord *coord);
+bool bgun_is_using_secondary_function(void);
+void bgun_tick_gameplay(bool triggeron);
+void bgun_set_passive_mode(bool enable);
+void bgun_set_aim_type(u32 aimtype);
+void bgun_set_aim_pos(struct coord *coord);
+void bgun_set_hit_pos(struct coord *coord);
 void bgun0f0a9494(u32 operation);
 void bgun0f0a94d0(u32 operation, struct coord *pos, struct coord *rot);
-void bgunSetGunAmmoVisible(u32 reason, bool enable);
-void bgunSetAmmoQuantity(s32 ammotype, s32 quantity);
-s32 bgunGetReservedAmmoCount(s32 type);
-s32 bgunGetAmmoCount(s32 ammotype);
-s32 bgunGetCapacityByAmmotype(s32 ammotype);
-bool bgunAmmotypeAllowsUnlimitedAmmo(u32 ammotype);
-void bgunGiveMaxAmmo(bool force);
-u32 bgunGetAmmoTypeForWeapon(u32 weaponnum, u32 func);
-s32 bgunGetAmmoQtyForWeapon(u32 weaponnum, u32 func);
-void bgunSetAmmoQtyForWeapon(u32 weaponnum, u32 func, u32 quantity);
-s32 bgunGetAmmoCapacityForWeapon(s32 weaponnum, s32 func);
-Gfx *bgunDrawHudString(Gfx *gdl, char *text, s32 x, bool halign, s32 y, s32 valign, u32 colour);
-Gfx *bgunDrawHudInteger(Gfx *gdl, s32 value, s32 x, bool halign, s32 y, s32 valign, u32 colour);
-void bgunResetAbmag(struct abmag *abmag);
+void bgun_set_gun_ammo_visible(u32 reason, bool enable);
+void bgun_set_ammo_quantity(s32 ammotype, s32 quantity);
+s32 bgun_get_reserved_ammo_count(s32 type);
+s32 bgun_get_ammo_count(s32 ammotype);
+s32 bgun_get_capacity_by_ammotype(s32 ammotype);
+bool bgun_ammotype_allows_unlimited_ammo(u32 ammotype);
+void bgun_give_max_ammo(bool force);
+u32 bgun_get_ammo_type_for_weapon(u32 weaponnum, u32 func);
+s32 bgun_get_ammo_qty_for_weapon(u32 weaponnum, u32 func);
+void bgun_set_ammo_qty_for_weapon(u32 weaponnum, u32 func, u32 quantity);
+s32 bgun_get_ammo_capacity_for_weapon(s32 weaponnum, s32 func);
+Gfx *bgun_draw_hud_string(Gfx *gdl, char *text, s32 x, bool halign, s32 y, s32 valign, u32 colour);
+Gfx *bgun_draw_hud_integer(Gfx *gdl, s32 value, s32 x, bool halign, s32 y, s32 valign, u32 colour);
+void bgun_reset_abmag(struct abmag *abmag);
 void bgun0f0a9da8(struct abmag *abmag, s32 remaining, s32 capacity, s32 height);
-Gfx *bgunDrawHudGauge(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, struct abmag *abmag, s32 remaining, s32 capacity, u32 vacantcolour, u32 occupiedcolour, bool flip);
-Gfx *bgunDrawHud(Gfx *gdl);
-void bgunAddBoost(s32 arg0);
-void bgunSubtractBoost(s32 arg0);
-void bgunApplyBoost(void);
-void bgunRevertBoost(void);
-void bgunTickBoost(void);
-void bgunSetSightVisible(u32 bits, bool visible);
-Gfx *bgunDrawSight(Gfx *gdl);
+Gfx *bgun_draw_hud_gauge(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, struct abmag *abmag, s32 remaining, s32 capacity, u32 vacantcolour, u32 occupiedcolour, bool flip);
+Gfx *bgun_draw_hud(Gfx *gdl);
+void bgun_add_boost(s32 arg0);
+void bgun_subtract_boost(s32 arg0);
+void bgun_apply_boost(void);
+void bgun_revert_boost(void);
+void bgun_tick_boost(void);
+void bgun_set_sight_visible(u32 bits, bool visible);
+Gfx *bgun_draw_sight(Gfx *gdl);
 void bgun0f0abd30(s32 handnum);
-s32 bgunGetWeaponNum2(s32 handnum);
-s8 bgunFreeFireslotWrapper(s32 fireslot);
-s8 bgunFreeFireslot(s32 fireslot);
+s32 bgun_get_weapon_num2(s32 handnum);
+s8 bgun_free_fireslot_wrapper(s32 fireslot);
+s8 bgun_free_fireslot(s32 fireslot);
 
 #endif

src/include/game/bondguninit.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-void bgunReset(void);
+void bgun_reset(void);
 
 #endif

src/include/game/bondhead.h

@@ -4,17 +4,17 @@
 #include "data.h"
 #include "types.h"
 
-void bheadReset(void);
+void bhead_reset(void);
 
-void bheadFlipAnimation(void);
-void bheadUpdateIdleRoll(void);
-void bheadUpdatePos(struct coord *vel);
-void bheadUpdateRot(struct coord *lookvel, struct coord *upvel);
-void bheadSetDamp(f32 headdamp);
-void bheadUpdate(f32 arg0, f32 arg1);
-void bheadAdjustAnimation(f32 speed);
-void bheadStartDeathAnimation(s16 animnum, u32 flip, f32 fstarttime, f32 speed);
-void bheadSetSpeed(f32 speed);
-f32 bheadGetBreathingValue(void);
+void bhead_flip_animation(void);
+void bhead_update_idle_roll(void);
+void bhead_update_pos(struct coord *vel);
+void bhead_update_rot(struct coord *lookvel, struct coord *upvel);
+void bhead_set_damp(f32 headdamp);
+void bhead_update(f32 arg0, f32 arg1);
+void bhead_adjust_animation(f32 speed);
+void bhead_start_death_animation(s16 animnum, u32 flip, f32 fstarttime, f32 speed);
+void bhead_set_speed(f32 speed);
+f32 bhead_get_breathing_value(void);
 
 #endif

src/include/game/bondmove.h

@@ -4,44 +4,44 @@
 #include "data.h"
 #include "types.h"
 
-void bmoveSetControlDef(u32 controldef);
-void bmoveSetAutoMoveCentreEnabled(bool enabled);
-void bmoveSetAutoAimY(bool enabled);
-bool bmoveIsAutoAimYEnabled(void);
-bool bmoveIsAutoAimYEnabledForCurrentWeapon(void);
-bool bmoveIsInSightAimMode(void);
-void bmoveUpdateAutoAimYProp(struct prop *prop, f32 autoaimy);
-void bmoveSetAutoAimX(bool enabled);
-bool bmoveIsAutoAimXEnabled(void);
-bool bmoveIsAutoAimXEnabledForCurrentWeapon(void);
-void bmoveUpdateAutoAimXProp(struct prop *prop, f32 autoaimx);
-struct prop *bmoveGetHoverbike(void);
-struct prop *bmoveGetGrabbedProp(void);
-void bmoveGrabProp(struct prop *prop);
-void bmoveSetMode(u32 movemode);
-void bmoveSetModeForAllPlayers(u32 movemode);
-void bmoveHandleActivate(void);
-void bmoveApplyMoveData(struct movedata *data);
-void bmoveUpdateSpeedTheta(void);
-f32 bmoveGetSpeedVertaLimit(f32 value);
-void bmoveUpdateSpeedVerta(f32 value);
-f32 bmoveGetSpeedThetaControlLimit(f32 value);
-void bmoveUpdateSpeedThetaControl(f32 value);
-f32 bmoveCalculateLookahead(void);
-void bmoveResetMoveData(struct movedata *data);
-void bmoveProcessInput(bool allowc1x, bool allowc1y, bool allowc1buttons, bool ignorec2);
-void bmoveFindEnteredRoomsByPos(struct player *player, struct coord *arg1, RoomNum *rooms);
-void bmoveFindEnteredRooms(struct player *player, RoomNum *rooms);
-void bmoveUpdateRooms(struct player *player);
+void bmove_set_control_def(u32 controldef);
+void bmove_set_auto_move_centre_enabled(bool enabled);
+void bmove_set_auto_aim_y(bool enabled);
+bool bmove_is_auto_aim_y_enabled(void);
+bool bmove_is_auto_aim_y_enabled_for_current_weapon(void);
+bool bmove_is_in_sight_aim_mode(void);
+void bmove_update_auto_aim_y_prop(struct prop *prop, f32 autoaimy);
+void bmove_set_auto_aim_x(bool enabled);
+bool bmove_is_auto_aim_x_enabled(void);
+bool bmove_is_auto_aim_x_enabled_for_current_weapon(void);
+void bmove_update_auto_aim_x_prop(struct prop *prop, f32 autoaimx);
+struct prop *bmove_get_hoverbike(void);
+struct prop *bmove_get_grabbed_prop(void);
+void bmove_grab_prop(struct prop *prop);
+void bmove_set_mode(u32 movemode);
+void bmove_set_mode_for_all_players(u32 movemode);
+void bmove_handle_activate(void);
+void bmove_apply_move_data(struct movedata *data);
+void bmove_update_speed_theta(void);
+f32 bmove_get_speed_verta_limit(f32 value);
+void bmove_update_speed_verta(f32 value);
+f32 bmove_get_speed_theta_control_limit(f32 value);
+void bmove_update_speed_theta_control(f32 value);
+f32 bmove_calculate_lookahead(void);
+void bmove_reset_move_data(struct movedata *data);
+void bmove_process_input(bool allowc1x, bool allowc1y, bool allowc1buttons, bool ignorec2);
+void bmove_find_entered_rooms_by_pos(struct player *player, struct coord *arg1, RoomNum *rooms);
+void bmove_find_entered_rooms(struct player *player, RoomNum *rooms);
+void bmove_update_rooms(struct player *player);
 void bmove0f0cb904(struct coord *coord);
 void bmove0f0cba88(f32 *a, f32 *b, struct coord *c, f32 mult1, f32 mult2);
-void bmoveUpdateMoveInitSpeed(struct coord *newpos);
-void bmoveTick(bool allowc1x, bool allowc1y, bool allowc1buttons, bool ignorec2);
-void bmoveUpdateVerta(void);
+void bmove_update_move_init_speed(struct coord *newpos);
+void bmove_tick(bool allowc1x, bool allowc1y, bool allowc1buttons, bool ignorec2);
+void bmove_update_verta(void);
 void bmove0f0cc19c(struct coord *arg);
-void bmoveUpdateHead(f32 arg0, f32 arg1, f32 arg2, Mtxf *arg3, f32 arg4);
+void bmove_update_head(f32 arg0, f32 arg1, f32 arg2, Mtxf *arg3, f32 arg4);
 void bmove0f0cc654(f32 arg0, f32 arg1, f32 arg2);
-s32 bmoveGetCrouchPos(void);
-s32 bmoveGetCrouchPosByPlayer(s32 playernum);
+s32 bmove_get_crouch_pos(void);
+s32 bmove_get_crouch_pos_by_player(s32 playernum);
 
 #endif

src/include/game/bondview.h

@@ -4,27 +4,27 @@
 #include "data.h"
 #include "types.h"
 
-Gfx *bviewDrawIrRect(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
-Gfx *bviewCopyPixels(Gfx *gdl, u16 *fb, s32 top, u32 tile, s32 arg4, f32 arg5, s32 left, s32 width);
-Gfx *bviewDrawFisheyeRect(Gfx *gdl, s32 arg1, f32 arg2, s32 arg3, s32 arg4);
-Gfx *bviewPrepareStaticRgba16(Gfx *gdl, u32 colour, u32 alpha);
-Gfx *bviewPrepareStaticI8(Gfx *gdl, u32 colour, u32 alpha);
-Gfx *bviewDrawMotionBlur(Gfx *gdl, u32 colour, u32 alpha);
-Gfx *bviewDrawStatic(Gfx *gdl, u32 arg1, s32 arg2);
-Gfx *bviewDrawSlayerRocketInterlace(Gfx *gdl, u32 arg1, u32 arg2);
-Gfx *bviewDrawFilmInterlace(Gfx *gdl, u32 colour, u32 alpha);
-Gfx *bviewDrawZoomBlur(Gfx *gdl, u32 colour, s32 alpha, f32 arg3, f32 arg4);
+Gfx *bview_draw_ir_rect(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
+Gfx *bview_copy_pixels(Gfx *gdl, u16 *fb, s32 top, u32 tile, s32 arg4, f32 arg5, s32 left, s32 width);
+Gfx *bview_draw_fisheye_rect(Gfx *gdl, s32 arg1, f32 arg2, s32 arg3, s32 arg4);
+Gfx *bview_prepare_static_rgba16(Gfx *gdl, u32 colour, u32 alpha);
+Gfx *bview_prepare_static_i8(Gfx *gdl, u32 colour, u32 alpha);
+Gfx *bview_draw_motion_blur(Gfx *gdl, u32 colour, u32 alpha);
+Gfx *bview_draw_static(Gfx *gdl, u32 arg1, s32 arg2);
+Gfx *bview_draw_slayer_rocket_interlace(Gfx *gdl, u32 arg1, u32 arg2);
+Gfx *bview_draw_film_interlace(Gfx *gdl, u32 colour, u32 alpha);
+Gfx *bview_draw_zoom_blur(Gfx *gdl, u32 colour, s32 alpha, f32 arg3, f32 arg4);
 f32 bview0f142d74(s32 arg0, f32 arg1, f32 arg2, f32 arg3);
-Gfx *bviewDrawFisheye(Gfx *gdl, u32 colour, u32 alpha, s32 shuttertime60, s8 startuptimer60, u8 hit);
-Gfx *bviewDrawEyespySideRect(Gfx *gdl, s32 *points, u8 r, u8 g, u8 b, u8 alpha);
-Gfx *bviewDrawEyespyMetrics(Gfx *gdl);
-Gfx *bviewDrawNvLens(Gfx *gdl);
-Gfx *bviewDrawIrLens(Gfx *gdl);
-Gfx *bviewDrawIntroText(Gfx *gdl);
-Gfx *bviewDrawHorizonScanner(Gfx *gdl);
-Gfx *bviewDrawIrBinoculars(Gfx *gdl);
-void bviewSetMotionBlur(u32 bluramount);
-void bviewClearMotionBlur(void);
-Gfx *bviewDrawNvBinoculars(Gfx *gdl);
+Gfx *bview_draw_fisheye(Gfx *gdl, u32 colour, u32 alpha, s32 shuttertime60, s8 startuptimer60, u8 hit);
+Gfx *bview_draw_eyespy_side_rect(Gfx *gdl, s32 *points, u8 r, u8 g, u8 b, u8 alpha);
+Gfx *bview_draw_eyespy_metrics(Gfx *gdl);
+Gfx *bview_draw_nv_lens(Gfx *gdl);
+Gfx *bview_draw_ir_lens(Gfx *gdl);
+Gfx *bview_draw_intro_text(Gfx *gdl);
+Gfx *bview_draw_horizon_scanner(Gfx *gdl);
+Gfx *bview_draw_ir_binoculars(Gfx *gdl);
+void bview_set_motion_blur(u32 bluramount);
+void bview_clear_motion_blur(void);
+Gfx *bview_draw_nv_binoculars(Gfx *gdl);
 
 #endif

src/include/game/bondwalk.h

@@ -4,31 +4,31 @@
 #include "data.h"
 #include "types.h"
 
-void bwalkInit(void);
-void bwalkSetSwayTarget(s32 value);
-void bwalkAdjustCrouchPos(s32 value);
+void bwalk_init(void);
+void bwalk_set_sway_target(s32 value);
+void bwalk_adjust_crouch_pos(s32 value);
 void bwalk0f0c3b38(struct coord *param_1, struct defaultobj *obj);
-s32 bwalkTryMoveUpwards(f32 amount);
-bool bwalkCalculateNewPosition(struct coord *vel, f32 rotateamount, bool apply, f32 extrawidth, s32 arg4);
-bool bwalkCalculateNewPositionWithPush(struct coord *delta, f32 rotateamount, bool apply, f32 extrawidth, s32 types);
+s32 bwalk_try_move_upwards(f32 amount);
+bool bwalk_calculate_new_position(struct coord *vel, f32 rotateamount, bool apply, f32 extrawidth, s32 arg4);
+bool bwalk_calculate_new_position_with_push(struct coord *delta, f32 rotateamount, bool apply, f32 extrawidth, s32 types);
 s32 bwalk0f0c4764(struct coord *delta, struct coord *arg1, struct coord *arg2, s32 types);
 s32 bwalk0f0c47d0(struct coord *a, struct coord *b, struct coord *c, struct coord *d, struct coord *e, s32 types);
 s32 bwalk0f0c494c(struct coord *a, struct coord *b, struct coord *c, s32 types);
 s32 bwalk0f0c4a5c(struct coord *a, struct coord *b, struct coord *c, s32 types);
 void bwalk0f0c4d98(void);
-void bwalkUpdateSpeedSideways(f32 targetspeed, f32 accelspeed, s32 mult);
-void bwalkUpdateSpeedForwards(f32 targetspeed, f32 accelspeed);
-void bwalkUpdateVertical(void);
-void bwalkApplyCrouchSpeed(void);
-void bwalkUpdateCrouchOffsetReal(void);
-void bwalkUpdateCrouchOffset(void);
-void bwalkUpdateTheta(void);
+void bwalk_update_speed_sideways(f32 targetspeed, f32 accelspeed, s32 mult);
+void bwalk_update_speed_forwards(f32 targetspeed, f32 accelspeed);
+void bwalk_update_vertical(void);
+void bwalk_apply_crouch_speed(void);
+void bwalk_update_crouch_offset_real(void);
+void bwalk_update_crouch_offset(void);
+void bwalk_update_theta(void);
 void bwalk0f0c63bc(struct coord *arg0, u32 arg1, s32 types);
-void bwalkUpdatePrevPos(void);
-void bwalkHandleActivate(void);
-void bwalkApplyMoveData(struct movedata *data);
-void bwalkUpdateSpeedTheta(void);
+void bwalk_update_prev_pos(void);
+void bwalk_handle_activate(void);
+void bwalk_apply_move_data(struct movedata *data);
+void bwalk_update_speed_theta(void);
 void bwalk0f0c69b8(void);
-void bwalkTick(void);
+void bwalk_tick(void);
 
 #endif

src/include/game/bossfile.h

@@ -4,10 +4,10 @@
 #include "data.h"
 #include "types.h"
 
-bool bossfileLoadFull(void);
-u32 bossfileFindFileId(void);
-void bossfileLoad(void);
-void bossfileSave(void);
-void bossfileSetDefaults(void);
+bool bossfile_load_full(void);
+u32 bossfile_find_file_id(void);
+void bossfile_load(void);
+void bossfile_save(void);
+void bossfile_set_defaults(void);
 
 #endif

src/include/game/bot.h

@@ -4,60 +4,60 @@
 #include "data.h"
 #include "types.h"
 
-bool botroomFindPos(RoomNum room, struct coord *pos, f32 *angleptr, s32 *padnumptr, s32 *covernumptr);
+bool botroom_find_pos(RoomNum room, struct coord *pos, f32 *angleptr, s32 *padnumptr, s32 *covernumptr);
 
-bool botIsDizzy(struct chrdata *chr);
-void botReset(struct chrdata *chr, u8 respawning);
-void botSpawn(struct chrdata *chr, u8 full);
-void botSpawnAll(void);
+bool bot_is_dizzy(struct chrdata *chr);
+void bot_reset(struct chrdata *chr, u8 respawning);
+void bot_spawn(struct chrdata *chr, u8 full);
+void bot_spawn_all(void);
 u32 add87654321(u32 value);
-u32 botPickupProp(struct prop *prop, struct chrdata *chr);
-bool botTestPropForPickup(struct prop *prop, struct chrdata *chr);
-void botCheckPickups(struct chrdata *chr);
-s32 botGuessCrouchPos(struct chrdata *chr);
-bool botApplyMovement(struct chrdata *chr);
-bool botIsAboutToAttack(struct chrdata *chr, bool arg1);
-s32 botTick(struct prop *prop);
-f32 botCalculateMaxSpeed(struct chrdata *chr);
+u32 bot_pickup_prop(struct prop *prop, struct chrdata *chr);
+bool bot_test_prop_for_pickup(struct prop *prop, struct chrdata *chr);
+void bot_check_pickups(struct chrdata *chr);
+s32 bot_guess_crouch_pos(struct chrdata *chr);
+bool bot_apply_movement(struct chrdata *chr);
+bool bot_is_about_to_attack(struct chrdata *chr, bool arg1);
+s32 bot_tick(struct prop *prop);
+f32 bot_calculate_max_speed(struct chrdata *chr);
 
 #if VERSION >= VERSION_NTSC_1_0
-void botUpdateLateral(struct chrdata *chr, f32 *move, s32 numupdates, f32 arg3);
+void bot_update_lateral(struct chrdata *chr, f32 *move, s32 numupdates, f32 arg3);
 #else
-void botUpdateLateral(struct chrdata *chr, f32 *move);
+void bot_update_lateral(struct chrdata *chr, f32 *move);
 #endif
 
-void botDisarm(struct chrdata *chr, struct prop *attacker);
-void botSetTarget(struct chrdata *chr, s32 propnum);
-bool botIsTargetInvisible(struct chrdata *botchr, struct chrdata *otherchr);
-bool botHasGround(struct chrdata *chr);
-void botUpdateZeroAngle(struct chrdata *chr);
-bool botPassesPeaceCheck(struct chrdata *botchr, struct chrdata *otherchr);
-bool botPassesCowardCheck(struct chrdata *botchr, struct chrdata *otherchr);
-void botChooseGeneralTarget(struct chrdata *chr);
-void botScheduleReload(struct chrdata *chr, s32 handnum);
-struct prop *botFindPickup(struct chrdata *chr, s32 criteria);
-s32 botGetNumOpponentsInHill(struct chrdata *chr);
-void botTickUnpaused(struct chrdata *chr);
-s32 botIsObjCollectable(struct defaultobj *obj);
-s32 botGetWeaponNum(struct chrdata *chr);
-u8 botGetTargetsWeaponNum(struct chrdata *chr);
-char *botGetCommandName(s32 command);
-void botApplyAttack(struct chrdata *chr, struct prop *prop);
-void botApplyFollow(struct chrdata *chr, struct prop *prop);
-void botApplyProtect(struct chrdata *chr, struct prop *prop);
-void botApplyDefend(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle);
-void botApplyHold(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle);
-void botApplyScenarioCommand(struct chrdata *chr, u32 arg1);
-bool botCanFollow(struct chrdata *leader, struct chrdata *follower);
-s32 botFindTeammateToFollow(struct chrdata *chr, f32 range);
-bool botCanDoCriticalPickup(struct chrdata *chr);
-struct prop *botFindDefaultPickup(struct chrdata *chr);
-struct prop *botFindAnyPickup(struct chrdata *chr);
-s32 botGetTeamSize(struct chrdata *chr);
-s32 botGetCountInTeamDoingCommand(struct chrdata *self, u32 command, bool includeself);
-s32 botIsChrsCtcTokenHeld(struct chrdata *chr);
-bool botShouldReturnCtcToken(struct chrdata *chr);
-s32 botGetNumTeammatesDefendingHill(struct chrdata *bot);
-void botCheckFetch(struct chrdata *chr);
+void bot_disarm(struct chrdata *chr, struct prop *attacker);
+void bot_set_target(struct chrdata *chr, s32 propnum);
+bool bot_is_target_invisible(struct chrdata *botchr, struct chrdata *otherchr);
+bool bot_has_ground(struct chrdata *chr);
+void bot_update_zero_angle(struct chrdata *chr);
+bool bot_passes_peace_check(struct chrdata *botchr, struct chrdata *otherchr);
+bool bot_passes_coward_check(struct chrdata *botchr, struct chrdata *otherchr);
+void bot_choose_general_target(struct chrdata *chr);
+void bot_schedule_reload(struct chrdata *chr, s32 handnum);
+struct prop *bot_find_pickup(struct chrdata *chr, s32 criteria);
+s32 bot_get_num_opponents_in_hill(struct chrdata *chr);
+void bot_tick_unpaused(struct chrdata *chr);
+s32 bot_is_obj_collectable(struct defaultobj *obj);
+s32 bot_get_weapon_num(struct chrdata *chr);
+u8 bot_get_targets_weapon_num(struct chrdata *chr);
+char *bot_get_command_name(s32 command);
+void bot_apply_attack(struct chrdata *chr, struct prop *prop);
+void bot_apply_follow(struct chrdata *chr, struct prop *prop);
+void bot_apply_protect(struct chrdata *chr, struct prop *prop);
+void bot_apply_defend(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle);
+void bot_apply_hold(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle);
+void bot_apply_scenario_command(struct chrdata *chr, u32 arg1);
+bool bot_can_follow(struct chrdata *leader, struct chrdata *follower);
+s32 bot_find_teammate_to_follow(struct chrdata *chr, f32 range);
+bool bot_can_do_critical_pickup(struct chrdata *chr);
+struct prop *bot_find_default_pickup(struct chrdata *chr);
+struct prop *bot_find_any_pickup(struct chrdata *chr);
+s32 bot_get_team_size(struct chrdata *chr);
+s32 bot_get_count_in_team_doing_command(struct chrdata *self, u32 command, bool includeself);
+s32 bot_is_chrs_ctc_token_held(struct chrdata *chr);
+bool bot_should_return_ctc_token(struct chrdata *chr);
+s32 bot_get_num_teammates_defending_hill(struct chrdata *bot);
+void bot_check_fetch(struct chrdata *chr);
 
 #endif

src/include/game/botact.h

@@ -4,22 +4,22 @@
 #include "data.h"
 #include "types.h"
 
-s32 botactGetAmmoTypeByFunction(s32 weaponnum, s32 funcnum);
-s32 botactGetClipCapacityByFunction(s32 weaponnum, u32 funcnum);
-void botactReload(struct chrdata *chr, s32 handnum, bool withsound);
-s32 botactGetAmmoQuantityByWeapon(struct aibot *aibot, s32 weaponnum, s32 funcnum, bool include_equipped);
-s32 botactGetAmmoQuantityByType(struct aibot *aibot, s32 ammotype, bool include_equipped);
-s32 botactTryRemoveAmmoFromReserve(struct aibot *aibot, s32 weaponnum, s32 funcnum, s32 qty);
-void botactGiveAmmoByWeapon(struct aibot *aibot, s32 weaponnum, s32 funcnum, s32 qty);
-void botactGiveAmmoByType(struct aibot *aibot, u32 ammotype, s32 quantity);
-bool botactShootFarsight(struct chrdata *chr, s32 arg1, struct coord *arg2, struct coord *arg3);
-bool botactIsWeaponThrowable(s32 weaponnum, bool is_secondary);
-u32 botactGetProjectileThrowInterval(u32 weapon);
-s32 botactGetWeaponByAmmoType(s32 ammotype);
-void botactThrow(struct chrdata *chr);
-s32 botactGetShootInterval60(s32 weaponnum, s32 funcnum);
-bool botactFindRocketRoute(struct chrdata *chr, struct coord *frompos, struct coord *topos, RoomNum *fromrooms, RoomNum *torooms, struct projectile *projectile);
-void botactGetRocketNextStepPos(u16 padnum, struct coord *pos);
-void botactCreateSlayerRocket(struct chrdata *chr);
+s32 botact_get_ammo_type_by_function(s32 weaponnum, s32 funcnum);
+s32 botact_get_clip_capacity_by_function(s32 weaponnum, u32 funcnum);
+void botact_reload(struct chrdata *chr, s32 handnum, bool withsound);
+s32 botact_get_ammo_quantity_by_weapon(struct aibot *aibot, s32 weaponnum, s32 funcnum, bool include_equipped);
+s32 botact_get_ammo_quantity_by_type(struct aibot *aibot, s32 ammotype, bool include_equipped);
+s32 botact_try_remove_ammo_from_reserve(struct aibot *aibot, s32 weaponnum, s32 funcnum, s32 qty);
+void botact_give_ammo_by_weapon(struct aibot *aibot, s32 weaponnum, s32 funcnum, s32 qty);
+void botact_give_ammo_by_type(struct aibot *aibot, u32 ammotype, s32 quantity);
+bool botact_shoot_farsight(struct chrdata *chr, s32 arg1, struct coord *arg2, struct coord *arg3);
+bool botact_is_weapon_throwable(s32 weaponnum, bool is_secondary);
+u32 botact_get_projectile_throw_interval(u32 weapon);
+s32 botact_get_weapon_by_ammo_type(s32 ammotype);
+void botact_throw(struct chrdata *chr);
+s32 botact_get_shoot_interval60(s32 weaponnum, s32 funcnum);
+bool botact_find_rocket_route(struct chrdata *chr, struct coord *frompos, struct coord *topos, RoomNum *fromrooms, RoomNum *torooms, struct projectile *projectile);
+void botact_get_rocket_next_step_pos(u16 padnum, struct coord *pos);
+void botact_create_slayer_rocket(struct chrdata *chr);
 
 #endif

src/include/game/botcmd.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void botcmdTickDistMode(struct chrdata *chr);
-void botcmdApply(struct chrdata *chr, u32 command);
+void botcmd_tick_dist_mode(struct chrdata *chr);
+void botcmd_apply(struct chrdata *chr, u32 command);
 
 #endif

src/include/game/botinv.h

@@ -4,27 +4,27 @@
 #include "data.h"
 #include "types.h"
 
-void botinvClear(struct chrdata *chr);
-struct invitem *botinvGetFreeSlot(struct chrdata *chr);
-struct invitem *botinvGetItem(struct chrdata *chr, s32 weaponnum);
-void botinvRemoveItem(struct chrdata *chr, s32 weaponnum);
-u32 botinvGetItemType(struct chrdata *chr, u32 weaponnum);
-bool botinvGiveSingleWeapon(struct chrdata *chr, u32 weaponnum);
-void botinvGiveDualWeapon(struct chrdata *chr, u32 weaponnum);
-s16 botinvGetWeaponPad(struct chrdata *chr, u32 weaponnum);
-bool botinvGiveProp(struct chrdata *chr, struct prop *prop);
-void botinvScoreAllWeapons(struct chrdata *chr, s32 *weaponnums, s32 *scores1, s32 *scores2);
-bool mpHasShield(void);
-s32 mpGetWeaponSlotByWeaponNum(s32 weaponnum);
-void botinvScoreWeapon(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2, bool arg7, bool learn);
-void botinvScoreWeaponAgainstTarget(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2);
-void botinvScoreWeaponByItself(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2);
-s32 botinvGetDistConfig(s32 weaponnum, s32 funcnum);
-bool botinvAllowsWeapon(struct chrdata *chr, s32 weaponnum, s32 funcnum);
-void botinvTick(struct chrdata *chr);
-bool botinvSwitchToWeapon(struct chrdata *chr, s32 weaponnum, s32 funcnum);
-void botinvDrop(struct chrdata *chr, s32 weaponnum, u8 dropall);
-void botinvDropAll(struct chrdata *chr, u32 weaponnum);
-void botinvDropOne(struct chrdata *chr, u32 weaponnum);
+void botinv_clear(struct chrdata *chr);
+struct invitem *botinv_get_free_slot(struct chrdata *chr);
+struct invitem *botinv_get_item(struct chrdata *chr, s32 weaponnum);
+void botinv_remove_item(struct chrdata *chr, s32 weaponnum);
+u32 botinv_get_item_type(struct chrdata *chr, u32 weaponnum);
+bool botinv_give_single_weapon(struct chrdata *chr, u32 weaponnum);
+void botinv_give_dual_weapon(struct chrdata *chr, u32 weaponnum);
+s16 botinv_get_weapon_pad(struct chrdata *chr, u32 weaponnum);
+bool botinv_give_prop(struct chrdata *chr, struct prop *prop);
+void botinv_score_all_weapons(struct chrdata *chr, s32 *weaponnums, s32 *scores1, s32 *scores2);
+bool mp_has_shield(void);
+s32 mp_get_weapon_slot_by_weapon_num(s32 weaponnum);
+void botinv_score_weapon(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2, bool arg7, bool learn);
+void botinv_score_weapon_against_target(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2);
+void botinv_score_weapon_by_itself(struct chrdata *chr, s32 weaponnum, s32 funcnum, s32 ifammo, bool dual, s32 *dst1, s32 *dst2);
+s32 botinv_get_dist_config(s32 weaponnum, s32 funcnum);
+bool botinv_allows_weapon(struct chrdata *chr, s32 weaponnum, s32 funcnum);
+void botinv_tick(struct chrdata *chr);
+bool botinv_switch_to_weapon(struct chrdata *chr, s32 weaponnum, s32 funcnum);
+void botinv_drop(struct chrdata *chr, s32 weaponnum, u8 dropall);
+void botinv_drop_all(struct chrdata *chr, u32 weaponnum);
+void botinv_drop_one(struct chrdata *chr, u32 weaponnum);
 
 #endif

src/include/game/botinvinit.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-void botinvInit(struct chrdata *chr, s32 maxitems);
+void botinv_init(struct chrdata *chr, s32 maxitems);
 
 #endif

src/include/game/botmgr.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void botmgrRemoveAll(void);
-void botmgrAllocateBot(s32 chrnum, s32 aibotnum);
+void botmgr_remove_all(void);
+void botmgr_allocate_bot(s32 chrnum, s32 aibotnum);
 
 #endif

src/include/game/camdraw.h

@@ -10,13 +10,13 @@ void func0f149e58(u8 *arg0, u32 size);
 void func0f14a00c(bool arg0);
 struct var8007f8e0 *func0f14a06c(s32 index);
 void func0f14a16c(s32 arg0);
-char *phGetStyleName(s32 stylenum);
-char *phGetColourName(s32 colournum);
+char *ph_get_style_name(s32 stylenum);
+char *ph_get_colour_name(s32 colournum);
 struct var8007f8dc *func0f14a20c(void);
 void func0f14a240(void);
 bool func0f14a2fc(s32 index, u32 line, char *file);
-void pheadInit(void);
-void pheadReset(void);
+void phead_init(void);
+void phead_reset(void);
 void func0f14a52c(void);
 void func0f14a560(void);
 void func0f14a594(s32 arg0);
@@ -86,8 +86,8 @@ void phead0f14fdb0(s32 arg0[8][8], u8 **arg1);
 void func0f14ff94(struct var8007f8e0 *arg0);
 void func0f150068(struct var8007f8e0 *arg0, s32 arg1);
 bool func0f15015c(s8 device, s32 filenum, u8 *arg2);
-void phGetGuid(s32 index, struct fileguid *guid);
-void pheadInit2(void);
+void ph_get_guid(s32 index, struct fileguid *guid);
+void phead_init2(void);
 
 extern const char var7f1b6050[];
 extern const char var7f1b6058[];

src/include/game/camera.h

@@ -4,45 +4,45 @@
 #include "data.h"
 #include "types.h"
 
-void camSetScreenSize(f32 width, f32 height);
-void camSetScreenPosition(f32 left, f32 top);
-void camSetPerspective(f32 near, f32 fovy, f32 aspect);
+void cam_set_screen_size(f32 width, f32 height);
+void cam_set_screen_position(f32 left, f32 top);
+void cam_set_perspective(f32 near, f32 fovy, f32 aspect);
 f32 cam0f0b49b8(f32 arg0);
-void camSetScale(void);
+void cam_set_scale(void);
 void cam0f0b4c3c(f32 pos2d[2], struct coord *dir2d, f32 arg2);
 void cam0f0b4d04(struct coord *in, f32 *out);
 void cam0f0b4d68(struct coord *in, f32 out[2]);
 void cam0f0b4dec(struct coord *in, f32 out[2]);
 void cam0f0b4e68(f32 in[2], f32 divisor, f32 out[2]);
 void cam0f0b4eb8(struct coord *arg0, f32 arg1[2], f32 zoom, f32 aspect);
-void camSetMtxL1738(Mtx *mtx);
-void camSetMtxL173c(Mtx *mtx);
-Mtx *camGetMtxL173c(void);
-void camSetMtxF006c(Mtxf *mtx);
-Mtxf *camGetMtxF006c(void);
-void camSetPerspectiveMtxL(Mtx *value);
-Mtx *camGetPerspectiveMtxL(void);
-void camSetOrthogonalMtxL(Mtx *mtx);
-Mtx *camGetOrthogonalMtxL(void);
-void camSetWorldToScreenMtxf(Mtxf *mtx);
+void cam_set_mtxl1738(Mtx *mtx);
+void cam_set_mtxl173c(Mtx *mtx);
+Mtx *cam_get_mtxl173c(void);
+void cam_set_mtxf006c(Mtxf *mtx);
+Mtxf *cam_get_mtxf006c(void);
+void cam_set_perspective_mtxl(Mtx *value);
+Mtx *cam_get_perspective_mtxl(void);
+void cam_set_orthogonal_mtxl(Mtx *mtx);
+Mtx *cam_get_orthogonal_mtxl(void);
+void cam_set_world_to_screen_mtxf(Mtxf *mtx);
 Mtxf *cam0f0b5050(u8 *arg0);
 Mtxf *cam0f0b53a4(u8 *arg0);
-Mtxf *camGetWorldToScreenMtxf(void);
-void camSetMtxF1754(Mtxf *mtx);
-Mtxf *camGetMtxF1754(void);
-void camSetProjectionMtxF(Mtxf *mtx);
-Mtxf *camGetProjectionMtxF(void);
-void camSetLookAt(LookAt *lookat);
-LookAt *camGetLookAt(void);
-f32 camGetLodScaleZ(void);
-f32 camGetScreenWidth(void);
-f32 camGetScreenHeight(void);
-f32 camGetScreenLeft(void);
-f32 camGetScreenTop(void);
-f32 camGetPerspAspect(void);
+Mtxf *cam_get_world_to_screen_mtxf(void);
+void cam_set_mtxf1754(Mtxf *mtx);
+Mtxf *cam_get_mtxf1754(void);
+void cam_set_projection_mtxf(Mtxf *mtx);
+Mtxf *cam_get_projection_mtxf(void);
+void cam_set_look_at(LookAt *lookat);
+LookAt *cam_get_look_at(void);
+f32 cam_get_lod_scale_z(void);
+f32 cam_get_screen_width(void);
+f32 cam_get_screen_height(void);
+f32 cam_get_screen_left(void);
+f32 cam_get_screen_top(void);
+f32 cam_get_persp_aspect(void);
 void cam0f0b5838(void);
 bool cam0f0b5b9c(struct coord *arg0, f32 arg1);
-bool camIsPosInScreenBox(struct coord *pos, f32 arg1, struct drawslot *drawslot);
-bool camIsPosInFovAndVisibleRoom(RoomNum *rooms, struct coord *pos, f32 arg2);
+bool cam_is_pos_in_screen_box(struct coord *pos, f32 arg1, struct drawslot *drawslot);
+bool cam_is_pos_in_fov_and_visible_room(RoomNum *rooms, struct coord *pos, f32 arg2);
 
 #endif

src/include/game/casing.h

@@ -4,8 +4,8 @@
 #include "data.h"
 #include "types.h"
 
-void casingsReset(void);
-void casingTick(struct casing *arg0);
-void casingsTick(void);
+void casings_reset(void);
+void casing_tick(struct casing *arg0);
+void casings_tick(void);
 
 #endif

src/include/game/challenge.h

@@ -7,45 +7,45 @@
 extern u32 g_MpChallengeIndex;
 extern struct mpconfigfull *g_MpCurrentChallengeConfig;
 
-void challengesInit(void);
+void challenges_init(void);
 
-void challengeDetermineUnlockedFeatures(void);
-void challengePerformSanityChecks(void);
-char *challengeGetNameBySlot(s32 slot);
-bool challengeIsCompletedByAnyChrWithNumPlayersBySlot(s32 slot, s32 numplayers);
-struct mpconfigfull *challengeLoadConfig(s32 confignum, u8 *buffer, s32 len);
-s32 challengeForceUnlockFeature(s32 featurenum, u8 *array, s32 tail, s32 len);
-s32 challengeForceUnlockSetupFeatures(struct mpsetup *mpsetup, u8 *array, s32 len);
-void challengeForceUnlockConfigFeatures(struct mpconfig *config, u8 *array, s32 len, s32 challengeindex);
-void challengeForceUnlockBotFeatures(void);
-void challengeApply(void);
-char *challengeGetCurrentDescription(void);
-char *challengeGetConfigDescription(struct mpconfigfull *mpconfig);
-bool challengeIsCompleteForEndscreen(void);
-bool aiMpInitSimulants(void);
-void vmPrintStatsIfEnabled(void);
-bool challengeIsAvailableToPlayer(s32 chrnum, s32 challengeindex);
-bool challengeIsAvailableToAnyPlayer(s32 challengeindex);
-s32 challengeGetNumAvailable(void);
-char *challengeGetName(s32 challengeindex);
-void challengeSetCurrentBySlot(s32 slotnum);
-s32 challengeGetCurrent(void);
-struct mpconfigfull *challengeLoad(s32 challengeindex, u8 *buffer, s32 len);
-struct mpconfigfull *challengeLoadBySlot(s32 n, u8 *buffer, s32 len);
-struct mpconfigfull *challengeLoadCurrent(u8 *buffer, s32 len);
-void challengeRemoveForceUnlocks(void);
-s32 challengeRemovePlayerLock(void);
-void challengeLoadAndStoreCurrent(u8 *buffer, s32 len);
-void challengeUnsetCurrent(void);
-bool challengeIsLoaded(void);
-s32 challengeGetAutoFocusedIndex(s32 mpchrnum);
-char *challengeGetName2(s32 playernum, s32 challengeindex);
-bool challengeIsCompletedByPlayerWithNumPlayers2(s32 mpchrnum, s32 index, s32 numplayers);
-bool challengeIsCompletedByAnyPlayerWithNumPlayers(s32 index, s32 numplayers);
-void challengeSetCompletedByAnyPlayerWithNumPlayers(s32 index, s32 numplayers, bool completed);
-bool challengeIsCompletedByPlayerWithNumPlayers(s32 mpchrnum, s32 index, s32 numplayers);
-void challengeSetCompletedByPlayerWithNumPlayers(u32 mpchrnum, s32 index, s32 numplayers, bool completed);
-void challengeConsiderMarkingComplete(void);
-bool challengeIsFeatureUnlocked(s32 feature);
+void challenge_determine_unlocked_features(void);
+void challenge_perform_sanity_checks(void);
+char *challenge_get_name_by_slot(s32 slot);
+bool challenge_is_completed_by_any_chr_with_num_players_by_slot(s32 slot, s32 numplayers);
+struct mpconfigfull *challenge_load_config(s32 confignum, u8 *buffer, s32 len);
+s32 challenge_force_unlock_feature(s32 featurenum, u8 *array, s32 tail, s32 len);
+s32 challenge_force_unlock_setup_features(struct mpsetup *mpsetup, u8 *array, s32 len);
+void challenge_force_unlock_config_features(struct mpconfig *config, u8 *array, s32 len, s32 challengeindex);
+void challenge_force_unlock_bot_features(void);
+void challenge_apply(void);
+char *challenge_get_current_description(void);
+char *challenge_get_config_description(struct mpconfigfull *mpconfig);
+bool challenge_is_complete_for_endscreen(void);
+bool ai_mp_init_simulants(void);
+void vm_print_stats_if_enabled(void);
+bool challenge_is_available_to_player(s32 chrnum, s32 challengeindex);
+bool challenge_is_available_to_any_player(s32 challengeindex);
+s32 challenge_get_num_available(void);
+char *challenge_get_name(s32 challengeindex);
+void challenge_set_current_by_slot(s32 slotnum);
+s32 challenge_get_current(void);
+struct mpconfigfull *challenge_load(s32 challengeindex, u8 *buffer, s32 len);
+struct mpconfigfull *challenge_load_by_slot(s32 n, u8 *buffer, s32 len);
+struct mpconfigfull *challenge_load_current(u8 *buffer, s32 len);
+void challenge_remove_force_unlocks(void);
+s32 challenge_remove_player_lock(void);
+void challenge_load_and_store_current(u8 *buffer, s32 len);
+void challenge_unset_current(void);
+bool challenge_is_loaded(void);
+s32 challenge_get_auto_focused_index(s32 mpchrnum);
+char *challenge_get_name2(s32 playernum, s32 challengeindex);
+bool challenge_is_completed_by_player_with_num_players2(s32 mpchrnum, s32 index, s32 numplayers);
+bool challenge_is_completed_by_any_player_with_num_players(s32 index, s32 numplayers);
+void challenge_set_completed_by_any_player_with_num_players(s32 index, s32 numplayers, bool completed);
+bool challenge_is_completed_by_player_with_num_players(s32 mpchrnum, s32 index, s32 numplayers);
+void challenge_set_completed_by_player_with_num_players(u32 mpchrnum, s32 index, s32 numplayers, bool completed);
+void challenge_consider_marking_complete(void);
+bool challenge_is_feature_unlocked(s32 feature);
 
 #endif

src/include/game/cheats.h

@@ -12,21 +12,21 @@ extern struct menudialogdef g_CheatsClassicWeaponsMenuDialog;
 extern struct menudialogdef g_CheatsWeaponsMenuDialog;
 extern struct menudialogdef g_CheatsBuddiesMenuDialog;
 
-u32 cheatIsUnlocked(s32 cheat_id);
-bool cheatIsActive(s32 cheat_id);
-void cheatActivate(s32 cheat_id);
-void cheatDeactivate(s32 cheat_id);
-void cheatsInit(void);
-void cheatsReset(void);
-char *cheatGetNameIfUnlocked(struct menuitem *item);
-char *cheatGetMarquee(struct menuitem *item);
-s32 cheatGetByTimedStageIndex(s32 stage_index, s32 difficulty);
-s32 cheatGetByCompletedStageIndex(s32 stage_index);
-s32 cheatGetTime(s32 cheat_id);
-char *cheatGetName(s32 cheat_id);
-MenuDialogHandlerResult cheatMenuHandleDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult cheatCheckboxMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult cheatMenuHandleBuddyCheckbox(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult cheatMenuHandleTurnOffAllCheats(s32 operation, struct menuitem *item, union handlerdata *data);
+u32 cheat_is_unlocked(s32 cheat_id);
+bool cheat_is_active(s32 cheat_id);
+void cheat_activate(s32 cheat_id);
+void cheat_deactivate(s32 cheat_id);
+void cheats_init(void);
+void cheats_reset(void);
+char *cheat_get_name_if_unlocked(struct menuitem *item);
+char *cheat_get_marquee(struct menuitem *item);
+s32 cheat_get_by_timed_stage_index(s32 stage_index, s32 difficulty);
+s32 cheat_get_by_completed_stage_index(s32 stage_index);
+s32 cheat_get_time(s32 cheat_id);
+char *cheat_get_name(s32 cheat_id);
+MenuDialogHandlerResult cheat_menu_handle_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult cheat_checkbox_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult cheat_menu_handle_buddy_checkbox(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult cheat_menu_handle_turn_off_all_cheats(s32 operation, struct menuitem *item, union handlerdata *data);
 
 #endif

src/include/game/chr.h

@@ -4,9 +4,9 @@
 #include "data.h"
 #include "types.h"
 
-void chrSetChrnum(struct chrdata *chr, s16 chrnum);
-void chrDeregister(s32 chrnum);
-void chrCalculatePushPos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, bool arg3);
+void chr_set_chrnum(struct chrdata *chr, s16 chrnum);
+void chr_deregister(s32 chrnum);
+void chr_calculate_push_pos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, bool arg3);
 
 #if VERSION >= VERSION_NTSC_1_0
 bool chr0f01f264(struct chrdata *chr, struct coord *pos, RoomNum *rooms, f32 arg3, bool arg4);
@@ -15,85 +15,85 @@ bool chr0f01f264(struct chrdata *chr, struct coord *pos, RoomNum *rooms, f32 arg
 #endif
 
 bool chr0f01f378(struct model *model, struct coord *arg1, struct coord *arg2, f32 *mangroundptr);
-s32 chrsGetNumFree(void);
-s16 chrsGetNextUnusedChrnum(void);
+s32 chrs_get_num_free(void);
+s16 chrs_get_next_unused_chrnum(void);
 struct prop *chr0f020b14(struct prop *prop, struct model *model, struct coord *pos, RoomNum *rooms, f32 arg3, u8 *ailist);
-void chrRemove(struct prop *prop, bool free);
-void chrUpdateAimProperties(struct chrdata *chr);
-void chrFlinchBody(struct chrdata *chr);
-void chrFlinchHead(struct chrdata *chr, f32 arg1);
-f32 chrGetFlinchAmount(struct chrdata *chr);
+void chr_remove(struct prop *prop, bool free);
+void chr_update_aim_properties(struct chrdata *chr);
+void chr_flinch_body(struct chrdata *chr);
+void chr_flinch_head(struct chrdata *chr, f32 arg1);
+f32 chr_get_flinch_amount(struct chrdata *chr);
 void chr0f021fa8(struct chrdata *chr, struct coord *pos, RoomNum *rooms);
 void chr0f0220ec(struct chrdata *chr, s32 lvupdate240, bool arg2);
 void chr0f022214(struct chrdata *chr, struct prop *child, bool fulltick);
-void chrUpdateCloak(struct chrdata *chr);
-s32 chrGetCloakAlpha(struct chrdata *chr);
-void chrSetPoisoned(struct chrdata *chr, struct prop *poisonprop);
-void chrTickPoisoned(struct chrdata *chr);
-bool chrTickBeams(struct prop *prop);
-s32 chrTick(struct prop *prop);
-void chrDropConcealedItems(struct chrdata *chr);
-void chrSetHudpieceVisible(struct chrdata *chr, bool visible);
-void chrDropItemsForOwnerReap(struct chrdata *chr);
+void chr_update_cloak(struct chrdata *chr);
+s32 chr_get_cloak_alpha(struct chrdata *chr);
+void chr_set_poisoned(struct chrdata *chr, struct prop *poisonprop);
+void chr_tick_poisoned(struct chrdata *chr);
+bool chr_tick_beams(struct prop *prop);
+s32 chr_tick(struct prop *prop);
+void chr_drop_concealed_items(struct chrdata *chr);
+void chr_set_hudpiece_visible(struct chrdata *chr, bool visible);
+void chr_drop_items_for_owner_reap(struct chrdata *chr);
 void chr0f0246e4(u8 *arg0);
 bool chr0f024738(struct chrdata *chr);
 bool chr0f024b18(struct model *model, struct modelnode *node);
-void chrRenderAttachedObject(struct prop *prop, struct modelrenderdata *renderdata, bool xlupass, struct chrdata *chr);
-void chrGetBloodColour(s16 bodynum, u8 *colour1, u32 *colour2);
-Gfx *chrRender(struct prop *prop, Gfx *gdl, bool xlupass);
-void chrEmitSparks(struct chrdata *chr, struct prop *prop, s32 hitpart, struct coord *coord, struct coord *coord2, struct chrdata *chr2);
+void chr_render_attached_object(struct prop *prop, struct modelrenderdata *renderdata, bool xlupass, struct chrdata *chr);
+void chr_get_blood_colour(s16 bodynum, u8 *colour1, u32 *colour2);
+Gfx *chr_render(struct prop *prop, Gfx *gdl, bool xlupass);
+void chr_emit_sparks(struct chrdata *chr, struct prop *prop, s32 hitpart, struct coord *coord, struct coord *coord2, struct chrdata *chr2);
 void chr0f0260c4(struct model *model, s32 hitpart, struct modelnode *node, struct coord *arg3);
-void chrBruise(struct model *model, s32 hitpart, struct modelnode *node, struct coord *arg3);
-void chrDisfigure(struct chrdata *chr, struct coord *exppos, f32 damageradius);
-f32 chrGetHitRadius(struct chrdata *chr);
-void chrTestHit(struct prop *prop, struct shotdata *shotdata, bool isshooting, bool cheap);
-void chrHit(struct shotdata *shotdata, struct hit *hit);
+void chr_bruise(struct model *model, s32 hitpart, struct modelnode *node, struct coord *arg3);
+void chr_disfigure(struct chrdata *chr, struct coord *exppos, f32 damageradius);
+f32 chr_get_hit_radius(struct chrdata *chr);
+void chr_test_hit(struct prop *prop, struct shotdata *shotdata, bool isshooting, bool cheap);
+void chr_hit(struct shotdata *shotdata, struct hit *hit);
 void chr0f028498(bool value);
-void chrsCheckForNoise(f32 noiseradius);
-bool chrCalculateAutoAim(struct prop *prop, struct coord *arg1, f32 *arg2, f32 *arg3);
+void chrs_check_for_noise(f32 noiseradius);
+bool chr_calculate_auto_aim(struct prop *prop, struct coord *arg1, f32 *arg2, f32 *arg3);
 s32 chr0f028e18(struct prop *arg0, struct modelnode *node, struct model *model, struct prop *arg3);
 bool chr0f028e6c(s32 arg0, struct prop *prop, struct prop **propptr, struct modelnode **nodeptr, struct model **modelptr);
-void shieldhitCreate(struct prop *prop, f32 shield, struct prop *arg2, struct modelnode *node, struct model *model, s32 side, s16 *arg6);
-void shieldhitRemove(struct shieldhit *shieldhit);
-void shieldhitsRemoveByProp(struct prop *prop);
+void shieldhit_create(struct prop *prop, f32 shield, struct prop *arg2, struct modelnode *node, struct model *model, s32 side, s16 *arg6);
+void shieldhit_remove(struct shieldhit *shieldhit);
+void shieldhits_remove_by_prop(struct prop *prop);
 s32 chr0f02932c(struct prop *prop, s32 arg1);
 s32 chr0f0293ec(struct prop *prop, s32 arg1);
 s32 chr0f0294cc(struct prop *prop, s32 arg1);
 void chr0f0295f8(f32 arg0, s32 *arg1, s32 *arg2, s32 *arg3);
-f32 propGetShieldThing(struct prop **propptr);
-Gfx *chrRenderShieldComponent(Gfx *gdl, struct shieldhit *hit, struct prop *prop, struct model *model, struct modelnode *node, s32 side, s32 arg6, s32 arg7, s32 alpha);
-Gfx *shieldhitRender(Gfx *gdl, struct prop *prop1, struct prop *prop2, s32 alpha, bool arg4, s32 cmnum1, s32 cmnum2, s32 cmnum3, s32 cmnum4);
-Gfx *chrRenderCloak(Gfx *gdl, struct prop *chr1, struct prop *chr2);
-Gfx *chrRenderShield(Gfx *gdl, struct chrdata *chr, u32 alpha);
-void shieldhitsTick(void);
-void chrSetDrCarollImages(struct chrdata *drcaroll, s32 imageleft, s32 imageright);
-s32 chrsGetNumSlots(void);
-void chrRegister(s32 chrnum, s32 chrindex);
-Vtx *chrAllocateVertices(s32 numvertices);
-void chrsSetVar8006297c(u32 arg0);
-u32 chrsGetVar8006297c(void);
-void chrsSetVar80062980(u32 arg0);
-u32 chrsGetVar80062980(void);
-void chrSetPerimEnabled(struct chrdata *chr, bool enable);
-void chrSetMaxDamage(struct chrdata *chr, f32 maxdamage);
-f32 chrGetMaxDamage(struct chrdata *chr);
-void chrAddHealth(struct chrdata *chr, f32 health);
-f32 chrGetArmor(struct chrdata *chr);
-void chrInit(struct prop *prop, u8 *ailist);
-struct prop *chrAllocate(struct model *model, struct coord *pos, RoomNum *rooms, f32 faceangle, u8 *ailist);
-void chrClearReferences(s32 propnum);
+f32 prop_get_shield_thing(struct prop **propptr);
+Gfx *chr_render_shield_component(Gfx *gdl, struct shieldhit *hit, struct prop *prop, struct model *model, struct modelnode *node, s32 side, s32 arg6, s32 arg7, s32 alpha);
+Gfx *shieldhit_render(Gfx *gdl, struct prop *prop1, struct prop *prop2, s32 alpha, bool arg4, s32 cmnum1, s32 cmnum2, s32 cmnum3, s32 cmnum4);
+Gfx *chr_render_cloak(Gfx *gdl, struct prop *chr1, struct prop *chr2);
+Gfx *chr_render_shield(Gfx *gdl, struct chrdata *chr, u32 alpha);
+void shieldhits_tick(void);
+void chr_set_dr_caroll_images(struct chrdata *drcaroll, s32 imageleft, s32 imageright);
+s32 chrs_get_num_slots(void);
+void chr_register(s32 chrnum, s32 chrindex);
+Vtx *chr_allocate_vertices(s32 numvertices);
+void chrs_set_var8006297c(u32 arg0);
+u32 chrs_get_var8006297c(void);
+void chrs_set_var80062980(u32 arg0);
+u32 chrs_get_var80062980(void);
+void chr_set_perim_enabled(struct chrdata *chr, bool enable);
+void chr_set_max_damage(struct chrdata *chr, f32 maxdamage);
+f32 chr_get_max_damage(struct chrdata *chr);
+void chr_add_health(struct chrdata *chr, f32 health);
+f32 chr_get_armor(struct chrdata *chr);
+void chr_init(struct prop *prop, u8 *ailist);
+struct prop *chr_allocate(struct model *model, struct coord *pos, RoomNum *rooms, f32 faceangle, u8 *ailist);
+void chr_clear_references(s32 propnum);
 void chr0f022084(struct chrdata *chr, RoomNum *room);
 void chr0f0220ac(struct chrdata *chr);
-void chrCloak(struct chrdata *chr, bool arg1);
-void chrUncloak(struct chrdata *chr, bool value);
-void chrUncloakTemporarily(struct chrdata *chr);
+void chr_cloak(struct chrdata *chr, bool arg1);
+void chr_uncloak(struct chrdata *chr, bool value);
+void chr_uncloak_temporarily(struct chrdata *chr);
 void chr0f02472c(void);
 void chr0f028490(f32 arg1);
-struct chrdata *chrFindByLiteralId(s32 chrnum);
-struct prop *chrGetHeldProp(struct chrdata *chr, s32 hand);
-struct prop *chrGetHeldUsableProp(struct chrdata *chr, s32 hand);
-struct prop *chrGetTargetProp(struct chrdata *chr);
-bool chrUpdateGeometry(struct prop *prop, u8 **start, u8 **end);
-void chrGetBbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
+struct chrdata *chr_find_by_literal_id(s32 chrnum);
+struct prop *chr_get_held_prop(struct chrdata *chr, s32 hand);
+struct prop *chr_get_held_usable_prop(struct chrdata *chr, s32 hand);
+struct prop *chr_get_target_prop(struct chrdata *chr);
+bool chr_update_geometry(struct prop *prop, u8 **start, u8 **end);
+void chr_get_bbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
 
 #endif

src/include/game/chraction.h

@@ -5,334 +5,334 @@
 #include "types.h"
 
 f32 func0f02dff0(s16 animnum);
-bool chrGoPosIsWaiting(struct chrdata *chr);
-bool weaponIsOneHanded(struct prop *prop);
-f32 chrGetRangedSpeed(struct chrdata *chr, f32 min, f32 max);
-s32 chrGetPercentageOfSlowness(struct chrdata *chr, s32 percentage);
-f32 chrGetRangedArghSpeed(struct chrdata *chr, f32 min, f32 max);
-f32 chrGetAttackEntityRelativeAngle(struct chrdata *chr, s32 attackflags, s32 entityid);
-f32 chrGetAttackEntityDistance(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_go_pos_is_waiting(struct chrdata *chr);
+bool weapon_is_one_handed(struct prop *prop);
+f32 chr_get_ranged_speed(struct chrdata *chr, f32 min, f32 max);
+s32 chr_get_percentage_of_slowness(struct chrdata *chr, s32 percentage);
+f32 chr_get_ranged_argh_speed(struct chrdata *chr, f32 min, f32 max);
+f32 chr_get_attack_entity_relative_angle(struct chrdata *chr, s32 attackflags, s32 entityid);
+f32 chr_get_attack_entity_distance(struct chrdata *chr, u32 attackflags, s32 entityid);
 void func0f02e3dc(struct coord *a, struct coord *b, struct coord *c, struct coord *d, struct coord *dst);
 void func0f02e4f8(struct coord *arg0, struct coord *arg1, struct coord *dst);
 f32 func0f02e550(struct prop *prop, f32 arg1, f32 arg2, u32 cdtypes, f32 ymax, f32 ymin);
 f32 func0f02e684(struct prop *prop, f32 arg1, f32 arg2);
-void chrChooseStandAnimation(struct chrdata *chr, f32 mergetime);
-void chrStand(struct chrdata *chr);
-bool chrFaceCover(struct chrdata *chr);
-void chrKneelChooseAnimation(struct chrdata *chr);
-void chrStartAlarmChooseAnimation(struct chrdata *chr);
-void chrThrowGrenadeChooseAnimation(struct chrdata *chr);
-void chrSurprisedChooseAnimation(struct chrdata *chr);
-void chrDoSurprisedOneHand(struct chrdata *chr);
-void chrSurrenderChooseAnimation(struct chrdata *chr);
-void chrSidestepChooseAnimation(struct chrdata *chr);
-void chrJumpOutChooseAnimation(struct chrdata *chr);
-void chrRunPosChooseAnimation(struct chrdata *chr);
-void chrAttackStand(struct chrdata *chr, u32 attackflags, s32 entityid);
-void chrAttackLie(struct chrdata *chr, u32 attackflags, s32 entityid);
-void chrAttackKneel(struct chrdata *chr, u32 attackflags, s32 entityid);
-void chrAttackWalkChooseAnimation(struct chrdata *chr);
-void chrAttackWalk(struct chrdata *chr, bool run);
-void chrAttackRollChooseAnimation(struct chrdata *chr);
-void chrAttackRoll(struct chrdata *chr, bool toleft);
-void chrStartAnim(struct chrdata *chr, s32 animnum, f32 startframe, f32 endframe, u8 chranimflags, s32 merge, f32 speed);
+void chr_choose_stand_animation(struct chrdata *chr, f32 mergetime);
+void chr_stand(struct chrdata *chr);
+bool chr_face_cover(struct chrdata *chr);
+void chr_kneel_choose_animation(struct chrdata *chr);
+void chr_start_alarm_choose_animation(struct chrdata *chr);
+void chr_throw_grenade_choose_animation(struct chrdata *chr);
+void chr_surprised_choose_animation(struct chrdata *chr);
+void chr_do_surprised_one_hand(struct chrdata *chr);
+void chr_surrender_choose_animation(struct chrdata *chr);
+void chr_sidestep_choose_animation(struct chrdata *chr);
+void chr_jump_out_choose_animation(struct chrdata *chr);
+void chr_run_pos_choose_animation(struct chrdata *chr);
+void chr_attack_stand(struct chrdata *chr, u32 attackflags, s32 entityid);
+void chr_attack_lie(struct chrdata *chr, u32 attackflags, s32 entityid);
+void chr_attack_kneel(struct chrdata *chr, u32 attackflags, s32 entityid);
+void chr_attack_walk_choose_animation(struct chrdata *chr);
+void chr_attack_walk(struct chrdata *chr, bool run);
+void chr_attack_roll_choose_animation(struct chrdata *chr);
+void chr_attack_roll(struct chrdata *chr, bool toleft);
+void chr_start_anim(struct chrdata *chr, s32 animnum, f32 startframe, f32 endframe, u8 chranimflags, s32 merge, f32 speed);
 void func0f031254(struct chrdata *chr);
-void chrAttack(struct chrdata *chr, struct attackanimgroup **animgroups, bool flip, bool *firing, u32 attackflags, s32 entityid, bool standing);
-void chrAttackAmount(struct chrdata *chr, u32 attackflags, u32 entityid, u32 maxshots);
-void chrBeginDeath(struct chrdata *chr, struct coord *dir, f32 relangle, s32 hitpart, struct gset *gset, bool knockout, s32 aplayernum);
-void chrBeginArgh(struct chrdata *chr, f32 angle, s32 hitpart);
-void chrReactToDamage(struct chrdata *chr, struct coord *dir, f32 angle, s32 hitpart, struct gset *gset, s32 playernum);
-void chrYeetFromPos(struct chrdata *chr, struct coord *pos, f32 arg2);
-s32 gsetGetBlurAmount(struct gset *gset);
-void chrKnockOut(struct chrdata *chr, f32 angle, s32 hitpart, struct gset *gset);
-bool chrIsAnimPreventingArgh(struct chrdata *chr, f32 *arg1);
-void chrChoke(struct chrdata *chr, s32 choketype);
-void chrSetShield(struct chrdata *chr, f32 shield);
+void chr_attack(struct chrdata *chr, struct attackanimgroup **animgroups, bool flip, bool *firing, u32 attackflags, s32 entityid, bool standing);
+void chr_attack_amount(struct chrdata *chr, u32 attackflags, u32 entityid, u32 maxshots);
+void chr_begin_death(struct chrdata *chr, struct coord *dir, f32 relangle, s32 hitpart, struct gset *gset, bool knockout, s32 aplayernum);
+void chr_begin_argh(struct chrdata *chr, f32 angle, s32 hitpart);
+void chr_react_to_damage(struct chrdata *chr, struct coord *dir, f32 angle, s32 hitpart, struct gset *gset, s32 playernum);
+void chr_yeet_from_pos(struct chrdata *chr, struct coord *pos, f32 arg2);
+s32 gset_get_blur_amount(struct gset *gset);
+void chr_knock_out(struct chrdata *chr, f32 angle, s32 hitpart, struct gset *gset);
+bool chr_is_anim_preventing_argh(struct chrdata *chr, f32 *arg1);
+void chr_choke(struct chrdata *chr, s32 choketype);
+void chr_set_shield(struct chrdata *chr, f32 shield);
 bool func0f034080(struct chrdata *chr, struct modelnode *node, struct prop *prop, struct model *model, s32 side, s16 *arg5);
-void chrDamageByMisc(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop);
-void chrDamageByLaser(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop);
+void chr_damage_by_misc(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop);
+void chr_damage_by_laser(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop);
 void func0f0341dc(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop, s32 hitpart, struct prop *prop2, struct modelnode *node, struct model *model, s32 side, s16 *arg10);
-void chrDamageByImpact(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop, s32 arg5);
-void chrDamageByExplosion(struct chrdata *chr, f32 damage, struct coord *vector, struct prop *prop, struct coord *explosionpos);
-void playerUpdateDamageStats(struct prop *attacker, struct prop *victim, f32 damage);
-void chrDamage(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *aprop, s32 hitpart, bool damageshield, struct prop *prop2, struct modelnode *node, struct model *model, s32 side, s16 *arg11, bool explosion, struct coord *explosionpos);
+void chr_damage_by_impact(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *prop, s32 arg5);
+void chr_damage_by_explosion(struct chrdata *chr, f32 damage, struct coord *vector, struct prop *prop, struct coord *explosionpos);
+void player_update_damage_stats(struct prop *attacker, struct prop *victim, f32 damage);
+void chr_damage(struct chrdata *chr, f32 damage, struct coord *vector, struct gset *gset, struct prop *aprop, s32 hitpart, bool damageshield, struct prop *prop2, struct modelnode *node, struct model *model, s32 side, s16 *arg11, bool explosion, struct coord *explosionpos);
 bool func0f03645c(struct chrdata *chr, struct coord *arg1, RoomNum *arg2, struct coord *arg3, struct coord *arg4, s32 cdtypes);
 bool func0f03654c(struct chrdata *chr, struct coord *pos, RoomNum *rooms, struct coord *pos2, RoomNum *rooms2, struct coord *vector, f32 arg6, u32 types);
-bool propchrHasClearLineToPos(struct prop *prop, struct coord *dstpos, struct coord *vector);
-bool propchrHasClearLineInVector(struct prop *prop, struct coord *coord, f32 arg2);
+bool propchr_has_clear_line_to_pos(struct prop *prop, struct coord *dstpos, struct coord *vector);
+bool propchr_has_clear_line_in_vector(struct prop *prop, struct coord *coord, f32 arg2);
 bool func0f036974(struct prop *prop, struct coord *coord);
-void chrGetSideVectorToTarget(struct chrdata *chr, bool side, struct coord *vector);
-bool chrCanRollInDirection(struct chrdata *chr, bool toleft, f32 distance);
-void chrGetSideVector(struct chrdata *chr, bool side, struct coord *vector);
-bool chrCanJumpInDirection(struct chrdata *chr, bool side, f32 distance);
-bool chrIsRoomOffScreen(struct chrdata *chr, struct coord *waypos, RoomNum *wayrooms);
-void chrGoPosInitMagic(struct chrdata *chr, struct waydata *waydata, struct coord *arg2, struct coord *prevpos);
-void chrGoPosGetCurWaypointInfoWithFlags(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 *flags);
+void chr_get_side_vector_to_target(struct chrdata *chr, bool side, struct coord *vector);
+bool chr_can_roll_in_direction(struct chrdata *chr, bool toleft, f32 distance);
+void chr_get_side_vector(struct chrdata *chr, bool side, struct coord *vector);
+bool chr_can_jump_in_direction(struct chrdata *chr, bool side, f32 distance);
+bool chr_is_room_off_screen(struct chrdata *chr, struct coord *waypos, RoomNum *wayrooms);
+void chr_go_pos_init_magic(struct chrdata *chr, struct waydata *waydata, struct coord *arg2, struct coord *prevpos);
+void chr_go_pos_get_cur_waypoint_info_with_flags(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 *flags);
 f32 func0f0370a8(struct chrdata *chr);
-s32 chrGoPosCalculateBaseTtl(struct chrdata *chr);
-void chrGoPosConsiderRestart(struct chrdata *chr);
-void chrGoPosInitExpensive(struct chrdata *chr);
-void chrGoPosAdvanceWaypoint(struct chrdata *chr);
-s32 chrPatrolCalculateStep(struct chrdata *chr, bool *forward, s32 numsteps);
-s16 chrPatrolCalculatePadNum(struct chrdata *chr, s32 numsteps);
-void chrPatrolGetCurWaypointInfoWithFlags(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 *flags);
+s32 chr_go_pos_calculate_base_ttl(struct chrdata *chr);
+void chr_go_pos_consider_restart(struct chrdata *chr);
+void chr_go_pos_init_expensive(struct chrdata *chr);
+void chr_go_pos_advance_waypoint(struct chrdata *chr);
+s32 chr_patrol_calculate_step(struct chrdata *chr, bool *forward, s32 numsteps);
+s16 chr_patrol_calculate_pad_num(struct chrdata *chr, s32 numsteps);
+void chr_patrol_get_cur_waypoint_info_with_flags(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 *flags);
 void func0f037580(struct chrdata *chr);
 void func0f0375b0(struct chrdata *chr);
-void chrNavTickMagic(struct chrdata *chr, struct waydata *waydata, f32 speed, struct coord *arg3, RoomNum *rooms);
-void chrCalculatePosition(struct chrdata *chr, struct coord *pos);
-void chrGoPosChooseAnimation(struct chrdata *chr);
-bool chrGoToRoomPos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 goposflags);
-void chrPatrolChooseAnimation(struct chrdata *chr);
-void chrStartPatrol(struct chrdata *chr, struct path *path);
-bool chrHasLosToEntity(struct chrdata *chr, struct coord *chrpos, RoomNum *chrrooms, bool allowextraheight, u32 attackflags, u32 entityid);
-bool chrHasLosToAttackTarget(struct chrdata *chr, struct coord *pos, RoomNum *rooms, bool allowextraheight);
-bool chrHasLosToChr(struct chrdata *chr, struct chrdata *target, RoomNum *room);
-bool chrHasLosToPos(struct chrdata *viewerchr, struct coord *pos, RoomNum *rooms);
-bool chrHasLosToPosWasteful(struct chrdata *chr, struct coord *pos, RoomNum *room);
-bool chrHasLosToProp(struct chrdata *chr, struct prop *prop);
-bool chrIsStopped(struct chrdata *chr);
-bool chrCheckCanSeeTarget(struct chrdata *chr);
-bool chrIsReadyForOrders(struct chrdata *chr);
-bool chrTrySidestep(struct chrdata *chr);
-bool chrTryJumpOut(struct chrdata *chr);
-bool chrTryRunSideways(struct chrdata *chr);
-bool chrTryAttackWalk(struct chrdata *chr);
-bool chrTryAttackRun(struct chrdata *chr);
-bool chrTryAttackRoll(struct chrdata *chr);
-bool chrTryAttackAmount(struct chrdata *chr, u32 arg1, u32 arg2, u8 arg3, u8 arg4);
-bool chrGoToPad(struct chrdata *chr, s32 padnum, u32 goposflags);
-bool chrGoToPos(struct chrdata *chr, struct coord *pos, u32 goposflags);
+void chr_nav_tick_magic(struct chrdata *chr, struct waydata *waydata, f32 speed, struct coord *arg3, RoomNum *rooms);
+void chr_calculate_position(struct chrdata *chr, struct coord *pos);
+void chr_go_pos_choose_animation(struct chrdata *chr);
+bool chr_go_to_room_pos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, u32 goposflags);
+void chr_patrol_choose_animation(struct chrdata *chr);
+void chr_start_patrol(struct chrdata *chr, struct path *path);
+bool chr_has_los_to_entity(struct chrdata *chr, struct coord *chrpos, RoomNum *chrrooms, bool allowextraheight, u32 attackflags, u32 entityid);
+bool chr_has_los_to_attack_target(struct chrdata *chr, struct coord *pos, RoomNum *rooms, bool allowextraheight);
+bool chr_has_los_to_chr(struct chrdata *chr, struct chrdata *target, RoomNum *room);
+bool chr_has_los_to_pos(struct chrdata *viewerchr, struct coord *pos, RoomNum *rooms);
+bool chr_has_los_to_pos_wasteful(struct chrdata *chr, struct coord *pos, RoomNum *room);
+bool chr_has_los_to_prop(struct chrdata *chr, struct prop *prop);
+bool chr_is_stopped(struct chrdata *chr);
+bool chr_check_can_see_target(struct chrdata *chr);
+bool chr_is_ready_for_orders(struct chrdata *chr);
+bool chr_try_sidestep(struct chrdata *chr);
+bool chr_try_jump_out(struct chrdata *chr);
+bool chr_try_run_sideways(struct chrdata *chr);
+bool chr_try_attack_walk(struct chrdata *chr);
+bool chr_try_attack_run(struct chrdata *chr);
+bool chr_try_attack_roll(struct chrdata *chr);
+bool chr_try_attack_amount(struct chrdata *chr, u32 arg1, u32 arg2, u8 arg3, u8 arg4);
+bool chr_go_to_pad(struct chrdata *chr, s32 padnum, u32 goposflags);
+bool chr_go_to_pos(struct chrdata *chr, struct coord *pos, u32 goposflags);
 s32 func0f03aca0(struct chrdata *chr, f32 arg1, u8 arg2);
-bool chrTryRunFromTarget(struct chrdata *chr);
-bool chrGoToCoverProp(struct chrdata *chr);
-bool chrDropItem(struct chrdata *chr, u32 modelnum, u32 weaponnum);
-void chrPunchInflictDamage(struct chrdata *chr, s32 damage, s32 range, u8 reverse);
-bool chrTryPunch(struct chrdata *chr, u8 reverse);
-struct eyespy *chrToEyespy(struct chrdata *chr);
-void chrTickStand(struct chrdata *chr);
-void chrTickAnim(struct chrdata *chr);
-void chrTickSurrender(struct chrdata *chr);
-void chrTickDead(struct chrdata *chr);
-void chrAlertOthersOfInjury(struct chrdata *chr, bool dying);
-void chrTickDie(struct chrdata *chr);
-void chrTickDruggedComingUp(struct chrdata *chr);
-void chrTickDruggedDrop(struct chrdata *chr);
-void chrTickDruggedKo(struct chrdata *chr);
-void chrTickArgh(struct chrdata *chr);
-void chrTickPreArgh(struct chrdata *chr);
-void chrTickSidestep(struct chrdata *chr);
-void chrTickJumpOut(struct chrdata *chr);
-void chrTickStartAlarm(struct chrdata *chr);
-void chrTickSurprised(struct chrdata *chr);
-void chrUpdateFireslot(struct chrdata *chr, s32 handnum, bool withsound, bool withbeam, struct coord *from, struct coord *to);
-f32 chrGetInverseTheta(struct chrdata *chr);
-f32 chrGetAimAngle(struct chrdata *chr);
-f32 chrGetPitchAngle(struct chrdata *chr);
-s32 chrTurn(struct chrdata *chr, s32 turning, f32 endanimframe, f32 speed, f32 toleranceangle);
+bool chr_try_run_from_target(struct chrdata *chr);
+bool chr_go_to_cover_prop(struct chrdata *chr);
+bool chr_drop_item(struct chrdata *chr, u32 modelnum, u32 weaponnum);
+void chr_punch_inflict_damage(struct chrdata *chr, s32 damage, s32 range, u8 reverse);
+bool chr_try_punch(struct chrdata *chr, u8 reverse);
+struct eyespy *chr_to_eyespy(struct chrdata *chr);
+void chr_tick_stand(struct chrdata *chr);
+void chr_tick_anim(struct chrdata *chr);
+void chr_tick_surrender(struct chrdata *chr);
+void chr_tick_dead(struct chrdata *chr);
+void chr_alert_others_of_injury(struct chrdata *chr, bool dying);
+void chr_tick_die(struct chrdata *chr);
+void chr_tick_drugged_coming_up(struct chrdata *chr);
+void chr_tick_drugged_drop(struct chrdata *chr);
+void chr_tick_drugged_ko(struct chrdata *chr);
+void chr_tick_argh(struct chrdata *chr);
+void chr_tick_pre_argh(struct chrdata *chr);
+void chr_tick_sidestep(struct chrdata *chr);
+void chr_tick_jump_out(struct chrdata *chr);
+void chr_tick_start_alarm(struct chrdata *chr);
+void chr_tick_surprised(struct chrdata *chr);
+void chr_update_fireslot(struct chrdata *chr, s32 handnum, bool withsound, bool withbeam, struct coord *from, struct coord *to);
+f32 chr_get_inverse_theta(struct chrdata *chr);
+f32 chr_get_aim_angle(struct chrdata *chr);
+f32 chr_get_pitch_angle(struct chrdata *chr);
+s32 chr_turn(struct chrdata *chr, s32 turning, f32 endanimframe, f32 speed, f32 toleranceangle);
 bool func0f03e9f4(struct chrdata *chr, struct attackanimconfig *animcfg, s32 arg2, s32 arg3, f32 arg4);
-void chrCalculateAimEndProperties(struct chrdata *chr, struct attackanimconfig *animcfg, bool firingleft, bool firingright, f32 shootrotx);
-f32 chrGetAimLimitAngle(f32 sqdist);
-void chrCalculateHit(struct chrdata *chr, bool *angleokptr, bool *hit, struct gset *gset);
-bool chrGetGunPos(struct chrdata *chr, s32 handnum, struct coord *gunpos);
-void chrCalculateShieldHit(struct chrdata *chr, struct coord *pos, struct coord *vector, struct modelnode **node, s32 *hitpart, struct model **model, s32 *side);
-void chrCalculateTrajectory(struct coord *frompos, f32 arg1, struct coord *aimpos, struct coord *arg3);
-void chrTickShoot(struct chrdata *chr, s32 handnum);
+void chr_calculate_aim_end_properties(struct chrdata *chr, struct attackanimconfig *animcfg, bool firingleft, bool firingright, f32 shootrotx);
+f32 chr_get_aim_limit_angle(f32 sqdist);
+void chr_calculate_hit(struct chrdata *chr, bool *angleokptr, bool *hit, struct gset *gset);
+bool chr_get_gun_pos(struct chrdata *chr, s32 handnum, struct coord *gunpos);
+void chr_calculate_shield_hit(struct chrdata *chr, struct coord *pos, struct coord *vector, struct modelnode **node, s32 *hitpart, struct model **model, s32 *side);
+void chr_calculate_trajectory(struct coord *frompos, f32 arg1, struct coord *aimpos, struct coord *arg3);
+void chr_tick_shoot(struct chrdata *chr, s32 handnum);
 void func0f041a74(struct chrdata *chr);
 bool func0f041c44(struct chrdata *chr);
-void chrAttackAmountUpdateAnimation(struct chrdata *chr);
-void chrTickFire(struct chrdata *chr);
-void chrTickAttackAmount(struct chrdata *chr);
-void robotSetMuzzleFlash(struct chrdata *chr, bool right, bool enabled);
-void robotAttack(struct chrdata *chr);
-void chrTickRobotAttack(struct chrdata *chr);
-void chrTickAttack(struct chrdata *chr);
-void chrTickAttackRoll(struct chrdata *chr);
-void propPrintDangerous(void);
-void chrTickThrowGrenade(struct chrdata *chr);
+void chr_attack_amount_update_animation(struct chrdata *chr);
+void chr_tick_fire(struct chrdata *chr);
+void chr_tick_attack_amount(struct chrdata *chr);
+void robot_set_muzzle_flash(struct chrdata *chr, bool right, bool enabled);
+void robot_attack(struct chrdata *chr);
+void chr_tick_robot_attack(struct chrdata *chr);
+void chr_tick_attack(struct chrdata *chr);
+void chr_tick_attack_roll(struct chrdata *chr);
+void prop_print_dangerous(void);
+void chr_tick_throw_grenade(struct chrdata *chr);
 bool func0f043f2c(struct chrdata *chr, struct coord *runpos, u32 arg2, f32 *turnspeed);
-void chrTickAttackWalk(struct chrdata *chr);
-bool posIsMovingTowardsPosOrStoppedInRange(struct coord *prevpos, struct coord *moveddelta, struct coord *targetpos, f32 range);
-bool posIsArrivingLaterallyAtPos(struct coord *prevpos, struct coord *curpos, struct coord *targetpos, f32 range);
-bool posIsArrivingAtPos(struct coord *prevpos, struct coord *curpos, struct coord *targetpos, f32 range);
-void chrTickRunPos(struct chrdata *chr);
+void chr_tick_attack_walk(struct chrdata *chr);
+bool pos_is_moving_towards_pos_or_stopped_in_range(struct coord *prevpos, struct coord *moveddelta, struct coord *targetpos, f32 range);
+bool pos_is_arriving_laterally_at_pos(struct coord *prevpos, struct coord *curpos, struct coord *targetpos, f32 range);
+bool pos_is_arriving_at_pos(struct coord *prevpos, struct coord *curpos, struct coord *targetpos, f32 range);
+void chr_tick_run_pos(struct chrdata *chr);
 void func0f044b68(struct coord *arg0, struct coord *arg1, struct coord *arg2);
-bool chrNavCanSeeNextPos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, struct coord *aimpos, struct coord *arg4, struct coord *arg5, f32 negchrradius, f32 chrradius, s32 cdtypes, s32 arg9);
-bool chrNavCheckForObstacle(struct chrdata *chr, struct coord *chrpos, RoomNum *chrrooms, struct coord *aimpos, struct coord *leftpos, struct coord *rightpos, f32 negchrradius, f32 chrradius, s32 cdtypes, bool hasobstacle);
-bool chrNavTryObstacle(struct chrdata *chr, struct coord *arg1, bool arg2, struct coord *arg3, f32 radius, bool arg5, struct coord *nextpos, struct waydata *waydata, f32 arg8, s32 cdtypes, s32 arg10);
-struct prop *chrOpenDoor(struct chrdata *chr, struct coord *rangepos);
-void chrNavTickMain(struct chrdata *chr, struct coord *pos, struct waydata *waydata, bool arg3);
-bool chrGoPosUpdateLiftAction(struct chrdata *chr, u32 curpadflags, bool arg2, bool arrivingatlift, s16 curpadnum, s32 nextpadnum);
-s16 chrGoPosGetNextPadNum(struct chrdata *chr);
-void chrTickGoPos(struct chrdata *chr);
-void chrTickPatrol(struct chrdata *chr);
-bool chrStartSkJump(struct chrdata *chr, u8 arg1, u8 arg2, s32 arg3, u8 arg4);
-void chrTickSkJump(struct chrdata *chr);
-void chraTick(struct chrdata *chr);
-void cutsceneStart(u32 ailistid);
-void chraTickBg(void);
-f32 chrGetAngleToPos(struct chrdata *chr, struct coord *pos);
-void chrGetAttackEntityPos(struct chrdata *chr, u32 attackflags, s32 entityid, struct coord *pos, RoomNum *rooms);
-f32 chrGetAngleFromTargetsFov(struct chrdata *chr);
-f32 chrGetVerticalAngleToTarget(struct chrdata *chr);
-bool chrIsInTargetsFovX(struct chrdata *chr, u8 fov360);
-bool chrIsVerticalAngleToTargetWithin(struct chrdata *chr, u8 arg1);
+bool chr_nav_can_see_next_pos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, struct coord *aimpos, struct coord *arg4, struct coord *arg5, f32 negchrradius, f32 chrradius, s32 cdtypes, s32 arg9);
+bool chr_nav_check_for_obstacle(struct chrdata *chr, struct coord *chrpos, RoomNum *chrrooms, struct coord *aimpos, struct coord *leftpos, struct coord *rightpos, f32 negchrradius, f32 chrradius, s32 cdtypes, bool hasobstacle);
+bool chr_nav_try_obstacle(struct chrdata *chr, struct coord *arg1, bool arg2, struct coord *arg3, f32 radius, bool arg5, struct coord *nextpos, struct waydata *waydata, f32 arg8, s32 cdtypes, s32 arg10);
+struct prop *chr_open_door(struct chrdata *chr, struct coord *rangepos);
+void chr_nav_tick_main(struct chrdata *chr, struct coord *pos, struct waydata *waydata, bool arg3);
+bool chr_go_pos_update_lift_action(struct chrdata *chr, u32 curpadflags, bool arg2, bool arrivingatlift, s16 curpadnum, s32 nextpadnum);
+s16 chr_go_pos_get_next_pad_num(struct chrdata *chr);
+void chr_tick_go_pos(struct chrdata *chr);
+void chr_tick_patrol(struct chrdata *chr);
+bool chr_start_sk_jump(struct chrdata *chr, u8 arg1, u8 arg2, s32 arg3, u8 arg4);
+void chr_tick_sk_jump(struct chrdata *chr);
+void chra_tick(struct chrdata *chr);
+void cutscene_start(u32 ailistid);
+void chra_tick_bg(void);
+f32 chr_get_angle_to_pos(struct chrdata *chr, struct coord *pos);
+void chr_get_attack_entity_pos(struct chrdata *chr, u32 attackflags, s32 entityid, struct coord *pos, RoomNum *rooms);
+f32 chr_get_angle_from_targets_fov(struct chrdata *chr);
+f32 chr_get_vertical_angle_to_target(struct chrdata *chr);
+bool chr_is_in_targets_fov_x(struct chrdata *chr, u8 fov360);
+bool chr_is_vertical_angle_to_target_within(struct chrdata *chr, u8 arg1);
 f32 func0f048fcc(struct chrdata *chr, u8 reverse);
-bool chrIsTargetInFov(struct chrdata *chr, u8 arg1, u8 reverse);
-bool chrIsLookingAtPos(struct chrdata *chr, struct coord *pos, u8 arg2);
-f32 chrGetSameFloorDistanceToPad(struct chrdata *chr, s32 pad_id);
-void chrsClearRefsToPlayer(s32 playernum);
-s32 chrResolveId(struct chrdata *ref, s32 id);
-f32 chrGetTimer(struct chrdata *chr);
-bool chrIsTargetAimingAtMe(struct chrdata *chr);
-bool chrSawInjury(struct chrdata *chr, u8 arg1);
-bool chrSawDeath(struct chrdata *chr, u8 arg1);
-bool waypointIsWithin90DegreesOfPosAngle(struct waypoint *waypoint, struct coord *pos, f32 angle);
-s32 chrFindWaypointWithinPosQuadrant(struct coord *pos, RoomNum *rooms, f32 angle, u8 quadrant);
+bool chr_is_target_in_fov(struct chrdata *chr, u8 arg1, u8 reverse);
+bool chr_is_looking_at_pos(struct chrdata *chr, struct coord *pos, u8 arg2);
+f32 chr_get_same_floor_distance_to_pad(struct chrdata *chr, s32 pad_id);
+void chrs_clear_refs_to_player(s32 playernum);
+s32 chr_resolve_id(struct chrdata *ref, s32 id);
+f32 chr_get_timer(struct chrdata *chr);
+bool chr_is_target_aiming_at_me(struct chrdata *chr);
+bool chr_saw_injury(struct chrdata *chr, u8 arg1);
+bool chr_saw_death(struct chrdata *chr, u8 arg1);
+bool waypoint_is_within_90_degrees_of_pos_angle(struct waypoint *waypoint, struct coord *pos, f32 angle);
+s32 chr_find_waypoint_within_pos_quadrant(struct coord *pos, RoomNum *rooms, f32 angle, u8 quadrant);
 bool func0f04a4ec(struct chrdata *chr, u8 quadrant);
-bool chrSetPadPresetToWaypointWithinTargetQuadrant(struct chrdata *chr, u8 arg1);
-bool chrSetChrPresetToChrNearPad(u32 checktype, struct chrdata *chr, f32 distance, s32 padnum);
-bool chrSetChrPresetToChrNearPos(u8 checktype, struct chrdata *chr, f32 distance, struct coord *pos, RoomNum *room);
-bool chrSetPadPresetToPadOnRouteToTarget(struct chrdata *chr);
-bool chrIsPosOffScreen(struct coord *pos, RoomNum *rooms);
+bool chr_set_pad_preset_to_waypoint_within_target_quadrant(struct chrdata *chr, u8 arg1);
+bool chr_set_chr_preset_to_chr_near_pad(u32 checktype, struct chrdata *chr, f32 distance, s32 padnum);
+bool chr_set_chr_preset_to_chr_near_pos(u8 checktype, struct chrdata *chr, f32 distance, struct coord *pos, RoomNum *room);
+bool chr_set_pad_preset_to_pad_on_route_to_target(struct chrdata *chr);
+bool chr_is_pos_off_screen(struct coord *pos, RoomNum *rooms);
 
 #if VERSION >= VERSION_NTSC_1_0
-bool chrAdjustPosForSpawn(f32 chrradius, struct coord *pos, RoomNum *rooms, f32 angle, bool allowonscreen, bool force, bool onlysurrounding);
+bool chr_adjust_pos_for_spawn(f32 chrradius, struct coord *pos, RoomNum *rooms, f32 angle, bool allowonscreen, bool force, bool onlysurrounding);
 #else
-bool chrAdjustPosForSpawn(f32 chrradius, struct coord *pos, RoomNum *rooms, f32 angle, bool allowonscreen, bool force);
+bool chr_adjust_pos_for_spawn(f32 chrradius, struct coord *pos, RoomNum *rooms, f32 angle, bool allowonscreen, bool force);
 #endif
 
-struct prop *chrSpawnAtCoord(s32 body, s32 head, struct coord *pos, RoomNum *room, f32 angle, u8 *ailist, u32 spawnflags);
-bool chrIsPropPresetBlockingSightToTarget(struct chrdata *chr);
-bool chrMoveToPos(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle, bool ignorebg);
-bool chrCheckCoverOutOfSight(struct chrdata *chr, s32 covernum, bool soft);
-s32 chrAssignCoverByCriteria(struct chrdata *chr, u16 arg1, s32 arg2);
-s32 chrAssignCoverAwayFromDanger(struct chrdata *chr, s32 mindist, s32 maxdist);
-bool chrRunFromPos(struct chrdata *chr, u32 goposflags, f32 distance, struct coord *frompos);
+struct prop *chr_spawn_at_coord(s32 body, s32 head, struct coord *pos, RoomNum *room, f32 angle, u8 *ailist, u32 spawnflags);
+bool chr_is_prop_preset_blocking_sight_to_target(struct chrdata *chr);
+bool chr_move_to_pos(struct chrdata *chr, struct coord *pos, RoomNum *room, f32 angle, bool ignorebg);
+bool chr_check_cover_out_of_sight(struct chrdata *chr, s32 covernum, bool soft);
+s32 chr_assign_cover_by_criteria(struct chrdata *chr, u16 arg1, s32 arg2);
+s32 chr_assign_cover_away_from_danger(struct chrdata *chr, s32 mindist, s32 maxdist);
+bool chr_run_from_pos(struct chrdata *chr, u32 goposflags, f32 distance, struct coord *frompos);
 f32 func0f04c784(struct chrdata *chr);
 bool chr0f04c874(struct chrdata *chr, u32 angle360, struct coord *pos, u8 arg3, u8 arg4);
-void rebuildTeams(void);
-void rebuildSquadrons(void);
-void chrAvoid(struct chrdata *chr);
+void rebuild_teams(void);
+void rebuild_squadrons(void);
+void chr_avoid(struct chrdata *chr);
 void func0f02e9a0(struct chrdata *chr, f32 mergetime);
 void func0f02ed28(struct chrdata *chr, f32 mergetime);
-void chrStop(struct chrdata *chr);
-void chrKneel(struct chrdata *chr);
-void chrStartAlarm(struct chrdata *chr);
-void chrThrowGrenade(struct chrdata *chr, s32 arg1, s32 arg2);
-void chrDoSurprisedSurrender(struct chrdata *chr);
-void chrDoSurprisedLookAround(struct chrdata *chr);
-void chrSurrender(struct chrdata *chr);
-void chrSidestep(struct chrdata *chr, bool side);
-void chrJumpOut(struct chrdata *chr, bool side);
-void chrRunToPos(struct chrdata *chr, struct coord *pos);
-void chrBeginDead(struct chrdata *chr);
-f32 chrGetShield(struct chrdata *chr);
-void chrDie(struct chrdata *chr, s32 aplayernum);
-void chrGoPosGetCurWaypointInfo(struct chrdata *chr, struct coord *pos, RoomNum *rooms);
-void chrGoPosClearRestartTtl(struct chrdata *chr);
-void chrPatrolGetCurWaypointInfo(struct chrdata *chr, struct coord *pos, RoomNum *rooms);
-struct path *pathFindById(u32 path_id);
-void chrRecordLastVisibleTargetTime(struct chrdata *chr);
-bool chrHasLosToTarget(struct chrdata *chr);
-void chrRecordLastSeeTargetTime(struct chrdata *chr);
-void chrRecordLastHearTargetTime(struct chrdata *chr);
-bool chrIsDead(struct chrdata *chr);
-bool chrTryAttackStand(struct chrdata *chr, u32 attackflags, s32 entityid);
-bool chrTryAttackKneel(struct chrdata *chr, u32 attackflags, s32 entityid);
-bool chrTryAttackLie(struct chrdata *chr, u32 attackflags, s32 entityid);
-bool chrTryModifyAttack(struct chrdata *chr, u32 attackflags, s32 entityid);
-bool chrFaceEntity(struct chrdata *chr, u32 attackflags, s32 entityid);
-bool chrSetPath(struct chrdata *chr, u32 path_id);
-bool chrTryStartPatrol(struct chrdata *chr);
-bool chrTrySurrender(struct chrdata *chr);
-bool chrFadeOut(struct chrdata *chr);
-bool chrGoToTarget(struct chrdata *chr, u32 goposflags);
-bool chrGoToChr(struct chrdata *chr, u32 dst_chrnum, u32 goposflags);
-bool chrGoToProp(struct chrdata *chr, struct prop *prop, u32 goposflags);
-bool chrTryStop(struct chrdata *chr);
-bool chrTrySurprisedOneHand(struct chrdata *chr);
-bool chrTrySurprisedSurrender(struct chrdata *chr);
-bool chrTrySurprisedLookAround(struct chrdata *chr);
-bool chrTryKneel(struct chrdata *chr);
-bool chrTryStartAnim(struct chrdata *chr, s32 animnum, f32 startframe, f32 endframe, u8 chranimflags, s32 merge, f32 speed);
-bool chrTryStartAlarm(struct chrdata *chr, s32 pad_id);
-bool chrConsiderGrenadeThrow(struct chrdata *chr, u32 attackflags, u32 entityid);
-void chrTickKneel(struct chrdata *chr);
-void chrFadeCorpse(struct chrdata *chr);
-void chrFadeCorpseWhenOffScreen(struct chrdata *chr);
-void chrTickTest(struct chrdata *chr);
-void chrSetLookAngle(struct chrdata *chr, f32 angle);
-f32 chrGetRotY(struct chrdata *chr);
-void chrSetRotY(struct chrdata *chr, f32 arg1);
-void chrResetAimEndProperties(struct chrdata *chr);
-void chrSetFiring(struct chrdata *chr, s32 hand, bool firing);
-void chrStopFiring(struct chrdata *chr);
-void chrSetHandFiring(struct chrdata *chr, s32 hand, bool arg2);
+void chr_stop(struct chrdata *chr);
+void chr_kneel(struct chrdata *chr);
+void chr_start_alarm(struct chrdata *chr);
+void chr_throw_grenade(struct chrdata *chr, s32 arg1, s32 arg2);
+void chr_do_surprised_surrender(struct chrdata *chr);
+void chr_do_surprised_look_around(struct chrdata *chr);
+void chr_surrender(struct chrdata *chr);
+void chr_sidestep(struct chrdata *chr, bool side);
+void chr_jump_out(struct chrdata *chr, bool side);
+void chr_run_to_pos(struct chrdata *chr, struct coord *pos);
+void chr_begin_dead(struct chrdata *chr);
+f32 chr_get_shield(struct chrdata *chr);
+void chr_die(struct chrdata *chr, s32 aplayernum);
+void chr_go_pos_get_cur_waypoint_info(struct chrdata *chr, struct coord *pos, RoomNum *rooms);
+void chr_go_pos_clear_restart_ttl(struct chrdata *chr);
+void chr_patrol_get_cur_waypoint_info(struct chrdata *chr, struct coord *pos, RoomNum *rooms);
+struct path *path_find_by_id(u32 path_id);
+void chr_record_last_visible_target_time(struct chrdata *chr);
+bool chr_has_los_to_target(struct chrdata *chr);
+void chr_record_last_see_target_time(struct chrdata *chr);
+void chr_record_last_hear_target_time(struct chrdata *chr);
+bool chr_is_dead(struct chrdata *chr);
+bool chr_try_attack_stand(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_try_attack_kneel(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_try_attack_lie(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_try_modify_attack(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_face_entity(struct chrdata *chr, u32 attackflags, s32 entityid);
+bool chr_set_path(struct chrdata *chr, u32 path_id);
+bool chr_try_start_patrol(struct chrdata *chr);
+bool chr_try_surrender(struct chrdata *chr);
+bool chr_fade_out(struct chrdata *chr);
+bool chr_go_to_target(struct chrdata *chr, u32 goposflags);
+bool chr_go_to_chr(struct chrdata *chr, u32 dst_chrnum, u32 goposflags);
+bool chr_go_to_prop(struct chrdata *chr, struct prop *prop, u32 goposflags);
+bool chr_try_stop(struct chrdata *chr);
+bool chr_try_surprised_one_hand(struct chrdata *chr);
+bool chr_try_surprised_surrender(struct chrdata *chr);
+bool chr_try_surprised_look_around(struct chrdata *chr);
+bool chr_try_kneel(struct chrdata *chr);
+bool chr_try_start_anim(struct chrdata *chr, s32 animnum, f32 startframe, f32 endframe, u8 chranimflags, s32 merge, f32 speed);
+bool chr_try_start_alarm(struct chrdata *chr, s32 pad_id);
+bool chr_consider_grenade_throw(struct chrdata *chr, u32 attackflags, u32 entityid);
+void chr_tick_kneel(struct chrdata *chr);
+void chr_fade_corpse(struct chrdata *chr);
+void chr_fade_corpse_when_off_screen(struct chrdata *chr);
+void chr_tick_test(struct chrdata *chr);
+void chr_set_look_angle(struct chrdata *chr, f32 angle);
+f32 chr_get_rot_y(struct chrdata *chr);
+void chr_set_rot_y(struct chrdata *chr, f32 arg1);
+void chr_reset_aim_end_properties(struct chrdata *chr);
+void chr_set_firing(struct chrdata *chr, s32 hand, bool firing);
+void chr_stop_firing(struct chrdata *chr);
+void chr_set_hand_firing(struct chrdata *chr, s32 hand, bool arg2);
 void func0f0429d8(struct chrdata *chr, f32 arg1, f32 arg2);
-void propUnsetDangerous(struct prop *prop);
-void propSetDangerous(struct prop *prop);
-bool chrDetectDangerousObject(struct chrdata *chr, u8 flags);
-void chrTickBondDie(struct chrdata *chr);
-s32 chrIsUsingLift(struct chrdata *chr);
-bool chrTrySkJump(struct chrdata *chr, u8 arg1, u8 arg2, s32 arg3, u8 arg4);
-bool chrSawTargetRecently(struct chrdata *chr);
-bool chrHeardTargetRecently(struct chrdata *chr);
-f32 chrGetAngleToTarget(struct chrdata *chr);
-f32 chrGetDistanceToTarget(struct chrdata *chr);
-f32 chrGetDistanceToTarget2(struct chrdata *chr);
-f32 chrGetDistanceToCurrentPlayer(struct chrdata *chr);
-f32 propGetDistanceToProp(struct prop *a, struct prop *b);
-f32 propGetLateralDistanceToProp(struct prop *a, struct prop *b);
-f32 chrGetDistanceToPad(struct chrdata *chr, s32 pad_id);
-f32 chrGetDistanceToCoord(struct chrdata *chr, struct coord *pos);
-f32 chrGetLateralDistanceToCoord(struct chrdata *chr, struct coord *pos);
-f32 chrGetLateralDistanceToPad(struct chrdata *chr, s32 pad_id);
-f32 chrGetSquaredDistanceToCoord(struct chrdata *chr, struct coord *pos);
-f32 coordGetSquaredDistanceToCoord(struct coord *a, struct coord *b);
-s32 chrGetPadRoom(struct chrdata *chr, s32 pad_id);
-s32 chrResolvePadId(struct chrdata *chr, s32 pad_id);
-struct chrdata *chrFindById(struct chrdata *data, s32 chrnum);
-s32 propGetIndexByChrId(struct chrdata *chr, s32 chrnum);
-f32 chrGetDistanceToChr(struct chrdata *chr1, s32 chr2num);
-f32 chrGetDistanceFromTargetToPad(struct chrdata *chr, s32 pad_id);
-void chrSetFlags(struct chrdata *chr, u32 flags, u8 bank);
-void chrUnsetFlags(struct chrdata *chr, u32 flags, u8 bank);
-bool chrHasFlag(struct chrdata *chr, u32 flag, u8 bank);
-void chrSetFlagsById(struct chrdata *ref, u32 chrnum, u32 flags, u32 bank);
-void chrUnsetFlagsById(struct chrdata *ref, u32 chrnum, u32 flags, u32 bank);
-bool chrHasFlagById(struct chrdata *ref, u32 chrnum, u32 flag, u32 bank);
-void chrSetStageFlag(struct chrdata *chr, u32 flag);
-void chrUnsetStageFlag(struct chrdata *chr, u32 flag);
-bool chrHasStageFlag(struct chrdata *chr, u32 flag);
-bool chrIsHearingTarget(struct chrdata *chr);
-void chrRestartTimer(struct chrdata *chr);
-bool chrResetNearMiss(struct chrdata *chr);
-s32 chrGetNumArghs(struct chrdata *chr);
-s32 chrGetNumCloseArghs(struct chrdata *chr);
-void decrementByte(u8 *dst, u8 amount);
-void incrementByte(u8 *dst, u8 amount);
-bool chrCanHearAlarm(struct chrdata *chr);
-bool chrSetChrPresetToAnyChrNearSelf(struct chrdata *chr, f32 distance);
-bool chrSetChrPresetToChrNearSelf(u8 checktype, struct chrdata *chr, f32 distance);
-bool chrCompareTeams(struct chrdata *chr1, struct chrdata *chr2, u8 checktype);
-void chrSetChrPreset(struct chrdata *chr, s32 chrpreset);
-void chrSetChrPresetByChrnum(struct chrdata *chr, s32 chrnum, s32 chrpreset);
-void chrSetPadPreset(struct chrdata *chr, s32 pad_id);
-void chrSetPadPresetByChrnum(struct chrdata *chr, s32 chrnum, s32 pad_id);
-struct prop *chrSpawnAtPad(struct chrdata *chr, s32 body, s32 head, s32 pad, u8 *ailist, u32 spawnflags);
-struct prop *chrSpawnAtChr(struct chrdata *basechr, s32 body, s32 head, u32 chrnum, u8 *ailist, u32 spawnflags);
-s16 chrGoToCover(struct chrdata *chr, u8 speed);
-void chrAddTargetToBdlist(struct chrdata *chr);
-s32 chrGetDistanceLostToTargetInLastSecond(struct chrdata *chr);
-bool chrIsTargetNearlyInSight(struct chrdata *chr, u32 distance);
-bool chrIsNearlyInTargetsSight(struct chrdata *chr, u32 distance);
-s16 *teamGetChrIds(s32 team_id);
-s16 *squadronGetChrIds(s32 squadron_id);
-void audioMarkAsRecentlyPlayed(s16 audioid);
-bool audioWasNotPlayedRecently(s16 audioid);
-Gfx *chrsRenderChrStats(Gfx *gdl, RoomNum *rooms);
-void chrToggleModelPart(struct chrdata *chr, s32 partnum);
-bool chrIsAvoiding(struct chrdata *chr);
-void chrDrCarollEmitSparks(struct chrdata *chr);
+void prop_unset_dangerous(struct prop *prop);
+void prop_set_dangerous(struct prop *prop);
+bool chr_detect_dangerous_object(struct chrdata *chr, u8 flags);
+void chr_tick_bond_die(struct chrdata *chr);
+s32 chr_is_using_lift(struct chrdata *chr);
+bool chr_try_sk_jump(struct chrdata *chr, u8 arg1, u8 arg2, s32 arg3, u8 arg4);
+bool chr_saw_target_recently(struct chrdata *chr);
+bool chr_heard_target_recently(struct chrdata *chr);
+f32 chr_get_angle_to_target(struct chrdata *chr);
+f32 chr_get_distance_to_target(struct chrdata *chr);
+f32 chr_get_distance_to_target2(struct chrdata *chr);
+f32 chr_get_distance_to_current_player(struct chrdata *chr);
+f32 prop_get_distance_to_prop(struct prop *a, struct prop *b);
+f32 prop_get_lateral_distance_to_prop(struct prop *a, struct prop *b);
+f32 chr_get_distance_to_pad(struct chrdata *chr, s32 pad_id);
+f32 chr_get_distance_to_coord(struct chrdata *chr, struct coord *pos);
+f32 chr_get_lateral_distance_to_coord(struct chrdata *chr, struct coord *pos);
+f32 chr_get_lateral_distance_to_pad(struct chrdata *chr, s32 pad_id);
+f32 chr_get_squared_distance_to_coord(struct chrdata *chr, struct coord *pos);
+f32 coord_get_squared_distance_to_coord(struct coord *a, struct coord *b);
+s32 chr_get_pad_room(struct chrdata *chr, s32 pad_id);
+s32 chr_resolve_pad_id(struct chrdata *chr, s32 pad_id);
+struct chrdata *chr_find_by_id(struct chrdata *data, s32 chrnum);
+s32 prop_get_index_by_chr_id(struct chrdata *chr, s32 chrnum);
+f32 chr_get_distance_to_chr(struct chrdata *chr1, s32 chr2num);
+f32 chr_get_distance_from_target_to_pad(struct chrdata *chr, s32 pad_id);
+void chr_set_flags(struct chrdata *chr, u32 flags, u8 bank);
+void chr_unset_flags(struct chrdata *chr, u32 flags, u8 bank);
+bool chr_has_flag(struct chrdata *chr, u32 flag, u8 bank);
+void chr_set_flags_by_id(struct chrdata *ref, u32 chrnum, u32 flags, u32 bank);
+void chr_unset_flags_by_id(struct chrdata *ref, u32 chrnum, u32 flags, u32 bank);
+bool chr_has_flag_by_id(struct chrdata *ref, u32 chrnum, u32 flag, u32 bank);
+void chr_set_stage_flag(struct chrdata *chr, u32 flag);
+void chr_unset_stage_flag(struct chrdata *chr, u32 flag);
+bool chr_has_stage_flag(struct chrdata *chr, u32 flag);
+bool chr_is_hearing_target(struct chrdata *chr);
+void chr_restart_timer(struct chrdata *chr);
+bool chr_reset_near_miss(struct chrdata *chr);
+s32 chr_get_num_arghs(struct chrdata *chr);
+s32 chr_get_num_close_arghs(struct chrdata *chr);
+void decrement_byte(u8 *dst, u8 amount);
+void increment_byte(u8 *dst, u8 amount);
+bool chr_can_hear_alarm(struct chrdata *chr);
+bool chr_set_chr_preset_to_any_chr_near_self(struct chrdata *chr, f32 distance);
+bool chr_set_chr_preset_to_chr_near_self(u8 checktype, struct chrdata *chr, f32 distance);
+bool chr_compare_teams(struct chrdata *chr1, struct chrdata *chr2, u8 checktype);
+void chr_set_chr_preset(struct chrdata *chr, s32 chrpreset);
+void chr_set_chr_preset_by_chrnum(struct chrdata *chr, s32 chrnum, s32 chrpreset);
+void chr_set_pad_preset(struct chrdata *chr, s32 pad_id);
+void chr_set_pad_preset_by_chrnum(struct chrdata *chr, s32 chrnum, s32 pad_id);
+struct prop *chr_spawn_at_pad(struct chrdata *chr, s32 body, s32 head, s32 pad, u8 *ailist, u32 spawnflags);
+struct prop *chr_spawn_at_chr(struct chrdata *basechr, s32 body, s32 head, u32 chrnum, u8 *ailist, u32 spawnflags);
+s16 chr_go_to_cover(struct chrdata *chr, u8 speed);
+void chr_add_target_to_bdlist(struct chrdata *chr);
+s32 chr_get_distance_lost_to_target_in_last_second(struct chrdata *chr);
+bool chr_is_target_nearly_in_sight(struct chrdata *chr, u32 distance);
+bool chr_is_nearly_in_targets_sight(struct chrdata *chr, u32 distance);
+s16 *team_get_chr_ids(s32 team_id);
+s16 *squadron_get_chr_ids(s32 squadron_id);
+void audio_mark_as_recently_played(s16 audioid);
+bool audio_was_not_played_recently(s16 audioid);
+Gfx *chrs_render_chr_stats(Gfx *gdl, RoomNum *rooms);
+void chr_toggle_model_part(struct chrdata *chr, s32 partnum);
+bool chr_is_avoiding(struct chrdata *chr);
+void chr_dr_caroll_emit_sparks(struct chrdata *chr);
 
 #endif

src/include/game/chrai.h

@@ -4,9 +4,9 @@
 #include "data.h"
 #include "types.h"
 
-s32 chraiGetListIdByList(u8 *ailist, bool *is_global);
-u32 chraiGoToLabel(u8 *ailist, u32 aioffset, u8 label);
-void chraiExecute(void *entity, s32 proptype);
-u32 chraiGetCommandLength(u8 *ailist, u32 aioffset);
+s32 chrai_get_list_id_by_list(u8 *ailist, bool *is_global);
+u32 chrai_go_to_label(u8 *ailist, u32 aioffset, u8 label);
+void chrai_execute(void *entity, s32 proptype);
+u32 chrai_get_command_length(u8 *ailist, u32 aioffset);
 
 #endif

src/include/game/chraicommands.h

@@ -4,448 +4,448 @@
 #include "data.h"
 #include "types.h"
 
-/*0x0000*/ bool aiGoToNext(void);
-/*0x0001*/ bool aiGoToFirst(void);
-/*0x0002*/ bool aiLabel(void);
-/*0x0003*/ bool aiYield(void);
-/*0x0004*/ bool aiEndList(void);
-/*0x0005*/ bool aiSetList(void);
-/*0x0006*/ bool aiSetReturnList(void);
-/*0x0007*/ bool aiSetShotList(void);
-/*0x0008*/ bool aiReturn(void);
-/*0x0009*/ bool aiStop(void);
-/*0x000a*/ bool aiKneel(void);
-/*0x000b*/ bool aiChrDoAnimation(void);
-/*0x000c*/ bool aiIfIdle(void);
-/*0x000d*/ bool aiBeSurprisedOneHand(void);
-/*0x000e*/ bool aiBeSurprisedLookAround(void);
-/*0x000f*/ bool aiTrySidestep(void);
-/*0x0010*/ bool aiTryJumpOut(void);
-/*0x0011*/ bool aiTryRunSideways(void);
-/*0x0012*/ bool aiTryAttackWalk(void);
-/*0x0013*/ bool aiTryAttackRun(void);
-/*0x0014*/ bool aiTryAttackRoll(void);
-/*0x0015*/ bool aiTryAttackStand(void);
-/*0x0016*/ bool aiTryAttackKneel(void);
-/*0x0017*/ bool aiTryModifyAttack(void);
-/*0x0018*/ bool aiFaceEntity(void);
+/*0x0000*/ bool ai_go_to_next(void);
+/*0x0001*/ bool ai_go_to_first(void);
+/*0x0002*/ bool ai_label(void);
+/*0x0003*/ bool ai_yield(void);
+/*0x0004*/ bool ai_end_list(void);
+/*0x0005*/ bool ai_set_list(void);
+/*0x0006*/ bool ai_set_return_list(void);
+/*0x0007*/ bool ai_set_shot_list(void);
+/*0x0008*/ bool ai_return(void);
+/*0x0009*/ bool ai_stop(void);
+/*0x000a*/ bool ai_kneel(void);
+/*0x000b*/ bool ai_chr_do_animation(void);
+/*0x000c*/ bool ai_if_idle(void);
+/*0x000d*/ bool ai_be_surprised_one_hand(void);
+/*0x000e*/ bool ai_be_surprised_look_around(void);
+/*0x000f*/ bool ai_try_sidestep(void);
+/*0x0010*/ bool ai_try_jump_out(void);
+/*0x0011*/ bool ai_try_run_sideways(void);
+/*0x0012*/ bool ai_try_attack_walk(void);
+/*0x0013*/ bool ai_try_attack_run(void);
+/*0x0014*/ bool ai_try_attack_roll(void);
+/*0x0015*/ bool ai_try_attack_stand(void);
+/*0x0016*/ bool ai_try_attack_kneel(void);
+/*0x0017*/ bool ai_try_modify_attack(void);
+/*0x0018*/ bool ai_face_entity(void);
 /*0x0019*/ bool ai0019(void);
-/*0x001a*/ bool aiChrDamageChr(void);
-/*0x001b*/ bool aiConsiderGrenadeThrow(void);
-/*0x001c*/ bool aiDropItem(void);
-/*0x001d*/ bool aiJogToPad(void);
-/*0x001e*/ bool aiGoToPadPreset(void);
-/*0x001f*/ bool aiWalkToPad(void);
-/*0x0020*/ bool aiRunToPad(void);
-/*0x0021*/ bool aiSetPath(void);
-/*0x0022*/ bool aiStartPatrol(void);
-/*0x0023*/ bool aiIfPatrolling(void);
-/*0x0024*/ bool aiSurrender(void);
-/*0x0025*/ bool aiFadeOut(void);
-/*0x0026*/ bool aiRemoveChr(void);
-/*0x0027*/ bool aiTryStartAlarm(void);
-/*0x0028*/ bool aiActivateAlarm(void);
-/*0x0029*/ bool aiDeactivateAlarm(void);
-/*0x002a*/ bool aiTryRunFromTarget(void);
-/*0x002b*/ bool aiTryJogToTargetProp(void);
-/*0x002c*/ bool aiTryWalkToTargetProp(void);
-/*0x002d*/ bool aiTryRunToTargetProp(void);
-/*0x002e*/ bool aiTryGoToCoverProp(void);
-/*0x002f*/ bool aiTryJogToChr(void);
-/*0x0030*/ bool aiTryWalkToChr(void);
-/*0x0031*/ bool aiTryRunToChr(void);
-/*0x0032*/ bool aiIfStopped(void);
-/*0x0033*/ bool aiIfChrDead(void);
-/*0x0034*/ bool aiIfChrDeathAnimationFinished(void);
-/*0x0035*/ bool aiIfCanSeeTarget(void);
-/*0x0036*/ bool aiRandom(void);
-/*0x0037*/ bool aiIfRandomLessThan(void);
-/*0x0038*/ bool aiIfRandomGreaterThan(void);
-/*0x0039*/ bool aiIfCanHearAlarm(void);
-/*0x003a*/ bool aiIfAlarmActive(void);
-/*0x003b*/ bool aiIfGasActive(void);
-/*0x003c*/ bool aiIfHearsTarget(void);
-/*0x003d*/ bool aiIfSawInjury(void);
-/*0x003e*/ bool aiIfSawDeath(void);
-/*0x003f*/ bool aiIfLosToTarget(void);
-/*0x0040*/ bool aiIfTargetNearlyInSight(void);
-/*0x0041*/ bool aiIfNearlyInTargetsSight(void);
-/*0x0042*/ bool aiSetPadPresetToPadOnRouteToTarget(void);
-/*0x0043*/ bool aiIfSawTargetRecently(void);
-/*0x0044*/ bool aiIfHeardTargetRecently(void);
-/*0x0045*/ bool aiIfLosToChr(void);
-/*0x0046*/ bool aiIfNeverBeenOnScreen(void);
-/*0x0047*/ bool aiIfOnScreen(void);
-/*0x0048*/ bool aiIfChrInOnScreenRoom(void);
-/*0x0049*/ bool aiIfRoomIsOnScreen(void);
-/*0x004a*/ bool aiIfTargetAimingAtMe(void);
-/*0x004b*/ bool aiIfNearMiss(void);
-/*0x004c*/ bool aiIfSeesSuspiciousItem(void);
-/*0x004d*/ bool aiIfTargetInFovLeft(void);
-/*0x004e*/ bool aiIfCheckFovWithTarget(void);
-/*0x004f*/ bool aiIfTargetOutOfFovLeft(void);
-/*0x0050*/ bool aiIfTargetInFov(void);
-/*0x0051*/ bool aiIfTargetOutOfFov(void);
-/*0x0052*/ bool aiIfDistanceToTargetLessThan(void);
-/*0x0053*/ bool aiIfDistanceToTargetGreaterThan(void);
-/*0x0054*/ bool aiIfChrDistanceToPadLessThan(void);
-/*0x0055*/ bool aiIfChrDistanceToPadGreaterThan(void);
-/*0x0056*/ bool aiIfDistanceToChrLessThan(void);
-/*0x0057*/ bool aiIfDistanceToChrGreaterThan(void);
+/*0x001a*/ bool ai_chr_damage_chr(void);
+/*0x001b*/ bool ai_consider_grenade_throw(void);
+/*0x001c*/ bool ai_drop_item(void);
+/*0x001d*/ bool ai_jog_to_pad(void);
+/*0x001e*/ bool ai_go_to_pad_preset(void);
+/*0x001f*/ bool ai_walk_to_pad(void);
+/*0x0020*/ bool ai_run_to_pad(void);
+/*0x0021*/ bool ai_set_path(void);
+/*0x0022*/ bool ai_start_patrol(void);
+/*0x0023*/ bool ai_if_patrolling(void);
+/*0x0024*/ bool ai_surrender(void);
+/*0x0025*/ bool ai_fade_out(void);
+/*0x0026*/ bool ai_remove_chr(void);
+/*0x0027*/ bool ai_try_start_alarm(void);
+/*0x0028*/ bool ai_activate_alarm(void);
+/*0x0029*/ bool ai_deactivate_alarm(void);
+/*0x002a*/ bool ai_try_run_from_target(void);
+/*0x002b*/ bool ai_try_jog_to_target_prop(void);
+/*0x002c*/ bool ai_try_walk_to_target_prop(void);
+/*0x002d*/ bool ai_try_run_to_target_prop(void);
+/*0x002e*/ bool ai_try_go_to_cover_prop(void);
+/*0x002f*/ bool ai_try_jog_to_chr(void);
+/*0x0030*/ bool ai_try_walk_to_chr(void);
+/*0x0031*/ bool ai_try_run_to_chr(void);
+/*0x0032*/ bool ai_if_stopped(void);
+/*0x0033*/ bool ai_if_chr_dead(void);
+/*0x0034*/ bool ai_if_chr_death_animation_finished(void);
+/*0x0035*/ bool ai_if_can_see_target(void);
+/*0x0036*/ bool ai_random(void);
+/*0x0037*/ bool ai_if_random_less_than(void);
+/*0x0038*/ bool ai_if_random_greater_than(void);
+/*0x0039*/ bool ai_if_can_hear_alarm(void);
+/*0x003a*/ bool ai_if_alarm_active(void);
+/*0x003b*/ bool ai_if_gas_active(void);
+/*0x003c*/ bool ai_if_hears_target(void);
+/*0x003d*/ bool ai_if_saw_injury(void);
+/*0x003e*/ bool ai_if_saw_death(void);
+/*0x003f*/ bool ai_if_los_to_target(void);
+/*0x0040*/ bool ai_if_target_nearly_in_sight(void);
+/*0x0041*/ bool ai_if_nearly_in_targets_sight(void);
+/*0x0042*/ bool ai_set_pad_preset_to_pad_on_route_to_target(void);
+/*0x0043*/ bool ai_if_saw_target_recently(void);
+/*0x0044*/ bool ai_if_heard_target_recently(void);
+/*0x0045*/ bool ai_if_los_to_chr(void);
+/*0x0046*/ bool ai_if_never_been_on_screen(void);
+/*0x0047*/ bool ai_if_on_screen(void);
+/*0x0048*/ bool ai_if_chr_in_on_screen_room(void);
+/*0x0049*/ bool ai_if_room_is_on_screen(void);
+/*0x004a*/ bool ai_if_target_aiming_at_me(void);
+/*0x004b*/ bool ai_if_near_miss(void);
+/*0x004c*/ bool ai_if_sees_suspicious_item(void);
+/*0x004d*/ bool ai_if_target_in_fov_left(void);
+/*0x004e*/ bool ai_if_check_fov_with_target(void);
+/*0x004f*/ bool ai_if_target_out_of_fov_left(void);
+/*0x0050*/ bool ai_if_target_in_fov(void);
+/*0x0051*/ bool ai_if_target_out_of_fov(void);
+/*0x0052*/ bool ai_if_distance_to_target_less_than(void);
+/*0x0053*/ bool ai_if_distance_to_target_greater_than(void);
+/*0x0054*/ bool ai_if_chr_distance_to_pad_less_than(void);
+/*0x0055*/ bool ai_if_chr_distance_to_pad_greater_than(void);
+/*0x0056*/ bool ai_if_distance_to_chr_less_than(void);
+/*0x0057*/ bool ai_if_distance_to_chr_greater_than(void);
 /*0x0058*/ bool ai0058(void);
-/*0x0059*/ bool aiIfDistanceFromTargetToPadLessThan(void);
-/*0x005a*/ bool aiIfDistanceFromTargetToPadGreaterThan(void);
-/*0x005b*/ bool aiIfChrInRoom(void);
-/*0x005c*/ bool aiIfTargetInRoom(void);
-/*0x005d*/ bool aiIfChrHasObject(void);
-/*0x005e*/ bool aiIfWeaponThrown(void);
-/*0x005f*/ bool aiIfWeaponThrownOnObject(void);
-/*0x0060*/ bool aiIfChrHasWeaponEquipped(void);
-/*0x0061*/ bool aiIfGunUnclaimed(void);
-/*0x0062*/ bool aiIfObjectHealthy(void);
-/*0x0063*/ bool aiIfChrActivatedObject(void);
-/*0x0065*/ bool aiObjInteract(void);
-/*0x0066*/ bool aiDestroyObject(void);
+/*0x0059*/ bool ai_if_distance_from_target_to_pad_less_than(void);
+/*0x005a*/ bool ai_if_distance_from_target_to_pad_greater_than(void);
+/*0x005b*/ bool ai_if_chr_in_room(void);
+/*0x005c*/ bool ai_if_target_in_room(void);
+/*0x005d*/ bool ai_if_chr_has_object(void);
+/*0x005e*/ bool ai_if_weapon_thrown(void);
+/*0x005f*/ bool ai_if_weapon_thrown_on_object(void);
+/*0x0060*/ bool ai_if_chr_has_weapon_equipped(void);
+/*0x0061*/ bool ai_if_gun_unclaimed(void);
+/*0x0062*/ bool ai_if_object_healthy(void);
+/*0x0063*/ bool ai_if_chr_activated_object(void);
+/*0x0065*/ bool ai_obj_interact(void);
+/*0x0066*/ bool ai_destroy_object(void);
 /*0x0067*/ bool ai0067(void);
-/*0x0068*/ bool aiChrDropItems(void);
-/*0x0069*/ bool aiChrDropWeapon(void);
-/*0x006a*/ bool aiGiveObjectToChr(void);
-/*0x006b*/ bool aiObjectMoveToPad(void);
-/*0x006c*/ bool aiOpenDoor(void);
-/*0x006d*/ bool aiCloseDoor(void);
-/*0x006e*/ bool aiIfDoorState(void);
-/*0x006f*/ bool aiIfObjectIsDoor(void);
-/*0x0070*/ bool aiLockDoor(void);
-/*0x0071*/ bool aiUnlockDoor(void);
-/*0x0072*/ bool aiIfDoorLocked(void);
-/*0x0073*/ bool aiIfObjectiveComplete(void);
-/*0x0074*/ bool aiIfObjectiveFailed(void);
+/*0x0068*/ bool ai_chr_drop_items(void);
+/*0x0069*/ bool ai_chr_drop_weapon(void);
+/*0x006a*/ bool ai_give_object_to_chr(void);
+/*0x006b*/ bool ai_object_move_to_pad(void);
+/*0x006c*/ bool ai_open_door(void);
+/*0x006d*/ bool ai_close_door(void);
+/*0x006e*/ bool ai_if_door_state(void);
+/*0x006f*/ bool ai_if_object_is_door(void);
+/*0x0070*/ bool ai_lock_door(void);
+/*0x0071*/ bool ai_unlock_door(void);
+/*0x0072*/ bool ai_if_door_locked(void);
+/*0x0073*/ bool ai_if_objective_complete(void);
+/*0x0074*/ bool ai_if_objective_failed(void);
 /*0x0075*/ bool ai0075(void);
-/*0x0076*/ bool aiSetPadPresetToTargetQuadrant(void);
-/*0x0077*/ bool aiIfDifficultyLessThan(void);
-/*0x0078*/ bool aiIfDifficultyGreaterThan(void);
-/*0x0079*/ bool aiIfStageTimerLessThan(void);
-/*0x007a*/ bool aiIfStageTimerGreaterThan(void);
-/*0x007b*/ bool aiIfStageIdLessThan(void);
-/*0x007c*/ bool aiIfStageIdGreaterThan(void);
-/*0x007d*/ bool aiIfNumArghsLessThan(void);
-/*0x007e*/ bool aiIfNumArghsGreaterThan(void);
-/*0x007f*/ bool aiIfNumCloseArghsLessThan(void);
-/*0x0080*/ bool aiIfNumCloseArghsGreaterThan(void);
-/*0x0081*/ bool aiIfChrHealthGreaterThan(void);
-/*0x0082*/ bool aiIfChrHealthLessThan(void);
-/*0x0083*/ bool aiIfInjured(void);
-/*0x0084*/ bool aiSetMorale(void);
-/*0x0085*/ bool aiAddMorale(void);
-/*0x0086*/ bool aiChrAddMorale(void);
-/*0x0087*/ bool aiSubtractMorale(void);
-/*0x0088*/ bool aiIfMoraleLessThan(void);
-/*0x0089*/ bool aiIfMoraleLessThanRandom(void);
-/*0x008a*/ bool aiSetAlertness(void);
-/*0x008b*/ bool aiAddAlertness(void);
-/*0x008c*/ bool aiChrAddAlertness(void);
-/*0x008d*/ bool aiSubtractAlertness(void);
-/*0x008e*/ bool aiIfAlertness(void);
-/*0x008f*/ bool aiIfChrAlertnessLessThan(void);
-/*0x0090*/ bool aiIfAlertnessLessThanRandom(void);
-/*0x0091*/ bool aiNoOp0091(void);
-/*0x0092*/ bool aiSetHearDistance(void);
-/*0x0093*/ bool aiSetViewDistance(void);
-/*0x0094*/ bool aiSetGrenadeProbability(void);
-/*0x0095*/ bool aiSetChrNum(void);
-/*0x0096*/ bool aiSetMaxDamage(void);
-/*0x0097*/ bool aiAddHealth(void);
-/*0x0098*/ bool aiSetReactionSpeed(void);
-/*0x0099*/ bool aiSetRecoverySpeed(void);
-/*0x009a*/ bool aiSetAccuracy(void);
-/*0x009b*/ bool aiSetFlag(void);
-/*0x009c*/ bool aiUnsetFlag(void);
-/*0x009d*/ bool aiIfHasFlag(void);
-/*0x009e*/ bool aiChrSetFlag(void);
-/*0x009f*/ bool aiChrUnsetFlag(void);
-/*0x00a0*/ bool aiIfChrHasFlag(void);
-/*0x00a1*/ bool aiSetStageFlag(void);
-/*0x00a2*/ bool aiUnsetStageFlag(void);
-/*0x00a3*/ bool aiIfStageFlagEq(void);
-/*0x00a4*/ bool aiSetChrflag(void);
-/*0x00a5*/ bool aiUnsetChrflag(void);
-/*0x00a6*/ bool aiIfHasChrflag(void);
-/*0x00a7*/ bool aiChrSetChrflag(void);
-/*0x00a8*/ bool aiChrUnsetChrflag(void);
-/*0x00a9*/ bool aiIfChrHasChrflag(void);
-/*0x00aa*/ bool aiSetObjFlag(void);
-/*0x00ab*/ bool aiUnsetObjFlag(void);
-/*0x00ac*/ bool aiIfObjHasFlag(void);
-/*0x00ad*/ bool aiSetObjFlag2(void);
-/*0x00ae*/ bool aiUnsetObjFlag2(void);
-/*0x00af*/ bool aiIfObjHasFlag2(void);
-/*0x00b0*/ bool aiSetChrPreset(void);
-/*0x00b1*/ bool aiSetChrTarget(void);
-/*0x00b2*/ bool aiSetPadPreset(void);
-/*0x00b3*/ bool aiChrSetPadPreset(void);
-/*0x00b4*/ bool aiChrCopyPadPreset(void);
-/*0x00b5*/ bool aiPrint(void);
-/*0x00b6*/ bool aiRestartTimer(void);
-/*0x00b7*/ bool aiResetTimer(void);
-/*0x00b8*/ bool aiPauseTimer(void);
-/*0x00b9*/ bool aiResumeTimer(void);
-/*0x00ba*/ bool aiIfTimerStopped(void);
-/*0x00bb*/ bool aiIfTimerGreaterThanRandom(void);
-/*0x00bc*/ bool aiIfTimerLessThan(void);
-/*0x00bd*/ bool aiIfTimerGreaterThan(void);
-/*0x00be*/ bool aiShowCountdownTimer(void);
-/*0x00bf*/ bool aiHideCountdownTimer(void);
-/*0x00c0*/ bool aiSetCountdownTimerValue(void);
-/*0x00c1*/ bool aiStopCountdownTimer(void);
-/*0x00c2*/ bool aiStartCountdownTimer(void);
-/*0x00c3*/ bool aiIfCountdownTimerStopped(void);
-/*0x00c4*/ bool aiIfCountdownTimerLessThan(void);
-/*0x00c5*/ bool aiIfCountdownTimerGreaterThan(void);
-/*0x00c6*/ bool aiSpawnChrAtPad(void);
-/*0x00c7*/ bool aiSpawnChrAtChr(void);
-/*0x00c8*/ bool aiTryEquipWeapon(void);
-/*0x00c9*/ bool aiTryEquipHat(void);
-/*0x00ca*/ bool aiDuplicateChr(void);
-/*0x00cb*/ bool aiShowHudmsg(void);
-/*0x00cc*/ bool aiShowHudmsgTopMiddle(void);
-/*0x00cd*/ bool aiSpeak(void);
-/*0x00ce*/ bool aiPlaySound(void);
-/*0x00cf*/ bool aiSetObjectSoundPlaying(void);
-/*0x00d0*/ bool aiPlayRepeatingSoundFromPad(void);
-/*0x00d1*/ bool aiSetObjectSoundVolume(void);
-/*0x00d2*/ bool aiSetObjectSoundVolumeByDistance(void);
-/*0x00d3*/ bool aiAudioMuteChannel(void);
-/*0x00d4*/ bool aiIfObjectSoundVolumeLessThan(void);
-/*0x00d5*/ bool aiHovercarBeginPath(void);
-/*0x00d6*/ bool aiSetVehicleSpeed(void);
-/*0x00d7*/ bool aiSetRotorSpeed(void);
-/*0x00d8*/ bool aiNoOp00d8(void);
-/*0x00d9*/ bool aiNoOp00d9(void);
-/*0x00da*/ bool aiSetObjImage(void);
-/*0x00db*/ bool aiNoOp00db(void);
-/*0x00dc*/ bool aiEndLevel(void);
+/*0x0076*/ bool ai_set_pad_preset_to_target_quadrant(void);
+/*0x0077*/ bool ai_if_difficulty_less_than(void);
+/*0x0078*/ bool ai_if_difficulty_greater_than(void);
+/*0x0079*/ bool ai_if_stage_timer_less_than(void);
+/*0x007a*/ bool ai_if_stage_timer_greater_than(void);
+/*0x007b*/ bool ai_if_stage_id_less_than(void);
+/*0x007c*/ bool ai_if_stage_id_greater_than(void);
+/*0x007d*/ bool ai_if_num_arghs_less_than(void);
+/*0x007e*/ bool ai_if_num_arghs_greater_than(void);
+/*0x007f*/ bool ai_if_num_close_arghs_less_than(void);
+/*0x0080*/ bool ai_if_num_close_arghs_greater_than(void);
+/*0x0081*/ bool ai_if_chr_health_greater_than(void);
+/*0x0082*/ bool ai_if_chr_health_less_than(void);
+/*0x0083*/ bool ai_if_injured(void);
+/*0x0084*/ bool ai_set_morale(void);
+/*0x0085*/ bool ai_add_morale(void);
+/*0x0086*/ bool ai_chr_add_morale(void);
+/*0x0087*/ bool ai_subtract_morale(void);
+/*0x0088*/ bool ai_if_morale_less_than(void);
+/*0x0089*/ bool ai_if_morale_less_than_random(void);
+/*0x008a*/ bool ai_set_alertness(void);
+/*0x008b*/ bool ai_add_alertness(void);
+/*0x008c*/ bool ai_chr_add_alertness(void);
+/*0x008d*/ bool ai_subtract_alertness(void);
+/*0x008e*/ bool ai_if_alertness(void);
+/*0x008f*/ bool ai_if_chr_alertness_less_than(void);
+/*0x0090*/ bool ai_if_alertness_less_than_random(void);
+/*0x0091*/ bool ai_noop_0091(void);
+/*0x0092*/ bool ai_set_hear_distance(void);
+/*0x0093*/ bool ai_set_view_distance(void);
+/*0x0094*/ bool ai_set_grenade_probability(void);
+/*0x0095*/ bool ai_set_chr_num(void);
+/*0x0096*/ bool ai_set_max_damage(void);
+/*0x0097*/ bool ai_add_health(void);
+/*0x0098*/ bool ai_set_reaction_speed(void);
+/*0x0099*/ bool ai_set_recovery_speed(void);
+/*0x009a*/ bool ai_set_accuracy(void);
+/*0x009b*/ bool ai_set_flag(void);
+/*0x009c*/ bool ai_unset_flag(void);
+/*0x009d*/ bool ai_if_has_flag(void);
+/*0x009e*/ bool ai_chr_set_flag(void);
+/*0x009f*/ bool ai_chr_unset_flag(void);
+/*0x00a0*/ bool ai_if_chr_has_flag(void);
+/*0x00a1*/ bool ai_set_stage_flag(void);
+/*0x00a2*/ bool ai_unset_stage_flag(void);
+/*0x00a3*/ bool ai_if_stage_flag_eq(void);
+/*0x00a4*/ bool ai_set_chrflag(void);
+/*0x00a5*/ bool ai_unset_chrflag(void);
+/*0x00a6*/ bool ai_if_has_chrflag(void);
+/*0x00a7*/ bool ai_chr_set_chrflag(void);
+/*0x00a8*/ bool ai_chr_unset_chrflag(void);
+/*0x00a9*/ bool ai_if_chr_has_chrflag(void);
+/*0x00aa*/ bool ai_set_obj_flag(void);
+/*0x00ab*/ bool ai_unset_obj_flag(void);
+/*0x00ac*/ bool ai_if_obj_has_flag(void);
+/*0x00ad*/ bool ai_set_obj_flag2(void);
+/*0x00ae*/ bool ai_unset_obj_flag2(void);
+/*0x00af*/ bool ai_if_obj_has_flag2(void);
+/*0x00b0*/ bool ai_set_chr_preset(void);
+/*0x00b1*/ bool ai_set_chr_target(void);
+/*0x00b2*/ bool ai_set_pad_preset(void);
+/*0x00b3*/ bool ai_chr_set_pad_preset(void);
+/*0x00b4*/ bool ai_chr_copy_pad_preset(void);
+/*0x00b5*/ bool ai_print(void);
+/*0x00b6*/ bool ai_restart_timer(void);
+/*0x00b7*/ bool ai_reset_timer(void);
+/*0x00b8*/ bool ai_pause_timer(void);
+/*0x00b9*/ bool ai_resume_timer(void);
+/*0x00ba*/ bool ai_if_timer_stopped(void);
+/*0x00bb*/ bool ai_if_timer_greater_than_random(void);
+/*0x00bc*/ bool ai_if_timer_less_than(void);
+/*0x00bd*/ bool ai_if_timer_greater_than(void);
+/*0x00be*/ bool ai_show_countdown_timer(void);
+/*0x00bf*/ bool ai_hide_countdown_timer(void);
+/*0x00c0*/ bool ai_set_countdown_timer_value(void);
+/*0x00c1*/ bool ai_stop_countdown_timer(void);
+/*0x00c2*/ bool ai_start_countdown_timer(void);
+/*0x00c3*/ bool ai_if_countdown_timer_stopped(void);
+/*0x00c4*/ bool ai_if_countdown_timer_less_than(void);
+/*0x00c5*/ bool ai_if_countdown_timer_greater_than(void);
+/*0x00c6*/ bool ai_spawn_chr_at_pad(void);
+/*0x00c7*/ bool ai_spawn_chr_at_chr(void);
+/*0x00c8*/ bool ai_try_equip_weapon(void);
+/*0x00c9*/ bool ai_try_equip_hat(void);
+/*0x00ca*/ bool ai_duplicate_chr(void);
+/*0x00cb*/ bool ai_show_hudmsg(void);
+/*0x00cc*/ bool ai_show_hudmsg_top_middle(void);
+/*0x00cd*/ bool ai_speak(void);
+/*0x00ce*/ bool ai_play_sound(void);
+/*0x00cf*/ bool ai_set_object_sound_playing(void);
+/*0x00d0*/ bool ai_play_repeating_sound_from_pad(void);
+/*0x00d1*/ bool ai_set_object_sound_volume(void);
+/*0x00d2*/ bool ai_set_object_sound_volume_by_distance(void);
+/*0x00d3*/ bool ai_audio_mute_channel(void);
+/*0x00d4*/ bool ai_if_object_sound_volume_less_than(void);
+/*0x00d5*/ bool ai_hovercar_begin_path(void);
+/*0x00d6*/ bool ai_set_vehicle_speed(void);
+/*0x00d7*/ bool ai_set_rotor_speed(void);
+/*0x00d8*/ bool ai_noop_00d8(void);
+/*0x00d9*/ bool ai_noop_00d9(void);
+/*0x00da*/ bool ai_set_obj_image(void);
+/*0x00db*/ bool ai_noop_00db(void);
+/*0x00dc*/ bool ai_end_level(void);
 /*0x00dd*/ bool ai00dd(void);
-/*0x00de*/ bool aiMoveCameraToPad(void);
-/*0x00df*/ bool aiMoveCameraToPreset(void);
-/*0x00e0*/ bool aiRevokeControl(void);
-/*0x00e1*/ bool aiGrantControl(void);
-/*0x00e2*/ bool aiChrMoveToPad(void);
+/*0x00de*/ bool ai_move_camera_to_pad(void);
+/*0x00df*/ bool ai_move_camera_to_preset(void);
+/*0x00e0*/ bool ai_revoke_control(void);
+/*0x00e1*/ bool ai_grant_control(void);
+/*0x00e2*/ bool ai_chr_move_to_pad(void);
 /*0x00e3*/ bool ai00e3(void);
 /*0x00e4*/ bool ai00e4(void);
-/*0x00e5*/ bool aiIfColourFadeComplete(void);
-/*0x00e8*/ bool aiSetDoorOpen(void);
+/*0x00e5*/ bool ai_if_colour_fade_complete(void);
+/*0x00e8*/ bool ai_set_door_open(void);
 /*0x00e9*/ bool ai00e9(void);
-/*0x00ea*/ bool aiIfNumPlayersLessThan(void);
-/*0x00eb*/ bool aiIfChrAmmoQuantityLessThan(void);
-/*0x00ec*/ bool aiChrDrawWeapon(void);
-/*0x00ed*/ bool aiChrDrawWeaponInCutscene(void);
+/*0x00ea*/ bool ai_if_num_players_less_than(void);
+/*0x00eb*/ bool ai_if_chr_ammo_quantity_less_than(void);
+/*0x00ec*/ bool ai_chr_draw_weapon(void);
+/*0x00ed*/ bool ai_chr_draw_weapon_in_cutscene(void);
 /*0x00ee*/ bool ai00ee(void);
-/*0x00ef*/ bool aiIfObjInRoom(void);
+/*0x00ef*/ bool ai_if_obj_in_room(void);
 /*0x00f0*/ bool ai00f0(void);
-/*0x00f1*/ bool aiIfAttacking(void);
-/*0x00f2*/ bool aiSwitchToAltSky(void);
-/*0x00f3*/ bool aiChrSetInvincible(void);
-/*0x00f4*/ bool aiMoveCameraToPos(void);
+/*0x00f1*/ bool ai_if_attacking(void);
+/*0x00f2*/ bool ai_switch_to_alt_sky(void);
+/*0x00f3*/ bool ai_chr_set_invincible(void);
+/*0x00f4*/ bool ai_move_camera_to_pos(void);
 /*0x00f5*/ bool ai00f5(void);
 /*0x00f6*/ bool ai00f6(void);
-/*0x00f7*/ bool aiIfAllObjectivesComplete(void);
-/*0x00f8*/ bool aiIfPlayerIsInvincible(void);
-/*0x00f9*/ bool aiPlayXTrack(void);
-/*0x00fa*/ bool aiStopXTrack(void);
-/*0x00fb*/ bool aiChrExplosions(void);
-/*0x00fc*/ bool aiIfKillCountGreaterThan(void);
+/*0x00f7*/ bool ai_if_all_objectives_complete(void);
+/*0x00f8*/ bool ai_if_player_is_invincible(void);
+/*0x00f9*/ bool ai_play_x_track(void);
+/*0x00fa*/ bool ai_stop_x_track(void);
+/*0x00fb*/ bool ai_chr_explosions(void);
+/*0x00fc*/ bool ai_if_kill_count_greater_than(void);
 /*0x00fd*/ bool ai00fd(void);
-/*0x00fe*/ bool aiKillBond(void);
-/*0x00ff*/ bool aiBeSurprisedSurrender(void);
-/*0x0100*/ bool aiNoOp0100(void);
-/*0x0101*/ bool aiNoOp0101(void);
-/*0x0102*/ bool aiSetLights(void);
-/*0x0103*/ bool aiIfPropPresetIsBlockingSightToTarget(void);
-/*0x0104*/ bool aiRemoveObjectAtPropPreset(void);
-/*0x0105*/ bool aiIfPropPresetHeightLessThan(void);
-/*0x0106*/ bool aiSetTarget(void);
-/*0x0107*/ bool aiIfPresetsTargetIsNotMyTarget(void);
-/*0x0108*/ bool aiIfChrTarget(void);
-/*0x0109*/ bool aiSetChrPresetToChrNearSelf(void);
-/*0x010a*/ bool aiSetChrPresetToChrNearPad(void);
-/*0x010b*/ bool aiChrSetTeam(void);
-/*0x010c*/ bool aiIfCompareChrPresetsTeam(void);
-/*0x010d*/ bool aiNoOp010d(void);
-/*0x010e*/ bool aiSetShield(void);
-/*0x010f*/ bool aiIfChrShieldLessThan(void);
-/*0x0110*/ bool aiIfChrShieldGreaterThan(void);
-/*0x0111*/ bool aiSetCameraAnimation(void);
-/*0x0112*/ bool aiObjectDoAnimation(void);
-/*0x0113*/ bool aiIfInCutscene(void);
-/*0x0114*/ bool aiEnableChr(void);
-/*0x0115*/ bool aiDisableChr(void);
-/*0x0116*/ bool aiEnableObj(void);
-/*0x0117*/ bool aiDisableObj(void);
-/*0x0118*/ bool aiSetObjFlag3(void);
-/*0x0119*/ bool aiUnsetObjFlag3(void);
-/*0x011a*/ bool aiIfObjHasFlag3(void);
-/*0x011b*/ bool aiChrSetHiddenFlag(void);
-/*0x011c*/ bool aiChrUnsetHiddenFlag(void);
-/*0x011d*/ bool aiIfChrHasHiddenFlag(void);
-/*0x011e*/ bool aiIfHuman(void);
-/*0x011f*/ bool aiIfSkedar(void);
-/*0x0120*/ bool aiIfSafety2LessThan(void);
-/*0x0121*/ bool aiFindCover(void);
-/*0x0122*/ bool aiFindCoverWithinDist(void);
-/*0x0123*/ bool aiFindCoverOutsideDist(void);
-/*0x0124*/ bool aiGoToCover(void);
-/*0x0125*/ bool aiCheckCoverOutOfSight(void);
-/*0x0126*/ bool aiIfPlayerUsingCmpOrAr34(void);
-/*0x0127*/ bool aiDetectEnemyOnSameFloor(void);
-/*0x0128*/ bool aiDetectEnemy(void);
-/*0x0129*/ bool aiIfSafetyLessThan(void);
-/*0x012a*/ bool aiIfTargetMovingSlowly(void);
-/*0x012b*/ bool aiIfTargetMovingCloser(void);
-/*0x012c*/ bool aiIfTargetMovingAway(void);
+/*0x00fe*/ bool ai_kill_bond(void);
+/*0x00ff*/ bool ai_be_surprised_surrender(void);
+/*0x0100*/ bool ai_noop_0100(void);
+/*0x0101*/ bool ai_noop_0101(void);
+/*0x0102*/ bool ai_set_lights(void);
+/*0x0103*/ bool ai_if_prop_preset_is_blocking_sight_to_target(void);
+/*0x0104*/ bool ai_remove_object_at_prop_preset(void);
+/*0x0105*/ bool ai_if_prop_preset_height_less_than(void);
+/*0x0106*/ bool ai_set_target(void);
+/*0x0107*/ bool ai_if_presets_target_is_not_my_target(void);
+/*0x0108*/ bool ai_if_chr_target(void);
+/*0x0109*/ bool ai_set_chr_preset_to_chr_near_self(void);
+/*0x010a*/ bool ai_set_chr_preset_to_chr_near_pad(void);
+/*0x010b*/ bool ai_chr_set_team(void);
+/*0x010c*/ bool ai_if_compare_chr_presets_team(void);
+/*0x010d*/ bool ai_noop_010d(void);
+/*0x010e*/ bool ai_set_shield(void);
+/*0x010f*/ bool ai_if_chr_shield_less_than(void);
+/*0x0110*/ bool ai_if_chr_shield_greater_than(void);
+/*0x0111*/ bool ai_set_camera_animation(void);
+/*0x0112*/ bool ai_object_do_animation(void);
+/*0x0113*/ bool ai_if_in_cutscene(void);
+/*0x0114*/ bool ai_enable_chr(void);
+/*0x0115*/ bool ai_disable_chr(void);
+/*0x0116*/ bool ai_enable_obj(void);
+/*0x0117*/ bool ai_disable_obj(void);
+/*0x0118*/ bool ai_set_obj_flag3(void);
+/*0x0119*/ bool ai_unset_obj_flag3(void);
+/*0x011a*/ bool ai_if_obj_has_flag3(void);
+/*0x011b*/ bool ai_chr_set_hidden_flag(void);
+/*0x011c*/ bool ai_chr_unset_hidden_flag(void);
+/*0x011d*/ bool ai_if_chr_has_hidden_flag(void);
+/*0x011e*/ bool ai_if_human(void);
+/*0x011f*/ bool ai_if_skedar(void);
+/*0x0120*/ bool ai_if_safety2_less_than(void);
+/*0x0121*/ bool ai_find_cover(void);
+/*0x0122*/ bool ai_find_cover_within_dist(void);
+/*0x0123*/ bool ai_find_cover_outside_dist(void);
+/*0x0124*/ bool ai_go_to_cover(void);
+/*0x0125*/ bool ai_check_cover_out_of_sight(void);
+/*0x0126*/ bool ai_if_player_using_cmp_or_ar34(void);
+/*0x0127*/ bool ai_detect_enemy_on_same_floor(void);
+/*0x0128*/ bool ai_detect_enemy(void);
+/*0x0129*/ bool ai_if_safety_less_than(void);
+/*0x012a*/ bool ai_if_target_moving_slowly(void);
+/*0x012b*/ bool ai_if_target_moving_closer(void);
+/*0x012c*/ bool ai_if_target_moving_away(void);
 /*0x012f*/ bool ai012f(void);
-/*0x0130*/ bool aiSayQuip(void);
-/*0x0131*/ bool aiIncreaseSquadronAlertness(void);
-/*0x0132*/ bool aiSetAction(void);
-/*0x0133*/ bool aiSetTeamOrders(void);
-/*0x0134*/ bool aiIfOrders(void);
-/*0x0135*/ bool aiIfHasOrders(void);
-/*0x0136*/ bool aiRetreat(void);
-/*0x0137*/ bool aiIfChrInSquadronDoingAction(void);
-/*0x0138*/ bool aiIfChannelFree(void);
+/*0x0130*/ bool ai_say_quip(void);
+/*0x0131*/ bool ai_increase_squadron_alertness(void);
+/*0x0132*/ bool ai_set_action(void);
+/*0x0133*/ bool ai_set_team_orders(void);
+/*0x0134*/ bool ai_if_orders(void);
+/*0x0135*/ bool ai_if_has_orders(void);
+/*0x0136*/ bool ai_retreat(void);
+/*0x0137*/ bool ai_if_chr_in_squadron_doing_action(void);
+/*0x0138*/ bool ai_if_channel_free(void);
 /*0x0139*/ bool ai0139(void);
-/*0x013a*/ bool aiSetChrPresetToUnalertedTeammate(void);
-/*0x013b*/ bool aiSetSquadron(void);
-/*0x013c*/ bool aiFaceCover(void);
-/*0x013d*/ bool aiIfDangerousObjectNearby(void);
+/*0x013a*/ bool ai_set_chr_preset_to_unalerted_teammate(void);
+/*0x013b*/ bool ai_set_squadron(void);
+/*0x013c*/ bool ai_face_cover(void);
+/*0x013d*/ bool ai_if_dangerous_object_nearby(void);
 /*0x013e*/ bool ai013e(void);
-/*0x013f*/ bool aiIfHeliWeaponsArmed(void);
-/*0x0140*/ bool aiIfHoverbotNextStep(void);
-/*0x0141*/ bool aiShuffleInvestigationTerminals(void);
-/*0x0142*/ bool aiSetPadPresetToInvestigationTerminal(void);
-/*0x0143*/ bool aiHeliArmWeapons(void);
-/*0x0144*/ bool aiHeliUnarmWeapons(void);
-/*0x0145*/ bool aiRebuildTeams(void);
-/*0x0146*/ bool aiRebuildSquadrons(void);
-/*0x0147*/ bool aiIfSquadronIsDead(void);
-/*0x0148*/ bool aiChrSetListening(void);
-/*0x0149*/ bool aiIfChrListening(void);
-/*0x014a*/ bool aiIfTrue(void);
-/*0x014b*/ bool aiIfNotListening(void);
-/*0x0152*/ bool aiIfNumChrsInSquadronGreaterThan(void);
-/*0x0157*/ bool aiSetTintedGlassEnabled(void);
-/*0x015b*/ bool aiPlayTrackIsolated(void);
-/*0x015c*/ bool aiPlayDefaultTracks(void);
-/*0x0165*/ bool aiIfChrInjured(void);
-/*0x0166*/ bool aiIfAction(void);
-/*0x0167*/ bool aiHovercopterFireRocket(void);
-/*0x0168*/ bool aiIfShieldDamaged(void);
-/*0x0169*/ bool aiIfNaturalAnim(void);
-/*0x016a*/ bool aiIfY(void);
-/*0x016b*/ bool aiPlayRepeatingSoundFromObject(void);
-/*0x016c*/ bool aiNoOp016c(void);
-/*0x016d*/ bool aiChrAdjustMotionBlur(void);
-/*0x016e*/ bool aiDamageChrByAmount(void);
-/*0x016f*/ bool aiIfChrHasGun(void);
-/*0x0170*/ bool aiDoGunCommand(void);
-/*0x0171*/ bool aiIfDistanceToGunLessThan(void);
-/*0x0172*/ bool aiRecoverGun(void);
-/*0x0173*/ bool aiChrCopyProperties(void);
-/*0x0174*/ bool aiIfCutsceneButtonPressed(void);
+/*0x013f*/ bool ai_if_heli_weapons_armed(void);
+/*0x0140*/ bool ai_if_hoverbot_next_step(void);
+/*0x0141*/ bool ai_shuffle_investigation_terminals(void);
+/*0x0142*/ bool ai_set_pad_preset_to_investigation_terminal(void);
+/*0x0143*/ bool ai_heli_arm_weapons(void);
+/*0x0144*/ bool ai_heli_unarm_weapons(void);
+/*0x0145*/ bool ai_rebuild_teams(void);
+/*0x0146*/ bool ai_rebuild_squadrons(void);
+/*0x0147*/ bool ai_if_squadron_is_dead(void);
+/*0x0148*/ bool ai_chr_set_listening(void);
+/*0x0149*/ bool ai_if_chr_listening(void);
+/*0x014a*/ bool ai_if_true(void);
+/*0x014b*/ bool ai_if_not_listening(void);
+/*0x0152*/ bool ai_if_num_chrs_in_squadron_greater_than(void);
+/*0x0157*/ bool ai_set_tinted_glass_enabled(void);
+/*0x015b*/ bool ai_play_track_isolated(void);
+/*0x015c*/ bool ai_play_default_tracks(void);
+/*0x0165*/ bool ai_if_chr_injured(void);
+/*0x0166*/ bool ai_if_action(void);
+/*0x0167*/ bool ai_hovercopter_fire_rocket(void);
+/*0x0168*/ bool ai_if_shield_damaged(void);
+/*0x0169*/ bool ai_if_natural_anim(void);
+/*0x016a*/ bool ai_if_y(void);
+/*0x016b*/ bool ai_play_repeating_sound_from_object(void);
+/*0x016c*/ bool ai_noop_016c(void);
+/*0x016d*/ bool ai_chr_adjust_motion_blur(void);
+/*0x016e*/ bool ai_damage_chr_by_amount(void);
+/*0x016f*/ bool ai_if_chr_has_gun(void);
+/*0x0170*/ bool ai_do_gun_command(void);
+/*0x0171*/ bool ai_if_distance_to_gun_less_than(void);
+/*0x0172*/ bool ai_recover_gun(void);
+/*0x0173*/ bool ai_chr_copy_properties(void);
+/*0x0174*/ bool ai_if_cutscene_button_pressed(void);
 /*0x0175*/ bool ai0175(void);
-/*0x0176*/ bool aiIfBotRespawning(void);
-/*0x0177*/ bool aiPlayerAutoWalk(void);
-/*0x0178*/ bool aiIfPlayerAutoWalkFinished(void);
-/*0x0179*/ bool aiPlaySoundFromEntity(void);
-/*0x017a*/ bool aiIfLosToAttackTarget(void);
-/*0x017b*/ bool aiIfChrKnockedOut(void);
-/*0x017c*/ bool aiAssignSound(void);
-/*0x017d*/ bool aiPlayCutsceneTrack(void);
-/*0x017e*/ bool aiStopCutsceneTrack(void);
-/*0x017f*/ bool aiPlayTemporaryTrack(void);
-/*0x0180*/ bool aiStopAmbientTrack(void);
-/*0x0181*/ bool aiIfPlayerLookingAtObject(void);
-/*0x0182*/ bool aiPunchOrKick(void);
-/*0x0183*/ bool aiIfTargetIsPlayer(void);
+/*0x0176*/ bool ai_if_bot_respawning(void);
+/*0x0177*/ bool ai_player_auto_walk(void);
+/*0x0178*/ bool ai_if_player_auto_walk_finished(void);
+/*0x0179*/ bool ai_play_sound_from_entity(void);
+/*0x017a*/ bool ai_if_los_to_attack_target(void);
+/*0x017b*/ bool ai_if_chr_knocked_out(void);
+/*0x017c*/ bool ai_assign_sound(void);
+/*0x017d*/ bool ai_play_cutscene_track(void);
+/*0x017e*/ bool ai_stop_cutscene_track(void);
+/*0x017f*/ bool ai_play_temporary_track(void);
+/*0x0180*/ bool ai_stop_ambient_track(void);
+/*0x0181*/ bool ai_if_player_looking_at_object(void);
+/*0x0182*/ bool ai_punch_or_kick(void);
+/*0x0183*/ bool ai_if_target_is_player(void);
 /*0x0184*/ bool ai0184(void);
-/*0x0185*/ bool aiMpInitSimulants(void);
-/*0x0186*/ bool aiIfSoundTimer(void);
-/*0x0187*/ bool aiSetTargetToEyespyIfInSight(void);
-/*0x0188*/ bool aiIfLiftStationary(void);
-/*0x0189*/ bool aiLiftGoToStop(void);
-/*0x018a*/ bool aiIfLiftAtStop(void);
-/*0x018b*/ bool aiConfigureRain(void);
-/*0x018c*/ bool aiChrToggleModelPart(void);
-/*0x018d*/ bool aiActivateLift(void);
-/*0x018e*/ bool aiMiniSkedarTryPounce(void);
-/*0x018f*/ bool aiIfObjectDistanceToPadLessThan(void);
-/*0x0190*/ bool aiSetSavefileFlag(void);
-/*0x0191*/ bool aiUnsetSavefileFlag(void);
-/*0x0192*/ bool aiIfSavefileFlagIsSet(void);
-/*0x0193*/ bool aiIfSavefileFlagIsUnset(void);
-/*0x019e*/ bool aiIfObjHealthLessThan(void);
-/*0x019f*/ bool aiSetObjHealth(void);
-/*0x01a0*/ bool aiSetChrSpecialDeathAnimation(void);
-/*0x01a1*/ bool aiSetRoomToSearch(void);
-/*0x01a2*/ bool aiSayCiStaffQuip(void);
-/*0x01a3*/ bool aiDoPresetAnimation(void);
-/*0x01a4*/ bool aiShowHudmsgMiddle(void);
-/*0x01a5*/ bool aiIfUsingLift(void);
-/*0x01a6*/ bool aiIfTargetYDifferenceLessThan(void);
-/*0x01a7*/ bool aiIfChrNotTalking(void);
+/*0x0185*/ bool ai_mp_init_simulants(void);
+/*0x0186*/ bool ai_if_sound_timer(void);
+/*0x0187*/ bool ai_set_target_to_eyespy_if_in_sight(void);
+/*0x0188*/ bool ai_if_lift_stationary(void);
+/*0x0189*/ bool ai_lift_go_to_stop(void);
+/*0x018a*/ bool ai_if_lift_at_stop(void);
+/*0x018b*/ bool ai_configure_rain(void);
+/*0x018c*/ bool ai_chr_toggle_model_part(void);
+/*0x018d*/ bool ai_activate_lift(void);
+/*0x018e*/ bool ai_mini_skedar_try_pounce(void);
+/*0x018f*/ bool ai_if_object_distance_to_pad_less_than(void);
+/*0x0190*/ bool ai_set_savefile_flag(void);
+/*0x0191*/ bool ai_unset_savefile_flag(void);
+/*0x0192*/ bool ai_if_savefile_flag_is_set(void);
+/*0x0193*/ bool ai_if_savefile_flag_is_unset(void);
+/*0x019e*/ bool ai_if_obj_health_less_than(void);
+/*0x019f*/ bool ai_set_obj_health(void);
+/*0x01a0*/ bool ai_set_chr_special_death_animation(void);
+/*0x01a1*/ bool ai_set_room_to_search(void);
+/*0x01a2*/ bool ai_say_ci_staff_quip(void);
+/*0x01a3*/ bool ai_do_preset_animation(void);
+/*0x01a4*/ bool ai_show_hudmsg_middle(void);
+/*0x01a5*/ bool ai_if_using_lift(void);
+/*0x01a6*/ bool ai_if_target_y_difference_less_than(void);
+/*0x01a7*/ bool ai_if_chr_not_talking(void);
 /*0x01aa*/ bool ai01aa(void);
-/*0x01ab*/ bool aiIfNumKnockedOutChrs(void);
-/*0x01ad*/ bool aiReleaseObject(void);
-/*0x01ae*/ bool aiClearInventory(void);
-/*0x01af*/ bool aiChrGrabObject(void);
-/*0x01b1*/ bool aiShuffleRuinsPillars(void);
-/*0x01b2*/ bool aiSetWindSpeed(void);
-/*0x01b3*/ bool aiToggleP1P2(void);
+/*0x01ab*/ bool ai_if_num_knocked_out_chrs(void);
+/*0x01ad*/ bool ai_release_object(void);
+/*0x01ae*/ bool ai_clear_inventory(void);
+/*0x01af*/ bool ai_chr_grab_object(void);
+/*0x01b1*/ bool ai_shuffle_ruins_pillars(void);
+/*0x01b2*/ bool ai_set_wind_speed(void);
+/*0x01b3*/ bool ai_toggle_p1p2(void);
 /*0x01b4*/ bool ai01b4(void);
-/*0x01b5*/ bool aiChrSetP1P2(void);
-/*0x01b6*/ bool aiConfigureSnow(void);
-/*0x01b7*/ bool aiChrSetCloaked(void);
-/*0x01b8*/ bool aiSetAutogunTargetTeam(void);
-/*0x01b9*/ bool aiShufflePelagicSwitches(void);
-/*0x01ba*/ bool aiTryAttackLie(void);
-/*0x01bb*/ bool aiNoOp01bb(void);
+/*0x01b5*/ bool ai_chr_set_p1p2(void);
+/*0x01b6*/ bool ai_configure_snow(void);
+/*0x01b7*/ bool ai_chr_set_cloaked(void);
+/*0x01b8*/ bool ai_set_autogun_target_team(void);
+/*0x01b9*/ bool ai_shuffle_pelagic_switches(void);
+/*0x01ba*/ bool ai_try_attack_lie(void);
+/*0x01bb*/ bool ai_noop_01bb(void);
 /*0x01bc*/ bool ai01bc(void);
-/*0x01bd*/ bool aiIfTrainingPcHolographed(void);
-/*0x01be*/ bool aiIfPlayerUsingDevice(void);
-/*0x01bf*/ bool aiChrBeginOrEndTeleport(void);
-/*0x01c0*/ bool aiIfChrTeleportFullWhite(void);
-/*0x01c1*/ bool aiSetPunchDodgeList(void);
-/*0x01c2*/ bool aiSetShootingAtMeList(void);
-/*0x01c3*/ bool aiSetDarkRoomList(void);
-/*0x01c4*/ bool aiSetPlayerDeadList(void);
-/*0x01c5*/ bool aiAvoid(void);
-/*0x01c6*/ bool aiSetDodgeRating(void);
-/*0x01c7*/ bool aiSetUnarmedDodgeRating(void);
-/*0x01c8*/ bool aiTitleInitMode(void);
-/*0x01c9*/ bool aiTryExitTitle(void);
-/*0x01ca*/ bool aiChrSetCutsceneWeapon(void);
-/*0x01cb*/ bool aiFadeScreen(void);
-/*0x01cc*/ bool aiIfFadeComplete(void);
-/*0x01cd*/ bool aiSetChrHudpieceVisible(void);
-/*0x01ce*/ bool aiSetPassiveMode(void);
-/*0x01cf*/ bool aiChrSetFiringInCutscene(void);
-/*0x01d0*/ bool aiSetPortalFlag(void);
-/*0x01d1*/ bool aiObjSetModelPartVisible(void);
-/*0x01d2*/ bool aiChrEmitSparks(void);
-/*0x01d3*/ bool aiSetDrCarollImages(void);
-/*0x01d4*/ bool aiSetRoomFlag(void);
-/*0x01d5*/ bool aiShowCutsceneChrs(void);
-/*0x01d6*/ bool aiConfigureEnvironment(void);
-/*0x01d7*/ bool aiIfDistanceToTarget2LessThan(void);
-/*0x01d8*/ bool aiIfDistanceToTarget2GreaterThan(void);
-/*0x01d9*/ bool aiPlaySoundFromProp(void);
-/*0x01da*/ bool aiPlayTemporaryPrimaryTrack(void);
-/*0x01db*/ bool aiChrKill(void);
-/*0x01dc*/ bool aiRemoveWeaponFromInventory(void);
-/*0x01dd*/ bool aiIfMusicEventQueueIsEmpty(void);
-/*0x01de*/ bool aiIfCoopMode(void);
-/*0x01df*/ bool aiIfChrSameFloorDistanceToPadLessThan(void);
-/*0x01e0*/ bool aiRemoveReferencesToChr(void);
+/*0x01bd*/ bool ai_if_training_pc_holographed(void);
+/*0x01be*/ bool ai_if_player_using_device(void);
+/*0x01bf*/ bool ai_chr_begin_or_end_teleport(void);
+/*0x01c0*/ bool ai_if_chr_teleport_full_white(void);
+/*0x01c1*/ bool ai_set_punch_dodge_list(void);
+/*0x01c2*/ bool ai_set_shooting_at_me_list(void);
+/*0x01c3*/ bool ai_set_dark_room_list(void);
+/*0x01c4*/ bool ai_set_player_dead_list(void);
+/*0x01c5*/ bool ai_avoid(void);
+/*0x01c6*/ bool ai_set_dodge_rating(void);
+/*0x01c7*/ bool ai_set_unarmed_dodge_rating(void);
+/*0x01c8*/ bool ai_title_init_mode(void);
+/*0x01c9*/ bool ai_try_exit_title(void);
+/*0x01ca*/ bool ai_chr_set_cutscene_weapon(void);
+/*0x01cb*/ bool ai_fade_screen(void);
+/*0x01cc*/ bool ai_if_fade_complete(void);
+/*0x01cd*/ bool ai_set_chr_hudpiece_visible(void);
+/*0x01ce*/ bool ai_set_passive_mode(void);
+/*0x01cf*/ bool ai_chr_set_firing_in_cutscene(void);
+/*0x01d0*/ bool ai_set_portal_flag(void);
+/*0x01d1*/ bool ai_obj_set_model_part_visible(void);
+/*0x01d2*/ bool ai_chr_emit_sparks(void);
+/*0x01d3*/ bool ai_set_dr_caroll_images(void);
+/*0x01d4*/ bool ai_set_room_flag(void);
+/*0x01d5*/ bool ai_show_cutscene_chrs(void);
+/*0x01d6*/ bool ai_configure_environment(void);
+/*0x01d7*/ bool ai_if_distance_to_target2_less_than(void);
+/*0x01d8*/ bool ai_if_distance_to_target2_greater_than(void);
+/*0x01d9*/ bool ai_play_sound_from_prop(void);
+/*0x01da*/ bool ai_play_temporary_primary_track(void);
+/*0x01db*/ bool ai_chr_kill(void);
+/*0x01dc*/ bool ai_remove_weapon_from_inventory(void);
+/*0x01dd*/ bool ai_if_music_event_queue_is_empty(void);
+/*0x01de*/ bool ai_if_coop_mode(void);
+/*0x01df*/ bool ai_if_chr_same_floor_distance_to_pad_less_than(void);
+/*0x01e0*/ bool ai_remove_references_to_chr(void);
 
-void propDecrementSoundCount(struct prop *prop);
+void prop_decrement_sound_count(struct prop *prop);
 
 #endif

src/include/game/chrmgr.h

@@ -4,9 +4,9 @@
 #include "data.h"
 #include "types.h"
 
-void chrmgrReset(void);
-void chrmgrConfigure(s32 numchrs);
+void chrmgr_reset(void);
+void chrmgr_configure(s32 numchrs);
 
-void chrmgrStop(void);
+void chrmgr_stop(void);
 
 #endif

src/include/game/crc.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void crcCalculateU32Pair(u8 *start, u8 *end, u32 *checksum);
-void crcCalculateU16Pair(u8 *start, u8 *end, u16 *checksum);
+void crc_calculate_u32_pair(u8 *start, u8 *end, u32 *checksum);
+void crc_calculate_u16_pair(u8 *start, u8 *end, u16 *checksum);
 
 #endif

src/include/game/credits.h

@@ -4,9 +4,9 @@
 #include "data.h"
 #include "types.h"
 
-Gfx *creditsDraw(Gfx *gdl);
-void creditsReset(void);
-void creditsRequestAltTitle(void);
+Gfx *credits_draw(Gfx *gdl);
+void credits_reset(void);
+void credits_request_alt_title(void);
 void credits0f13ae04(Mtxf *mtx);
 
 #endif

src/include/game/debug.h

@@ -6,48 +6,48 @@
 
 void debug0f119a80nb(void);
 u32 dprint();
-s32 debugGetProfileMode(void);
-bool debugIsBgRenderingEnabled(void);
-bool debugIsPropRenderingEnabled(void);
+s32 debug_get_profile_mode(void);
+bool debug_is_bg_rendering_enabled(void);
+bool debug_is_prop_rendering_enabled(void);
 bool debug0f11ed88(void);
-bool debugIsManPosEnabled(void);
-bool debugIsRoomGfxExtraMemEnabled(void);
-bool debugIsObjDeformDebugEnabled(void);
-bool debugIsRoomStateDebugEnabled(void);
-s32 debugIsTurboModeEnabled(void);
-bool debugForceAllObjectivesComplete(void);
-bool debugIsZBufferDisabled(void);
+bool debug_is_man_pos_enabled(void);
+bool debug_is_room_gfx_extra_mem_enabled(void);
+bool debug_is_obj_deform_debug_enabled(void);
+bool debug_is_room_state_debug_enabled(void);
+s32 debug_is_turbo_mode_enabled(void);
+bool debug_force_all_objectives_complete(void);
+bool debug_is_z_buffer_disabled(void);
 bool debug0f11ee40(void);
 bool debug0f1199f0nb(void);
 bool debug0f119a14nb(void);
-s32 debugGetSlowMotion(void);
-s32 debugGetTilesDebugMode(void);
-s32 debugGetPadsDebugMode(void);
+s32 debug_get_slow_motion(void);
+s32 debug_get_tiles_debug_mode(void);
+s32 debug_get_pads_debug_mode(void);
 bool debug0f11eea8(void);
-bool debugDangerousProps(void);
-s32 debugGetMotionBlur(void);
-bool debugIsFootstepsEnabled(void);
-bool debugIsAllChallengesEnabled(void);
-bool debugIsAllBuddiesEnabled(void);
-bool debugIsSetCompleteEnabled(void);
-bool debugIsAllTrainingEnabled(void);
-bool debugAllowEndLevel(void);
-bool debugIsChrStatsEnabled(void);
+bool debug_dangerous_props(void);
+s32 debug_get_motion_blur(void);
+bool debug_is_footsteps_enabled(void);
+bool debug_is_all_challenges_enabled(void);
+bool debug_is_all_buddies_enabled(void);
+bool debug_is_set_complete_enabled(void);
+bool debug_is_all_training_enabled(void);
+bool debug_allow_end_level(void);
+bool debug_is_chr_stats_enabled(void);
 bool debug0f11ef80(void);
-bool debugIsMemInfoEnabled(void);
+bool debug_is_mem_info_enabled(void);
 
-s32 dmenuGetSelectedOption(void);
-void dmenuSetSelectedOption(s32 option);
-void dmenuSetMenu(char **labels, s32 (*positions)[2], s32 *offsets);
-void dmenuNavigateRight(void);
-void dmenuNavigateLeft(void);
-void dmenuNavigateUp(void);
-void dmenuNavigateDown(void);
-Gfx *dmenuRender(Gfx *gdl);
+s32 dmenu_get_selected_option(void);
+void dmenu_set_selected_option(s32 option);
+void dmenu_set_menu(char **labels, s32 (*positions)[2], s32 *offsets);
+void dmenu_navigate_right(void);
+void dmenu_navigate_left(void);
+void dmenu_navigate_up(void);
+void dmenu_navigate_down(void);
+Gfx *dmenu_render(Gfx *gdl);
 
-void debugUpdateMenu(void);
-bool debugProcessInput(s8 stickx, s8 sticky, u16 buttons, u16 buttonsthisframe);
-bool debugIsLineModeEnabled(void);
+void debug_update_menu(void);
+bool debug_process_input(s8 stickx, s8 sticky, u16 buttons, u16 buttonsthisframe);
+bool debug_is_line_mode_enabled(void);
 
 extern s32 var800786f4nb;
 extern s32 g_DebugMenuPositions[][2];

src/include/game/dlights.h

@@ -5,45 +5,45 @@
 #include "types.h"
 
 u32 func0f000920(s32 portalnum1, s32 portalnum2);
-struct light *roomGetLight(s32 roomnum, s32 lightnum);
-u8 roomGetFinalBrightness(s32 roomnum);
-u8 roomGetFinalBrightnessForPlayer(s32 roomnum);
-u8 roomGetSettledRegionalBrightnessForPlayer(s32 roomnum);
-u8 roomGetSettledLocalBrightness(s32 room);
-s32 roomGetFlashBrightness(s32 roomnum);
-f32 roomGetLightOpCurFrac(s32 roomnum);
-f32 roomGetSettledLocalBrightnessFrac(s32 roomnum);
-bool lightGetBboxCentre(s32 roomnum, u32 lightnum, struct coord *pos);
-bool lightIsHealthy(s32 roomnum, s32 lightnum);
-bool lightIsVulnerable(s32 roomnum, s32 lightnum);
-bool lightIsOn(s32 roomnum, s32 lightnum);
-void roomSetFlashBrightness(s32 roomnum, s32 value);
-void roomSetDefaults(struct room *room);
-Gfx *lightsSetForRoom(Gfx *gdl, RoomNum roomnum);
-Gfx *lightsSetDefault(Gfx *gdl);
-void roomInitLights(s32 roomnum);
-bool lightsHandleHit(struct coord *gunpos, struct coord *hitpos, s32 roomnum);
-void roomSetLightsFaulty(s32 roomnum, s32 chance);
-void roomSetLightBroken(s32 roomnum, s32 lightnum);
-void lightsReset(void);
+struct light *room_get_light(s32 roomnum, s32 lightnum);
+u8 room_get_final_brightness(s32 roomnum);
+u8 room_get_final_brightness_for_player(s32 roomnum);
+u8 room_get_settled_regional_brightness_for_player(s32 roomnum);
+u8 room_get_settled_local_brightness(s32 room);
+s32 room_get_flash_brightness(s32 roomnum);
+f32 room_get_light_op_cur_frac(s32 roomnum);
+f32 room_get_settled_local_brightness_frac(s32 roomnum);
+bool light_get_bbox_centre(s32 roomnum, u32 lightnum, struct coord *pos);
+bool light_is_healthy(s32 roomnum, s32 lightnum);
+bool light_is_vulnerable(s32 roomnum, s32 lightnum);
+bool light_is_on(s32 roomnum, s32 lightnum);
+void room_set_flash_brightness(s32 roomnum, s32 value);
+void room_set_defaults(struct room *room);
+Gfx *lights_set_for_room(Gfx *gdl, RoomNum roomnum);
+Gfx *lights_set_default(Gfx *gdl);
+void room_init_lights(s32 roomnum);
+bool lights_handle_hit(struct coord *gunpos, struct coord *hitpos, s32 roomnum);
+void room_set_lights_faulty(s32 roomnum, s32 chance);
+void room_set_light_broken(s32 roomnum, s32 lightnum);
+void lights_reset(void);
 void func0f001c0c(void);
 void func0f00215c(u8 *arg0);
-void lightsCalculateRoomDimensions(void);
+void lights_calculate_room_dimensions(void);
 void func0f00259c(s32 roomnum);
 void func0f002844(s32 roomnum, f32 arg1, s32 arg2, s32 portalnum);
 void func0f002a98(void);
-void roomSetLightsOn(s32 roomnum, s32 enable);
-void roomSetLightOp(s32 roomnum, s32 operation, u8 br_to, u8 br_from, u8 duration60);
-bool lightTickBroken(s32 roomnum, s32 lightnum);
-void lightingTick(void);
-void lightsConfigureForPerfectDarknessCutscene(void);
-void lightsConfigureForPerfectDarknessGameplay(void);
-void lightsTickPerfectDarkness(void);
-void roomsTickLighting(void);
-void lightsTick(void);
-void roomFlashLighting(s32 roomnum, s32 start, s32 limit);
-void roomFlashLocalLighting(s32 roomnum, s32 increment, s32 limit);
-void roomHighlight(s32 roomnum);
+void room_set_lights_on(s32 roomnum, s32 enable);
+void room_set_light_op(s32 roomnum, s32 operation, u8 br_to, u8 br_from, u8 duration60);
+bool light_tick_broken(s32 roomnum, s32 lightnum);
+void lighting_tick(void);
+void lights_configure_for_perfect_darkness_cutscene(void);
+void lights_configure_for_perfect_darkness_gameplay(void);
+void lights_tick_perfect_darkness(void);
+void rooms_tick_lighting(void);
+void lights_tick(void);
+void room_flash_lighting(s32 roomnum, s32 start, s32 limit);
+void room_flash_local_lighting(s32 roomnum, s32 increment, s32 limit);
+void room_highlight(s32 roomnum);
 void func0f004c6c(void);
 void func0f00505c(void);
 f32 func0f0053d0(s32 room1, struct coord *arg1, s32 portal1, s32 room2, struct coord *arg4, s32 portal2, f32 *arg6);

src/include/game/dyntex.h

@@ -4,11 +4,11 @@
 #include "data.h"
 #include "types.h"
 
-void dyntexTickRoom(s32 roomnum, Vtx *vertices);
-void dyntexAddVertex(Vtx *vertex);
-void dyntexSetCurrentType(s16 type);
-void dyntexSetCurrentRoom(RoomNum roomnum);
-void dyntexReset(void);
-bool dyntexHasRoom(void);
+void dyntex_tick_room(s32 roomnum, Vtx *vertices);
+void dyntex_add_vertex(Vtx *vertex);
+void dyntex_set_current_type(s16 type);
+void dyntex_set_current_room(RoomNum roomnum);
+void dyntex_reset(void);
+bool dyntex_has_room(void);
 
 #endif

src/include/game/endscreen.h

@@ -4,39 +4,39 @@
 #include "data.h"
 #include "types.h"
 
-MenuDialogHandlerResult endscreenHandleRetryMission(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult endscreenHandle2PCompleted(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult endscreenHandle2PFailed(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult endscreenHandleDeclineMission(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult endscreenHandleCheatInfo(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult endscreenHandleContinueMission(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult endscreenHandleReplayLastLevel(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult endscreenHandleReplayPreviousMission(s32 operation, struct menuitem *item, union handlerdata *data);
-char *endscreenMenuTitleRetryMission(struct menudialogdef *dialogdef);
-char *endscreenMenuTitleNextMission(struct menudialogdef *dialogdef);
-char *endscreenMenuTextNumKills(struct menuitem *item);
-char *endscreenMenuTextNumShots(struct menuitem *item);
-char *endscreenMenuTextNumHeadShots(struct menuitem *item);
-char *endscreenMenuTextNumBodyShots(struct menuitem *item);
-char *endscreenMenuTextNumLimbShots(struct menuitem *item);
-char *endscreenMenuTextNumOtherShots(struct menuitem *item);
-char *endscreenMenuTextAccuracy(struct menuitem *item);
-char *endscreenMenuTextMissionStatus(struct menuitem *item);
-char *endscreenMenuTextAgentStatus(struct menuitem *item);
-char *endscreenMenuTitleStageCompleted(struct menuitem *item);
-char *endscreenMenuTextCurrentStageName3(struct menuitem *item);
-char *endscreenMenuTitleStageFailed(struct menuitem *item);
-char *endscreenMenuTextMissionTime(struct menuitem *item);
-struct menudialogdef *endscreenAdvance(void);
-void endscreenResetModels(void);
-void endscreenContinue(s32 context);
-char *endscreenMenuTextTimedCheatName(struct menuitem *item);
-char *endscreenMenuTextCompletionCheatName(struct menuitem *item);
-char *endscreenMenuTextTargetTime(struct menuitem *item);
-void endscreenSetCoopCompleted(void);
-void endscreenPrepare(void);
-void endscreenPushCoop(void);
-void endscreenPushSolo(void);
-void endscreenPushAnti(void);
+MenuDialogHandlerResult endscreen_handle_retry_mission(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult endscreen_handle_2p_completed(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult endscreen_handle_2p_failed(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult endscreen_handle_decline_mission(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult endscreen_handle_cheat_info(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult endscreen_handle_continue_mission(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult endscreen_handle_replay_last_level(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult endscreen_handle_replay_previous_mission(s32 operation, struct menuitem *item, union handlerdata *data);
+char *endscreen_menu_title_retry_mission(struct menudialogdef *dialogdef);
+char *endscreen_menu_title_next_mission(struct menudialogdef *dialogdef);
+char *endscreen_menu_text_num_kills(struct menuitem *item);
+char *endscreen_menu_text_num_shots(struct menuitem *item);
+char *endscreen_menu_text_num_head_shots(struct menuitem *item);
+char *endscreen_menu_text_num_body_shots(struct menuitem *item);
+char *endscreen_menu_text_num_limb_shots(struct menuitem *item);
+char *endscreen_menu_text_num_other_shots(struct menuitem *item);
+char *endscreen_menu_text_accuracy(struct menuitem *item);
+char *endscreen_menu_text_mission_status(struct menuitem *item);
+char *endscreen_menu_text_agent_status(struct menuitem *item);
+char *endscreen_menu_title_stage_completed(struct menuitem *item);
+char *endscreen_menu_text_current_stage_name3(struct menuitem *item);
+char *endscreen_menu_title_stage_failed(struct menuitem *item);
+char *endscreen_menu_text_mission_time(struct menuitem *item);
+struct menudialogdef *endscreen_advance(void);
+void endscreen_reset_models(void);
+void endscreen_continue(s32 context);
+char *endscreen_menu_text_timed_cheat_name(struct menuitem *item);
+char *endscreen_menu_text_completion_cheat_name(struct menuitem *item);
+char *endscreen_menu_text_target_time(struct menuitem *item);
+void endscreen_set_coop_completed(void);
+void endscreen_prepare(void);
+void endscreen_push_coop(void);
+void endscreen_push_solo(void);
+void endscreen_push_anti(void);
 
 #endif

src/include/game/env.h

@@ -10,18 +10,18 @@ struct distfadesettings {
     f32 refdist;
 };
 
-struct environment *envGetCurrent(void);
-f32 envGetSquaredFogMax(void);
-void envTick(void);
-void envApplyFogEnvironment(struct fogenvironment *sky);
-void envApplyNoFogEnvironment(struct nofogenvironment *sky);
-void envSetStageNum(s32 stagenum);
-void envChooseAndApply(s32 stagenum, bool allowoverride);
-void envApplyTransitionFrac(f32 arg0);
-Gfx *envStartFog(Gfx *gdl, bool xlupass);
-Gfx *envStopFog(Gfx *gdl);
-bool envIsPosInFogMaxDistance(struct coord *pos, f32 tolerance);
-struct distfadesettings *envGetDistFadeSettings(void);
-s32 envGetObjShadeMode(struct prop *prop, f32 arg1[4]);
+struct environment *env_get_current(void);
+f32 env_get_squared_fog_max(void);
+void env_tick(void);
+void env_apply_fog_environment(struct fogenvironment *sky);
+void env_apply_no_fog_environment(struct nofogenvironment *sky);
+void env_set_stage_num(s32 stagenum);
+void env_choose_and_apply(s32 stagenum, bool allowoverride);
+void env_apply_transition_frac(f32 arg0);
+Gfx *env_start_fog(Gfx *gdl, bool xlupass);
+Gfx *env_stop_fog(Gfx *gdl);
+bool env_is_pos_in_fog_max_distance(struct coord *pos, f32 tolerance);
+struct distfadesettings *env_get_dist_fade_settings(void);
+s32 env_get_obj_shade_mode(struct prop *prop, f32 arg1[4]);
 
 #endif

src/include/game/explosions.h

@@ -4,23 +4,23 @@
 #include "data.h"
 #include "types.h"
 
-void explosionsReset(void);
+void explosions_reset(void);
 
-void explosionsStop(void);
+void explosions_stop(void);
 
-bool explosionCreateSimple(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum);
-bool explosionCreateComplex(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum);
-f32 explosionGetHorizontalRangeAtFrame(struct explosion *exp, s32 frame);
-f32 explosionGetVerticalRangeAtFrame(struct explosion *exp, s32 frame);
-void explosionGetBboxAtFrame(struct coord *lower, struct coord *upper, s32 frame, struct prop *prop);
-void explosionAlertChrs(f32 *radius, struct coord *noisepos);
-bool explosionCreate(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum, bool makescorch, struct coord *arg6, RoomNum room, struct coord *arg8);
-void explosionsUpdateShake(struct coord *arg0, struct coord *arg1, struct coord *arg2);
-bool explosionOverlapsProp(struct explosion *exp, struct prop *prop, struct coord *pos1, struct coord *pos2);
-void explosionInflictDamage(struct prop *prop);
-u32 explosionTick(struct prop *prop);
-u32 explosionTickPlayer(struct prop *prop);
-Gfx *explosionRender(struct prop *prop, Gfx *gdl, bool xlupass);
-Gfx *explosionRenderPart(struct explosion *exp, struct explosionpart *part, Gfx *gdl, struct coord *coord, s32 arg4);
+bool explosion_create_simple(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum);
+bool explosion_create_complex(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum);
+f32 explosion_get_horizontal_range_at_frame(struct explosion *exp, s32 frame);
+f32 explosion_get_vertical_range_at_frame(struct explosion *exp, s32 frame);
+void explosion_get_bbox_at_frame(struct coord *lower, struct coord *upper, s32 frame, struct prop *prop);
+void explosion_alert_chrs(f32 *radius, struct coord *noisepos);
+bool explosion_create(struct prop *prop, struct coord *pos, RoomNum *rooms, s16 type, s32 playernum, bool makescorch, struct coord *arg6, RoomNum room, struct coord *arg8);
+void explosions_update_shake(struct coord *arg0, struct coord *arg1, struct coord *arg2);
+bool explosion_overlaps_prop(struct explosion *exp, struct prop *prop, struct coord *pos1, struct coord *pos2);
+void explosion_inflict_damage(struct prop *prop);
+u32 explosion_tick(struct prop *prop);
+u32 explosion_tick_player(struct prop *prop);
+Gfx *explosion_render(struct prop *prop, Gfx *gdl, bool xlupass);
+Gfx *explosion_render_part(struct explosion *exp, struct explosionpart *part, Gfx *gdl, struct coord *coord, s32 arg4);
 
 #endif

src/include/game/file.h

@@ -4,17 +4,17 @@
 #include "data.h"
 #include "types.h"
 
-romptr_t fileGetRomAddress(s32 filenum);
-s32 fileGetRomSize(s32 filenum);
-void filesInit(void);
-void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len);
-u32 fileGetInflatedSize(s32 filenum);
-void *fileLoadToNew(s32 filenum, u32 method);
-void *fileLoadToAddr(s32 filenum, s32 method, u8 *ptr, u32 size);
-u32 fileGetLoadedSize(s32 filenum);
-u32 fileGetAllocationSize(s32 filenum);
-void fileSetSize(s32 filenum, void *ptr, u32 size, bool reallocate);
-void filesStop(u8 arg0);
+romptr_t file_get_rom_address(s32 filenum);
+s32 file_get_rom_size(s32 filenum);
+void files_init(void);
+void file_load_part_to_addr(u16 filenum, void *memaddr, s32 offset, u32 len);
+u32 file_get_inflated_size(s32 filenum);
+void *file_load_to_new(s32 filenum, u32 method);
+void *file_load_to_addr(s32 filenum, s32 method, u8 *ptr, u32 size);
+u32 file_get_loaded_size(s32 filenum);
+u32 file_get_allocation_size(s32 filenum);
+void file_set_size(s32 filenum, void *ptr, u32 size, bool reallocate);
+void files_stop(u8 arg0);
 void func0f167330(void);
 
 #endif

src/include/game/filelist.h

@@ -6,10 +6,10 @@
 
 void func0f110bf0(void);
 void func0f110bf8(void);
-void filelistCreate(s32 listnum, u8 filetype);
-s32 filelistFindOrCreate(u8 filetype);
-void filelistInvalidatePak(s32 device);
-void filelistsTick(void);
-void filelistUpdate(struct filelist *list);
+void filelist_create(s32 listnum, u8 filetype);
+s32 filelist_find_or_create(u8 filetype);
+void filelist_invalidate_pak(s32 device);
+void filelists_tick(void);
+void filelist_update(struct filelist *list);
 
 #endif

src/include/game/filemgr.h

@@ -6,80 +6,80 @@
 
 extern struct menudialogdef g_ChooseLanguageMenuDialog;
 
-char *filemgrGetDeviceName(s32 index);
-char *filemgrMenuTextDeviceName(struct menuitem *item);
-void filemgrGetSelectName(char *buffer, struct filelistfile *file, u32 filetype);
-char *filemgrMenuTextDeleteFileName(struct menuitem *item);
-void filemgrSetDevice1BySerial(s32 deviceserial);
-void filemgrSetDevice1ByFile(struct filelistfile *file);
-void filemgrSetFileToDelete(struct filelistfile *file, s32 filetype);
-char *filemgrMenuTextFailReason(struct menuitem *item);
-char *filemgrMenuTextDeviceNameForError(struct menuitem *item);
-void filemgrPushErrorDialog(u16 errno);
-s32 filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex);
-char *filemgrMenuTextErrorTitle(struct menuitem *item);
-char *filemgrMenuTextFileType(struct menuitem *item);
+char *filemgr_get_device_name(s32 index);
+char *filemgr_menu_text_device_name(struct menuitem *item);
+void filemgr_get_select_name(char *buffer, struct filelistfile *file, u32 filetype);
+char *filemgr_menu_text_delete_file_name(struct menuitem *item);
+void filemgr_set_device1_by_serial(s32 deviceserial);
+void filemgr_set_device1_by_file(struct filelistfile *file);
+void filemgr_set_file_to_delete(struct filelistfile *file, s32 filetype);
+char *filemgr_menu_text_fail_reason(struct menuitem *item);
+char *filemgr_menu_text_device_name_for_error(struct menuitem *item);
+void filemgr_push_error_dialog(u16 errno);
+s32 filemgr_get_device_name_or_start_index(s32 listnum, s32 operation, s32 optionindex);
+char *filemgr_menu_text_error_title(struct menuitem *item);
+char *filemgr_menu_text_file_type(struct menuitem *item);
 void func0f10898c(void);
-void filemgrHandleSuccess(void);
-void filemgrEraseCorruptFile(void);
-char *filemgrMenuTextInsertOriginalPak(struct menuitem *item);
-void filemgrRetrySave(s32 arg0);
-bool filemgrAttemptOperation(s32 device, bool closeonsuccess);
-bool filemgrSaveOrLoad(struct fileguid *guid, s32 fileop, u32 playernum);
-void filemgrDeleteCurrentFile(void);
+void filemgr_handle_success(void);
+void filemgr_erase_corrupt_file(void);
+char *filemgr_menu_text_insert_original_pak(struct menuitem *item);
+void filemgr_retry_save(s32 arg0);
+bool filemgr_attempt_operation(s32 device, bool closeonsuccess);
+bool filemgr_save_or_load(struct fileguid *guid, s32 fileop, u32 playernum);
+void filemgr_delete_current_file(void);
 void func0f1097d0(s32 device);
-void filemgrSaveGameToDevice(s32 device);
-void filemgrGetFileName(char *dst, struct filelistfile *file);
-void filemgrGetRenameName(char *buffer);
-void filemgrSetRenameName(char *name);
-bool filemgrIsNameAvailable(s32 arg0);
-void filemgrSaveToDevice(void);
-char *filemgrMenuTextDeviceNameContainingDuplicateFile(struct menuitem *item);
-char *filemgrMenuTextDuplicateFileName(struct menuitem *item);
-char *filemgrMenuTextLocationName2(struct menuitem *item);
-char *filemgrMenuTextSaveLocationSpaces(struct menuitem *item);
-void filemgrPushSelectLocationDialog(s32 arg0, u32 filetype);
-char *filemgrMenuTextFileInUseDescription(struct menuitem *item);
-Gfx *filemgrRenderPerfectHeadThumbnail(Gfx *gdl, struct menuitemrenderdata *renderdata, s32 filenum, s32 deviceserial);
-bool filemgrIsFileInUse(struct filelistfile *file);
-MenuItemHandlerResult filemgrFileToCopyOrDeleteListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data, bool isdelete);
-void filemgrPushDeleteFileDialog(s32 listnum);
-char *pakMenuTextPagesFree(struct menuitem *item);
-char *pakMenuTextPagesUsed(struct menuitem *item);
-char *pakMenuTextStatusMessage(struct menuitem *item);
-char *pakMenuTextEditingPakName(struct menuitem *item);
-bool filemgrConsiderPushingFileSelectDialog(void);
-void bootmenuReset(void);
-MenuItemHandlerResult filemgrChooseAgentListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult pakGameNoteListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrFileToCopyListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrFileToDeleteListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult filemgrInsertOriginalPakMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult filemgrCopyOrDeleteListMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult pakGameNotesMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult pakChoosePakMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult filemgrMainMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult filemgrDeviceNameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrFileNameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrDeviceNameForErrorMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrRetrySaveMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrCancelSave2MenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrAcknowledgeFileLostMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrReinsertedOkMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrReinsertedCancelMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrDuplicateRenameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrDuplicateCancelMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrCancelSaveMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrDeleteFilesForSaveMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrConfirmDeleteMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult pakDeleteGameNoteMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult pakSelectionMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrAgentNameKeyboardMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrOpenCopyFileMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrOpenDeleteFileMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrConfirmRenameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrSaveElsewhereYesMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult filemgrSelectLocationMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
+void filemgr_save_game_to_device(s32 device);
+void filemgr_get_file_name(char *dst, struct filelistfile *file);
+void filemgr_get_rename_name(char *buffer);
+void filemgr_set_rename_name(char *name);
+bool filemgr_is_name_available(s32 arg0);
+void filemgr_save_to_device(void);
+char *filemgr_menu_text_device_name_containing_duplicate_file(struct menuitem *item);
+char *filemgr_menu_text_duplicate_file_name(struct menuitem *item);
+char *filemgr_menu_text_location_name2(struct menuitem *item);
+char *filemgr_menu_text_save_location_spaces(struct menuitem *item);
+void filemgr_push_select_location_dialog(s32 arg0, u32 filetype);
+char *filemgr_menu_text_file_in_use_description(struct menuitem *item);
+Gfx *filemgr_render_perfect_head_thumbnail(Gfx *gdl, struct menuitemrenderdata *renderdata, s32 filenum, s32 deviceserial);
+bool filemgr_is_file_in_use(struct filelistfile *file);
+MenuItemHandlerResult filemgr_file_to_copy_or_delete_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data, bool isdelete);
+void filemgr_push_delete_file_dialog(s32 listnum);
+char *pak_menu_text_pages_free(struct menuitem *item);
+char *pak_menu_text_pages_used(struct menuitem *item);
+char *pak_menu_text_status_message(struct menuitem *item);
+char *pak_menu_text_editing_pak_name(struct menuitem *item);
+bool filemgr_consider_pushing_file_select_dialog(void);
+void bootmenu_reset(void);
+MenuItemHandlerResult filemgr_choose_agent_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult pak_game_note_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_file_to_copy_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_file_to_delete_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult filemgr_insert_original_pak_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult filemgr_copy_or_delete_list_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult pak_game_notes_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult pak_choose_pak_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult filemgr_main_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult filemgr_device_name_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_file_name_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_device_name_for_error_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_retry_save_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_cancel_save2_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_acknowledge_file_lost_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_reinserted_ok_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_reinserted_cancel_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_duplicate_rename_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_duplicate_cancel_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_cancel_save_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_delete_files_for_save_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_confirm_delete_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult pak_delete_game_note_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult pak_selection_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_agent_name_keyboard_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_open_copy_file_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_open_delete_file_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_confirm_rename_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_save_elsewhere_yes_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult filemgr_select_location_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
 
 extern const char var7f1b3214[];
 extern const char var7f1b3218[];

src/include/game/fmb.h

@@ -4,11 +4,11 @@
 #include "data.h"
 #include "types.h"
 
-void fmbReset(void);
-MenuItemHandlerResult fmbHandleDropOut(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult fmdHandleAbortGame(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult fmbHandleAdvancedSetup(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult fmbHandleAcceptChallenge(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult fmbHandleMainMenu(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+void fmb_reset(void);
+MenuItemHandlerResult fmb_handle_drop_out(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult fmd_handle_abort_game(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult fmb_handle_advanced_setup(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult fmb_handle_accept_challenge(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult fmb_handle_main_menu(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
 
 #endif

src/include/game/footstep.h

@@ -4,8 +4,8 @@
 #include "data.h"
 #include "types.h"
 
-s32 footstepChooseSound(struct chrdata *chr, s32 index);
-void footstepCheckDefault(struct chrdata *chr);
-void footstepCheckMagic(struct chrdata *chr);
+s32 footstep_choose_sound(struct chrdata *chr, s32 index);
+void footstep_check_default(struct chrdata *chr);
+void footstep_check_magic(struct chrdata *chr);
 
 #endif

src/include/game/game_006900.h

@@ -4,11 +4,11 @@
 #include "data.h"
 #include "types.h"
 
-u32 colourBlend(u32 a, u32 b, u32 weight);
-void menuTickTimers(void);
-f32 menuGetSinOscFrac(f32 freq);
-f32 menuGetCosOscFrac(f32 freq);
-f32 menuGetLinearIntervalFrac(f32 freq);
-f32 menuGetLinearOscPauseFrac(f32 frac);
+u32 colour_blend(u32 a, u32 b, u32 weight);
+void menu_tick_timers(void);
+f32 menu_get_sin_osc_frac(f32 freq);
+f32 menu_get_cos_osc_frac(f32 freq);
+f32 menu_get_linear_interval_frac(f32 freq);
+f32 menu_get_linear_osc_pause_frac(f32 frac);
 
 #endif

src/include/game/game_00b320.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-void langReset(s32 stagenum);
+void lang_reset(s32 stagenum);
 
 #endif

src/include/game/game_00b820.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void resetSomeStageThings(void);
-void stageAllocateBgChrs(void);
+void reset_some_stage_things(void);
+void stage_allocate_bg_chrs(void);
 
 #endif

src/include/game/game_0147d0.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void boltbeamsReset(void);
-void lasersightsReset(void);
+void boltbeams_reset(void);
+void lasersights_reset(void);
 
 #endif

src/include/game/game_096360.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void mtxLoadRandomRotation(Mtxf *mtx);
+void mtx_load_random_rotation(Mtxf *mtx);
 void func0f0964b4(struct coord *arg0, Mtxf *mtx);
 void func0f0965e4(f32 *arg0, f32 *arg1, f32 arg2);
 void func0f096698(Mtxf *arg0, Mtxf *arg1, s32 count);

src/include/game/game_0b0fd0.h

@@ -4,38 +4,38 @@
 #include "data.h"
 #include "types.h"
 
-struct weapon *weaponFindById(s32 itemid);
-struct weaponfunc *weaponGetFunctionById(u32 weaponnum, u32 which);
-struct weaponfunc *gsetGetWeaponFunction2(struct gset *gset);
-struct weaponfunc *gsetGetWeaponFunction(struct gset *gset);
-struct weaponfunc *weaponGetFunction(struct gset *gset, s32 which);
-struct weaponfunc *currentPlayerGetWeaponFunction(u32 hand);
-struct invaimsettings *gsetGetAimSettings(struct gset *gset);
-struct inventory_ammo *weaponGetAmmoByFunction(u32 weaponnum, u32 funcnum);
-f32 handGetXShift(s32 handnum);
+struct weapon *weapon_find_by_id(s32 itemid);
+struct weaponfunc *weapon_get_function_by_id(u32 weaponnum, u32 which);
+struct weaponfunc *gset_get_weapon_function2(struct gset *gset);
+struct weaponfunc *gset_get_weapon_function(struct gset *gset);
+struct weaponfunc *weapon_get_function(struct gset *gset, s32 which);
+struct weaponfunc *current_player_get_weapon_function(u32 hand);
+struct invaimsettings *gset_get_aim_settings(struct gset *gset);
+struct inventory_ammo *weapon_get_ammo_by_function(u32 weaponnum, u32 funcnum);
+f32 hand_get_x_shift(s32 handnum);
 f32 func0f0b131c(s32 handnum);
-f32 currentPlayerGetGunZoomFov(void);
-void currentPlayerZoomOut(f32 fovpersec);
-void currentPlayerZoomIn(f32 fovpersec);
-bool weaponHasFlag(s32 itemid, u32 flag);
-bool weaponHasAimFlag(s32 weaponnum, u32 flag);
-bool weaponHasAmmoFlag(s32 weaponnum, s32 funcnum, u32 flag);
-s32 currentPlayerGetDeviceState(s32 weaponnum);
-void currentPlayerSetDeviceActive(s32 weaponum, bool active);
-u16 weaponGetFileNum(s32 weaponnum);
-u16 weaponGetFileNum2(s32 weaponnum);
-void gsetPopulateFromCurrentPlayer(s32 handnum, struct gset *gset);
-struct inventory_ammo *gsetGetAmmoDefinition(struct gset *gset);
-u8 gsetGetSinglePenetration(struct gset *gset);
-f32 gsetGetImpactForce(struct gset *gset);
-f32 gsetGetDamage(struct gset *gset);
-u8 gsetGetFireslotDuration(struct gset *gset);
-u16 gsetGetSingleShootSound(struct gset *gset);
-bool gsetHasFunctionFlags(struct gset *gset, u32 flags);
-s8 weaponGetNumTicksPerShot(u32 weaponnum, u32 funcindex);
-u32 currentPlayerGetSight(void);
-void gsetGetNoiseSettings(struct gset *gset, struct noisesettings *settings);
-struct guncmd *gsetGetPriToSecAnim(struct gset *gset);
-struct guncmd *gsetGetSecToPriAnim(struct gset *gset);
+f32 current_player_get_gun_zoom_fov(void);
+void current_player_zoom_out(f32 fovpersec);
+void current_player_zoom_in(f32 fovpersec);
+bool weapon_has_flag(s32 itemid, u32 flag);
+bool weapon_has_aim_flag(s32 weaponnum, u32 flag);
+bool weapon_has_ammo_flag(s32 weaponnum, s32 funcnum, u32 flag);
+s32 current_player_get_device_state(s32 weaponnum);
+void current_player_set_device_active(s32 weaponum, bool active);
+u16 weapon_get_file_num(s32 weaponnum);
+u16 weapon_get_file_num2(s32 weaponnum);
+void gset_populate_from_current_player(s32 handnum, struct gset *gset);
+struct inventory_ammo *gset_get_ammo_definition(struct gset *gset);
+u8 gset_get_single_penetration(struct gset *gset);
+f32 gset_get_impact_force(struct gset *gset);
+f32 gset_get_damage(struct gset *gset);
+u8 gset_get_fireslot_duration(struct gset *gset);
+u16 gset_get_single_shoot_sound(struct gset *gset);
+bool gset_has_function_flags(struct gset *gset, u32 flags);
+s8 weapon_get_num_ticks_per_shot(u32 weaponnum, u32 funcindex);
+u32 current_player_get_sight(void);
+void gset_get_noise_settings(struct gset *gset, struct noisesettings *settings);
+struct guncmd *gset_get_pri_to_sec_anim(struct gset *gset);
+struct guncmd *gset_get_sec_to_pri_anim(struct gset *gset);
 
 #endif

src/include/game/game_13c510.h

@@ -4,14 +4,14 @@
 #include "data.h"
 #include "types.h"
 
-void artifactsClear(void);
-void artifactsTick(void);
+void artifacts_clear(void);
+void artifacts_tick(void);
 u16 func0f13c574(f32 arg0);
 s32 func0f13c710(f32 arg0);
-void artifactsCalculateGlaresForRoom(s32 roomnum);
+void artifacts_calculate_glares_for_room(s32 roomnum);
 u8 func0f13d3c4(u8 arg0, u8 arg1);
-Gfx *artifactsConfigureForGlares(Gfx *gdl);
-Gfx *artifactsUnconfigureForGlares(Gfx *gdl);
-Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum);
+Gfx *artifacts_configure_for_glares(Gfx *gdl);
+Gfx *artifacts_unconfigure_for_glares(Gfx *gdl);
+Gfx *artifacts_render_glares_for_room(Gfx *gdl, s32 roomnum);
 
 #endif

src/include/game/game_1531a0.h

@@ -8,16 +8,16 @@
 #define DIAGMODE_REDRAW  1
 #define DIAGMODE_FADEOUT 2
 
-void textInit(void);
-void textSetRotation90(bool rotated);
-void textSetWrapIndent(s32 count);
+void text_init(void);
+void text_set_rotation90(bool rotated);
+void text_set_wrap_indent(s32 count);
 void text0f1531d0(s32 arg0);
 void text0f1531dc(bool arg0);
-void textLoadFont(u8 *romstart, u8 *romend, struct font **fontptr, struct fontchar **charsptr, bool monospace);
-void textReset(void);
+void text_load_font(u8 *romstart, u8 *romend, struct font **fontptr, struct fontchar **charsptr, bool monospace);
+void text_reset(void);
 Gfx *text0f153628(Gfx *gdl);
 Gfx *text0f153780(Gfx *gdl);
-Gfx *textSetPrimColour(Gfx *gdl, u32 colour);
+Gfx *text_set_prim_colour(Gfx *gdl, u32 colour);
 Gfx *text0f153838(Gfx *gdl);
 Gfx *text0f153858(Gfx *gdl, s32 *x1, s32 *y1, s32 *x2, s32 *y2);
 Gfx *text0f1538e4(Gfx *gdl, s32 *x1, s32 *y1, s32 *x2, s32 *y2);
@@ -26,18 +26,18 @@ Gfx *text0f153a34(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour);
 Gfx *text0f153ab0(Gfx *gdl);
 void text0f153b40(void);
 void text0f153b6c(s32 arg0);
-void textSetDiagonalBlend(s32 x, s32 y, f32 redrawtimer, u8 populated);
-void textBackupDiagonalBlendSettings(void);
-void textRestoreDiagonalBlendSettings(void);
-void textSetHorizontalBlend(s32 x1, s32 x2, u32 arg2);
-void textBackupAndResetBlends(void);
-void textRestoreBlends(void);
-void textSetWaveBlend(s32 arg0, s32 arg1, s32 cthresh);
-void textSetMenuBlend(f32 arg0);
-void textSetWaveColours(u32 colour1, u32 colour2);
-void textResetBlends(void);
-bool textHasDiagonalBlend(void);
-u32 textApplyProjectionColour(s32 x, s32 y, u32 colour);
+void text_set_diagonal_blend(s32 x, s32 y, f32 redrawtimer, u8 populated);
+void text_backup_diagonal_blend_settings(void);
+void text_restore_diagonal_blend_settings(void);
+void text_set_horizontal_blend(s32 x1, s32 x2, u32 arg2);
+void text_backup_and_reset_blends(void);
+void text_restore_blends(void);
+void text_set_wave_blend(s32 arg0, s32 arg1, s32 cthresh);
+void text_set_menu_blend(f32 arg0);
+void text_set_wave_colours(u32 colour1, u32 colour2);
+void text_reset_blends(void);
+bool text_has_diagonal_blend(void);
+u32 text_apply_projection_colour(s32 x, s32 y, u32 colour);
 u32 text0f1543ac(s32 x, s32 y, u32 colour);
 Gfx *text0f154ecc(Gfx *gdl, u32 arg1, u32 arg2);
 Gfx *text0f154f38(Gfx *gdl, s32 *arg1, struct fontchar *curchar, struct fontchar *prevchar, struct font *font, f32 widthscale, f32 heightscale, f32 x, f32 y);
@@ -45,12 +45,12 @@ Gfx *text0f1552d4(Gfx *gdl, f32 x, f32 y, f32 widthscale, f32 heightscale, char
 Gfx *text0f15568c(Gfx *gdl, s32 *x, s32 *y, struct fontchar *curchar, struct fontchar *prevchar, struct font *font, s32 savedx, s32 savedy, s32 width, s32 height, s32 arg10);
 void text0f156024(s32 arg0);
 void text0f156030(u32 colour);
-Gfx *textRenderProjected(Gfx *gdl, s32 *x, s32 *y, char *text, struct fontchar *chars, struct font *font, s32 colour, s32 width, s32 height, s32 arg9, s32 lineheight);
+Gfx *text_render_projected(Gfx *gdl, s32 *x, s32 *y, char *text, struct fontchar *chars, struct font *font, s32 colour, s32 width, s32 height, s32 arg9, s32 lineheight);
 Gfx *text0f1566cc(Gfx *gdl, u32 arg1, u32 arg2);
 Gfx *text0f156a24(Gfx *gdl, s32 x, s32 y, struct fontchar *char1, s32 arg4, s32 arg5, s32 arg6, s32 arg7);
-Gfx *textRender(Gfx *gdl, s32 *x, s32 *y, char *text, struct fontchar *font1, struct font *font2, u32 arg6, u32 colour, s32 width, s32 height, u32 arg10, s32 arg11);
-void textMeasure(s32 *textheight, s32 *textwidth, char *text, struct fontchar *font1, struct font *font2, s32 lineheight);
-void textWrap(s32 width, char *in, char *out, struct fontchar *font1, struct font *font2);
+Gfx *text_render(Gfx *gdl, s32 *x, s32 *y, char *text, struct fontchar *font1, struct font *font2, u32 arg6, u32 colour, s32 width, s32 height, u32 arg10, s32 arg11);
+void text_measure(s32 *textheight, s32 *textwidth, char *text, struct fontchar *font1, struct font *font2, s32 lineheight);
+void text_wrap(s32 width, char *in, char *out, struct fontchar *font1, struct font *font2);
 
 Gfx *func0f1574d0jf(Gfx *gdl, s32 *x, s32 *y, char *text, struct fontchar *font1, struct font *font2, s32 colour, u32 colour2, s32 width, s32 height, s32 arg9, u32 arg10);
 

src/include/game/gamefile.h

@@ -4,14 +4,14 @@
 #include "data.h"
 #include "types.h"
 
-u32 gamefileHasFlag(u32 value);
-void gamefileSetFlag(u32 value);
-void gamefileUnsetFlag(u32 value);
-void gamefilePrintFlags(void);
-void gamefileApplyOptions(struct gamefile *file);
-void gamefileLoadDefaults(struct gamefile *file);
-s32 gamefileLoad(s32 device);
-s32 gamefileSave(s32 device, s32 filenum, u16 deviceserial);
-void gamefileGetOverview(char *arg0, char *name, u8 *stage, u8 *difficulty, u32 *time);
+u32 gamefile_has_flag(u32 value);
+void gamefile_set_flag(u32 value);
+void gamefile_unset_flag(u32 value);
+void gamefile_print_flags(void);
+void gamefile_apply_options(struct gamefile *file);
+void gamefile_load_defaults(struct gamefile *file);
+s32 gamefile_load(s32 device);
+s32 gamefile_save(s32 device, s32 filenum, u16 deviceserial);
+void gamefile_get_overview(char *arg0, char *name, u8 *stage, u8 *difficulty, u32 *time);
 
 #endif

src/include/game/getitle.h

@@ -4,9 +4,9 @@
 #include "data.h"
 #include "types.h"
 
-void getitleReset(void);
+void getitle_reset(void);
 
-void getitleLoad(void *addr, u32 arg1);
-Gfx *getitleRender(Gfx *gdl);
+void getitle_load(void *addr, u32 arg1);
+Gfx *getitle_render(Gfx *gdl);
 
 #endif

src/include/game/gfxmemory.h

@@ -6,14 +6,14 @@
 
 extern u8 *g_GfxBuffers[3];
 
-void gfxReset(void);
-Gfx *gfxGetMasterDisplayList(void);
-Vtx *gfxAllocateVertices(u32 count);
-void *gfxAllocateMatrix(void);
-LookAt *gfxAllocateLookAt(s32 count);
-Col *gfxAllocateColours(s32 count);
-void *gfxAllocate(u32 size);
-void gfxSwapBuffers(void);
-s32 gfxGetFreeGfx(Gfx *gdl);
+void gfx_reset(void);
+Gfx *gfx_get_master_display_list(void);
+Vtx *gfx_allocate_vertices(u32 count);
+void *gfx_allocate_matrix(void);
+LookAt *gfx_allocate_look_at(s32 count);
+Col *gfx_allocate_colours(s32 count);
+void *gfx_allocate(u32 size);
+void gfx_swap_buffers(void);
+s32 gfx_get_free_gfx(Gfx *gdl);
 
 #endif

src/include/game/gfxreplace.h

@@ -4,7 +4,7 @@
 #include "data.h"
 #include "types.h"
 
-void gfxReplaceGbiCommands(Gfx *gdl, Gfx *endgdl, s32 type);
-void gfxReplaceGbiCommandsRecursively(struct roomblock *arg0, s32 type);
+void gfx_replace_gbi_commands(Gfx *gdl, Gfx *endgdl, s32 type);
+void gfx_replace_gbi_commands_recursively(struct roomblock *arg0, s32 type);
 
 #endif

src/include/game/gunfx.h

@@ -4,34 +4,34 @@
 #include "data.h"
 #include "types.h"
 
-void boltbeamsReset(void);
-void lasersightsReset(void);
+void boltbeams_reset(void);
+void lasersights_reset(void);
 
-void beamCreate(struct beam *beam, s32 weaponnum, struct coord *from, struct coord *to);
-void beamCreateForHand(s32 handnum);
-Gfx *beamRenderGeneric(Gfx *gdl, struct textureconfig *arg1, f32 arg2, struct coord *arg3, u32 colour1, f32 arg5, struct coord *arg6, u32 colour2);
-Gfx *beamRender(Gfx *gdl, struct beam *beam, bool arg2, u8 arg3);
-void beamTick(struct beam *beam);
+void beam_create(struct beam *beam, s32 weaponnum, struct coord *from, struct coord *to);
+void beam_create_for_hand(s32 handnum);
+Gfx *beam_render_generic(Gfx *gdl, struct textureconfig *arg1, f32 arg2, struct coord *arg3, u32 colour1, f32 arg5, struct coord *arg6, u32 colour2);
+Gfx *beam_render(Gfx *gdl, struct beam *beam, bool arg2, u8 arg3);
+void beam_tick(struct beam *beam);
 
-struct casing *casingCreate(struct modeldef *modeldef, Mtxf *mtx);
-void casingCreateForHand(s32 handnum, f32 ground, Mtxf *mtx);
-void casingRender(struct casing *casing, Gfx **gdlptr);
-void casingsRender(Gfx **gdlptr);
+struct casing *casing_create(struct modeldef *modeldef, Mtxf *mtx);
+void casing_create_for_hand(s32 handnum, f32 ground, Mtxf *mtx);
+void casing_render(struct casing *casing, Gfx **gdlptr);
+void casings_render(Gfx **gdlptr);
 
-s32 boltbeamFindByProp(struct prop *prop);
-s32 boltbeamCreate(struct prop *prop);
-void boltbeamSetHeadPos(s32 beamnum, struct coord *pos);
-void boltbeamSetTailPos(s32 beamnum, struct coord *pos);
-void boltbeamIncrementHeadPos(s32 beamnum, f32 newlength, bool arg2);
-void boltbeamSetAutomatic(s32 beamnum, f32 speed);
-Gfx *boltbeamsRender(Gfx *gdl);
-void boltbeamsTick(void);
+s32 boltbeam_find_by_prop(struct prop *prop);
+s32 boltbeam_create(struct prop *prop);
+void boltbeam_set_head_pos(s32 beamnum, struct coord *pos);
+void boltbeam_set_tail_pos(s32 beamnum, struct coord *pos);
+void boltbeam_increment_head_pos(s32 beamnum, f32 newlength, bool arg2);
+void boltbeam_set_automatic(s32 beamnum, f32 speed);
+Gfx *boltbeams_render(Gfx *gdl);
+void boltbeams_tick(void);
 
-bool lasersightExists(s32 id, s32 *index);
-Gfx *lasersightRenderDot(Gfx *gdl);
-Gfx *lasersightRenderBeam(Gfx *gdl);
-void lasersightSetBeam(s32 id, s32 arg1, struct coord *near, struct coord *far);
-void lasersightSetDot(s32 arg0, struct coord *pos, struct coord *rot);
-void lasersightFree(s32 arg0);
+bool lasersight_exists(s32 id, s32 *index);
+Gfx *lasersight_render_dot(Gfx *gdl);
+Gfx *lasersight_render_beam(Gfx *gdl);
+void lasersight_set_beam(s32 id, s32 arg1, struct coord *near, struct coord *far);
+void lasersight_set_dot(s32 arg0, struct coord *pos, struct coord *rot);
+void lasersight_free(s32 arg0);
 
 #endif

src/include/game/healthbar.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-Gfx *healthbarDraw(Gfx *gdl, struct chrdata *chr, s32 offy, f32 heightfrac);
+Gfx *healthbar_draw(Gfx *gdl, struct chrdata *chr, s32 offy, f32 heightfrac);
 
 #endif

src/include/game/hudmsg.h

@@ -4,31 +4,31 @@
 #include "data.h"
 #include "types.h"
 
-u8 hudmsgsAreActive(void);
-s32 hudmsgIsZoomRangeVisible(void);
-Gfx *hudmsgRenderMissionTimer(Gfx *gdl, u32 alpha);
-Gfx *hudmsgRenderZoomRange(Gfx *gdl, u32 alpha);
-Gfx *hudmsgRenderBox(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, f32 bgopacity, u32 bordercolour, f32 textopacity);
+u8 hudmsgs_are_active(void);
+s32 hudmsg_is_zoom_range_visible(void);
+Gfx *hudmsg_render_mission_timer(Gfx *gdl, u32 alpha);
+Gfx *hudmsg_render_zoom_range(Gfx *gdl, u32 alpha);
+Gfx *hudmsg_render_box(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, f32 bgopacity, u32 bordercolour, f32 textopacity);
 s32 hudmsg0f0ddb1c(s32 *arg0, s32 arg1);
-void hudmsgsHideByChannel(s32 value);
-void hudmsgsReset(void);
-void hudmsgRemoveAll(void);
-s32 hudmsgGetNext(s32 refid);
-void hudmsgCreate(char *text, s32 type);
-void hudmsgCreateWithFlags(char *text, s32 type, u32 flags);
-void hudmsgCreateWithColour(char *text, s32 type, u8 colour);
-void hudmsgCreateWithDuration(char *text, s32 type, struct hudmsgtype *config, s32 duration60);
-void hudmsgCreateAsSubtitle(char *text, s32 type, u8 colourindex, s32 audiochannelnum);
-void hudmsgCalculatePosition(struct hudmessage *msg);
-void hudmsgCreateFromArgs(char *text, s32 type, s32 conf00, s32 conf01, s32 conf02,
+void hudmsgs_hide_by_channel(s32 value);
+void hudmsgs_reset(void);
+void hudmsg_remove_all(void);
+s32 hudmsg_get_next(s32 refid);
+void hudmsg_create(char *text, s32 type);
+void hudmsg_create_with_flags(char *text, s32 type, u32 flags);
+void hudmsg_create_with_colour(char *text, s32 type, u8 colour);
+void hudmsg_create_with_duration(char *text, s32 type, struct hudmsgtype *config, s32 duration60);
+void hudmsg_create_as_subtitle(char *text, s32 type, u8 colourindex, s32 audiochannelnum);
+void hudmsg_calculate_position(struct hudmessage *msg);
+void hudmsg_create_from_args(char *text, s32 type, s32 conf00, s32 conf01, s32 conf02,
 		struct fontchar **conf04, struct font **conf08,
 		u32 textcolour, u32 shadowcolour,
 		u32 alignh, s32 conf16, u32 alignv, s32 conf18, s32 arg14, u32 flags);
-void hudmsgsTick(void);
-void hudmsgsSetOn(u32 reason);
-void hudmsgsSetOff(u32 reason);
-void hudmsgsRemoveForDeadPlayer(s32 playernum);
-Gfx *hudmsgsRender(Gfx *gdl);
-void hudmsgsStop(void);
+void hudmsgs_tick(void);
+void hudmsgs_set_on(u32 reason);
+void hudmsgs_set_off(u32 reason);
+void hudmsgs_remove_for_dead_player(s32 playernum);
+Gfx *hudmsgs_render(Gfx *gdl);
+void hudmsgs_stop(void);
 
 #endif

src/include/game/inv.h

@@ -8,52 +8,52 @@ extern struct noisesettings invnoisesettings_silent;
 extern struct invaimsettings invaimsettings_default;
 extern struct weapon *g_Weapons[WEAPON_SUICIDEPILL + 1];
 
-void invReset(void);
-void invInit(s32 numdoubles);
+void inv_reset(void);
+void inv_init(s32 numdoubles);
 
-void invClear(void);
-void invSortItem(struct invitem *item);
-void invInsertItem(struct invitem *item);
-void invRemoveItem(struct invitem *item);
-struct invitem *invFindUnusedSlot(void);
-void invSetAllGuns(bool enable);
-struct invitem *invFindSingleWeapon(s32 weaponnum);
-bool invHasSingleWeaponExcAllGuns(s32 weaponnum);
-struct invitem *invFindDoubleWeapon(s32 weapon1, s32 weapon2);
-bool invHasDoubleWeaponExcAllGuns(s32 weapon1, s32 weapon2);
-bool invHasSingleWeaponOrProp(s32 weaponnum);
-s32 invAddOneIfCantHaveSlayer(s32 arg0);
-s32 currentStageForbidsSlayer(void);
-bool invCanHaveAllGunsWeapon(s32 weaponnum);
-bool invHasSingleWeaponIncAllGuns(s32 weaponnum);
-bool invHasDoubleWeaponIncAllGuns(s32 weapon1, s32 weapon2);
-bool invGiveSingleWeapon(s32 weaponnum);
-bool invGiveDoubleWeapon(s32 weapon1, s32 weapon2);
-void invRemoveItemByNum(s32 weaponnum);
-bool invGiveProp(struct prop *prop);
-void invRemoveProp(struct prop *prop);
-s32 invGiveWeaponsByProp(struct prop *prop);
-void invChooseCycleForwardWeapon(s32 *weaponnum1, s32 *weaponnum2, bool arg2);
-void invChooseCycleBackWeapon(s32 *weaponnum1, s32 *weaponnum2, bool arg2);
-bool invHasKeyFlags(u32 wantkeyflags);
-bool invHasBriefcase(void);
-bool invHasDataUplink(void);
-bool invHasProp(struct prop *prop);
-s32 invGetCount(void);
-struct invitem *invGetItemByIndex(s32 index);
-struct textoverride *invGetTextOverrideForObj(struct defaultobj *obj);
-struct textoverride *invGetTextOverrideForWeapon(s32 weaponnum);
-s32 invGetWeaponNumByIndex(s32 index);
-u16 invGetNameIdByIndex(s32 index);
-char *invGetNameByIndex(s32 index);
-char *invGetShortNameByIndex(s32 index);
-void invInsertTextOverride(struct textoverride *override);
-u32 invGetCurrentIndex(void);
-void invSetCurrentIndex(u32 item);
-void invCalculateCurrentIndex(void);
-char *invGetPickupTextByObj(struct defaultobj *obj);
-char *invGetPickupTextByWeaponNum(s32 weaponnum);
-void invIncrementHeldTime(s32 param_1, s32 param_2);
-void invGetWeaponOfChoice(s32 *weapon1, s32 *weapon2);
+void inv_clear(void);
+void inv_sort_item(struct invitem *item);
+void inv_insert_item(struct invitem *item);
+void inv_remove_item(struct invitem *item);
+struct invitem *inv_find_unused_slot(void);
+void inv_set_all_guns(bool enable);
+struct invitem *inv_find_single_weapon(s32 weaponnum);
+bool inv_has_single_weapon_exc_all_guns(s32 weaponnum);
+struct invitem *inv_find_double_weapon(s32 weapon1, s32 weapon2);
+bool inv_has_double_weapon_exc_all_guns(s32 weapon1, s32 weapon2);
+bool inv_has_single_weapon_or_prop(s32 weaponnum);
+s32 inv_add_one_if_cant_have_slayer(s32 arg0);
+s32 current_stage_forbids_slayer(void);
+bool inv_can_have_all_guns_weapon(s32 weaponnum);
+bool inv_has_single_weapon_inc_all_guns(s32 weaponnum);
+bool inv_has_double_weapon_inc_all_guns(s32 weapon1, s32 weapon2);
+bool inv_give_single_weapon(s32 weaponnum);
+bool inv_give_double_weapon(s32 weapon1, s32 weapon2);
+void inv_remove_item_by_num(s32 weaponnum);
+bool inv_give_prop(struct prop *prop);
+void inv_remove_prop(struct prop *prop);
+s32 inv_give_weapons_by_prop(struct prop *prop);
+void inv_choose_cycle_forward_weapon(s32 *weaponnum1, s32 *weaponnum2, bool arg2);
+void inv_choose_cycle_back_weapon(s32 *weaponnum1, s32 *weaponnum2, bool arg2);
+bool inv_has_key_flags(u32 wantkeyflags);
+bool inv_has_briefcase(void);
+bool inv_has_data_uplink(void);
+bool inv_has_prop(struct prop *prop);
+s32 inv_get_count(void);
+struct invitem *inv_get_item_by_index(s32 index);
+struct textoverride *inv_get_text_override_for_obj(struct defaultobj *obj);
+struct textoverride *inv_get_text_override_for_weapon(s32 weaponnum);
+s32 inv_get_weapon_num_by_index(s32 index);
+u16 inv_get_name_id_by_index(s32 index);
+char *inv_get_name_by_index(s32 index);
+char *inv_get_short_name_by_index(s32 index);
+void inv_insert_text_override(struct textoverride *override);
+u32 inv_get_current_index(void);
+void inv_set_current_index(u32 item);
+void inv_calculate_current_index(void);
+char *inv_get_pickup_text_by_obj(struct defaultobj *obj);
+char *inv_get_pickup_text_by_weapon_num(s32 weaponnum);
+void inv_increment_held_time(s32 param_1, s32 param_2);
+void inv_get_weapon_of_choice(s32 *weapon1, s32 *weapon2);
 
 #endif

src/include/game/lang.h

@@ -6,20 +6,20 @@
 
 extern u8 *g_LangBuffer;
 
-void langInit(void);
-void langReset(s32 stagenum);
-void langTick(void);
+void lang_init(void);
+void lang_reset(s32 stagenum);
+void lang_tick(void);
 
-u32 langGetLangBankIndexFromStagenum(s32 stagenum);
-struct jpncharpixels *langGetJpnCharPixels(s32 codepoint);
-s32 langGetFileNumOffset(void);
-s32 langGetFileId(s32 bank);
-void langLoad(s32 bank);
-void langLoadToAddr(s32 bank, u8 *dst, s32 size);
-void langClearBank(s32 bank);
-char *langGet(s32 textid);
-void langReload(void);
-void langSetEuropean(u32 arg0);
-void langSetJpnEnabled(bool enable);
+u32 lang_get_lang_bank_index_from_stagenum(s32 stagenum);
+struct jpncharpixels *lang_get_jpn_char_pixels(s32 codepoint);
+s32 lang_get_file_num_offset(void);
+s32 lang_get_file_id(s32 bank);
+void lang_load(s32 bank);
+void lang_load_to_addr(s32 bank, u8 *dst, s32 size);
+void lang_clear_bank(s32 bank);
+char *lang_get(s32 textid);
+void lang_reload(void);
+void lang_set_european(u32 arg0);
+void lang_set_jpn_enabled(bool enable);
 
 #endif

src/include/game/lv.h

@@ -4,38 +4,38 @@
 #include "data.h"
 #include "types.h"
 
-u32 getVar80084040(void);
-void lvInit(void);
-void lvResetMiscSfx(void);
-s32 lvGetMiscSfxIndex(u32 arg0);
-void lvSetMiscSfxState(u32 type, bool play);
-void lvUpdateMiscSfx(void);
-void lvReset(s32 stagenum);
-Gfx *lvRenderFade(Gfx *gdl);
-void lvFadeReset(void);
-bool lvUpdateTrackedProp(struct trackedprop *trackedprop, s32 index);
-void lvFindThreatsForProp(struct prop *prop, bool inchild, struct coord *playerpos, s32 *activeslots, f32 *param_5);
+u32 get_var80084040(void);
+void lv_init(void);
+void lv_reset_misc_sfx(void);
+s32 lv_get_misc_sfx_index(u32 arg0);
+void lv_set_misc_sfx_state(u32 type, bool play);
+void lv_update_misc_sfx(void);
+void lv_reset(s32 stagenum);
+Gfx *lv_render_fade(Gfx *gdl);
+void lv_fade_reset(void);
+bool lv_update_tracked_prop(struct trackedprop *trackedprop, s32 index);
+void lv_find_threats_for_prop(struct prop *prop, bool inchild, struct coord *playerpos, s32 *activeslots, f32 *param_5);
 void func0f168f24(struct prop *prop, bool inchild, struct coord *playerpos, s32 *activeslots, f32 *distances);
-void lvFindThreats(void);
-Gfx *lvRender(Gfx *gdl);
-void lvUpdateSoloHandicaps(void);
+void lv_find_threats(void);
+Gfx *lv_render(Gfx *gdl);
+void lv_update_solo_handicaps(void);
 s32 sub54321(s32 value);
-void lvUpdateCutsceneTime(void);
-s32 lvGetSlowMotionType(void);
-void lvTick(void);
-void lvTickPlayer(void);
-void lvCheckPauseStateChanged(void);
-void lvSetPaused(bool paused);
-void lvConfigureFade(u32 color, s16 num_frames);
-bool lvIsFadeActive(void);
-void lvStop(void);
-bool lvIsPaused(void);
-s32 lvGetDifficulty(void);
-void lvSetDifficulty(s32 difficulty);
-void lvSetMpTimeLimit60(u32 limit);
-void lvSetMpScoreLimit(u32 limit);
-void lvSetMpTeamScoreLimit(u32 limit);
-f32 lvGetStageTimeInSeconds(void);
-s32 lvGetStageTime60(void);
+void lv_update_cutscene_time(void);
+s32 lv_get_slow_motion_type(void);
+void lv_tick(void);
+void lv_tick_player(void);
+void lv_check_pause_state_changed(void);
+void lv_set_paused(bool paused);
+void lv_configure_fade(u32 color, s16 num_frames);
+bool lv_is_fade_active(void);
+void lv_stop(void);
+bool lv_is_paused(void);
+s32 lv_get_difficulty(void);
+void lv_set_difficulty(s32 difficulty);
+void lv_set_mp_time_limit60(u32 limit);
+void lv_set_mp_score_limit(u32 limit);
+void lv_set_mp_team_score_limit(u32 limit);
+f32 lv_get_stage_time_in_seconds(void);
+s32 lv_get_stage_time60(void);
 
 #endif

src/include/game/mainmenu.h

@@ -11,79 +11,79 @@ extern struct menudialogdef g_PreAndPostMissionBriefingMenuDialog;
 extern struct menudialogdef g_RetryMissionMenuDialog;
 extern struct menudialogdef g_NextMissionMenuDialog;
 
-char *menuTextCurrentStageName(struct menuitem *item);
-char *soloMenuTextDifficulty(struct menuitem *item);
-MenuItemHandlerResult menuhandlerControlStyleImpl(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpindex);
-char *soloMenuTitleStageOverview(struct menudialogdef *dialogdef);
+char *menu_text_current_stage_name(struct menuitem *item);
+char *solo_menu_text_difficulty(struct menuitem *item);
+MenuItemHandlerResult menuhandler_control_style_impl(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpindex);
+char *solo_menu_title_stage_overview(struct menudialogdef *dialogdef);
 f32 func0f1036ac(u8 value, s32 prop);
-bool isStageDifficultyUnlocked(s32 stageindex, s32 difficulty);
-char *soloMenuTextBestTime(struct menuitem *item);
-s32 getMaxAiBuddies(void);
-s32 getNumUnlockedSpecialStages(void);
+bool is_stage_difficulty_unlocked(s32 stageindex, s32 difficulty);
+char *solo_menu_text_best_time(struct menuitem *item);
+s32 get_max_ai_buddies(void);
+s32 get_num_unlocked_special_stages(void);
 s32 func0f104720(s32 value);
 char *func0f105664(struct menuitem *item);
 char *func0f1056a0(struct menuitem *item);
-char *invMenuTextPrimaryFunction(struct menuitem *item);
-char *invMenuTextSecondaryFunction(struct menuitem *item);
+char *inv_menu_text_primary_function(struct menuitem *item);
+char *inv_menu_text_secondary_function(struct menuitem *item);
 void func0f105948(s32 weaponnum);
-char *invMenuTextWeaponName(struct menuitem *item);
-char *invMenuTextWeaponManufacturer(struct menuitem *item);
-char *invMenuTextWeaponDescription(struct menuitem *item);
-bool soloChoosePauseDialog(void);
-MenuDialogHandlerResult menudialogBriefing(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+char *inv_menu_text_weapon_name(struct menuitem *item);
+char *inv_menu_text_weapon_manufacturer(struct menuitem *item);
+char *inv_menu_text_weapon_description(struct menuitem *item);
+bool solo_choose_pause_dialog(void);
+MenuDialogHandlerResult menudialog_briefing(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
 MenuDialogHandlerResult menudialog00103608(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult menudialogCoopAntiOptions(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult menudialog_coop_anti_options(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
 MenuDialogHandlerResult menudialog0010559c(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult inventoryMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult menudialogAbortMission(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult soloMenuDialogPauseStatus(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult inventory_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult menudialog_abort_mission(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult solo_menu_dialog_pause_status(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
 MenuItemHandlerResult menuhandler001024dc(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler001024fc(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAcceptMission(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAcceptPdModeSettings(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerBuddyOptionsContinue(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCoopDifficulty(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAntiDifficulty(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMissionList(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerControlStyle(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerFrInventoryList(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerInventoryList(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAbortMission(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCinema(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAimControl(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAlternativeTitle(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAlwaysShowTarget(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAmmoOnScreen(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAntiPlayer(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAntiRadar(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerAutoAim(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerChangeAgent(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCoopBuddy(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCoopFriendlyFire(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCoopRadar(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerCutsceneSubtitles(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerHeadRoll(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerHiRes(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerInGameSubtitles(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerLangFilter(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerLookAhead(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMusicVolume(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerPaintball(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerPdMode(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerPdModeSetting(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerReversePitch(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerScreenRatio(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_accept_mission(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_accept_pd_mode_settings(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_buddy_options_continue(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_coop_difficulty(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_anti_difficulty(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mission_list(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_control_style(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_fr_inventory_list(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_inventory_list(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_abort_mission(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_cinema(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_aim_control(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_alternative_title(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_always_show_target(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_ammo_on_screen(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_anti_player(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_anti_radar(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_auto_aim(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_change_agent(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_coop_buddy(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_coop_friendly_fire(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_coop_radar(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_cutscene_subtitles(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_head_roll(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_hi_res(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_in_game_subtitles(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_lang_filter(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_look_ahead(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_music_volume(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_paintball(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_pd_mode(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_pd_mode_setting(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_reverse_pitch(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_screen_ratio(s32 operation, struct menuitem *item, union handlerdata *data);
 #if PAL
-MenuItemHandlerResult menuhandlerLanguage(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_language(s32 operation, struct menuitem *item, union handlerdata *data);
 #endif
-MenuItemHandlerResult menuhandlerScreenSize(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerScreenSplit(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerSfxVolume(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerShowGunFunction(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerShowMissionTime(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerShowZoomRange(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerSightOnScreen(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerSoloDifficulty(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerSoundMode(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_screen_size(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_screen_split(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_sfx_volume(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_show_gun_function(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_show_mission_time(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_show_zoom_range(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_sight_on_screen(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_solo_difficulty(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_sound_mode(s32 operation, struct menuitem *item, union handlerdata *data);
 
 #endif

src/include/game/menu.h

@@ -8,20 +8,20 @@ extern const struct menucolourpalette g_MenuColours[];
 extern const struct menucolourpalette g_MenuWave1Colours[];
 extern const struct menucolourpalette g_MenuWave2Colours[];
 
-void menuTick(void);
+void menu_tick(void);
 
-void menuStop(void);
+void menu_stop(void);
 
-void menuPlaySound(s32 menusound);
-bool menuIsSoloMissionOrMp(void);
-bool currentPlayerIsMenuOpenInSoloOrMp(void);
+void menu_play_sound(s32 menusound);
+bool menu_is_solo_mission_or_mp(void);
+bool current_player_is_menu_open_in_solo_or_mp(void);
 bool func0f0f0c68(void);
-void menuSetBanner(s32 bannernum, bool allplayers);
+void menu_set_banner(s32 bannernum, bool allplayers);
 
 #if VERSION >= VERSION_NTSC_1_0
-Gfx *menuRenderBanner(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, bool big, s32 msgnum, s32 arg7, s32 arg8);
+Gfx *menu_render_banner(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, bool big, s32 msgnum, s32 arg7, s32 arg8);
 #else
-Gfx *menuRenderBanner(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, bool big, s32 msgnum);
+Gfx *menu_render_banner(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, bool big, s32 msgnum);
 #endif
 
 struct menudfc *func0f0f1338(struct menuitem *item);
@@ -29,26 +29,26 @@ void func0f0f139c(struct menuitem *item, f32 arg1);
 void func0f0f13ec(struct menuitem *item);
 void func0f0f1418(void);
 void func0f0f1494(void);
-char *menuResolveText(uintptr_t thing, void *dialogoritem);
-char *menuResolveParam2Text(struct menuitem *item);
-char *menuResolveDialogTitle(struct menudialogdef *dialogdef);
-void menuGetItemBlocksRequired(struct menuitem *item, s32 *arg1);
-void menuCalculateItemSize(struct menuitem *item, s16 *width, s16 *height, struct menudialog *dialog);
+char *menu_resolve_text(uintptr_t thing, void *dialogoritem);
+char *menu_resolve_param2_text(struct menuitem *item);
+char *menu_resolve_dialog_title(struct menudialogdef *dialogdef);
+void menu_get_item_blocks_required(struct menuitem *item, s32 *arg1);
+void menu_calculate_item_size(struct menuitem *item, s16 *width, s16 *height, struct menudialog *dialog);
 void func0f0f1d6c(struct menudialogdef *dialogdef, struct menudialog *dialog, struct menu *menu);
 void dialog0f0f1ef4(struct menudialog *dialog);
-void dialogCalculateContentSize(struct menudialogdef *dialogdef, struct menudialog *dialog, struct menu *menu);
-s32 dialogFindItem(struct menudialog *dialog, struct menuitem *item, s32 *rowindex, s32 *colindex);
-bool menuIsScrollableUnscrollable(struct menuitem *item);
-bool menuIsItemDisabled(struct menuitem *item, struct menudialog *dialog);
-bool menuIsItemFocusable(struct menuitem *item, struct menudialog *dialog, s32 arg2);
-struct menuitem *dialogFindItemAtColY(s32 targety, s32 colindex, struct menudialogdef *dialogdef, s32 *rowindexptr, struct menudialog *dialog);
-struct menuitem *dialogFindFirstItem(struct menudialog *dialog);
-struct menuitem *dialogFindFirstItemRight(struct menudialog *dialog);
-void dialogChangeItemFocusVertically(struct menudialog *dialog, s32 updown);
-s32 dialogChangeItemFocusHorizontally(struct menudialog *dialog, s32 leftright);
-s32 dialogChangeItemFocus(struct menudialog *dialog, s32 leftright, s32 updown);
-void menuOpenDialog(struct menudialogdef *dialogdef, struct menudialog *arg1, struct menu *menu);
-void menuPushDialog(struct menudialogdef *dialogdef);
+void dialog_calculate_content_size(struct menudialogdef *dialogdef, struct menudialog *dialog, struct menu *menu);
+s32 dialog_find_item(struct menudialog *dialog, struct menuitem *item, s32 *rowindex, s32 *colindex);
+bool menu_is_scrollable_unscrollable(struct menuitem *item);
+bool menu_is_item_disabled(struct menuitem *item, struct menudialog *dialog);
+bool menu_is_item_focusable(struct menuitem *item, struct menudialog *dialog, s32 arg2);
+struct menuitem *dialog_find_item_at_col_y(s32 targety, s32 colindex, struct menudialogdef *dialogdef, s32 *rowindexptr, struct menudialog *dialog);
+struct menuitem *dialog_find_first_item(struct menudialog *dialog);
+struct menuitem *dialog_find_first_item_right(struct menudialog *dialog);
+void dialog_change_item_focus_vertically(struct menudialog *dialog, s32 updown);
+s32 dialog_change_item_focus_horizontally(struct menudialog *dialog, s32 leftright);
+s32 dialog_change_item_focus(struct menudialog *dialog, s32 leftright, s32 updown);
+void menu_open_dialog(struct menudialogdef *dialogdef, struct menudialog *arg1, struct menu *menu);
+void menu_push_dialog(struct menudialogdef *dialogdef);
 
 #if VERSION >= VERSION_NTSC_1_0
 bool func0f0f3220(s32 arg0);
@@ -56,62 +56,62 @@ bool func0f0f3220(s32 arg0);
 void func0f0f3220(s32 arg0);
 #endif
 
-void menuCloseDialog(void);
-void menuUpdateCurFrame(void);
-void menuPopDialog(void);
+void menu_close_dialog(void);
+void menu_update_cur_frame(void);
+void menu_pop_dialog(void);
 void func0f0f3704(struct menudialogdef *dialogdef);
-void menuConfigureModel(struct menumodel *menumodel, f32 x, f32 y, f32 z, f32 rotx, f32 roty, f32 rotz, f32 scale, u8 flags);
-void menuUnsetModel(struct menumodel *menumodel);
-Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype);
-void menuGetTeamTitlebarColours(u32 *top, u32 *middle, u32 *bottom);
-Gfx *menuApplyScissor(Gfx *gdl);
-Gfx *dialogRender(Gfx *gdl, struct menudialog *dialog, struct menu *menu, bool lightweight);
-void menuGetContPads(s8 *contpadnum1, s8 *contpadnum2);
+void menu_configure_model(struct menumodel *menumodel, f32 x, f32 y, f32 z, f32 rotx, f32 roty, f32 rotz, f32 scale, u8 flags);
+void menu_unset_model(struct menumodel *menumodel);
+Gfx *menu_render_model(Gfx *gdl, struct menumodel *menumodel, s32 modeltype);
+void menu_get_team_titlebar_colours(u32 *top, u32 *middle, u32 *bottom);
+Gfx *menu_apply_scissor(Gfx *gdl);
+Gfx *dialog_render(Gfx *gdl, struct menudialog *dialog, struct menu *menu, bool lightweight);
+void menu_get_cont_pads(s8 *contpadnum1, s8 *contpadnum2);
 void func0f0f7594(s32 arg0, s32 *vdir, s32 *hdir);
 
 #if VERSION >= VERSION_JPN_FINAL
-void menuFindAvailableSize(s32 *xmin, s32 *ymin, s32 *xmax, s32 *ymax, struct menudialog *dialog);
+void menu_find_available_size(s32 *xmin, s32 *ymin, s32 *xmax, s32 *ymax, struct menudialog *dialog);
 #else
-void menuFindAvailableSize(s32 *xmin, s32 *ymin, s32 *xmax, s32 *ymax);
+void menu_find_available_size(s32 *xmin, s32 *ymin, s32 *xmax, s32 *ymax);
 #endif
 
-void dialogCalculatePosition(struct menudialog *dialog);
-void menuClose(void);
+void dialog_calculate_position(struct menudialog *dialog);
+void menu_close(void);
 void func0f0f8120(void);
 void func0f0f820c(struct menudialogdef *dialogdef, s32 root);
-void menuSetBackground(s32 bg);
+void menu_set_background(s32 bg);
 void func0f0f8300(void);
-void menuPushRootDialog(struct menudialogdef *dialogdef, s32 arg1);
+void menu_push_root_dialog(struct menudialogdef *dialogdef, s32 arg1);
 void func0f0f85e0(struct menudialogdef *dialogdef, s32 root);
-Gfx *menuRenderDialog(Gfx *gdl, struct menudialog *dialog, struct menu *menu, bool lightweight);
-Gfx *menuRenderDialogs(Gfx *gdl);
-void menuResetModel(struct menumodel *menumodel, u32 allocationlen, bool allocate);
-void menuReset(void);
-void menuSwipe(s32 direction);
-void dialogTick(struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags);
-void dialogInitItems(struct menudialog *dialog);
+Gfx *menu_render_dialog(Gfx *gdl, struct menudialog *dialog, struct menu *menu, bool lightweight);
+Gfx *menu_render_dialogs(Gfx *gdl);
+void menu_reset_model(struct menumodel *menumodel, u32 allocationlen, bool allocate);
+void menu_reset(void);
+void menu_swipe(s32 direction);
+void dialog_tick(struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags);
+void dialog_init_items(struct menudialog *dialog);
 void func0f0fa6ac(void);
-void menuProcessInput(void);
-Gfx *menuRenderBackgroundLayer1(Gfx *gdl, u8 bg, f32 frac);
-Gfx *menuRenderBackgroundLayer2(Gfx *gdl, u8 bg, f32 frac);
-Gfx *menuRender(Gfx *gdl);
-u32 menuChooseMusic(void);
-u32 menuGetRoot(void);
-void menuPushPakDialogForPlayer(struct menudialogdef *dialogdef, s32 playernum, s32 arg2);
-char *menuTextSaveDeviceName(struct menuitem *item);
-s32 menuPakNumToPlayerNum(s32 paknum);
-bool menuIsReadyForPakError(s32 device, s32 arg1);
-void menuPushPakErrorDialog(s32 arg0, s32 arg1);
+void menu_process_input(void);
+Gfx *menu_render_background_layer1(Gfx *gdl, u8 bg, f32 frac);
+Gfx *menu_render_background_layer2(Gfx *gdl, u8 bg, f32 frac);
+Gfx *menu_render(Gfx *gdl);
+u32 menu_choose_music(void);
+u32 menu_get_root(void);
+void menu_push_pak_dialog_for_player(struct menudialogdef *dialogdef, s32 playernum, s32 arg2);
+char *menu_text_save_device_name(struct menuitem *item);
+s32 menu_pak_num_to_player_num(s32 paknum);
+bool menu_is_ready_for_pak_error(s32 device, s32 arg1);
+void menu_push_pak_error_dialog(s32 arg0, s32 arg1);
 void func0f0fd494(struct coord *pos);
 void func0f0fd548(s32 arg0);
-struct menudialog *menuIsDialogOpen(struct menudialogdef *dialogdef);
-struct chrdata *currentPlayerGetCommandingAibot(void);
+struct menudialog *menu_is_dialog_open(struct menudialogdef *dialogdef);
+struct chrdata *current_player_get_commanding_aibot(void);
 
 MenuItemHandlerResult menuhandler000fcc34(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult amPickTargetMenuList(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerRepairPak(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerRetrySavePak(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerWarnRepairPak(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult am_pick_target_menu_list(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_repair_pak(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_retry_save_pak(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_warn_repair_pak(s32 operation, struct menuitem *item, union handlerdata *data);
 
 extern const char var7f1b2658[];
 extern const char var7f1b265c[];

src/include/game/menugfx.h

@@ -4,36 +4,36 @@
 #include "data.h"
 #include "types.h"
 
-void menugfxCreateBlur(void);
-Gfx *menugfxRenderBgBlur(Gfx *gdl, u32 colour, s16 arg2, s16 arg3);
-Gfx *menugfxRenderDialogBackground(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, struct menudialog *dialog, u32 colour1, u32 colour2, f32 arg8);
-Gfx *menugfxRenderBgGreenHaze(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
-Gfx *menugfxDrawDropdownBackground(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
+void menugfx_create_blur(void);
+Gfx *menugfx_render_bg_blur(Gfx *gdl, u32 colour, s16 arg2, s16 arg3);
+Gfx *menugfx_render_dialog_background(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, struct menudialog *dialog, u32 colour1, u32 colour2, f32 arg8);
+Gfx *menugfx_render_bg_green_haze(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
+Gfx *menugfx_draw_dropdown_background(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2);
 
 #if VERSION >= VERSION_NTSC_1_0
-Gfx *menugfxDrawListGroupHeader(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 x3, u8 alpha);
+Gfx *menugfx_draw_list_group_header(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 x3, u8 alpha);
 #else
-Gfx *menugfxDrawListGroupHeader(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 x3);
+Gfx *menugfx_draw_list_group_header(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 x3);
 #endif
 
-Gfx *menugfxRenderGradient(Gfx *gdl, s32 x, s32 y, s32 width, s32 height, u32 colour1, u32 colour2, u32 colour3);
-Gfx *menugfxRenderSlider(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 markerx, u32 colour);
+Gfx *menugfx_render_gradient(Gfx *gdl, s32 x, s32 y, s32 width, s32 height, u32 colour1, u32 colour2, u32 colour3);
+Gfx *menugfx_render_slider(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, s32 markerx, u32 colour);
 Gfx *menugfx0f0e2348(Gfx *gdl);
 Gfx *menugfx0f0e2498(Gfx *gdl);
-Gfx *menugfxDrawTri2(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2, bool arg7);
-Gfx *menugfxDrawLine(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
-Gfx *menugfxDrawProjectedLine(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
-Gfx *menugfxDrawShimmer(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour, bool arg6, s32 arg7, bool lefttoright);
-Gfx *menugfxDrawDialogBorderLine(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
-Gfx *menugfxDrawFilledRect(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
-Gfx *menugfxDrawCarouselChevron(Gfx *gdl, s32 x, s32 y, s32 size, s32 direction, u32 colour1, u32 colour2);
-Gfx *menugfxDrawDialogChevron(Gfx *gdl, s32 x, s32 y, s32 arg2, s32 arg3, u32 colour1, u32 colour2, f32 arg7);
-Gfx *menugfxDrawCheckbox(Gfx *gdl, s32 x, s32 y, s32 size, bool fill, u32 bordercolour, u32 fillcolour);
-Gfx *menugfxRenderBgFailure(Gfx *gdl);
-Gfx *menugfxRenderBgCone(Gfx *gdl);
-Gfx *menugfxRenderBgFailureCopy(Gfx *gdl);
-void menugfxFreeParticles(void);
-u32 menugfxGetParticleArraySize(void);
-Gfx *menugfxRenderBgSuccess(Gfx *gdl);
+Gfx *menugfx_draw_tri2(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2, bool arg7);
+Gfx *menugfx_draw_line(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
+Gfx *menugfx_draw_projected_line(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
+Gfx *menugfx_draw_shimmer(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour, bool arg6, s32 arg7, bool lefttoright);
+Gfx *menugfx_draw_dialog_border_line(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
+Gfx *menugfx_draw_filled_rect(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2);
+Gfx *menugfx_draw_carousel_chevron(Gfx *gdl, s32 x, s32 y, s32 size, s32 direction, u32 colour1, u32 colour2);
+Gfx *menugfx_draw_dialog_chevron(Gfx *gdl, s32 x, s32 y, s32 arg2, s32 arg3, u32 colour1, u32 colour2, f32 arg7);
+Gfx *menugfx_draw_checkbox(Gfx *gdl, s32 x, s32 y, s32 size, bool fill, u32 bordercolour, u32 fillcolour);
+Gfx *menugfx_render_bg_failure(Gfx *gdl);
+Gfx *menugfx_render_bg_cone(Gfx *gdl);
+Gfx *menugfx_render_bg_failure_copy(Gfx *gdl);
+void menugfx_free_particles(void);
+u32 menugfx_get_particle_array_size(void);
+Gfx *menugfx_render_bg_success(Gfx *gdl);
 
 #endif

src/include/game/menuitem.h

@@ -5,78 +5,78 @@
 #include "types.h"
 
 s32 menuitem0f0e5d2c(s32 arg0, struct menuitem *item);
-s16 menuitemListGetOffsetY(s16 optionindex, struct menuitem *item);
-Gfx *menuitemListRenderHeader(Gfx *gdl, s16 x1, s16 y1, s16 width, s16 arg4, s16 height, char *text, struct menudialog *dialog);
-Gfx *menuitemListOverlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2);
-Gfx *menuitemListRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemListTick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+s16 menuitem_list_get_offset_y(s16 optionindex, struct menuitem *item);
+Gfx *menuitem_list_render_header(Gfx *gdl, s16 x1, s16 y1, s16 width, s16 arg4, s16 height, char *text, struct menudialog *dialog);
+Gfx *menuitem_list_overlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2);
+Gfx *menuitem_list_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_list_tick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
 
-void menuitemDropdownInit(struct menuitem *item, union menuitemdata *data);
-Gfx *menuitemDropdownRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemDropdownTick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_dropdown_init(struct menuitem *item, union menuitemdata *data);
+Gfx *menuitem_dropdown_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_dropdown_tick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
 
-Gfx *menuitemDropdownOverlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
-bool menuitemKeyboardIsStringEmptyOrSpaces(char *text);
-Gfx *menuitemKeyboardRender(Gfx *gdl, struct menurendercontext *thing);
-bool menuitemKeyboardTick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-void menuitemKeyboardInit(struct menuitem *item, union menuitemdata *data);
+Gfx *menuitem_dropdown_overlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
+bool menuitem_keyboard_is_string_empty_or_spaces(char *text);
+Gfx *menuitem_keyboard_render(Gfx *gdl, struct menurendercontext *thing);
+bool menuitem_keyboard_tick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_keyboard_init(struct menuitem *item, union menuitemdata *data);
 
-Gfx *menuitemSeparatorRender(Gfx *gdl, struct menurendercontext *context);
+Gfx *menuitem_separator_render(Gfx *gdl, struct menurendercontext *context);
 
-Gfx *menuitemObjectivesRenderOne(Gfx *gdl, struct menudialog *dialog, s32 index, s32 position, s16 objx, s16 objy, s16 width, s16 height, bool withstatus, bool narrow);
-Gfx *menuitemObjectivesRender(Gfx *gdl, struct menurendercontext *context);
+Gfx *menuitem_objectives_render_one(Gfx *gdl, struct menudialog *dialog, s32 index, s32 position, s16 objx, s16 objy, s16 width, s16 height, bool withstatus, bool narrow);
+Gfx *menuitem_objectives_render(Gfx *gdl, struct menurendercontext *context);
 
-Gfx *menuitemModelRender(Gfx *gdl, struct menurendercontext *context);
+Gfx *menuitem_model_render(Gfx *gdl, struct menurendercontext *context);
 
-Gfx *menuitemLabelRender(Gfx *gdl, struct menurendercontext *context);
+Gfx *menuitem_label_render(Gfx *gdl, struct menurendercontext *context);
 
-Gfx *menuitemMeterRender(Gfx *gdl, struct menurendercontext *context);
+Gfx *menuitem_meter_render(Gfx *gdl, struct menurendercontext *context);
 
-Gfx *menuitemSelectableRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemSelectableTick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
+Gfx *menuitem_selectable_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_selectable_tick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
 
-Gfx *menuitemSliderRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemSliderTick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-void menuitemSliderInit(union menuitemdata *data);
+Gfx *menuitem_slider_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_slider_tick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_slider_init(union menuitemdata *data);
 
-Gfx *menuitemCarouselRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemCarouselTick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
+Gfx *menuitem_carousel_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_carousel_tick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
 
-Gfx *menuitemCheckboxRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemCheckboxTick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
+Gfx *menuitem_checkbox_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_checkbox_tick(struct menuitem *item, struct menuinputs *inputs, u32 tickflags);
 
-char *menuitemScrollableGetText(u32 type);
-Gfx *menuitemScrollableRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemScrollableTick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-void menuitemScrollableInit(union menuitemdata *data);
+char *menuitem_scrollable_get_text(u32 type);
+Gfx *menuitem_scrollable_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_scrollable_tick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_scrollable_init(union menuitemdata *data);
 
-Gfx *menuitemMarqueeRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemMarqueeTick(struct menuitem *item, union menuitemdata *data);
-void menuitemMarqueeInit(union menuitemdata *data);
+Gfx *menuitem_marquee_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_marquee_tick(struct menuitem *item, union menuitemdata *data);
+void menuitem_marquee_init(union menuitemdata *data);
 
-Gfx *menuitem07Render(Gfx *gdl);
+Gfx *menuitem07_render(Gfx *gdl);
 
-Gfx *menuitemRankingRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemRankingTick(struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-void menuitemRankingInit(union menuitemdata *data);
+Gfx *menuitem_ranking_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_ranking_tick(struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_ranking_init(union menuitemdata *data);
 
-Gfx *menuitemPlayerStatsRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemPlayerStatsTick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-Gfx *menuitemPlayerStatsOverlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
-void menuitemPlayerStatsInit(struct menuitem *item, union menuitemdata *data);
+Gfx *menuitem_player_stats_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_player_stats_tick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+Gfx *menuitem_player_stats_overlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
+void menuitem_player_stats_init(struct menuitem *item, union menuitemdata *data);
 
-Gfx *menuitemControllerRenderLine(Gfx *gdl, s32 speed, s32 x1, s32 y1, s32 x2, s32 y2);
-Gfx *menuitemControllerRenderTexture(Gfx *gdl, s32 x, s32 y, s32 texturenum, u32 alpha);
-Gfx *menuitemControllerRenderLines(Gfx *gdl, struct menurendercontext *context, s32 firstindex, s32 lastindex, s32 padx, s32 pady, u32 alpha);
-u16 menuitemControllerGetButtonAction(s32 mode, s32 buttonnum);
-Gfx *menuitemControllerRenderText(Gfx *gdl, s32 curmode, struct menurendercontext *context, s32 padx, s32 pady, u32 valuecolour, u32 labelcolour, s8 prevmode);
-Gfx *menuitemControllerRenderPad(Gfx *gdl, struct menurendercontext *context, s32 padx, s32 pady, s32 curmode, u32 alpha, u32 colour1, u32 colour2, s8 prevmode);
-Gfx *menuitemControllerRender(Gfx *gdl, struct menurendercontext *context);
-void menuitemControllerInit(union menuitemdata *data);
+Gfx *menuitem_controller_render_line(Gfx *gdl, s32 speed, s32 x1, s32 y1, s32 x2, s32 y2);
+Gfx *menuitem_controller_render_texture(Gfx *gdl, s32 x, s32 y, s32 texturenum, u32 alpha);
+Gfx *menuitem_controller_render_lines(Gfx *gdl, struct menurendercontext *context, s32 firstindex, s32 lastindex, s32 padx, s32 pady, u32 alpha);
+u16 menuitem_controller_get_button_action(s32 mode, s32 buttonnum);
+Gfx *menuitem_controller_render_text(Gfx *gdl, s32 curmode, struct menurendercontext *context, s32 padx, s32 pady, u32 valuecolour, u32 labelcolour, s8 prevmode);
+Gfx *menuitem_controller_render_pad(Gfx *gdl, struct menurendercontext *context, s32 padx, s32 pady, s32 curmode, u32 alpha, u32 colour1, u32 colour2, s8 prevmode);
+Gfx *menuitem_controller_render(Gfx *gdl, struct menurendercontext *context);
+void menuitem_controller_init(union menuitemdata *data);
 
-Gfx *menuitemRender(Gfx *gdl, struct menurendercontext *context);
-bool menuitemTick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
-void menuitemInit(struct menuitem *item, union menuitemdata *data);
-Gfx *menuitemOverlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
+Gfx *menuitem_render(Gfx *gdl, struct menurendercontext *context);
+bool menuitem_tick(struct menuitem *item, struct menudialog *dialog, struct menuinputs *inputs, u32 tickflags, union menuitemdata *data);
+void menuitem_init(struct menuitem *item, union menuitemdata *data);
+Gfx *menuitem_overlay(Gfx *gdl, s16 x, s16 y, s16 x2, s16 y2, struct menuitem *item, struct menudialog *dialog, union menuitemdata *data);
 
 #endif

src/include/game/modeldef.h

@@ -5,8 +5,8 @@
 #include "types.h"
 
 void modeldef0f1a7560(struct modeldef *modeldef, u16 filenum, u32 arg2, struct modeldef *modeldef2, struct texpool *texpool, bool arg5);
-void modelPromoteTypeToPointer(struct modeldef *modeldef);
-struct modeldef *modeldefLoad(u16 fileid, u8 *arg1, s32 arg2, struct texpool *arg3);
-struct modeldef *modeldefLoadToNew(u16 fileid);
+void model_promote_type_to_pointer(struct modeldef *modeldef);
+struct modeldef *modeldef_load(u16 fileid, u8 *arg1, s32 arg2, struct texpool *arg3);
+struct modeldef *modeldef_load_to_new(u16 fileid);
 
 #endif

src/include/game/modelmgr.h

@@ -4,14 +4,14 @@
 #include "data.h"
 #include "types.h"
 
-bool modelmgrCanSlotFitRwdata(struct model *modelslot, struct modeldef *modeldef);
-void modelmgrPrintCounts(void);
-struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool arg1);
-struct model *modelmgrInstantiateModelWithoutAnim(struct modeldef *modeldef);
-void modelmgrFreeModel(struct model *model);
-struct model *modelmgrInstantiateModelWithAnim(struct modeldef *modeldef);
-void modelmgrAttachHead(struct model *model, struct modelnode *node, struct modeldef *headmodeldef);
-struct anim *modelmgrInstantiateAnim(void);
-void modelmgrFreeAnim(struct anim *anim);
+bool modelmgr_can_slot_fit_rwdata(struct model *modelslot, struct modeldef *modeldef);
+void modelmgr_print_counts(void);
+struct model *modelmgr_instantiate_model(struct modeldef *modeldef, bool arg1);
+struct model *modelmgr_instantiate_model_without_anim(struct modeldef *modeldef);
+void modelmgr_free_model(struct model *model);
+struct model *modelmgr_instantiate_model_with_anim(struct modeldef *modeldef);
+void modelmgr_attach_head(struct model *model, struct modelnode *node, struct modeldef *headmodeldef);
+struct anim *modelmgr_instantiate_anim(void);
+void modelmgr_free_anim(struct anim *anim);
 
 #endif

src/include/game/mplayer/ingame.h

@@ -4,26 +4,26 @@
 #include "data.h"
 #include "types.h"
 
-MenuItemHandlerResult mpStatsForPlayerDropdownHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextInGameLimit(struct menuitem *item);
-char *menutextPauseOrUnpause(s32 arg0);
-char *menutextMatchTime(s32 arg0);
-char *mpMenuTextWeaponDescription(struct menuitem *item);
-char *mpMenuTitleStatsFor(struct menudialogdef *dialogdef);
-char *mpMenuTextWeaponOfChoiceName(struct menuitem *item);
-char *mpMenuTextAward1(struct menuitem *item);
-char *mpMenuTextAward2(struct menuitem *item);
-char *mpMenuTextPlacementWithSuffix(struct menuitem *item);
-MenuItemHandlerResult mpPlacementMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult mpAwardsMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult mpPlayerTitleMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextPlayerTitle(s32 arg0);
-MenuItemHandlerResult mpConfirmPlayerNameHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-void mpPushPauseDialog(void);
-void mpPushEndscreenDialog(u32 arg0, u32 playernum);
-MenuItemHandlerResult menuhandlerMpEndGame(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult mp_stats_for_player_dropdown_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_in_game_limit(struct menuitem *item);
+char *menutext_pause_or_unpause(s32 arg0);
+char *menutext_match_time(s32 arg0);
+char *mp_menu_text_weapon_description(struct menuitem *item);
+char *mp_menu_title_stats_for(struct menudialogdef *dialogdef);
+char *mp_menu_text_weapon_of_choice_name(struct menuitem *item);
+char *mp_menu_text_award1(struct menuitem *item);
+char *mp_menu_text_award2(struct menuitem *item);
+char *mp_menu_text_placement_with_suffix(struct menuitem *item);
+MenuItemHandlerResult mp_placement_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult mp_awards_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult mp_player_title_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_player_title(s32 arg0);
+MenuItemHandlerResult mp_confirm_player_name_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+void mp_push_pause_dialog(void);
+void mp_push_endscreen_dialog(u32 arg0, u32 playernum);
+MenuItemHandlerResult menuhandler_mp_end_game(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler00178018(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpInGameLimitLabel(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpPause(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_in_game_limit_label(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_pause(s32 operation, struct menuitem *item, union handlerdata *data);
 
 #endif

src/include/game/mplayer/mplayer.h

@@ -4,119 +4,119 @@
 #include "data.h"
 #include "types.h"
 
-f32 mpHandicapToDamageScale(u8 value);
+f32 mp_handicap_to_damage_scale(u8 value);
 void func0f187838(struct mpchrconfig *mpchr);
-void mpStartMatch(void);
-void mpReset(void);
-void mpCalculateTeamIsOnlyAi(void);
+void mp_start_match(void);
+void mp_reset(void);
+void mp_calculate_team_is_only_ai(void);
 void func0f187fbc(s32 playernum);
 void func0f187fec(void);
-void mpPlayerSetDefaults(s32 playernum, bool autonames);
+void mp_player_set_defaults(s32 playernum, bool autonames);
 void func0f1881d4(s32 index);
-void mpInit(void);
-void mpGetTeamsWithDefaultName(u8 *mask);
-void mpSetTeamNamesToDefault(u8 mask);
-void mpSetDefaultNamesIfEmpty(void);
-s32 mpCalculateTeamScoreLimit(void);
-void mpApplyLimits(void);
-s32 mpGetPlayerRankings(struct ranking *rankings);
-s32 mpCalculateTeamScore(s32 arg0, s32 *arg1);
-s32 mpGetTeamRankings(struct ranking *rankings);
+void mp_init(void);
+void mp_get_teams_with_default_name(u8 *mask);
+void mp_set_team_names_to_default(u8 mask);
+void mp_set_default_names_if_empty(void);
+s32 mp_calculate_team_score_limit(void);
+void mp_apply_limits(void);
+s32 mp_get_player_rankings(struct ranking *rankings);
+s32 mp_calculate_team_score(s32 arg0, s32 *arg1);
+s32 mp_get_team_rankings(struct ranking *rankings);
 s32 func0f188bcc(void);
-s32 mpGetNumWeaponOptions(void);
-char *mpGetWeaponLabel(s32 weaponnum);
-void mpSetWeaponSlot(s32 slot, s32 mpweaponnum);
-s32 mpGetWeaponSlot(s32 slot);
-struct mpweapon *mpGetMpWeaponByLocation(s32 locationindex);
-s32 mpCountWeaponSetThing(s32 weaponsetindex);
+s32 mp_get_num_weapon_options(void);
+char *mp_get_weapon_label(s32 weaponnum);
+void mp_set_weapon_slot(s32 slot, s32 mpweaponnum);
+s32 mp_get_weapon_slot(s32 slot);
+struct mpweapon *mp_get_mp_weapon_by_location(s32 locationindex);
+s32 mp_count_weapon_set_thing(s32 weaponsetindex);
 s32 func0f188f9c(s32 arg0);
 s32 func0f189058(bool full);
 s32 func0f189088(void);
-char *mpGetWeaponSetName(s32 arg0);
+char *mp_get_weapon_set_name(s32 arg0);
 void func0f18913c(void);
-void mpApplyWeaponSet(void);
-void mpSetWeaponSet(s32 weaponsetnum);
+void mp_apply_weapon_set(void);
+void mp_set_weapon_set(s32 weaponsetnum);
 void func0f1895e8(void);
-s32 mpGetWeaponSet(void);
-bool mpIsPaused(void);
-void mpSetPaused(u8 mode);
-Gfx *mpRenderModalText(Gfx *gdl);
-s32 mpFindMaxInt(s32 playercount, s32 val0, s32 val1, s32 val2, s32 val3);
-s32 mpFindMinInt(s32 playercount, s32 val0, s32 val1, s32 val2, s32 val3);
-s32 mpFindMaxFloat(s32 playercount, f32 val0, f32 val1, f32 val2, f32 val3);
-s32 mpFindMinFloat(s32 playercount, f32 val0, f32 val1, f32 val2, f32 val3);
-void mpCalculatePlayerTitle(struct mpplayerconfig *mpplayer);
-void mpCalculateAwards(void);
-void mpEndMatch(void);
-s32 mpGetNumHeads2(void);
-s32 mpGetNumHeads(void);
-s32 mpGetHeadId(u8 headnum);
-s32 mpGetHeadRequiredFeature(u8 headnum);
-s32 mpGetBeauHeadId(u8 headnum);
-u32 mpGetNumBodies(void);
-s32 mpGetBodyId(u8 bodynum);
-s32 mpGetMpbodynumByBodynum(u16 bodynum);
-char *mpGetBodyName(u8 mpbodynum);
-u8 mpGetBodyRequiredFeature(u8 bodynum);
-s32 mpGetMpheadnumByMpbodynum(s32 bodynum);
-s32 mpChooseRandomLockPlayer(void);
-bool mpSetLock(s32 locktype, s32 playernum);
-s32 mpGetLockType(void);
-u32 mpGetLockPlayerNum(void);
-bool mpIsPlayerLockedOut(s32 playernum);
-void mpCalculateLockIfLastWinnerOrLoser(void);
-bool mpIsTrackUnlocked(s32 tracknum);
-s32 mpGetTrackSlotIndex(s32 tracknum);
-s32 mpGetTrackNumAtSlotIndex(s32 slotindex);
-s32 mpGetNumUnlockedTracks(void);
-s32 mpGetTrackMusicNum(s32 slotindex);
-char *mpGetTrackName(s32 slotindex);
-void mpSetUsingMultipleTunes(bool enable);
-bool mpGetUsingMultipleTunes(void);
-bool mpIsMultiTrackSlotEnabled(s32 slot);
-void mpSetMultiTrackSlotEnabled(s32 slot, bool enable);
-void mpSetTrackSlotEnabled(s32 slot);
-void mpEnableAllMultiTracks(void);
-void mpDisableAllMultiTracks(void);
-void mpRandomiseMultiTracks(void);
-void mpSetTrackToRandom(void);
-s32 mpGetCurrentTrackSlotNum(void);
-s32 mpChooseTrack(void);
-struct mpchrconfig *mpGetChrConfigBySlotNum(s32 slot);
-s32 mpGetChrIndexBySlotNum(s32 slot);
-s32 mpGetNumChrs(void);
-u8 mpFindUnusedTeamNum(void);
-void mpCreateBotFromProfile(s32 botnum, u8 difficulty);
-void mpSetBotDifficulty(s32 botnum, s32 difficulty);
-s32 mpGetSlotForNewBot(void);
-void mpRemoveSimulant(s32 index);
-bool mpHasSimulants(void);
-bool mpHasUnusedBotSlots(void);
-bool mpIsSimSlotEnabled(s32 slot);
-s32 mpFindBotProfile(s32 type, s32 difficulty);
-void mpGenerateBotNames(void);
-s32 mpPlayerGetIndex(struct chrdata *chr);
-struct chrdata *mpGetChrFromPlayerIndex(s32 index);
+s32 mp_get_weapon_set(void);
+bool mp_is_paused(void);
+void mp_set_paused(u8 mode);
+Gfx *mp_render_modal_text(Gfx *gdl);
+s32 mp_find_max_int(s32 playercount, s32 val0, s32 val1, s32 val2, s32 val3);
+s32 mp_find_min_int(s32 playercount, s32 val0, s32 val1, s32 val2, s32 val3);
+s32 mp_find_max_float(s32 playercount, f32 val0, f32 val1, f32 val2, f32 val3);
+s32 mp_find_min_float(s32 playercount, f32 val0, f32 val1, f32 val2, f32 val3);
+void mp_calculate_player_title(struct mpplayerconfig *mpplayer);
+void mp_calculate_awards(void);
+void mp_end_match(void);
+s32 mp_get_num_heads2(void);
+s32 mp_get_num_heads(void);
+s32 mp_get_head_id(u8 headnum);
+s32 mp_get_head_required_feature(u8 headnum);
+s32 mp_get_beau_head_id(u8 headnum);
+u32 mp_get_num_bodies(void);
+s32 mp_get_body_id(u8 bodynum);
+s32 mp_get_mpbodynum_by_bodynum(u16 bodynum);
+char *mp_get_body_name(u8 mpbodynum);
+u8 mp_get_body_required_feature(u8 bodynum);
+s32 mp_get_mpheadnum_by_mpbodynum(s32 bodynum);
+s32 mp_choose_random_lock_player(void);
+bool mp_set_lock(s32 locktype, s32 playernum);
+s32 mp_get_lock_type(void);
+u32 mp_get_lock_player_num(void);
+bool mp_is_player_locked_out(s32 playernum);
+void mp_calculate_lock_if_last_winner_or_loser(void);
+bool mp_is_track_unlocked(s32 tracknum);
+s32 mp_get_track_slot_index(s32 tracknum);
+s32 mp_get_track_num_at_slot_index(s32 slotindex);
+s32 mp_get_num_unlocked_tracks(void);
+s32 mp_get_track_music_num(s32 slotindex);
+char *mp_get_track_name(s32 slotindex);
+void mp_set_using_multiple_tunes(bool enable);
+bool mp_get_using_multiple_tunes(void);
+bool mp_is_multi_track_slot_enabled(s32 slot);
+void mp_set_multi_track_slot_enabled(s32 slot, bool enable);
+void mp_set_track_slot_enabled(s32 slot);
+void mp_enable_all_multi_tracks(void);
+void mp_disable_all_multi_tracks(void);
+void mp_randomise_multi_tracks(void);
+void mp_set_track_to_random(void);
+s32 mp_get_current_track_slot_num(void);
+s32 mp_choose_track(void);
+struct mpchrconfig *mp_get_chr_config_by_slot_num(s32 slot);
+s32 mp_get_chr_index_by_slot_num(s32 slot);
+s32 mp_get_num_chrs(void);
+u8 mp_find_unused_team_num(void);
+void mp_create_bot_from_profile(s32 botnum, u8 difficulty);
+void mp_set_bot_difficulty(s32 botnum, s32 difficulty);
+s32 mp_get_slot_for_new_bot(void);
+void mp_remove_simulant(s32 index);
+bool mp_has_simulants(void);
+bool mp_has_unused_bot_slots(void);
+bool mp_is_sim_slot_enabled(s32 slot);
+s32 mp_find_bot_profile(s32 type, s32 difficulty);
+void mp_generate_bot_names(void);
+s32 mp_player_get_index(struct chrdata *chr);
+struct chrdata *mp_get_chr_from_player_index(s32 index);
 s32 func0f18d074(s32 index);
 s32 func0f18d0e8(s32 arg0);
-void mpplayerfileLoadGunFuncs(struct savebuffer *buffer, s32 playernum);
-void mpplayerfileSaveGunFuncs(struct savebuffer *buffer, s32 playernum);
-void mpplayerfileLoadWad(s32 playernum, struct savebuffer *buffer, s32 arg2);
-void mpplayerfileSaveWad(s32 playernum, struct savebuffer *buffer);
-void mpplayerfileGetOverview(char *arg0, char *name, u32 *playtime);
-s32 mpplayerfileSave(s32 playernum, s32 device, s32 fileid, u16 deviceserial);
-s32 mpplayerfileLoad(s32 playernum, s32 device, s32 arg2, u16 deviceserial);
-s32 mpGetNumPresets(void);
-bool mpIsPresetUnlocked(s32 presetnum);
-s32 mpGetNumUnlockedPresets(void);
-char *mpGetPresetNameBySlot(s32 slot);
-void mpApplyConfig(struct mpconfigfull *mpconfig);
+void mpplayerfile_load_gun_funcs(struct savebuffer *buffer, s32 playernum);
+void mpplayerfile_save_gun_funcs(struct savebuffer *buffer, s32 playernum);
+void mpplayerfile_load_wad(s32 playernum, struct savebuffer *buffer, s32 arg2);
+void mpplayerfile_save_wad(s32 playernum, struct savebuffer *buffer);
+void mpplayerfile_get_overview(char *arg0, char *name, u32 *playtime);
+s32 mpplayerfile_save(s32 playernum, s32 device, s32 fileid, u16 deviceserial);
+s32 mpplayerfile_load(s32 playernum, s32 device, s32 arg2, u16 deviceserial);
+s32 mp_get_num_presets(void);
+bool mp_is_preset_unlocked(s32 presetnum);
+s32 mp_get_num_unlocked_presets(void);
+char *mp_get_preset_name_by_slot(s32 slot);
+void mp_apply_config(struct mpconfigfull *mpconfig);
 void mp0f18dec4(s32 arg0);
-void mpsetupfileLoadWad(struct savebuffer *buffer);
-void mpsetupfileSaveWad(struct savebuffer *buffer);
-void mpsetupfileGetOverview(char *arg0, char *filename, u16 *numsims, u16 *stagenum, u16 *scenarionum);
-s32 mpsetupfileSave(s32 device, s32 filenum, u16 deviceserial);
-s32 mpsetupfileLoad(s32 device, s32 filenum, u16 deviceserial);
+void mpsetupfile_load_wad(struct savebuffer *buffer);
+void mpsetupfile_save_wad(struct savebuffer *buffer);
+void mpsetupfile_get_overview(char *arg0, char *filename, u16 *numsims, u16 *stagenum, u16 *scenarionum);
+s32 mpsetupfile_save(s32 device, s32 filenum, u16 deviceserial);
+s32 mpsetupfile_load(s32 device, s32 filenum, u16 deviceserial);
 void func0f18e558(void);
 struct modeldef *func0f18e57c(s32 index, s32 *headnum);
 

src/include/game/mplayer/scenarios.h

@@ -16,18 +16,18 @@ struct mpscenariooverview {
 
 extern struct mpscenariooverview g_MpScenarioOverviews[6];
 
-MenuItemHandlerResult menuhandlerMpOpenOptions(s32 operation, struct menuitem *item, union handlerdata *data);
-void scenarioReadSave(struct savebuffer *buffer);
-void scenarioWriteSave(struct savebuffer *buffer);
-void scenarioInit(void);
-s32 scenarioNumProps(void);
-void scenarioInitProps(void);
-void scenarioTick(void);
-void scenarioTickChr(struct chrdata *chr);
-Gfx *scenarioRadarExtra(Gfx *gdl);
-bool scenarioRadarChr(Gfx **gdl, struct prop *prop);
-f32 scenarioChooseSpawnLocation(f32 chrradius, struct coord *pos, RoomNum *rooms, struct prop *prop);
-s32 scenarioGetMaxTeams(void);
-void scenarioHighlightRoom(RoomNum room, s32 *arg1, s32 *arg2, s32 *arg3);
+MenuItemHandlerResult menuhandler_mp_open_options(s32 operation, struct menuitem *item, union handlerdata *data);
+void scenario_read_save(struct savebuffer *buffer);
+void scenario_write_save(struct savebuffer *buffer);
+void scenario_init(void);
+s32 scenario_num_props(void);
+void scenario_init_props(void);
+void scenario_tick(void);
+void scenario_tick_chr(struct chrdata *chr);
+Gfx *scenario_radar_extra(Gfx *gdl);
+bool scenario_radar_chr(Gfx **gdl, struct prop *prop);
+f32 scenario_choose_spawn_location(f32 chrradius, struct coord *pos, RoomNum *rooms, struct prop *prop);
+s32 scenario_get_max_teams(void);
+void scenario_highlight_room(RoomNum room, s32 *arg1, s32 *arg2, s32 *arg3);
 
 #endif

src/include/game/mplayer/setup.h

@@ -4,178 +4,178 @@
 #include "data.h"
 #include "types.h"
 
-char *mpGetCurrentPlayerName(struct menuitem *item);
-s16 mpChooseRandomStage(void);
-MenuItemHandlerResult mpArenaMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextWeaponNameForSlot(struct menuitem *item);
-char *mpMenuTextSetupName(struct menuitem *item);
-MenuItemHandlerResult mpCharacterBodyMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpbodynum, s32 mpheadnum, bool isplayer);
+char *mp_get_current_player_name(struct menuitem *item);
+s16 mp_choose_random_stage(void);
+MenuItemHandlerResult mp_arena_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_weapon_name_for_slot(struct menuitem *item);
+char *mp_menu_text_setup_name(struct menuitem *item);
+MenuItemHandlerResult mp_character_body_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpbodynum, s32 mpheadnum, bool isplayer);
 MenuDialogHandlerResult menudialog0017a174(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult mpChallengesListHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextKills(struct menuitem *item);
-char *mpMenuTextDeaths(struct menuitem *item);
-char *mpMenuTextGamesPlayed(struct menuitem *item);
-char *mpMenuTextGamesWon(struct menuitem *item);
-char *mpMenuTextGamesLost(struct menuitem *item);
-char *mpMenuTextHeadShots(struct menuitem *item);
-char *mpMenuTextMedalAccuracy(struct menuitem *item);
-char *mpMenuTextMedalHeadShot(struct menuitem *item);
-char *mpMenuTextMedalKillMaster(struct menuitem *item);
-char *mpMenuTextMedalSurvivor(struct menuitem *item);
-char *mpMenuTextAmmoUsed(struct menuitem *item);
-char *mpMenuTextDistance(struct menuitem *item);
-char *mpMenuTextTime(struct menuitem *item);
-char *mpMenuTextAccuracy(struct menuitem *item);
-void mpFormatDamageValue(char *dst, f32 damage);
-char *mpMenuTextPainReceived(struct menuitem *item);
-char *mpMenuTextDamageDealt(struct menuitem *item);
-MenuItemHandlerResult mpMedalMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTitleStatsForPlayerName(struct menudialogdef *dialogdef);
-char *mpMenuTextUsernamePassword(struct menuitem *item);
-MenuItemHandlerResult mpCharacterHeadMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpheadnum, bool arg4);
-char *mpMenuTextBodyName(struct menuitem *item);
+MenuItemHandlerResult mp_challenges_list_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_kills(struct menuitem *item);
+char *mp_menu_text_deaths(struct menuitem *item);
+char *mp_menu_text_games_played(struct menuitem *item);
+char *mp_menu_text_games_won(struct menuitem *item);
+char *mp_menu_text_games_lost(struct menuitem *item);
+char *mp_menu_text_head_shots(struct menuitem *item);
+char *mp_menu_text_medal_accuracy(struct menuitem *item);
+char *mp_menu_text_medal_head_shot(struct menuitem *item);
+char *mp_menu_text_medal_kill_master(struct menuitem *item);
+char *mp_menu_text_medal_survivor(struct menuitem *item);
+char *mp_menu_text_ammo_used(struct menuitem *item);
+char *mp_menu_text_distance(struct menuitem *item);
+char *mp_menu_text_time(struct menuitem *item);
+char *mp_menu_text_accuracy(struct menuitem *item);
+void mp_format_damage_value(char *dst, f32 damage);
+char *mp_menu_text_pain_received(struct menuitem *item);
+char *mp_menu_text_damage_dealt(struct menuitem *item);
+MenuItemHandlerResult mp_medal_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_title_stats_for_player_name(struct menudialogdef *dialogdef);
+char *mp_menu_text_username_password(struct menuitem *item);
+MenuItemHandlerResult mp_character_head_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data, s32 mpheadnum, bool arg4);
+char *mp_menu_text_body_name(struct menuitem *item);
 void func0f17b8f0(void);
-MenuItemHandlerResult mpPlayerNameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult mpLoadSettingsMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextMpconfigMarquee(struct menuitem *item);
-MenuItemHandlerResult mpLoadPlayerMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpHandicapPlayer(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextHandicapPlayerName(struct menuitem *item);
-MenuItemHandlerResult mpAddChangeSimulantMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextSimulantDescription(struct menuitem *item);
+MenuItemHandlerResult mp_player_name_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult mp_load_settings_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_mpconfig_marquee(struct menuitem *item);
+MenuItemHandlerResult mp_load_player_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_handicap_player(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_handicap_player_name(struct menuitem *item);
+MenuItemHandlerResult mp_add_change_simulant_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_simulant_description(struct menuitem *item);
 MenuDialogHandlerResult menudialog0017ccfc(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult mpBotDifficultyMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTitleEditSimulant(struct menudialogdef *dialogdef);
-char *mpMenuTextSimulantName(struct menuitem *item);
-MenuItemHandlerResult menuhandlerMpNTeams(s32 operation, struct menuitem *item, union handlerdata *data, s32 numteams);
-char *mpMenuTextChrNameForTeamSetup(struct menuitem *item);
+MenuItemHandlerResult mp_bot_difficulty_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_title_edit_simulant(struct menudialogdef *dialogdef);
+char *mp_menu_text_simulant_name(struct menuitem *item);
+MenuItemHandlerResult menuhandler_mp_n_teams(s32 operation, struct menuitem *item, union handlerdata *data, s32 numteams);
+char *mp_menu_text_chr_name_for_team_setup(struct menuitem *item);
 MenuItemHandlerResult func0f17dac4(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextSelectTuneOrTunes(struct menuitem *item);
-MenuItemHandlerResult mpSelectTuneListHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextCurrentTrack(struct menuitem *item);
-MenuItemHandlerResult mpTeamNameMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextTeamName(struct menuitem *item);
+char *mp_menu_text_select_tune_or_tunes(struct menuitem *item);
+MenuItemHandlerResult mp_select_tune_list_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_current_track(struct menuitem *item);
+MenuItemHandlerResult mp_team_name_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_team_name(struct menuitem *item);
 char *func0f17e318(struct menudialogdef *dialogdef);
 MenuDialogHandlerResult menudialog0017e3fc(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult mpChallengesListMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-char *mpMenuTextChallengeName(struct menuitem *item);
-MenuDialogHandlerResult mpCombatChallengesMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-char *mpMenuTextSavePlayerOrCopy(struct menuitem *item);
-char *mpMenuTextArenaName(struct menuitem *item);
-char *mpMenuTextWeaponSetName(struct menuitem *item);
-void mpConfigureQuickTeamPlayers(void);
-void mpConfigureQuickTeamSimulants(void);
+MenuItemHandlerResult mp_challenges_list_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+char *mp_menu_text_challenge_name(struct menuitem *item);
+MenuDialogHandlerResult mp_combat_challenges_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+char *mp_menu_text_save_player_or_copy(struct menuitem *item);
+char *mp_menu_text_arena_name(struct menuitem *item);
+char *mp_menu_text_weapon_set_name(struct menuitem *item);
+void mp_configure_quick_team_players(void);
+void mp_configure_quick_team_simulants(void);
 void func0f17f428(void);
-MenuItemHandlerResult menuhandlerPlayerTeam(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpNumberOfSimulants(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSimulantsPerTeam(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult mpQuickTeamSimulantDifficultyHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-void mpCloseDialogsForNewSetup(void);
+MenuItemHandlerResult menuhandler_player_team(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_number_of_simulants(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_simulants_per_team(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult mp_quick_team_simulant_difficulty_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+void mp_close_dialogs_for_new_setup(void);
 void func0f17fcb0(s32 silent);
-MenuItemHandlerResult menuhandlerMpSlowMotion(s32 operation, struct menuitem *item, union handlerdata *data);
-void htbAddPad(s16 padnum);
-void htbRemoveAmmoCrateAtPad(s16 padnum);
-void htbReset(void);
-void htbCreateToken(void);
-Gfx *htbRenderHud(Gfx *gdl);
-void ctcInitProps(void);
-bool ctcHighlightProp(struct prop *prop, s32 *colour);
-void ctcAddPad(s32 *cmd);
-void ctcHighlightRoom(RoomNum roomnum, s32 *arg1, s32 *arg2, s32 *arg3);
-void kohTick(void);
-Gfx *kohRenderHud(Gfx *gdl);
-void kohAddHill(s32 *cmd);
-void kohHighlightRoom(RoomNum roomnum, s32 *arg1, s32 *arg2, s32 *arg3);
-void htmAddPad(s16 padnum);
-void htmReset(void);
-void htbCreateUplink(void);
-void htmInitProps(void);
-void htmTickChr(struct chrdata *chr);
-Gfx *htmRenderHud(Gfx *gdl);
-Gfx *htmRadarExtra(Gfx *gdl);
-void pacReset(void);
-bool pacHighlightProp(struct prop *prop, s32 *colour);
-void pacApplyNextVictim(void);
-void pacHandleDeath(s32 cplayernum, s32 vplayernum);
-void pacTick(void);
-Gfx *pacRenderHud(Gfx *gdl);
-bool pacRadarChr(Gfx **gdl, struct prop *prop);
-MenuDialogHandlerResult mpOptionsMenuDialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-char *mpMenuTextScenarioShortName(struct menuitem *item);
-char *mpMenuTextScenarioName(struct menuitem *item);
-MenuItemHandlerResult scenarioScenarioMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data);
-void scenarioCreateMatchStartHudmsgs(void);
-Gfx *scenarioRenderHud(Gfx *gdl);
-void scenarioCalculatePlayerScore(struct mpchrconfig *mpchr, s32 chrnum, s32 *arg2, s32 *arg3);
-bool scenarioHighlightProp(struct prop *prop, s32 *colour);
-void scenarioReset(void);
-struct prop *scenarioCreateObj(s32 modelnum, s16 padnum, f32 arg2, u32 flags, u32 flags2, u32 flags3);
-void scenarioCreateHudmsg(s32 playernum, char *message);
-bool scenarioChrsAreSameTeam(s32 playernum1, s32 playernum2);
-s32 scenarioPickUpBriefcase(struct chrdata *chr, struct prop *prop);
-void scenarioHandleDroppedToken(struct chrdata *chr, struct prop *prop);
-s32 scenarioPickUpUplink(struct chrdata *chr, struct prop *prop);
-void scenarioHandleActivatedProp(struct chrdata *chr, struct prop *prop);
-MenuItemHandlerResult menuhandlerMpDropOut(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTeamsLabel(s32 operation, struct menuitem *item, union handlerdata *data);
-s32 mpGetNumStages(void);
-MenuItemHandlerResult menuhandlerMpControlStyle(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpWeaponSlot(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpWeaponSetDropdown(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpControlCheckbox(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpAimControl(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpCheckboxOption(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTeamsEnabled(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpDisplayOptionCheckbox(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpConfirmSaveChr(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSetupName(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSaveSetupOverwrite(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSaveSetupCopy(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpCharacterBody(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpUsernamePassword(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpCharacterHead(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTimeLimitSlider(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpScoreLimitSlider(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTeamScoreLimitSlider(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpRestoreScoreDefaults(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpRestoreHandicapDefaults(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpReady(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpSimulant(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSimulantHead(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSimulantBody(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpDeleteSimulant(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpChangeSimulantType(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpClearAllSimulants(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpAddSimulant(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSimulantSlot(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpSimulants(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTwoTeams(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpThreeTeams(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpFourTeams(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpMaximumTeams(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpHumansVsSimulants(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpHumanSimulantPairs(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTeamSlot(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpSelectTune(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpMultipleTunes(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpTeamNameSlot(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_slow_motion(s32 operation, struct menuitem *item, union handlerdata *data);
+void htb_add_pad(s16 padnum);
+void htb_remove_ammo_crate_at_pad(s16 padnum);
+void htb_reset(void);
+void htb_create_token(void);
+Gfx *htb_render_hud(Gfx *gdl);
+void ctc_init_props(void);
+bool ctc_highlight_prop(struct prop *prop, s32 *colour);
+void ctc_add_pad(s32 *cmd);
+void ctc_highlight_room(RoomNum roomnum, s32 *arg1, s32 *arg2, s32 *arg3);
+void koh_tick(void);
+Gfx *koh_render_hud(Gfx *gdl);
+void koh_add_hill(s32 *cmd);
+void koh_highlight_room(RoomNum roomnum, s32 *arg1, s32 *arg2, s32 *arg3);
+void htm_add_pad(s16 padnum);
+void htm_reset(void);
+void htb_create_uplink(void);
+void htm_init_props(void);
+void htm_tick_chr(struct chrdata *chr);
+Gfx *htm_render_hud(Gfx *gdl);
+Gfx *htm_radar_extra(Gfx *gdl);
+void pac_reset(void);
+bool pac_highlight_prop(struct prop *prop, s32 *colour);
+void pac_apply_next_victim(void);
+void pac_handle_death(s32 cplayernum, s32 vplayernum);
+void pac_tick(void);
+Gfx *pac_render_hud(Gfx *gdl);
+bool pac_radar_chr(Gfx **gdl, struct prop *prop);
+MenuDialogHandlerResult mp_options_menu_dialog(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+char *mp_menu_text_scenario_short_name(struct menuitem *item);
+char *mp_menu_text_scenario_name(struct menuitem *item);
+MenuItemHandlerResult scenario_scenario_menu_handler(s32 operation, struct menuitem *item, union handlerdata *data);
+void scenario_create_match_start_hudmsgs(void);
+Gfx *scenario_render_hud(Gfx *gdl);
+void scenario_calculate_player_score(struct mpchrconfig *mpchr, s32 chrnum, s32 *arg2, s32 *arg3);
+bool scenario_highlight_prop(struct prop *prop, s32 *colour);
+void scenario_reset(void);
+struct prop *scenario_create_obj(s32 modelnum, s16 padnum, f32 arg2, u32 flags, u32 flags2, u32 flags3);
+void scenario_create_hudmsg(s32 playernum, char *message);
+bool scenario_chrs_are_same_team(s32 playernum1, s32 playernum2);
+s32 scenario_pick_up_briefcase(struct chrdata *chr, struct prop *prop);
+void scenario_handle_dropped_token(struct chrdata *chr, struct prop *prop);
+s32 scenario_pick_up_uplink(struct chrdata *chr, struct prop *prop);
+void scenario_handle_activated_prop(struct chrdata *chr, struct prop *prop);
+MenuItemHandlerResult menuhandler_mp_drop_out(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_teams_label(s32 operation, struct menuitem *item, union handlerdata *data);
+s32 mp_get_num_stages(void);
+MenuItemHandlerResult menuhandler_mp_control_style(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_weapon_slot(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_weapon_set_dropdown(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_control_checkbox(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_aim_control(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_checkbox_option(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_teams_enabled(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_display_option_checkbox(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_confirm_save_chr(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_setup_name(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_save_setup_overwrite(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_save_setup_copy(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_character_body(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_username_password(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_character_head(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_time_limit_slider(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_score_limit_slider(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_team_score_limit_slider(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_restore_score_defaults(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_restore_handicap_defaults(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_ready(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_simulant(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_simulant_head(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_simulant_body(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_delete_simulant(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_change_simulant_type(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_clear_all_simulants(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_add_simulant(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_simulant_slot(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_simulants(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_two_teams(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_three_teams(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_four_teams(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_maximum_teams(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_humans_vs_simulants(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_human_simulant_pairs(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_team_slot(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_select_tune(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_multiple_tunes(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_team_name_slot(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler0017e38c(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler0017e9d8(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpAbortChallenge(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpStartChallenge(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_abort_challenge(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_start_challenge(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler0017ec64(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpLock(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSavePlayer(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_lock(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_save_player(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandler0017ef30(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpSaveSettings(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpGameSetup(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuDialogHandlerResult menudialogMpQuickGo(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpFinishedSetup(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerQuickTeamSeparator(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpQuickTeamOption(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuDialogHandlerResult menudialogCombatSimulator(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpAdvancedSetup(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpDisplayTeam(s32 operation, struct menuitem *item, union handlerdata *data);
-MenuItemHandlerResult menuhandlerMpOneHitKills(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_save_settings(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_game_setup(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuDialogHandlerResult menudialog_mp_quick_go(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_finished_setup(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_quick_team_separator(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_quick_team_option(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuDialogHandlerResult menudialog_combat_simulator(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_advanced_setup(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_display_team(s32 operation, struct menuitem *item, union handlerdata *data);
+MenuItemHandlerResult menuhandler_mp_one_hit_kills(s32 operation, struct menuitem *item, union handlerdata *data);
 
 #endif

src/include/game/mpstats.h

@@ -4,19 +4,19 @@
 #include "data.h"
 #include "types.h"
 
-void mpstatsIncrementPlayerShotCount(struct gset *gset, s32 region);
-void mpstatsIncrementPlayerShotCount2(struct gset *gset, s32 region);
+void mpstats_increment_player_shot_count(struct gset *gset, s32 region);
+void mpstats_increment_player_shot_count2(struct gset *gset, s32 region);
 void mpstats0f0b0520(void);
-s32 mpstatsGetPlayerShotCountByRegion(u32 type);
-void mpstatsIncrementTotalKillCount(void);
-void mpstatsIncrementTotalKnockoutCount(void);
-void mpstatsDecrementTotalKnockoutCount(void);
-u8 mpstatsGetTotalKnockoutCount(void);
-u32 mpstatsGetTotalKillCount(void);
-void mpstatsRecordPlayerKill(void);
-s32 mpstatsGetPlayerKillCount(void);
-void mpstatsRecordPlayerDeath(void);
-void mpstatsRecordPlayerSuicide(void);
-void mpstatsRecordDeath(s32 aplayernum, s32 vplayernum);
+s32 mpstats_get_player_shot_count_by_region(u32 type);
+void mpstats_increment_total_kill_count(void);
+void mpstats_increment_total_knockout_count(void);
+void mpstats_decrement_total_knockout_count(void);
+u8 mpstats_get_total_knockout_count(void);
+u32 mpstats_get_total_kill_count(void);
+void mpstats_record_player_kill(void);
+s32 mpstats_get_player_kill_count(void);
+void mpstats_record_player_death(void);
+void mpstats_record_player_suicide(void);
+void mpstats_record_death(s32 aplayernum, s32 vplayernum);
 
 #endif

src/include/game/mtxf2lbulk.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-void mtxF2LBulk(Mtxf *matrices, s32 count);
+void mtx_f2l_bulk(Mtxf *matrices, s32 count);
 
 #endif

src/include/game/music.h

@@ -4,42 +4,42 @@
 #include "data.h"
 #include "types.h"
 
-u16 musicGetVolume(void);
-void musicSetVolume(u16 volume);
-bool musicIsTrackState(s32 tracktype, s32 state);
-s32 musicGetTrackState(s32 tracktype);
-void musicQueueStartEvent(u32 tracktype, u32 tracknum, f32 arg2, u16 volume);
-void musicQueueStopEvent(s32 tracktype);
-void musicQueueFadeEvent(s32 tracktype, f32 arg1, bool keepafterfade);
-void musicReset(void);
-void musicQueueStopAllEvent(void);
-void musicSaveInterval(void);
-void musicRestoreInterval(void);
-void musicStartPrimary(f32 arg0);
-void musicStartAmbient(f32 arg0);
-bool musicIsAnyPlayerInAmbientRoom(void);
-void musicStartNrg(f32 arg0);
-void musicStartTrackAsMenu(s32 tracknum);
-void musicSetStageAndStartMusic(s32 stagenum);
-void musicSetStage(s32 stagenum);
-void musicStop(void);
-void musicActivateNrg(void);
-void musicDeactivateNrg(void);
-void musicStartMenu(void);
-void musicEndMenu(void);
-void musicStartSoloDeath(void);
-void _musicStartMpDeath(f32 arg0);
-void musicStartMpDeath(void);
-void musicEndDeath(void);
-void musicPlayTrackIsolated(s32 tracknum);
-void musicPlayDefaultTracks(void);
-void musicStartTemporaryPrimary(s32 tracknum);
-void musicStartCutscene(s32 tracknum);
-void musicEndCutscene(void);
-void musicStartTemporaryAmbient(s32 tracknum);
-void musicEndTemporaryAmbient(void);
-void musicSetXReason(s32 reason, u32 minsecs, u32 maxsecs);
-void musicUnsetXReason(s32 reason);
-void musicTickAmbient(void);
+u16 music_get_volume(void);
+void music_set_volume(u16 volume);
+bool music_is_track_state(s32 tracktype, s32 state);
+s32 music_get_track_state(s32 tracktype);
+void music_queue_start_event(u32 tracktype, u32 tracknum, f32 arg2, u16 volume);
+void music_queue_stop_event(s32 tracktype);
+void music_queue_fade_event(s32 tracktype, f32 arg1, bool keepafterfade);
+void music_reset(void);
+void music_queue_stop_all_event(void);
+void music_save_interval(void);
+void music_restore_interval(void);
+void music_start_primary(f32 arg0);
+void music_start_ambient(f32 arg0);
+bool music_is_any_player_in_ambient_room(void);
+void music_start_nrg(f32 arg0);
+void music_start_track_as_menu(s32 tracknum);
+void music_set_stage_and_start_music(s32 stagenum);
+void music_set_stage(s32 stagenum);
+void music_stop(void);
+void music_activate_nrg(void);
+void music_deactivate_nrg(void);
+void music_start_menu(void);
+void music_end_menu(void);
+void music_start_solo_death(void);
+void _music_start_mp_death(f32 arg0);
+void music_start_mp_death(void);
+void music_end_death(void);
+void music_play_track_isolated(s32 tracknum);
+void music_play_default_tracks(void);
+void music_start_temporary_primary(s32 tracknum);
+void music_start_cutscene(s32 tracknum);
+void music_end_cutscene(void);
+void music_start_temporary_ambient(s32 tracknum);
+void music_end_temporary_ambient(void);
+void music_set_x_reason(s32 reason, u32 minsecs, u32 maxsecs);
+void music_unset_x_reason(s32 reason);
+void music_tick_ambient(void);
 
 #endif

src/include/game/nbomb.h

@@ -5,18 +5,18 @@
 #include "types.h"
 
 Gfx *func0f008558(Gfx *gdl, s32 depth);
-void nbombReset(struct nbomb *nbomb);
-s32 nbombCalculateAlpha(struct nbomb *nbomb);
-Gfx *nbombCreateGdl(void);
-Gfx *nbombRender(Gfx *gdl, struct nbomb *nbomb, Gfx *subgdl);
+void nbomb_reset(struct nbomb *nbomb);
+s32 nbomb_calculate_alpha(struct nbomb *nbomb);
+Gfx *nbomb_create_gdl(void);
+Gfx *nbomb_render(Gfx *gdl, struct nbomb *nbomb, Gfx *subgdl);
 void func0f0099a4(void);
-void nbombInflictDamage(struct nbomb *nbomb);
-void nbombTick(struct nbomb *nbomb);
-void nbombsTick(void);
-Gfx *nbombsRender(Gfx *gdl);
-void nbombCreateStorm(struct coord *pos, struct prop *ownerprop);
-f32 gasGetDoorFrac(s32 tagnum);
-Gfx *nbombRenderOverlay(Gfx *gdl);
-Gfx *gasRender(Gfx *gdl);
+void nbomb_inflict_damage(struct nbomb *nbomb);
+void nbomb_tick(struct nbomb *nbomb);
+void nbombs_tick(void);
+Gfx *nbombs_render(Gfx *gdl);
+void nbomb_create_storm(struct coord *pos, struct prop *ownerprop);
+f32 gas_get_door_frac(s32 tagnum);
+Gfx *nbomb_render_overlay(Gfx *gdl);
+Gfx *gas_render(Gfx *gdl);
 
 #endif

src/include/game/objectives.h

@@ -4,33 +4,33 @@
 #include "data.h"
 #include "types.h"
 
-void objectivesStop(void);
+void objectives_stop(void);
 
-void objectivesReset(void);
-void tagInsert(struct tag *tag);
-void briefingInsert(struct briefingobj *obj);
-void objectiveInsert(struct objective *objective);
-void objectiveAddRoomEnteredCriteria(struct criteria_roomentered *criteria);
-void objectiveAddThrowInRoomCriteria(struct criteria_throwinroom *criteria);
-void objectiveAddHolographCriteria(struct criteria_holograph *criteria);
+void objectives_reset(void);
+void tag_insert(struct tag *tag);
+void briefing_insert(struct briefingobj *obj);
+void objective_insert(struct objective *objective);
+void objective_add_room_entered_criteria(struct criteria_roomentered *criteria);
+void objective_add_throw_in_room_criteria(struct criteria_throwinroom *criteria);
+void objective_add_holograph_criteria(struct criteria_holograph *criteria);
 
-u32 xorBaffbeff(u32 value);
-u32 xorBabeffff(u32 value);
-u32 xorBoobless(u32 value);
-void tagsReset(void);
-s32 objGetTagNum(struct defaultobj *obj);
-s32 objectiveGetCount(void);
-u32 objectiveGetDifficultyBits(s32 index);
-s32 objectiveCheck(s32 index);
-bool objectiveIsAllComplete(void);
-void objectivesDisableChecking(void);
-void objectivesShowHudmsg(char *buffer, s32 hudmsgtype);
-void objectivesCheckAll(void);
-void objectiveCheckRoomEntered(s32 currentroom);
-void objectiveCheckThrowInRoom(s32 arg0, RoomNum *requiredrooms);
-void objectiveCheckHolograph(f32 sqdist);
-struct prop *chopperGetTargetProp(struct chopperobj *heli);
-struct defaultobj *objFindByTagId(s32 tag_id);
-struct tag *tagFindById(s32 tag_id);
+u32 xor_baffbeff(u32 value);
+u32 xor_babeffff(u32 value);
+u32 xor_boobless(u32 value);
+void tags_reset(void);
+s32 obj_get_tag_num(struct defaultobj *obj);
+s32 objective_get_count(void);
+u32 objective_get_difficulty_bits(s32 index);
+s32 objective_check(s32 index);
+bool objective_is_all_complete(void);
+void objectives_disable_checking(void);
+void objectives_show_hudmsg(char *buffer, s32 hudmsgtype);
+void objectives_check_all(void);
+void objective_check_room_entered(s32 currentroom);
+void objective_check_throw_in_room(s32 arg0, RoomNum *requiredrooms);
+void objective_check_holograph(f32 sqdist);
+struct prop *chopper_get_target_prop(struct chopperobj *heli);
+struct defaultobj *obj_find_by_tag_id(s32 tag_id);
+struct tag *tag_find_by_id(s32 tag_id);
 
 #endif

src/include/game/options.h

@@ -4,47 +4,47 @@
 #include "data.h"
 #include "types.h"
 
-s32 optionsGetControlMode(s32 mpchrnum);
-void optionsSetControlMode(s32 mpchrnum, s32 mode);
-s32 optionsGetContpadNum1(s32 mpchrnum);
-s32 optionsGetContpadNum2(s32 mpchrnum);
-s32 optionsGetForwardPitch(s32 mpchrnum);
-s32 optionsGetAutoAim(s32 mpchrnum);
-s32 optionsGetLookAhead(s32 mpchrnum);
-s32 optionsGetAimControl(s32 mpchrnum);
-s32 optionsGetSightOnScreen(s32 mpchrnum);
-s32 optionsGetAmmoOnScreen(s32 mpchrnum);
-s32 optionsGetShowGunFunction(s32 mpchrnum);
-s32 optionsGetAlwaysShowTarget(s32 mpchrnum);
-s32 optionsGetShowZoomRange(s32 mpchrnum);
-s32 optionsGetPaintball(s32 mpchrnum);
-s32 optionsGetShowMissionTime(s32 mpchrnum);
-u8 optionsGetInGameSubtitles(void);
-u8 optionsGetCutsceneSubtitles(void);
-s32 optionsGetHeadRoll(s32 mpchrnum);
+s32 options_get_control_mode(s32 mpchrnum);
+void options_set_control_mode(s32 mpchrnum, s32 mode);
+s32 options_get_contpad_num1(s32 mpchrnum);
+s32 options_get_contpad_num2(s32 mpchrnum);
+s32 options_get_forward_pitch(s32 mpchrnum);
+s32 options_get_auto_aim(s32 mpchrnum);
+s32 options_get_look_ahead(s32 mpchrnum);
+s32 options_get_aim_control(s32 mpchrnum);
+s32 options_get_sight_on_screen(s32 mpchrnum);
+s32 options_get_ammo_on_screen(s32 mpchrnum);
+s32 options_get_show_gun_function(s32 mpchrnum);
+s32 options_get_always_show_target(s32 mpchrnum);
+s32 options_get_show_zoom_range(s32 mpchrnum);
+s32 options_get_paintball(s32 mpchrnum);
+s32 options_get_show_mission_time(s32 mpchrnum);
+u8 options_get_in_game_subtitles(void);
+u8 options_get_cutscene_subtitles(void);
+s32 options_get_head_roll(s32 mpchrnum);
 
-void optionsSetForwardPitch(s32 mpchrnum, bool enable);
-void optionsSetAutoAim(s32 mpchrnum, bool enable);
-void optionsSetLookAhead(s32 mpchrnum, bool enable);
-void optionsSetAimControl(s32 mpchrnum, s32 index);
-void optionsSetSightOnScreen(s32 mpchrnum, bool enable);
-void optionsSetAmmoOnScreen(s32 mpchrnum, bool enable);
-void optionsSetShowGunFunction(s32 mpchrnum, bool enable);
-void optionsSetAlwaysShowTarget(s32 mpchrnum, bool enable);
-void optionsSetShowZoomRange(s32 mpchrnum, bool enable);
-void optionsSetPaintball(s32 mpchrnum, bool enable);
-void optionsSetShowMissionTime(s32 mpchrnum, bool enable);
-void optionsSetInGameSubtitles(s32 enable);
-void optionsSetCutsceneSubtitles(s32 enable);
-void optionsSetHeadRoll(s32 mpchrnum, bool enable);
-s32 optionsGetEffectiveScreenSize(void);
-s32 optionsGetScreenSize(void);
-void optionsSetScreenSize(s32 size);
-s32 optionsGetScreenRatio(void);
-void optionsSetScreenRatio(s32 ratio);
-u8 optionsGetScreenSplit(void);
-void optionsSetScreenSplit(u8 split);
-u16 optionsGetMusicVolume(void);
-void optionsSetMusicVolume(u16 volume);
+void options_set_forward_pitch(s32 mpchrnum, bool enable);
+void options_set_auto_aim(s32 mpchrnum, bool enable);
+void options_set_look_ahead(s32 mpchrnum, bool enable);
+void options_set_aim_control(s32 mpchrnum, s32 index);
+void options_set_sight_on_screen(s32 mpchrnum, bool enable);
+void options_set_ammo_on_screen(s32 mpchrnum, bool enable);
+void options_set_show_gun_function(s32 mpchrnum, bool enable);
+void options_set_always_show_target(s32 mpchrnum, bool enable);
+void options_set_show_zoom_range(s32 mpchrnum, bool enable);
+void options_set_paintball(s32 mpchrnum, bool enable);
+void options_set_show_mission_time(s32 mpchrnum, bool enable);
+void options_set_in_game_subtitles(s32 enable);
+void options_set_cutscene_subtitles(s32 enable);
+void options_set_head_roll(s32 mpchrnum, bool enable);
+s32 options_get_effective_screen_size(void);
+s32 options_get_screen_size(void);
+void options_set_screen_size(s32 size);
+s32 options_get_screen_ratio(void);
+void options_set_screen_ratio(s32 ratio);
+u8 options_get_screen_split(void);
+void options_set_screen_split(u8 split);
+u16 options_get_music_volume(void);
+void options_set_music_volume(u16 volume);
 
 #endif

src/include/game/pad.h

@@ -4,20 +4,20 @@
 #include "data.h"
 #include "types.h"
 
-void padUnpack(s32 padnum, u32 fields, struct pad *pad);
-bool padHasBboxData(s32 padnum);
-void padGetCentre(s32 padnum, struct coord *coord);
-void padRotateForDoor(s32 padnum);
-void padCopyBboxFromPad(s32 padnum, struct pad *src);
-void padSetFlag(s32 padnum, u32 flag);
-void padUnsetFlag(s32 padnum, u32 flag);
-s32 coverGetCount(void);
-bool coverUnpack(s32 covernum, struct cover *cover);
-bool coverIsInUse(s32 covernum);
-void coverSetInUse(s32 covernum, bool enable);
-void coverSetFlag(s32 covernum, u32 flag);
-void coverUnsetFlag(s32 covernum, u32 flag);
-void coverSetOutOfSight(s32 covernum, bool enable);
-bool coverIsSpecial(struct cover *cover);
+void pad_unpack(s32 padnum, u32 fields, struct pad *pad);
+bool pad_has_bbox_data(s32 padnum);
+void pad_get_centre(s32 padnum, struct coord *coord);
+void pad_rotate_for_door(s32 padnum);
+void pad_copy_bbox_from_pad(s32 padnum, struct pad *src);
+void pad_set_flag(s32 padnum, u32 flag);
+void pad_unset_flag(s32 padnum, u32 flag);
+s32 cover_get_count(void);
+bool cover_unpack(s32 covernum, struct cover *cover);
+bool cover_is_in_use(s32 covernum);
+void cover_set_in_use(s32 covernum, bool enable);
+void cover_set_flag(s32 covernum, u32 flag);
+void cover_unset_flag(s32 covernum, u32 flag);
+void cover_set_out_of_sight(s32 covernum, bool enable);
+bool cover_is_special(struct cover *cover);
 
 #endif

src/include/game/padhalllv.h

@@ -4,28 +4,28 @@
 #include "data.h"
 #include "types.h"
 
-void navSetSeed(u32 upper, u32 lower);
-struct waypoint *waypointFindClosestToPos(struct coord *pos, RoomNum *rooms);
-struct waygroup *waygroupChooseNeighbour(s32 *groupnums, s32 step, u32 ignoremask);
-void waygroupSetStepIfUndiscovered(s32 *groupnums, s32 step, u32 ignoremask);
-bool waygroupDiscoverOneStep(struct waygroup *group, s32 step, u32 ignoremask);
-bool waygroupDiscoverSteps(struct waygroup *from, struct waygroup *to, struct waygroup *groups, bool discoverall, u32 ignoremask);
-bool waygroupFindRoute(struct waygroup *from, struct waygroup *to, struct waygroup *groups);
-struct waypoint *waypointChooseNeighbour(s32 *pointnums, s32 step, s32 groupnum, u32 ignoremask);
-void waypointSetStepIfUndiscovered(s32 *pointnums, s32 value, s32 groupnum, u32 ignoremask);
-bool waypointDiscoverOneStep(s32 *pointnums, s32 step, s32 groupnum, u32 ignoremask);
-void waypointDiscoverSteps(struct waypoint *from, struct waypoint *to, bool discoverall, u32 ignoremask);
-void waypointFindRoute(struct waypoint *from, struct waypoint *to);
-s32 waypointCollectLocal(struct waypoint *from, struct waypoint *to, struct waypoint **arr, s32 arrlen);
-void waypointFindSegmentIntoGroup(struct waygroup *fromgroup, struct waygroup *togroup, struct waypoint **frompoint, struct waypoint **topoint);
-s32 navFindRoute(struct waypoint *from, struct waypoint *to, struct waypoint **arr, s32 arrlen);
-void waypointResetAllSteps(void);
-struct waypoint *waypointFindRandomAtStep(s32 *pointnums, s32 step);
-struct waygroup *waygroupFindRandomAtStep(s32 *groupnums, s32 step);
-struct waypoint *navChooseRetreatPoint(struct waypoint *chrpoint, struct waypoint *targetpoint);
-void navDisableSegmentInDirection(struct waypoint *a, struct waypoint *b);
-void navEnableSegmentInDirection(struct waypoint *a, struct waypoint *b);
-void navDisableSegment(struct waypoint *a, struct waypoint *b);
-void navEnableSegment(struct waypoint *a, struct waypoint *b);
+void nav_set_seed(u32 upper, u32 lower);
+struct waypoint *waypoint_find_closest_to_pos(struct coord *pos, RoomNum *rooms);
+struct waygroup *waygroup_choose_neighbour(s32 *groupnums, s32 step, u32 ignoremask);
+void waygroup_set_step_if_undiscovered(s32 *groupnums, s32 step, u32 ignoremask);
+bool waygroup_discover_one_step(struct waygroup *group, s32 step, u32 ignoremask);
+bool waygroup_discover_steps(struct waygroup *from, struct waygroup *to, struct waygroup *groups, bool discoverall, u32 ignoremask);
+bool waygroup_find_route(struct waygroup *from, struct waygroup *to, struct waygroup *groups);
+struct waypoint *waypoint_choose_neighbour(s32 *pointnums, s32 step, s32 groupnum, u32 ignoremask);
+void waypoint_set_step_if_undiscovered(s32 *pointnums, s32 value, s32 groupnum, u32 ignoremask);
+bool waypoint_discover_one_step(s32 *pointnums, s32 step, s32 groupnum, u32 ignoremask);
+void waypoint_discover_steps(struct waypoint *from, struct waypoint *to, bool discoverall, u32 ignoremask);
+void waypoint_find_route(struct waypoint *from, struct waypoint *to);
+s32 waypoint_collect_local(struct waypoint *from, struct waypoint *to, struct waypoint **arr, s32 arrlen);
+void waypoint_find_segment_into_group(struct waygroup *fromgroup, struct waygroup *togroup, struct waypoint **frompoint, struct waypoint **topoint);
+s32 nav_find_route(struct waypoint *from, struct waypoint *to, struct waypoint **arr, s32 arrlen);
+void waypoint_reset_all_steps(void);
+struct waypoint *waypoint_find_random_at_step(s32 *pointnums, s32 step);
+struct waygroup *waygroup_find_random_at_step(s32 *groupnums, s32 step);
+struct waypoint *nav_choose_retreat_point(struct waypoint *chrpoint, struct waypoint *targetpoint);
+void nav_disable_segment_in_direction(struct waypoint *a, struct waypoint *b);
+void nav_enable_segment_in_direction(struct waypoint *a, struct waypoint *b);
+void nav_disable_segment(struct waypoint *a, struct waypoint *b);
+void nav_enable_segment(struct waypoint *a, struct waypoint *b);
 
 #endif

src/include/game/pak.h

@@ -4,117 +4,117 @@
 #include "data.h"
 #include "types.h"
 
-u32 pakGetBlockSize(s8 device);
-u32 pakAlign(s8 device, u32 size);
-s32 pakGetAlignedFileLenByBodyLen(s8 device, u32 bodylen);
-u32 pakGetBodyLenByFileLen(u32 filelen);
-u32 pakGenerateSerial(s8 device);
-bool mempakIsOkay(s8 device);
-s32 pakGetFileIdsByType(s8 device, u32 filetype, u32 *fileids);
+u32 pak_get_block_size(s8 device);
+u32 pak_align(s8 device, u32 size);
+s32 pak_get_aligned_file_len_by_body_len(s8 device, u32 bodylen);
+u32 pak_get_body_len_by_file_len(u32 filelen);
+u32 pak_generate_serial(s8 device);
+bool mempak_is_okay(s8 device);
+s32 pak_get_file_ids_by_type(s8 device, u32 filetype, u32 *fileids);
 s32 pak0f1167d8(s8 device);
-s32 pakReadBodyAtGuid(s8 device, s32 fileid, u8 *body, s32 arg3);
-s32 pakSaveAtGuid(s8 device, s32 fileid, s32 filetype, u8 *body, s32 *outfileid, u8 *olddata);
-bool pakDeleteFile(s8 device, s32 fileid);
-PakErr1 pakDeleteGameNote(s8 device, u16 company_code, u32 game_code, char *game_name, char *ext_name);
+s32 pak_read_body_at_guid(s8 device, s32 fileid, u8 *body, s32 arg3);
+s32 pak_save_at_guid(s8 device, s32 fileid, s32 filetype, u8 *body, s32 *outfileid, u8 *olddata);
+bool pak_delete_file(s8 device, s32 fileid);
+PakErr1 pak_delete_game_note(s8 device, u16 company_code, u32 game_code, char *game_name, char *ext_name);
 PakErr1 pak0f1168c4(s8 device, struct pakdata **arg1);
-s32 pakGetType(s8 device);
-s32 pakGetSerial(s8 device);
+s32 pak_get_type(s8 device);
+s32 pak_get_serial(s8 device);
 void pak0f11698c(s8 device);
 void pak0f116994(void);
 void pak0f1169c8(s8 device, bool tick);
-bool mempakIsReady(s8 device);
-bool mempakIsReadyOrFull(s8 device);
+bool mempak_is_ready(s8 device);
+bool mempak_is_ready_or_full(s8 device);
 void pak0f116bdc(s8 device, u8 *arg1, u8 *arg2);
-u16 _pakGetSerial(s8 device);
-u32 _pakGetType(s8 device);
-void pakSetState(s8 device, s32 value);
+u16 _pak_get_serial(s8 device);
+u32 _pak_get_type(s8 device);
+void pak_set_state(s8 device, s32 value);
 s32 pak0f116df0(s8 device, struct pakdata **arg1);
-s32 _pakDeleteGameNote(s8 device, u16 company_code, u32 game_code, char *game_name, char *ext_name);
-s32 _pakDeleteFile(s8 device, s32 fileid);
-s32 pakGetPlugCount(s8 device);
-u32 pakGetMaxFileSize(s8 device);
-s32 pakGetBodyLenByType(s8 device, u32 filetype);
+s32 _pak_delete_game_note(s8 device, u16 company_code, u32 game_code, char *game_name, char *ext_name);
+s32 _pak_delete_file(s8 device, s32 fileid);
+s32 pak_get_plug_count(s8 device);
+u32 pak_get_max_file_size(s8 device);
+s32 pak_get_body_len_by_type(s8 device, u32 filetype);
 void pak0f117150(s8 device, u8 *ptr);
 void pak0f1171b4(s8 device, s32 arg1, s32 arg2);
-s32 pakGetUnk008(s8 device);
-bool pakRetrieveBlockFromCache(s8 device, u32 offset, u8 *dst);
-PakErr2 pakReadHeaderAtOffset(s8 device, u32 offset, struct pakfileheader *header);
-void pakDumpBuffer(u8 *buffer, u32 len, char *name);
-void pakDumpEeprom(void);
-s32 _pakSaveAtGuid(s8 device, s32 fileid, s32 filetype, u8 *newdata, s32 *outfileid, u8 *olddata);
+s32 pak_get_unk008(s8 device);
+bool pak_retrieve_block_from_cache(s8 device, u32 offset, u8 *dst);
+PakErr2 pak_read_header_at_offset(s8 device, u32 offset, struct pakfileheader *header);
+void pak_dump_buffer(u8 *buffer, u32 len, char *name);
+void pak_dump_eeprom(void);
+s32 _pak_save_at_guid(s8 device, s32 fileid, s32 filetype, u8 *newdata, s32 *outfileid, u8 *olddata);
 
 #if VERSION >= VERSION_NTSC_1_0
-PakErr1 pakInitPak(OSMesgQueue *mq, OSPfs *pfs, s32 channel, s32 *arg3);
+PakErr1 pak_init_pak(OSMesgQueue *mq, OSPfs *pfs, s32 channel, s32 *arg3);
 #else
-PakErr1 pakInitPak(OSMesgQueue *mq, OSPfs *pfs, s32 channel);
+PakErr1 pak_init_pak(OSMesgQueue *mq, OSPfs *pfs, s32 channel);
 #endif
 
-PakErr1 _pakReadWriteBlock(OSPfs *pfs, s32 file_no, u8 flag, u32 address, u32 len, u8 *buffer);
-PakErr1 pakQueryNumNotes(OSPfs *pfs, s32 *max_files, s32 *files_used);
-PakErr1 pakQueryNumFreeBytes(OSPfs *pfs, s32 *bytes_not_used);
-PakErr1 pakQueryNoteState(OSPfs *pfs, s32 file_no, OSPfsState *note);
-PakErr1 pakAllocateNote(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name, s32 size, s32 *file_no);
-PakErr1 pakDeleteGameNote3(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name);
-PakErr1 pakFindNote(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name, s32 *file_no);
-PakErr1 _pakResizeNote(OSPfs *pfs, u16 company_code, u32 game_code, u8 *game_name, u8 *ext_name, u32 numbytes);
-s32 pakGetPdNumPages(s8 device);
-u32 pakGetPdNumBytes(s8 device);
-s32 pakQueryNumFreePages(s8 device);
-bool pakCanFitCameraFileInPak(s8 device);
-s32 pakGetNumFreeCameraSpacesInPak(s8 device);
-s32 _pakCreateCameraFile(s8 device, s32 *outfileid);
-bool pakResizeNote(s8 device, s32 numpages);
+PakErr1 _pak_read_write_block(OSPfs *pfs, s32 file_no, u8 flag, u32 address, u32 len, u8 *buffer);
+PakErr1 pak_query_num_notes(OSPfs *pfs, s32 *max_files, s32 *files_used);
+PakErr1 pak_query_num_free_bytes(OSPfs *pfs, s32 *bytes_not_used);
+PakErr1 pak_query_note_state(OSPfs *pfs, s32 file_no, OSPfsState *note);
+PakErr1 pak_allocate_note(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name, s32 size, s32 *file_no);
+PakErr1 pak_delete_game_note3(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name);
+PakErr1 pak_find_note(OSPfs *pfs, u16 company_code, u32 game_code, char *game_name, char *ext_name, s32 *file_no);
+PakErr1 _pak_resize_note(OSPfs *pfs, u16 company_code, u32 game_code, u8 *game_name, u8 *ext_name, u32 numbytes);
+s32 pak_get_pd_num_pages(s8 device);
+u32 pak_get_pd_num_bytes(s8 device);
+s32 pak_query_num_free_pages(s8 device);
+bool pak_can_fit_camera_file_in_pak(s8 device);
+s32 pak_get_num_free_camera_spaces_in_pak(s8 device);
+s32 _pak_create_camera_file(s8 device, s32 *outfileid);
+bool pak_resize_note(s8 device, s32 numpages);
 void pak0f1185e0(s8 device, s32 arg1, s32 arg2);
 u32 pak0f118674(s8 device, u32 filetype, s32 *outfileid);
 void pak0f1189d0(void);
-void paksInit(void);
-void pakCalculateChecksum(u8 *arg0, u8 *arg1, u16 *arg2);
-s32 _pakReadBodyAtGuid(s8 device, s32 fileid, u8 *body, s32 arg3);
-s32 _pakGetFileIdsByType(s8 device, u32 filetype, u32 *fileids);
-s32 pakCheckFileCanFitInNote(s8 device, s32 filetype, s32 *numspaces);
+void paks_init(void);
+void pak_calculate_checksum(u8 *arg0, u8 *arg1, u16 *arg2);
+s32 _pak_read_body_at_guid(s8 device, s32 fileid, u8 *body, s32 arg3);
+s32 _pak_get_file_ids_by_type(s8 device, u32 filetype, u32 *fileids);
+s32 pak_check_file_can_fit_in_note(s8 device, s32 filetype, s32 *numspaces);
 u32 pak0f119298(s8 device);
 void pak0f119340(u32 arg0);
-s32 pakFindFile(s8 device, u32 fileid, struct pakfileheader *header);
+s32 pak_find_file(s8 device, u32 fileid, struct pakfileheader *header);
 #if VERSION >= VERSION_NTSC_FINAL
-bool pakWriteBlankFile(s8 device, u32 offset, struct pakfileheader *header);
+bool pak_write_blank_file(s8 device, u32 offset, struct pakfileheader *header);
 #endif
-bool pakRepairAsBlank(s8 device, u32 *offset, struct pakfileheader *header);
-s32 pakRepairFilesystem(s8 device);
-void pakCorrupt(void);
+bool pak_repair_as_blank(s8 device, u32 *offset, struct pakfileheader *header);
+s32 pak_repair_filesystem(s8 device);
+void pak_corrupt(void);
 
 #if VERSION >= VERSION_NTSC_1_0
-bool pakCreateInitialFiles(s8 device);
+bool pak_create_initial_files(s8 device);
 #else
-void pakCreateInitialFiles(s8 device);
+void pak_create_initial_files(s8 device);
 #endif
 
-s32 pakFindMaxFileId(s8 device);
-void pakMergeBlanks(s8 device);
-void paksReset(void);
-void pakSetFeatures(s8 device, u8 features, u32 line, char *file);
-void pakSetDefaults(s8 arg0);
-PakErr1 pakReadWriteBlock(s8 device, OSPfs *pfs, s32 file_no, u8 flag, u32 address, u32 len, u8 *buffer);
-bool pakQueryTotalUsage(s8 device);
-void pakQueryPdSize(s8 device);
-bool mempakPrepare(s8 device);
-bool pakProbe(s8 device);
-void pakWipe(s8 device, u32 blocknumstart, u32 blocknumend);
-void pakSaveHeaderToCache(s8 device, s32 blocknum, struct pakfileheader *header);
-bool pakRetrieveHeaderFromCache(s8 device, s32 blocknum, struct pakfileheader *header);
-s32 pakCreateFilesystem(s8 device);
-bool pakGetFilesystemLength(s8 device, u32 *outlen);
+s32 pak_find_max_file_id(s8 device);
+void pak_merge_blanks(s8 device);
+void paks_reset(void);
+void pak_set_features(s8 device, u8 features, u32 line, char *file);
+void pak_set_defaults(s8 arg0);
+PakErr1 pak_read_write_block(s8 device, OSPfs *pfs, s32 file_no, u8 flag, u32 address, u32 len, u8 *buffer);
+bool pak_query_total_usage(s8 device);
+void pak_query_pd_size(s8 device);
+bool mempak_prepare(s8 device);
+bool pak_probe(s8 device);
+void pak_wipe(s8 device, u32 blocknumstart, u32 blocknumend);
+void pak_save_header_to_cache(s8 device, s32 blocknum, struct pakfileheader *header);
+bool pak_retrieve_header_from_cache(s8 device, s32 blocknum, struct pakfileheader *header);
+s32 pak_create_filesystem(s8 device);
+bool pak_get_filesystem_length(s8 device, u32 *outlen);
 s32 pak0f11b86c(s8 device, u32 offset, u8 *data, struct pakfileheader *header, s32 arg4);
-bool pakReplaceFileAtOffsetWithBlank(s8 device, u32 offset);
-s32 pakWriteFileAtOffset(s8 device, u32 offset, u32 filetype, u8 *newdata, s32 bodylen, s32 *outfileid, u8 *olddata, u32 fileid, u32 generation);
-bool pakRepair(s8 device);
-bool pakHandleResult(s32 err1, s8 device, bool arg2, u32 line);
-void paksTick(void);
+bool pak_replace_file_at_offset_with_blank(s8 device, u32 offset);
+s32 pak_write_file_at_offset(s8 device, u32 offset, u32 filetype, u8 *newdata, s32 bodylen, s32 *outfileid, u8 *olddata, u32 fileid, u32 generation);
+bool pak_repair(s8 device);
+bool pak_handle_result(s32 err1, s8 device, bool arg2, u32 line);
+void paks_tick(void);
 void pak0f11c6d0(void);
-void pakExecuteDebugOperations(void);
-void pakCheckPlugged(void);
-void gbpakHandleError(u32 arg0);
-bool gbpakRead(s8 device, u16 address, u8 *buffer, u16 size);
-bool gbpakWrite(s8 device, u16 address, u8 *buffer, u16 size);
+void pak_execute_debug_operations(void);
+void pak_check_plugged(void);
+void gbpak_handle_error(u32 arg0);
+bool gbpak_read(s8 device, u16 address, u8 *buffer, u16 size);
+bool gbpak_write(s8 device, u16 address, u8 *buffer, u16 size);
 bool pak0f11cd00(s8 device, u16 arg1, char *arg2, s32 arg3, s32 arg4);
 bool pak0f11ce00(s8 device, u16 arg1, char *arg2, s32 arg3, bool arg4);
 void pak0f11d118(u8 *arg0, u8 arg1, u32 arg2);
@@ -129,31 +129,31 @@ void pak0f11d620(s8 device);
 void pak0f11d9c4(s8 device, u8 *arg1, u8 *arg2, u32 arg3);
 
 #if VERSION >= VERSION_NTSC_1_0
-void pakRumble(s32 device, f32 numsecs, s32 onduration, s32 offduration);
+void pak_rumble(s32 device, f32 numsecs, s32 onduration, s32 offduration);
 #else
-void pakRumble(s8 device, f32 numsecs, s32 onduration, s32 offduration);
+void pak_rumble(s8 device, f32 numsecs, s32 onduration, s32 offduration);
 #endif
 
-void paksStop(bool disablepolling);
-void pakDisableRumbleForPlayer(s8 playernum);
-void pakEnableRumbleForPlayer(s8 playernum);
-void pakDisableRumbleForAllPlayers(void);
-void pakEnableRumbleForAllPlayers(void);
-void pakDumpPak(void);
-void pakTickState(s8 device);
+void paks_stop(bool disablepolling);
+void pak_disable_rumble_for_player(s8 playernum);
+void pak_enable_rumble_for_player(s8 playernum);
+void pak_disable_rumble_for_all_players(void);
+void pak_enable_rumble_for_all_players(void);
+void pak_dump_pak(void);
+void pak_tick_state(s8 device);
 void pak0f11e3bc(s8 device);
-void pakProbeEeprom(void);
-PakErr1 pakReadEeprom(u8 address, u8 *buffer, u32 len);
-PakErr1 pakWriteEeprom(u8 address, u8 *buffer, u32 len);
-void pakSetBitflag(s32 flagnum, u8 *bitstream, bool set);
-bool pakHasBitflag(u32 flagnum, u8 *stream);
-void pakClearAllBitflags(u8 *flags);
-void pakN64FontCodeToAscii(char *src, char *dst, s32 len);
-s8 pakFindBySerial(s32 deviceserial);
+void pak_probe_eeprom(void);
+PakErr1 pak_read_eeprom(u8 address, u8 *buffer, u32 len);
+PakErr1 pak_write_eeprom(u8 address, u8 *buffer, u32 len);
+void pak_set_bitflag(s32 flagnum, u8 *bitstream, bool set);
+bool pak_has_bitflag(u32 flagnum, u8 *stream);
+void pak_clear_all_bitflags(u8 *flags);
+void pak_n64_font_code_to_ascii(char *src, char *dst, s32 len);
+s8 pak_find_by_serial(s32 deviceserial);
 s32 pak0f11e750(s8 device);
-bool gbpakIsAnyPerfectDark(void);
-bool gbpakStrcmp(char *a, char *b);
-s32 gbpakIdentifyGame(s8 device);
+bool gbpak_is_any_perfect_dark(void);
+bool gbpak_strcmp(char *a, char *b);
+s32 gbpak_identify_game(s8 device);
 bool pak0f11ea34(s8 device);
 
 extern const char var7f1b423c[];

src/include/game/pdmode.h

@@ -4,11 +4,11 @@
 #include "data.h"
 #include "types.h"
 
-f32 pdmodeGetEnemyReactionSpeed(void);
-f32 pdmodeGetEnemyHealth(void);
-f32 pdmodeGetEnemyDamage(void);
-f32 pdmodeGetEnemyAccuracy(void);
+f32 pdmode_get_enemy_reaction_speed(void);
+f32 pdmode_get_enemy_health(void);
+f32 pdmode_get_enemy_damage(void);
+f32 pdmode_get_enemy_accuracy(void);
 void func0f01b148(u32 arg0);
-void titleSetNextStage(s32 stagenum);
+void title_set_next_stage(s32 stagenum);
 
 #endif

src/include/game/player.h

@@ -4,107 +4,107 @@
 #include "data.h"
 #include "types.h"
 
-f32 playerChooseSpawnLocation(f32 chrradius, struct coord *dstpos, RoomNum *dstrooms, struct prop *prop, s16 *spawnpads, s32 numspawnpads);
-f32 playerChooseGeneralSpawnLocation(f32 chrradius, struct coord *pos, RoomNum *rooms, struct prop *prop);
-void playerStartNewLife(void);
-void playerLoadDefaults(void);
-bool playerSpawnAnti(struct chrdata *chr, s32 param_2);
-void playerSpawn(void);
-void playerResetBond(struct playerbond *pb, struct coord *pos);
-void playersTickAllChrBodies(void);
-void playerChooseBodyAndHead(s32 *bodynum, s32 *headnum, s32 *arg2);
-void playerTickChrBody(void);
-void playerRemoveChrBody(void);
-void playerTickMpSwirl(void);
-void playerChangeCamera(void);
-void playerStartCutscene(s16 anim_id);
-void playerReorientForCutsceneStop(s32 tweenduration60);
-void playerTickCutscene(bool arg0);
-f32 playerGetCutsceneBlurFrac(void);
-void playerSetZoomFovY(f32 fovy, f32 timemax);
-f32 playerGetZoomFovY(void);
-void playerTweenFovY(f32 targetfovy);
-f32 playerGetTeleportFovY(void);
-void playerUpdateZoom(void);
-void playerStopAudioForPause(void);
-void playerTickPauseMenu(void);
-void playerPause(s32 root);
-void playerUnpause(void);
+f32 player_choose_spawn_location(f32 chrradius, struct coord *dstpos, RoomNum *dstrooms, struct prop *prop, s16 *spawnpads, s32 numspawnpads);
+f32 player_choose_general_spawn_location(f32 chrradius, struct coord *pos, RoomNum *rooms, struct prop *prop);
+void player_start_new_life(void);
+void player_load_defaults(void);
+bool player_spawn_anti(struct chrdata *chr, s32 param_2);
+void player_spawn(void);
+void player_reset_bond(struct playerbond *pb, struct coord *pos);
+void players_tick_all_chr_bodies(void);
+void player_choose_body_and_head(s32 *bodynum, s32 *headnum, s32 *arg2);
+void player_tick_chr_body(void);
+void player_remove_chr_body(void);
+void player_tick_mp_swirl(void);
+void player_change_camera(void);
+void player_start_cutscene(s16 anim_id);
+void player_reorient_for_cutscene_stop(s32 tweenduration60);
+void player_tick_cutscene(bool arg0);
+f32 player_get_cutscene_blur_frac(void);
+void player_set_zoom_fov_y(f32 fovy, f32 timemax);
+f32 player_get_zoom_fov_y(void);
+void player_tween_fov_y(f32 targetfovy);
+f32 player_get_teleport_fov_y(void);
+void player_update_zoom(void);
+void player_stop_audio_for_pause(void);
+void player_tick_pause_menu(void);
+void player_pause(s32 root);
+void player_unpause(void);
 Gfx *player0f0baf84(Gfx *gdl);
-Gfx *playerDrawFade(Gfx *gdl, u32 r, u32 g, u32 b, f32 frac);
-Gfx *playerDrawStoredFade(Gfx *gdl);
-void playerUpdateColourScreenProperties(void);
-void playerTickChrFade(void);
-void playerDisplayHealth(void);
-void playerTickDamageAndHealth(void);
-void playerDisplayDamage(void);
-Gfx *playerRenderHealthBar(Gfx *gdl);
-void playerSurroundWithExplosions(s32 arg0);
-void playerTickExplode(void);
-void playerResetLoResIf4Mb(void);
-s16 playerGetFbWidth(void);
-s16 playerGetFbHeight(void);
-bool playerHasSharedViewport(void);
-s16 playerGetViewportWidth(void);
-s16 playerGetViewportLeft(void);
-s16 playerGetViewportHeight(void);
-s16 playerGetViewportTop(void);
-f32 playerGetAspectRatio(void);
-void playerUpdateShake(void);
-void playerTickTeleport(f32 *arg0);
-void playerConfigureVi(void);
-void playerTick(bool arg0);
-void playerAllocateMatrices(struct coord *cam_pos, struct coord *cam_look, struct coord *cam_up);
-Gfx *playerUpdateShootRot(Gfx *gdl);
-void playerDisplayShield(void);
-Gfx *playerRenderShield(Gfx *gdl);
-Gfx *playerRenderHud(Gfx *gdl);
-void playerDie(bool force);
-void playerDieByShooter(u32 shooter, bool force);
-void playerCheckIfShotInBack(s32 attackerplayernum, f32 x, f32 z);
-f32 playerGetHealthBarHeightFrac(void);
-void playerMoveCameraFromPosRooms(struct coord *pos, struct coord *up, struct coord *look, struct coord *pos2, RoomNum *rooms);
-void playerMoveCameraFromPosRoom(struct coord *pos, struct coord *up, struct coord *look, struct coord *memcampos, s32 memcamroom);
-void playerMoveCamera(struct coord *pos, struct coord *up, struct coord *look);
-void playersClearMemCamRoom(void);
-void playerSetPerimEnabled(struct prop *prop, bool enable);
-bool playerUpdateGeometry(struct prop *prop, u8 **start, u8 **end);
-void playerUpdatePerimInfo(void);
-void playerGetBbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
-f32 playerGetHealthFrac(void);
-f32 playerGetShieldFrac(void);
-void playerSetShieldFrac(f32 frac);
-s32 playerGetMissionTime(void);
-s32 playerTickBeams(struct prop *prop);
-s32 playerTickThirdPerson(struct prop *prop);
-void playerChooseThirdPersonAnimation(struct chrdata *chr, s32 crouchpos, f32 speedsideways, f32 speedforwards, f32 speedtheta, f32 *angleoffset, struct attackanimconfig **animcfg);
-Gfx *playerRender(struct prop *prop, Gfx *gdl, bool xlupass);
-Gfx *playerLoadMatrix(Gfx *gdl);
+Gfx *player_draw_fade(Gfx *gdl, u32 r, u32 g, u32 b, f32 frac);
+Gfx *player_draw_stored_fade(Gfx *gdl);
+void player_update_colour_screen_properties(void);
+void player_tick_chr_fade(void);
+void player_display_health(void);
+void player_tick_damage_and_health(void);
+void player_display_damage(void);
+Gfx *player_render_health_bar(Gfx *gdl);
+void player_surround_with_explosions(s32 arg0);
+void player_tick_explode(void);
+void player_reset_lo_res_if_4mb(void);
+s16 player_get_fb_width(void);
+s16 player_get_fb_height(void);
+bool player_has_shared_viewport(void);
+s16 player_get_viewport_width(void);
+s16 player_get_viewport_left(void);
+s16 player_get_viewport_height(void);
+s16 player_get_viewport_top(void);
+f32 player_get_aspect_ratio(void);
+void player_update_shake(void);
+void player_tick_teleport(f32 *arg0);
+void player_configure_vi(void);
+void player_tick(bool arg0);
+void player_allocate_matrices(struct coord *cam_pos, struct coord *cam_look, struct coord *cam_up);
+Gfx *player_update_shoot_rot(Gfx *gdl);
+void player_display_shield(void);
+Gfx *player_render_shield(Gfx *gdl);
+Gfx *player_render_hud(Gfx *gdl);
+void player_die(bool force);
+void player_die_by_shooter(u32 shooter, bool force);
+void player_check_if_shot_in_back(s32 attackerplayernum, f32 x, f32 z);
+f32 player_get_health_bar_height_frac(void);
+void player_move_camera_from_pos_rooms(struct coord *pos, struct coord *up, struct coord *look, struct coord *pos2, RoomNum *rooms);
+void player_move_camera_from_pos_room(struct coord *pos, struct coord *up, struct coord *look, struct coord *memcampos, s32 memcamroom);
+void player_move_camera(struct coord *pos, struct coord *up, struct coord *look);
+void players_clear_mem_cam_room(void);
+void player_set_perim_enabled(struct prop *prop, bool enable);
+bool player_update_geometry(struct prop *prop, u8 **start, u8 **end);
+void player_update_perim_info(void);
+void player_get_bbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
+f32 player_get_health_frac(void);
+f32 player_get_shield_frac(void);
+void player_set_shield_frac(f32 frac);
+s32 player_get_mission_time(void);
+s32 player_tick_beams(struct prop *prop);
+s32 player_tick_third_person(struct prop *prop);
+void player_choose_third_person_animation(struct chrdata *chr, s32 crouchpos, f32 speedsideways, f32 speedforwards, f32 speedtheta, f32 *angleoffset, struct attackanimconfig **animcfg);
+Gfx *player_render(struct prop *prop, Gfx *gdl, bool xlupass);
+Gfx *player_load_matrix(Gfx *gdl);
 void player0f0c3320(Mtxf *matrices, s32 count);
-void playerSetTickMode(s32 tickmode);
-void playerBeginGeFadeIn(void);
-void playersBeginMpSwirl(void);
+void player_set_tick_mode(s32 tickmode);
+void player_begin_ge_fade_in(void);
+void players_begin_mp_swirl(void);
 void player0f0b9a20(void);
-void playerEndCutscene(void);
-void playerPrepareMoveCameraToPad(s16 pad_id);
-void playerPrepareMoveCameraToPreset(struct camerapresetobj *preset, bool hasdir, s32 arg2);
-void playerPrepareMoveCameraToPos(f32 posangle, f32 rotangle, f32 range, f32 height1, f32 height2, s32 padnum);
-void playerStartCutscene2(void);
-void playerSetFadeColour(s32 r, s32 g, s32 b, f32 a);
-void playerAdjustFade(f32 maxfadetime, s32 r, s32 g, s32 b, f32 frac);
-void playerSetFadeFrac(f32 maxfadetime, f32 frac);
-bool playerIsFadeComplete(void);
-void playerStartChrFade(f32 duration60, f32 targetfrac);
-void playerSetHiResEnabled(bool enable);
-void playerAutoWalk(s16 aimpad, u8 walkspeed, u8 turnspeed, u8 lookup, u8 dist);
-void playerLaunchSlayerRocket(struct weaponobj *rocket);
-void playerSetGlobalDrawWorldOffset(s32 room);
-void playerSetGlobalDrawCameraOffset(void);
-bool playerIsHealthVisible(void);
-void playerSetCameraMode(s32 mode);
-void playerSetCamPropertiesInBounds(struct coord *pos, struct coord *up, struct coord *look, s32 room);
-void playerSetCamPropertiesOutOfBounds(struct coord *pos, struct coord *up, struct coord *look, s32 room);
-void playerSetCamProperties(struct coord *pos, struct coord *up, struct coord *look, s32 room);
-void playerClearMemCamRoom(void);
+void player_end_cutscene(void);
+void player_prepare_move_camera_to_pad(s16 pad_id);
+void player_prepare_move_camera_to_preset(struct camerapresetobj *preset, bool hasdir, s32 arg2);
+void player_prepare_move_camera_to_pos(f32 posangle, f32 rotangle, f32 range, f32 height1, f32 height2, s32 padnum);
+void player_start_cutscene2(void);
+void player_set_fade_colour(s32 r, s32 g, s32 b, f32 a);
+void player_adjust_fade(f32 maxfadetime, s32 r, s32 g, s32 b, f32 frac);
+void player_set_fade_frac(f32 maxfadetime, f32 frac);
+bool player_is_fade_complete(void);
+void player_start_chr_fade(f32 duration60, f32 targetfrac);
+void player_set_hi_res_enabled(bool enable);
+void player_auto_walk(s16 aimpad, u8 walkspeed, u8 turnspeed, u8 lookup, u8 dist);
+void player_launch_slayer_rocket(struct weaponobj *rocket);
+void player_set_global_draw_world_offset(s32 room);
+void player_set_global_draw_camera_offset(void);
+bool player_is_health_visible(void);
+void player_set_camera_mode(s32 mode);
+void player_set_cam_properties_in_bounds(struct coord *pos, struct coord *up, struct coord *look, s32 room);
+void player_set_cam_properties_out_of_bounds(struct coord *pos, struct coord *up, struct coord *look, s32 room);
+void player_set_cam_properties(struct coord *pos, struct coord *up, struct coord *look, s32 room);
+void player_clear_mem_cam_room(void);
 
 #endif

src/include/game/playermgr.h

@@ -4,22 +4,22 @@
 #include "data.h"
 #include "types.h"
 
-void playermgrInit(void);
-void playermgrReset(void);
-void playermgrAllocatePlayers(s32 count);
-void playermgrAllocatePlayer(s32 index);
-void playermgrCalculateAiBuddyNums(void);
-void setCurrentPlayerNum(s32 playernum);
-s32 playermgrGetPlayerNumByProp(struct prop *prop);
-void playermgrSetViewSize(s32 viewx, s32 viewy);
-void playermgrSetViewPosition(s32 viewleft, s32 viewtop);
-void playermgrSetFovY(f32 fovy);
-void playermgrSetAspectRatio(f32 aspect);
-s32 playermgrGetModelOfWeapon(s32 weapon);
-void playermgrDeleteWeapon(s32 hand);
-void playermgrCreateWeapon(s32 hand);
-void playermgrShuffle(void);
-s32 playermgrGetOrderOfPlayer(s32 playernum);
-s32 playermgrGetPlayerAtOrder(s32 ordernum);
+void playermgr_init(void);
+void playermgr_reset(void);
+void playermgr_allocate_players(s32 count);
+void playermgr_allocate_player(s32 index);
+void playermgr_calculate_ai_buddy_nums(void);
+void set_current_player_num(s32 playernum);
+s32 playermgr_get_player_num_by_prop(struct prop *prop);
+void playermgr_set_view_size(s32 viewx, s32 viewy);
+void playermgr_set_view_position(s32 viewleft, s32 viewtop);
+void playermgr_set_fov_y(f32 fovy);
+void playermgr_set_aspect_ratio(f32 aspect);
+s32 playermgr_get_model_of_weapon(s32 weapon);
+void playermgr_delete_weapon(s32 hand);
+void playermgr_create_weapon(s32 hand);
+void playermgr_shuffle(void);
+s32 playermgr_get_order_of_player(s32 playernum);
+s32 playermgr_get_player_at_order(s32 ordernum);
 
 #endif

src/include/game/playerreset.h

@@ -4,11 +4,11 @@
 #include "data.h"
 #include "types.h"
 
-void modelmgrReset(void);
-void modelmgrSetLvResetting(bool value);
-void modelmgrAllocateSlots(s32 numobjs, s32 numchrs);
-bool modelmgrLoadProjectileModeldefs(s32 weaponnum);
-void playerInitEyespy(void);
-void playerReset(void);
+void modelmgr_reset(void);
+void modelmgr_set_lv_resetting(bool value);
+void modelmgr_allocate_slots(s32 numobjs, s32 numchrs);
+bool modelmgr_load_projectile_modeldefs(s32 weaponnum);
+void player_init_eyespy(void);
+void player_reset(void);
 
 #endif

src/include/game/portal.h

@@ -4,12 +4,12 @@
 #include "data.h"
 #include "types.h"
 
-void portalSetXluFrac2(s32 portalnum, f32 frac);
-void portalSetXluFrac(s32 portalnum, f32 frac);
-f32 portalGetXluFrac2(s32 arg0);
-f32 portalGetXluFrac(s32 arg0);
+void portal_set_xlu_frac2(s32 portalnum, f32 frac);
+void portal_set_xlu_frac(s32 portalnum, f32 frac);
+f32 portal_get_xlu_frac2(s32 arg0);
+f32 portal_get_xlu_frac(s32 arg0);
 void portal0f0b65a8(s32 numportals);
-void portalsReset(void);
-void acousticReset(void);
+void portals_reset(void);
+void acoustic_reset(void);
 
 #endif

src/include/game/portalconv.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-s32 portalConvertCoordinates(s32 portalnum, s32 *start, struct portalthing2 *things);
+s32 portal_convert_coordinates(s32 portalnum, s32 *start, struct portalthing2 *things);
 
 #endif

src/include/game/prop.h

@@ -6,63 +6,63 @@
 
 extern f32 g_AutoAimScale;
 
-void propsTick(void);
+void props_tick(void);
 
-void propsStop(void);
+void props_stop(void);
 
-void propsSort(void);
-void propEnable(struct prop *prop);
-void propDisable(struct prop *prop);
-struct prop *propAllocate(void);
-void propFree(struct prop *prop);
-void propActivate(struct prop *prop);
-void propActivateThisFrame(struct prop *prop);
-void propDelist(struct prop *prop);
-void propReparent(struct prop *mover, struct prop *adopter);
-void propDetach(struct prop *prop);
-Gfx *propRender(Gfx *gdl, struct prop *prop, bool xlupass);
-Gfx *propsRender(Gfx *gdl, RoomNum renderroomnum, s32 renderpass, RoomNum *roomnumsbyprop);
-void weaponPlayWhooshSound(s32 weaponnum, struct prop *prop);
+void props_sort(void);
+void prop_enable(struct prop *prop);
+void prop_disable(struct prop *prop);
+struct prop *prop_allocate(void);
+void prop_free(struct prop *prop);
+void prop_activate(struct prop *prop);
+void prop_activate_this_frame(struct prop *prop);
+void prop_delist(struct prop *prop);
+void prop_reparent(struct prop *mover, struct prop *adopter);
+void prop_detach(struct prop *prop);
+Gfx *prop_render(Gfx *gdl, struct prop *prop, bool xlupass);
+Gfx *props_render(Gfx *gdl, RoomNum renderroomnum, s32 renderpass, RoomNum *roomnumsbyprop);
+void weapon_play_whoosh_sound(s32 weaponnum, struct prop *prop);
 void func0f060bac(s32 weaponnum, struct prop *prop);
-struct prop *shotCalculateHits(s32 handnum, bool isshooting, struct coord *gunpos2d, struct coord *gundir2d, struct coord *gunpos3d, struct coord *gundir3d, u32 arg6, f32 distance, bool arg8);
-struct prop *propFindAimingAt(s32 handnum, bool isshooting, u32 context);
-void shotCreate(s32 handnum, bool arg1, bool dorandom, s32 numshots, bool arg4);
-void hitCreate(struct shotdata *shotdata, struct prop *prop, f32 hitdistance, s32 hitpart, struct modelnode *bboxnode, struct hitthing *hitthing, s32 arg6, struct modelnode *dlnode, struct model *model, bool slowsbullet, bool bulletproof, struct coord *arg11, struct coord *arg12);
-void handInflictMeleeDamage(s32 handnum, struct gset *gset, bool arg2);
-void handTickAttack(s32 handnum);
-void handsTickAttack(void);
-void propExecuteTickOperation(struct prop *prop, s32 op);
-struct prop *propFindForInteract(bool eyespy);
-void propFindForUplink(void);
-bool currentPlayerInteract(bool eyespy);
-void propPause(struct prop *prop);
-void propUnpause(struct prop *prop);
-void propsTickPlayer(bool islastplayer);
-void propsTickPadEffects(void);
-void propSetPerimEnabled(struct prop *prop, bool enable);
-void propsTestForPickup(void);
+struct prop *shot_calculate_hits(s32 handnum, bool isshooting, struct coord *gunpos2d, struct coord *gundir2d, struct coord *gunpos3d, struct coord *gundir3d, u32 arg6, f32 distance, bool arg8);
+struct prop *prop_find_aiming_at(s32 handnum, bool isshooting, u32 context);
+void shot_create(s32 handnum, bool arg1, bool dorandom, s32 numshots, bool arg4);
+void hit_create(struct shotdata *shotdata, struct prop *prop, f32 hitdistance, s32 hitpart, struct modelnode *bboxnode, struct hitthing *hitthing, s32 arg6, struct modelnode *dlnode, struct model *model, bool slowsbullet, bool bulletproof, struct coord *arg11, struct coord *arg12);
+void hand_inflict_melee_damage(s32 handnum, struct gset *gset, bool arg2);
+void hand_tick_attack(s32 handnum);
+void hands_tick_attack(void);
+void prop_execute_tick_operation(struct prop *prop, s32 op);
+struct prop *prop_find_for_interact(bool eyespy);
+void prop_find_for_uplink(void);
+bool current_player_interact(bool eyespy);
+void prop_pause(struct prop *prop);
+void prop_unpause(struct prop *prop);
+void props_tick_player(bool islastplayer);
+void props_tick_pad_effects(void);
+void prop_set_perim_enabled(struct prop *prop, bool enable);
+void props_test_for_pickup(void);
 f32 func0f06438c(struct prop *prop, struct coord *arg1, f32 *arg2, f32 *arg3, f32 *arg4, bool throughobjects, bool cangangsta, s32 arg7);
-void farsightChooseTarget(void);
-void autoaimTick(void);
-u32 propDoorGetCdTypes(struct prop *prop);
-bool propIsOfCdType(struct prop *prop, u32 types);
-void roomsCopy(RoomNum *srcrooms, RoomNum *dstrooms);
-void roomsAppend(RoomNum *newrooms, RoomNum *dstrooms, s32 maxlen);
-bool arrayIntersects(RoomNum *a, RoomNum *b);
-bool propTryAddToChunk(s16 propnum, s32 chunkindex);
-s32 roomAllocatePropListChunk(s32 room, s32 arg1);
-void propRegisterRoom(struct prop *prop, RoomNum room);
-void propDeregisterRoom(struct prop *prop, RoomNum room);
-void propDeregisterRooms(struct prop *prop);
-void propRegisterRooms(struct prop *prop);
+void farsight_choose_target(void);
+void autoaim_tick(void);
+u32 prop_door_get_cd_types(struct prop *prop);
+bool prop_is_of_cd_type(struct prop *prop, u32 types);
+void rooms_copy(RoomNum *srcrooms, RoomNum *dstrooms);
+void rooms_append(RoomNum *newrooms, RoomNum *dstrooms, s32 maxlen);
+bool array_intersects(RoomNum *a, RoomNum *b);
+bool prop_try_add_to_chunk(s16 propnum, s32 chunkindex);
+s32 room_allocate_prop_list_chunk(s32 room, s32 arg1);
+void prop_register_room(struct prop *prop, RoomNum room);
+void prop_deregister_room(struct prop *prop, RoomNum room);
+void prop_deregister_rooms(struct prop *prop);
+void prop_register_rooms(struct prop *prop);
 void func0f065d1c(struct coord *pos, RoomNum *rooms, struct coord *newpos, RoomNum *newrooms, RoomNum *morerooms, u32 arg5);
 void func0f065dd8(struct coord *pos, RoomNum *rooms, struct coord *newpos, RoomNum *newrooms);
 void func0f065dfc(struct coord *pos, RoomNum *rooms, struct coord *newpos, RoomNum *newrooms, RoomNum *morerooms, u32 arg5);
 void func0f065e74(struct coord *pos, RoomNum *rooms, struct coord *newpos, RoomNum *newrooms);
 void func0f065e98(struct coord *pos, RoomNum *rooms, struct coord *pos2, RoomNum *rooms2);
-void roomGetProps(RoomNum *room, s16 *propnums, s32 len);
-void propsDefragRoomProps(void);
-void propGetBbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
-bool propUpdateGeometry(struct prop *prop, u8 **start, u8 **end);
+void room_get_props(RoomNum *room, s16 *propnums, s32 len);
+void props_defrag_room_props(void);
+void prop_get_bbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
+bool prop_update_geometry(struct prop *prop, u8 **start, u8 **end);
 
 #endif

src/include/game/propobj.h

@@ -15,43 +15,43 @@ extern f32 g_AutogunDamageTxScale;
 extern f32 g_AutogunDamageRxScale;
 extern struct beam *g_ThrownLaptopBeams;
 
-void alarmActivate(void);
-void alarmDeactivate(void);
-bool alarmIsActive(void);
-f32 countdownTimerGetValue60(void);
-bool countdownTimerIsVisible(void);
-bool countdownTimerIsRunning(void);
-void countdownTimerSetRunning(bool running);
-void countdownTimerSetValue60(f32 value);
-void countdownTimerSetVisible(u32 reason, bool visible);
-void countdownTimerTick(void);
-bool doorCallLift(struct prop *doorprop, bool allowclose);
-bool doorIsPadlockFree(struct doorobj *door);
-bool objCanPickupFromSafe(struct defaultobj *obj);
-void objUpdateLinkedScenery(struct defaultobj *obj, struct prop *prop);
-f32 objGetLocalXMin(struct modelrodata_bbox *bbox);
-f32 objGetLocalXMax(struct modelrodata_bbox *bbox);
-f32 objGetLocalYMin(struct modelrodata_bbox *bbox);
-f32 objGetLocalYMax(struct modelrodata_bbox *bbox);
-f32 objGetLocalZMin(struct modelrodata_bbox *bbox);
-f32 objGetLocalZMax(struct modelrodata_bbox *bbox);
-f32 objGetRotatedLocalXMinByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalXMaxByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalYMinByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalYMaxByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalZMinByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalZMaxByMtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
-f32 objGetRotatedLocalXMinByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalXMaxByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalYMinByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalYMaxByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalZMinByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalZMaxByMtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
-f32 objGetRotatedLocalMin(struct modelrodata_bbox *bbox, f32 arg1, f32 arg2, f32 arg3);
-f32 objGetRotatedLocalMax(struct modelrodata_bbox *bbox, f32 arg1, f32 arg2, f32 arg3);
-s32 objCalculateGeoBlockVertices(f32 xmin, f32 xmax, f32 ymin, f32 ymax, f32 zmin, f32 zmax, Mtxf *mtx, struct geoblock *block);
-void objCalculateGeoBlockFromBboxAndMtx(struct modelrodata_bbox *bbox, Mtxf *mtx, struct geoblock *block);
-void objCalculateGeoBlockFromNode19Data(struct modelrodata_type19 *rodata19, struct modelrodata_bbox *bbox, Mtxf *mtx, struct geoblock *block);
+void alarm_activate(void);
+void alarm_deactivate(void);
+bool alarm_is_active(void);
+f32 countdown_timer_get_value60(void);
+bool countdown_timer_is_visible(void);
+bool countdown_timer_is_running(void);
+void countdown_timer_set_running(bool running);
+void countdown_timer_set_value60(f32 value);
+void countdown_timer_set_visible(u32 reason, bool visible);
+void countdown_timer_tick(void);
+bool door_call_lift(struct prop *doorprop, bool allowclose);
+bool door_is_padlock_free(struct doorobj *door);
+bool obj_can_pickup_from_safe(struct defaultobj *obj);
+void obj_update_linked_scenery(struct defaultobj *obj, struct prop *prop);
+f32 obj_get_local_x_min(struct modelrodata_bbox *bbox);
+f32 obj_get_local_x_max(struct modelrodata_bbox *bbox);
+f32 obj_get_local_y_min(struct modelrodata_bbox *bbox);
+f32 obj_get_local_y_max(struct modelrodata_bbox *bbox);
+f32 obj_get_local_z_min(struct modelrodata_bbox *bbox);
+f32 obj_get_local_z_max(struct modelrodata_bbox *bbox);
+f32 obj_get_rotated_local_x_min_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_x_max_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_y_min_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_y_max_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_z_min_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_z_max_by_mtx4(struct modelrodata_bbox *bbox, Mtxf *mtx);
+f32 obj_get_rotated_local_x_min_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_x_max_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_y_min_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_y_max_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_z_min_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_z_max_by_mtx3(struct modelrodata_bbox *bbox, f32 realrot[3][3]);
+f32 obj_get_rotated_local_min(struct modelrodata_bbox *bbox, f32 arg1, f32 arg2, f32 arg3);
+f32 obj_get_rotated_local_max(struct modelrodata_bbox *bbox, f32 arg1, f32 arg2, f32 arg3);
+s32 obj_calculate_geo_block_vertices(f32 xmin, f32 xmax, f32 ymin, f32 ymax, f32 zmin, f32 zmax, Mtxf *mtx, struct geoblock *block);
+void obj_calculate_geo_block_from_bbox_and_mtx(struct modelrodata_bbox *bbox, Mtxf *mtx, struct geoblock *block);
+void obj_calculate_geo_block_from_node19_data(struct modelrodata_type19 *rodata19, struct modelrodata_bbox *bbox, Mtxf *mtx, struct geoblock *block);
 bool func0f0675c8(struct coord *pos, f32 arg1, struct modelrodata_bbox *bbox, Mtxf *mtx);
 bool func0f0677ac(struct coord *coord, struct coord *arg1, struct coord *pos, struct coord *normal, struct coord *up, struct coord *look, f32 xmin, f32 xmax, f32 ymin, f32 ymax, f32 zmin, f32 zmax);
 bool func0f0678f8(struct coord *coord, struct coord *arg1, s32 padnum);
@@ -59,295 +59,295 @@ bool func0f06797c(struct coord *coord, f32 arg1, s32 padnum);
 bool func0f0679ac(struct model *model, f32 *max, f32 *min, f32 arg3[2], f32 arg4[2]);
 void func0f067bc4(struct model *model, f32 *max, f32 *min, s32 axis);
 void func0f067d88(struct model *model, f32 *arg1, f32 *arg2, f32 *arg3, f32 *arg4);
-bool modelGetScreenCoords2(struct model *model, f32 *x2, f32 *x1, f32 *y2, f32 *y1);
-bool modelGetScreenCoords(struct model *model, f32 *x2, f32 *x1, f32 *y2, f32 *y1);
+bool model_get_screen_coords2(struct model *model, f32 *x2, f32 *x1, f32 *y2, f32 *y1);
+bool model_get_screen_coords(struct model *model, f32 *x2, f32 *x1, f32 *y2, f32 *y1);
 void func0f06803c(struct coord *arg0, f32 *arg1, f32 *arg2, f32 *arg3, f32 *arg4);
-struct defaultobj *objFindByPadNum(s32 padnum);
-struct defaultobj *objFindByPos(struct coord *pos, RoomNum *rooms);
-void projectileFree(struct projectile *projectile);
-void projectilesUnrefOwner(struct prop *owner);
-void projectileReset(struct projectile *projectile);
-struct projectile *projectileAllocate(void);
+struct defaultobj *obj_find_by_pad_num(s32 padnum);
+struct defaultobj *obj_find_by_pos(struct coord *pos, RoomNum *rooms);
+void projectile_free(struct projectile *projectile);
+void projectiles_unref_owner(struct prop *owner);
+void projectile_reset(struct projectile *projectile);
+struct projectile *projectile_allocate(void);
 void func0f0685e4(struct prop *prop);
-void projectileSetSticky(struct prop *prop);
-void embedmentFree(struct embedment *embedment);
-struct embedment *embedmentAllocate(void);
-s32 objGetShotsTaken(struct defaultobj *obj);
-s32 objGetDestroyedLevel(struct defaultobj *obj);
+void projectile_set_sticky(struct prop *prop);
+void embedment_free(struct embedment *embedment);
+struct embedment *embedment_allocate(void);
+s32 obj_get_shots_taken(struct defaultobj *obj);
+s32 obj_get_destroyed_level(struct defaultobj *obj);
 struct modelnode *func0f0687e4(struct model *model);
-struct modelnode *modeldefFindBboxNode(struct modeldef *modeldef);
-struct modelrodata_bbox *modeldefFindBboxRodata(struct modeldef *modeldef);
-struct modelnode *modelFindBboxNode(struct model *model);
-struct modelrodata_bbox *modelFindBboxRodata(struct model *model);
-struct modelnode *objFindBboxNode(struct defaultobj *obj);
-struct modelrodata_bbox *objFindBboxRodata(struct defaultobj *obj);
-s32 objGetAverageBrightnessInRooms(RoomNum *rooms, s32 arg1);
+struct modelnode *modeldef_find_bbox_node(struct modeldef *modeldef);
+struct modelrodata_bbox *modeldef_find_bbox_rodata(struct modeldef *modeldef);
+struct modelnode *model_find_bbox_node(struct model *model);
+struct modelrodata_bbox *model_find_bbox_rodata(struct model *model);
+struct modelnode *obj_find_bbox_node(struct defaultobj *obj);
+struct modelrodata_bbox *obj_find_bbox_rodata(struct defaultobj *obj);
+s32 obj_get_average_brightness_in_rooms(RoomNum *rooms, s32 arg1);
 s32 door0f068c04(struct prop *prop, s32 *arg1, s32 *arg2);
 s32 func0f068fc8(struct prop *prop, bool arg1);
-void propCalculateShadeColour(struct prop *prop, u8 *nextcol, u16 floorcol);
-void propCalculateShadeInfo(struct prop *prop, u8 *nextcol, u16 floorcol);
-void colourTween(u8 *col, u8 *nextcol);
-void objMergeColourFracs(s32 *colour, s32 shademode, f32 fracs[4]);
+void prop_calculate_shade_colour(struct prop *prop, u8 *nextcol, u16 floorcol);
+void prop_calculate_shade_info(struct prop *prop, u8 *nextcol, u16 floorcol);
+void colour_tween(u8 *col, u8 *nextcol);
+void obj_merge_colour_fracs(s32 *colour, s32 shademode, f32 fracs[4]);
 void func0f069850(struct defaultobj *obj, struct coord *pos, f32 rot[3][3], struct geocyl *cyl);
 void func0f069b4c(struct defaultobj *obj);
 void func0f069c1c(struct defaultobj *obj);
 void func0f069c70(struct defaultobj *obj, bool arg1, bool arg2);
-void objInitToggleNodes(struct defaultobj *obj);
-void objCreateOneDebris(struct defaultobj *obj, s32 partindex, struct prop *prop);
-void objCreateDebris(struct defaultobj *obj, struct prop *prop);
-struct prop *objInit(struct defaultobj *obj, struct modeldef *modeldef, struct prop *prop, struct model *model);
-struct prop *objInitWithModelDef(struct defaultobj *obj, struct modeldef *modeldef);
-struct prop *objInitWithAutoModel(struct defaultobj *obj);
+void obj_init_toggle_nodes(struct defaultobj *obj);
+void obj_create_one_debris(struct defaultobj *obj, s32 partindex, struct prop *prop);
+void obj_create_debris(struct defaultobj *obj, struct prop *prop);
+struct prop *obj_init(struct defaultobj *obj, struct modeldef *modeldef, struct prop *prop, struct model *model);
+struct prop *obj_init_with_model_def(struct defaultobj *obj, struct modeldef *modeldef);
+struct prop *obj_init_with_auto_model(struct defaultobj *obj);
 void func0f06a580(struct defaultobj *obj, struct coord *pos, Mtxf *matrix, RoomNum *rooms);
 f32 func0f06a620(struct defaultobj *obj);
 void func0f06a730(struct defaultobj *obj, struct coord *arg1, Mtxf *matrix, RoomNum *rooms, struct coord *arg4);
 void func0f06ab60(struct defaultobj *obj, struct coord *arg1, Mtxf *matrix, RoomNum *rooms, struct coord *arg4);
-void objFreeProjectile(struct defaultobj *obj);
-void objFreeEmbedmentOrProjectile(struct prop *prop);
-void objFree(struct defaultobj *obj, bool freeprop, bool canregen);
-void objFreePermanently(struct defaultobj *obj, bool freeprop);
-f32 objGetRadius(struct defaultobj *obj);
+void obj_free_projectile(struct defaultobj *obj);
+void obj_free_embedment_or_projectile(struct prop *prop);
+void obj_free(struct defaultobj *obj, bool freeprop, bool canregen);
+void obj_free_permanently(struct defaultobj *obj, bool freeprop);
+f32 obj_get_radius(struct defaultobj *obj);
 bool func0f06b39c(struct coord *pos, struct coord *dir, struct coord *aimpos, f32 arg3);
 bool func0f06b488(struct prop *prop, struct coord *arg1, struct coord *arg2, struct coord *arg3, struct coord *arg4, struct coord *arg5, f32 *arg6);
 bool func0f06b610(struct defaultobj *obj, struct coord *arg1, struct coord *arg2, struct coord *arg3, f32 arg4, struct coord *arg5, struct coord *arg6, struct coord *arg7, struct coord *arg8, f32 *arg9);
 bool func0f06bea0(struct model *model, struct modelnode *arg1, struct modelnode *arg2, struct coord *arg3, struct coord *arg4, void *arg5, f32 *arg6, struct modelnode **arg7, s32 *hitpart, s32 *arg9, struct modelnode **arg10);
 bool func0f06c28c(struct chrdata *chr, struct coord *arg1, struct coord *arg2, struct coord *arg3, f32 arg4, struct coord *arg5, struct coord *arg6, struct coord *arg7, struct coord *arg8, f32 *arg9);
-bool projectileFindCollidingProp(struct prop *prop, struct coord *pos, struct coord *arg2, u32 cdtypes, struct coord *arg4, struct coord *arg5, RoomNum *rooms);
+bool projectile_find_colliding_prop(struct prop *prop, struct coord *pos, struct coord *arg2, u32 cdtypes, struct coord *arg4, struct coord *arg5, RoomNum *rooms);
 s32 func0f06cd00(struct defaultobj *obj, struct coord *pos, struct coord *arg2, struct coord *arg3);
 bool func0f06d37c(struct defaultobj *obj, struct coord *arg1, struct coord *arg2, struct coord *arg3);
-void applySpeed(f32 *distdone, f32 maxdist, f32 *speed, f32 accel, f32 decel, f32 maxspeed);
-void applyRotation(f32 *angle, f32 maxrot, f32 *speed, f32 accel, f32 decel, f32 maxspeed);
-void projectileFall(struct defaultobj *obj, f32 mtx[3][3]);
-void knifePlayWooshSound(struct defaultobj *obj);
+void apply_speed(f32 *distdone, f32 maxdist, f32 *speed, f32 accel, f32 decel, f32 maxspeed);
+void apply_rotation(f32 *angle, f32 maxrot, f32 *speed, f32 accel, f32 decel, f32 maxspeed);
+void projectile_fall(struct defaultobj *obj, f32 mtx[3][3]);
+void knife_play_woosh_sound(struct defaultobj *obj);
 void func0f06e9cc(struct coord *arg0, Mtxf *arg1);
-void objLand2(struct defaultobj *obj, struct coord *arg1, struct coord *arg2);
-void boltLand(struct weaponobj *weapon, struct coord *arg1);
-void knifeLand(struct defaultobj *obj, struct coord *arg1, struct coord *arg2);
-bool objEmbed(struct prop *prop, struct prop *parent, struct model *model, struct modelnode *node);
-void objLand(struct prop *prop, struct coord *arg1, struct coord *arg2, bool *embedded);
-bool propExplode(struct prop *prop, s32 explosiontype);
-void ammocrateTick(struct prop *ammocrate);
-void weaponTick(struct prop *weapon);
+void obj_land2(struct defaultobj *obj, struct coord *arg1, struct coord *arg2);
+void bolt_land(struct weaponobj *weapon, struct coord *arg1);
+void knife_land(struct defaultobj *obj, struct coord *arg1, struct coord *arg2);
+bool obj_embed(struct prop *prop, struct prop *parent, struct model *model, struct modelnode *node);
+void obj_land(struct prop *prop, struct coord *arg1, struct coord *arg2, bool *embedded);
+bool prop_explode(struct prop *prop, s32 explosiontype);
+void ammocrate_tick(struct prop *ammocrate);
+void weapon_tick(struct prop *weapon);
 void func0f07063c(struct prop *prop, bool fulltick);
-void objDropRecursively(struct prop *prop, bool arg1);
+void obj_drop_recursively(struct prop *prop, bool arg1);
 void func0f0706f8(struct prop *prop, bool fulltick);
 void func0f07079c(struct prop *prop, bool fulltick);
-s32 glassCalculateOpacity(struct coord *pos, f32 xludist, f32 opadist, f32 arg3);
+s32 glass_calculate_opacity(struct coord *pos, f32 xludist, f32 opadist, f32 arg3);
 void func0f070a1c(struct modelrodata_bbox *bbox, f32 realrot[3][3], struct coord *pos, struct coord *vertices);
 void func0f070bd0(struct modelrodata_type19 *rodata, f32 realrot[3][3], struct coord *pos, struct coord *vertices);
 void func0f070ca0(struct defaultobj *obj, struct geotilef *tile, u32 flags, struct modelrodata_bbox *bbox, struct modelrodata_type19 *rodata);
-void liftActivate(struct prop *prop, u8 liftnum);
-struct prop *liftFindByPad(s16 padnum);
-f32 liftGetY(struct liftobj *lift);
-void liftUpdateTiles(struct liftobj *lift, bool stationary);
-void liftGoToStop(struct liftobj *lift, s32 stopnum);
-f32 objGetHovBobOffsetY(struct defaultobj *obj);
-void hovUpdateGround(struct defaultobj *obj, struct hov *hov, struct coord *pos, RoomNum *rooms, f32 matrix[3][3]);
-void hovTick(struct defaultobj *obj, struct hov *hov);
-s32 objIsHoverpropOrBike(struct defaultobj *obj);
-f32 hoverpropGetTurnAngle(struct defaultobj *obj);
-void hoverpropSetTurnAngle(struct defaultobj *obj, f32 angle);
+void lift_activate(struct prop *prop, u8 liftnum);
+struct prop *lift_find_by_pad(s16 padnum);
+f32 lift_get_y(struct liftobj *lift);
+void lift_update_tiles(struct liftobj *lift, bool stationary);
+void lift_go_to_stop(struct liftobj *lift, s32 stopnum);
+f32 obj_get_hov_bob_offset_y(struct defaultobj *obj);
+void hov_update_ground(struct defaultobj *obj, struct hov *hov, struct coord *pos, RoomNum *rooms, f32 matrix[3][3]);
+void hov_tick(struct defaultobj *obj, struct hov *hov);
+s32 obj_is_hoverprop_or_bike(struct defaultobj *obj);
+f32 hoverprop_get_turn_angle(struct defaultobj *obj);
+void hoverprop_set_turn_angle(struct defaultobj *obj, f32 angle);
 s32 func0f072144(struct defaultobj *obj, struct coord *arg1, f32 arg2, bool arg3);
-void hovercarFindNextPath(struct hovercarobj *hovercar);
-void hovercarStartNextPath(struct hovercarobj *hovercar);
-void hovercarIncrementStep(struct hovercarobj *hovercar);
-f32 objCollide(struct defaultobj *obj, struct coord *arg1, f32 arg2);
-void hoverbikeUpdateMovement(struct hoverbikeobj *hoverbike, f32 arg1, f32 arg2, f32 arg3);
-void platformDisplaceProps2(struct prop *platform, Mtxf *arg1);
-bool rocketTickFbw(struct weaponobj *rocket);
-s32 projectileLaunch(struct defaultobj *obj, struct projectile *projectile, struct coord *arg2, struct coord *arg3);
-s32 projectileTick(struct defaultobj *obj, bool *embedded);
-void doorTick(struct prop *doorprop);
-void doorUpdatePortalIfWindowed(struct prop *door, s32 playercount);
-void doorInitMatrices(struct prop *door);
-void platformDisplaceProps(struct prop *platform, s16 *propnums, struct coord *prevpos, struct coord *newpos);
-void liftTick(struct prop *lift);
-void escastepTick(struct prop *escalator);
-void cctvTick(struct prop *camera);
-void cctvInitMatrices(struct prop *cctv, Mtxf *mtx);
-void fanTick(struct prop *fan);
-void fanUpdateModel(struct prop *fan);
-void autogunTick(struct prop *autogun);
-void autogunInitMatrices(struct prop *autogun, Mtxf *mtx);
-void autogunTickShoot(struct prop *autogun);
-void chopperInitMatrices(struct prop *chopper);
-struct chopperobj *chopperFromHovercar(struct chopperobj *obj);
-bool chopperCheckTargetInFov(struct chopperobj *hovercar, u8 param_2);
-bool chopperCheckTargetInSight(struct chopperobj *obj);
-void chopperSetTarget(struct chopperobj *obj, u32 chrnum);
-bool chopperAttack(struct chopperobj *obj);
-bool chopperStop(struct chopperobj *obj);
-bool chopperSetArmed(struct chopperobj *obj, bool armed);
-void chopperRestartTimer(struct chopperobj *obj);
-f32 chopperGetTimer(struct chopperobj *heli);
-void chopperSetMaxDamage(struct chopperobj *obj, u16 health);
+void hovercar_find_next_path(struct hovercarobj *hovercar);
+void hovercar_start_next_path(struct hovercarobj *hovercar);
+void hovercar_increment_step(struct hovercarobj *hovercar);
+f32 obj_collide(struct defaultobj *obj, struct coord *arg1, f32 arg2);
+void hoverbike_update_movement(struct hoverbikeobj *hoverbike, f32 arg1, f32 arg2, f32 arg3);
+void platform_displace_props2(struct prop *platform, Mtxf *arg1);
+bool rocket_tick_fbw(struct weaponobj *rocket);
+s32 projectile_launch(struct defaultobj *obj, struct projectile *projectile, struct coord *arg2, struct coord *arg3);
+s32 projectile_tick(struct defaultobj *obj, bool *embedded);
+void door_tick(struct prop *doorprop);
+void door_update_portal_if_windowed(struct prop *door, s32 playercount);
+void door_init_matrices(struct prop *door);
+void platform_displace_props(struct prop *platform, s16 *propnums, struct coord *prevpos, struct coord *newpos);
+void lift_tick(struct prop *lift);
+void escastep_tick(struct prop *escalator);
+void cctv_tick(struct prop *camera);
+void cctv_init_matrices(struct prop *cctv, Mtxf *mtx);
+void fan_tick(struct prop *fan);
+void fan_update_model(struct prop *fan);
+void autogun_tick(struct prop *autogun);
+void autogun_init_matrices(struct prop *autogun, Mtxf *mtx);
+void autogun_tick_shoot(struct prop *autogun);
+void chopper_init_matrices(struct prop *chopper);
+struct chopperobj *chopper_from_hovercar(struct chopperobj *obj);
+bool chopper_check_target_in_fov(struct chopperobj *hovercar, u8 param_2);
+bool chopper_check_target_in_sight(struct chopperobj *obj);
+void chopper_set_target(struct chopperobj *obj, u32 chrnum);
+bool chopper_attack(struct chopperobj *obj);
+bool chopper_stop(struct chopperobj *obj);
+bool chopper_set_armed(struct chopperobj *obj, bool armed);
+void chopper_restart_timer(struct chopperobj *obj);
+f32 chopper_get_timer(struct chopperobj *heli);
+void chopper_set_max_damage(struct chopperobj *obj, u16 health);
 f32 func0f07b164(struct coord *pos1, struct coord *pos2, struct coord *pos3, struct coord *result);
-void chopperFireRocket(struct chopperobj *chopper, bool side);
-void chopperIncrementBarrel(struct prop *prop, bool firing);
-void chopperIncrementMovement(struct prop *prop, f32 goalroty, f32 goalrotx, struct coord *dir, bool firing);
-void chopperTickFall(struct prop *chopper);
-void chopperTickIdle(struct prop *chopper);
-void chopperTickPatrol(struct prop *chopper);
-void chopperTickCombat(struct prop *chopper);
-void hovercarTick(struct prop *hovercar);
-void hoverpropTick(struct prop *hoverprop, bool arg1);
-void hoverbikeTick(struct prop *hoverbike, bool arg1);
-void dropshipUpdateInterior(struct prop *prop);
-void glassUpdatePortal(struct prop *glass, s32 playercount, bool *arg2);
-void weaponInitMatrices(struct prop *weapon);
-void hangingmonitorInitMatrices(struct prop *hangingmonitors);
-void objInitMatrices(struct prop *prop);
-bool propCanRegen(struct prop *prop);
-u32 objTick(struct prop *prop);
-s32 objTickPlayer(struct prop *prop);
-Gfx *propsRenderBeams(Gfx *gdl);
-void tvscreenSetCmdlist(struct tvscreen *screen, u32 *cmdlist);
-void tvscreenSetImageByNum(struct tvscreen *screen, s32 imagenum);
-void tvscreenSetTexture(struct tvscreen *screen, s32 texturenum);
-Gfx *tvscreenRender(struct model *model, struct modelnode *node, struct tvscreen *screen, Gfx *gdl, s32 arg4, s32 arg5);
-void objRenderProp(struct prop *prop, struct modelrenderdata *renderdata, bool xlupass);
-Gfx *gfxRenderRadialShadow(Gfx *gdl, f32 x, f32 y, f32 z, f32 angle, f32 radius, u32 colour);
-Gfx *objRenderShadow(struct defaultobj *obj, Gfx *gdl);
-Gfx *objRender(struct prop *prop, Gfx *gdl, bool xlupass);
-bool modelIsNodeNotTvscreen(struct modeldef *modeldef, struct modelnode *node);
-void objDeform(struct defaultobj *obj, s32 level);
-void objBounce(struct defaultobj *obj, struct coord *gundir2d);
-void objSetDropped(struct prop *prop, u32 droptype);
-void objApplyMomentum(struct defaultobj *obj, struct coord *speed, f32 rotation, bool addspeed, bool addrotation);
-void piracyRestore(void);
+void chopper_fire_rocket(struct chopperobj *chopper, bool side);
+void chopper_increment_barrel(struct prop *prop, bool firing);
+void chopper_increment_movement(struct prop *prop, f32 goalroty, f32 goalrotx, struct coord *dir, bool firing);
+void chopper_tick_fall(struct prop *chopper);
+void chopper_tick_idle(struct prop *chopper);
+void chopper_tick_patrol(struct prop *chopper);
+void chopper_tick_combat(struct prop *chopper);
+void hovercar_tick(struct prop *hovercar);
+void hoverprop_tick(struct prop *hoverprop, bool arg1);
+void hoverbike_tick(struct prop *hoverbike, bool arg1);
+void dropship_update_interior(struct prop *prop);
+void glass_update_portal(struct prop *glass, s32 playercount, bool *arg2);
+void weapon_init_matrices(struct prop *weapon);
+void hangingmonitor_init_matrices(struct prop *hangingmonitors);
+void obj_init_matrices(struct prop *prop);
+bool prop_can_regen(struct prop *prop);
+u32 obj_tick(struct prop *prop);
+s32 obj_tick_player(struct prop *prop);
+Gfx *props_render_beams(Gfx *gdl);
+void tvscreen_set_cmdlist(struct tvscreen *screen, u32 *cmdlist);
+void tvscreen_set_image_by_num(struct tvscreen *screen, s32 imagenum);
+void tvscreen_set_texture(struct tvscreen *screen, s32 texturenum);
+Gfx *tvscreen_render(struct model *model, struct modelnode *node, struct tvscreen *screen, Gfx *gdl, s32 arg4, s32 arg5);
+void obj_render_prop(struct prop *prop, struct modelrenderdata *renderdata, bool xlupass);
+Gfx *gfx_render_radial_shadow(Gfx *gdl, f32 x, f32 y, f32 z, f32 angle, f32 radius, u32 colour);
+Gfx *obj_render_shadow(struct defaultobj *obj, Gfx *gdl);
+Gfx *obj_render(struct prop *prop, Gfx *gdl, bool xlupass);
+bool model_is_node_not_tvscreen(struct modeldef *modeldef, struct modelnode *node);
+void obj_deform(struct defaultobj *obj, s32 level);
+void obj_bounce(struct defaultobj *obj, struct coord *gundir2d);
+void obj_set_dropped(struct prop *prop, u32 droptype);
+void obj_apply_momentum(struct defaultobj *obj, struct coord *speed, f32 rotation, bool addspeed, bool addrotation);
+void piracy_restore(void);
 void func0f082e84(struct defaultobj *obj, struct coord *pos, struct coord *dir, struct coord *tween, bool addrotation);
-void objDetach(struct prop *prop);
-bool objDrop(struct prop *prop, bool lazy);
-void objFall(struct defaultobj *obj, s32 playernum);
-void objDestroySupportedObjects(struct prop *prop, s32 playernum);
-void objCheckDestroyed(struct defaultobj *obj, struct coord *pos, s32 playernum);
+void obj_detach(struct prop *prop);
+bool obj_drop(struct prop *prop, bool lazy);
+void obj_fall(struct defaultobj *obj, s32 playernum);
+void obj_destroy_supported_objects(struct prop *prop, s32 playernum);
+void obj_check_destroyed(struct defaultobj *obj, struct coord *pos, s32 playernum);
 bool func0f084594(struct model *model, struct modelnode *node, struct coord *arg2, struct coord *arg3, struct hitthing *arg4, s32 *arg5, struct modelnode **arg6);
 bool func0f0849dc(struct model *model, struct modelnode *nodearg, struct coord *arg2, struct coord *arg3, struct hitthing *hitthing, s32 *dstmtxindex, struct modelnode **dstnode);
 u32 add43214321(u32 value);
-void glassDestroy(struct defaultobj *obj);
-void doorDestroyGlass(struct doorobj *door);
-void cctvHandleLensShot(struct defaultobj *obj);
+void glass_destroy(struct defaultobj *obj);
+void door_destroy_glass(struct doorobj *door);
+void cctv_handle_lens_shot(struct defaultobj *obj);
 void func0f085050(struct prop *prop, f32 damage, struct coord *pos, s32 arg3, s32 playernum);
 bool func0f085194(struct defaultobj *obj);
-bool objIsMortal(struct defaultobj *obj);
-void objTakeGunfire(struct defaultobj *obj, f32 damage, struct coord *pos, s32 weaponnum, s32 playernum);
-void objDamage(struct defaultobj *obj, f32 damage, struct coord *pos, s32 weaponnum, s32 playernum);
+bool obj_is_mortal(struct defaultobj *obj);
+void obj_take_gunfire(struct defaultobj *obj, f32 damage, struct coord *pos, s32 weaponnum, s32 playernum);
+void obj_damage(struct defaultobj *obj, f32 damage, struct coord *pos, s32 weaponnum, s32 playernum);
 void func0f0859a0(struct prop *prop, struct shotdata *shotdata);
-void objTestHit(struct prop *prop, struct shotdata *shotdata);
-void objHit(struct shotdata *shotdata, struct hit *hit);
-u32 propobjGetCiTagId(struct prop *prop);
-bool objIsHealthy(struct defaultobj *obj);
-bool objTestForInteract(struct prop *prop);
-bool currentPlayerTryMountHoverbike(struct prop *prop);
-bool propobjInteract(struct prop *prop);
-void objSetPerimEnabled(struct prop *prop, bool enable);
-bool objUpdateGeometry(struct prop *prop, u8 **start, u8 **end);
-void objGetBbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
-void ammotypeGetPickedUpText(char *dst);
-void ammotypeGetDeterminer(char *dst, s32 ammotype, s32 qty);
-void ammotypeGetPickupName(char *dst, s32 ammotype, s32 qty);
-void ammotypePlayPickupSound(u32 ammotype);
-s32 propPlayPickupSound(struct prop *prop, s32 weapon);
-void weaponPlayPickupSound(s32 weaponnum);
-void ammotypeGetPickupMessage(char *dst, s32 ammotype, s32 qty);
-void currentPlayerQueuePickupAmmoHudmsg(s32 ammotype, s32 pickupqty);
-void ammoHandlePickup(s32 ammotype, s32 quantity, bool withsound, bool withhudmsg);
-s32 ammocrateGetPickupAmmoQty(struct ammocrateobj *crate);
-s32 weaponGetPickupAmmoQty(struct weaponobj *weapon);
-void weaponGetPickupText(char *buffer, s32 weaponnum, bool dual);
-void currentPlayerQueuePickupWeaponHudmsg(u32 weaponnum, bool dual);
-s32 propPickupByPlayer(struct prop *prop, bool showhudmsg);
-s32 objTestForPickup(struct prop *prop);
+void obj_test_hit(struct prop *prop, struct shotdata *shotdata);
+void obj_hit(struct shotdata *shotdata, struct hit *hit);
+u32 propobj_get_ci_tag_id(struct prop *prop);
+bool obj_is_healthy(struct defaultobj *obj);
+bool obj_test_for_interact(struct prop *prop);
+bool current_player_try_mount_hoverbike(struct prop *prop);
+bool propobj_interact(struct prop *prop);
+void obj_set_perim_enabled(struct prop *prop, bool enable);
+bool obj_update_geometry(struct prop *prop, u8 **start, u8 **end);
+void obj_get_bbox(struct prop *prop, f32 *radius, f32 *ymax, f32 *ymin);
+void ammotype_get_picked_up_text(char *dst);
+void ammotype_get_determiner(char *dst, s32 ammotype, s32 qty);
+void ammotype_get_pickup_name(char *dst, s32 ammotype, s32 qty);
+void ammotype_play_pickup_sound(u32 ammotype);
+s32 prop_play_pickup_sound(struct prop *prop, s32 weapon);
+void weapon_play_pickup_sound(s32 weaponnum);
+void ammotype_get_pickup_message(char *dst, s32 ammotype, s32 qty);
+void current_player_queue_pickup_ammo_hudmsg(s32 ammotype, s32 pickupqty);
+void ammo_handle_pickup(s32 ammotype, s32 quantity, bool withsound, bool withhudmsg);
+s32 ammocrate_get_pickup_ammo_qty(struct ammocrateobj *crate);
+s32 weapon_get_pickup_ammo_qty(struct weaponobj *weapon);
+void weapon_get_pickup_text(char *buffer, s32 weaponnum, bool dual);
+void current_player_queue_pickup_weapon_hudmsg(u32 weaponnum, bool dual);
+s32 prop_pickup_by_player(struct prop *prop, bool showhudmsg);
+s32 obj_test_for_pickup(struct prop *prop);
 bool func0f0899dc(struct prop *prop, struct coord *arg1, f32 *arg2, f32 *arg3);
-void modelFreeVertices(s32 vtxstoretype, struct model *model);
-struct prop *hatApplyToChr(struct hatobj *hat, struct chrdata *chr, struct modeldef *modeldef, struct prop *prop, struct model *model);
-void hatLoadAndApplyToChr(struct hatobj *hat, struct chrdata *chr);
-void hatAssignToChr(struct hatobj *hat, struct chrdata *chr);
-struct prop *hatCreateForChr(struct chrdata *chr, s32 modelnum, u32 flags);
-struct weaponobj *weaponCreate(bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
-struct hatobj *hatCreate(bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
-struct ammocrateobj *ammocrateAllocate(void);
-struct defaultobj *debrisAllocate(void);
-void playerActivateRemoteMineDetonator(s32 playernum);
-struct weaponobj *weaponFindChildByWeaponNum(s32 weaponnum, struct prop *prop);
-struct weaponobj *weaponFindLanded(s32 weaponnum);
-void weaponRegisterProxy(struct weaponobj *weapon);
-void weaponUnregisterProxy(struct weaponobj *weapon);
-void coordTriggerProxies(struct coord *pos, bool arg1);
-void chrsTriggerProxies(void);
-void propweaponSetDual(struct weaponobj *weapon1, struct weaponobj *weapon2);
+void model_free_vertices(s32 vtxstoretype, struct model *model);
+struct prop *hat_apply_to_chr(struct hatobj *hat, struct chrdata *chr, struct modeldef *modeldef, struct prop *prop, struct model *model);
+void hat_load_and_apply_to_chr(struct hatobj *hat, struct chrdata *chr);
+void hat_assign_to_chr(struct hatobj *hat, struct chrdata *chr);
+struct prop *hat_create_for_chr(struct chrdata *chr, s32 modelnum, u32 flags);
+struct weaponobj *weapon_create(bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
+struct hatobj *hat_create(bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
+struct ammocrateobj *ammocrate_allocate(void);
+struct defaultobj *debris_allocate(void);
+void player_activate_remote_mine_detonator(s32 playernum);
+struct weaponobj *weapon_find_child_by_weapon_num(s32 weaponnum, struct prop *prop);
+struct weaponobj *weapon_find_landed(s32 weaponnum);
+void weapon_register_proxy(struct weaponobj *weapon);
+void weapon_unregister_proxy(struct weaponobj *weapon);
+void coord_trigger_proxies(struct coord *pos, bool arg1);
+void chrs_trigger_proxies(void);
+void propweapon_set_dual(struct weaponobj *weapon1, struct weaponobj *weapon2);
 struct prop *func0f08adc8(struct weaponobj *weapon, struct modeldef *modeldef, struct prop *prop, struct model *model);
 struct prop *func0f08ae0c(struct weaponobj *weapon, struct modeldef *modeldef);
-bool chrEquipWeapon(struct weaponobj *weapon, struct chrdata *chr);
+bool chr_equip_weapon(struct weaponobj *weapon, struct chrdata *chr);
 struct prop *func0f08b108(struct weaponobj *weapon, struct chrdata *chr, struct modeldef *modeldef, struct prop *prop, struct model *model);
 void func0f08b208(struct weaponobj *weapon, struct chrdata *chr);
 void func0f08b25c(struct weaponobj *weapon, struct chrdata *chr);
-struct autogunobj *laptopDeploy(s32 modelnum, struct gset *gset, struct chrdata *chr);
-struct weaponobj *weaponCreateProjectileFromGset(s32 modelnum, struct gset *gset, struct chrdata *chr);
-struct weaponobj *weaponCreateProjectileFromWeaponNum(s32 modelnum, s32 weaponnum, struct chrdata *chr);
-void weaponDeleteFromChr(struct chrdata *chr, s32 hand);
-struct prop *weaponCreateForChr(struct chrdata *chr, s32 modelnum, s32 weaponnum, u32 flags, struct weaponobj *obj, struct modeldef *modeldef);
-struct prop *chrGiveWeapon(struct chrdata *chr, s32 model, s32 weaponnum, u32 flags);
-s32 weaponTestForPickup(struct prop *prop);
-void weaponSetGunfireVisible(struct prop *prop, bool visible, RoomNum room);
-bool weaponIsGunfireVisible(struct prop *prop);
-s32 hatGetType(struct prop *prop);
-bool doorIsUnlocked(struct prop *playerprop, struct prop *doorprop);
-bool doorIsPosInRange(struct doorobj *door, struct coord *pos, f32 arg2, bool isbike);
-bool doorIsObjInRange(struct doorobj *door, struct defaultobj *obj, bool isbike);
-bool vectorIsInFrontOfDoor(struct doorobj *door, struct coord *vector);
-bool doorIsRangeEmpty(struct doorobj *door);
-void doorsCheckAutomatic(void);
+struct autogunobj *laptop_deploy(s32 modelnum, struct gset *gset, struct chrdata *chr);
+struct weaponobj *weapon_create_projectile_from_gset(s32 modelnum, struct gset *gset, struct chrdata *chr);
+struct weaponobj *weapon_create_projectile_from_weapon_num(s32 modelnum, s32 weaponnum, struct chrdata *chr);
+void weapon_delete_from_chr(struct chrdata *chr, s32 hand);
+struct prop *weapon_create_for_chr(struct chrdata *chr, s32 modelnum, s32 weaponnum, u32 flags, struct weaponobj *obj, struct modeldef *modeldef);
+struct prop *chr_give_weapon(struct chrdata *chr, s32 model, s32 weaponnum, u32 flags);
+s32 weapon_test_for_pickup(struct prop *prop);
+void weapon_set_gunfire_visible(struct prop *prop, bool visible, RoomNum room);
+bool weapon_is_gunfire_visible(struct prop *prop);
+s32 hat_get_type(struct prop *prop);
+bool door_is_unlocked(struct prop *playerprop, struct prop *doorprop);
+bool door_is_pos_in_range(struct doorobj *door, struct coord *pos, f32 arg2, bool isbike);
+bool door_is_obj_in_range(struct doorobj *door, struct defaultobj *obj, bool isbike);
+bool vector_is_in_front_of_door(struct doorobj *door, struct coord *vector);
+bool door_is_range_empty(struct doorobj *door);
+void doors_check_automatic(void);
 void func0f08c424(struct doorobj *door, Mtxf *matrix);
-void doorGetBbox(struct doorobj *door, struct modelrodata_bbox *dst);
-void doorUpdateTiles(struct doorobj *door);
+void door_get_bbox(struct doorobj *door, struct modelrodata_bbox *dst);
+void door_update_tiles(struct doorobj *door);
 void door0f08cb20(struct doorobj *door, Vtx *src, Vtx *dst, s32 numvertices);
 void func0f08d3dc(struct doorobj *door);
 void func0f08d460(struct doorobj *door);
-void doorActivatePortal(struct doorobj *door);
-void doorDeactivatePortal(struct doorobj *door);
-struct prop *doorInit(struct doorobj *door, struct coord *pos, Mtxf *mtx, RoomNum *rooms, struct coord *coord, struct coord *centre);
-void doorPlayOpeningSound(s32 soundtype, struct prop *prop);
-void doorPlayClosingSound(s32 soundtype, struct prop *prop);
-void doorPlayOpenedSound(s32 soundtype, struct prop *prop);
-void doorPlayClosedSound(s32 soundtype, struct prop *prop);
-void doorStartOpen(struct doorobj *door);
-void doorStartClose(struct doorobj *door);
-u32 decodeXorAaaaaaaa(u32 value);
-void doorFinishOpen(struct doorobj *door);
-void doorFinishClose(struct doorobj *door);
-void doorSetMode(struct doorobj *door, s32 newmode);
-void doorsRequestMode(struct doorobj *door, s32 newmode);
-s32 doorIsClosed(struct doorobj *door);
-s32 doorIsOpen(struct doorobj *door);
+void door_activate_portal(struct doorobj *door);
+void door_deactivate_portal(struct doorobj *door);
+struct prop *door_init(struct doorobj *door, struct coord *pos, Mtxf *mtx, RoomNum *rooms, struct coord *coord, struct coord *centre);
+void door_play_opening_sound(s32 soundtype, struct prop *prop);
+void door_play_closing_sound(s32 soundtype, struct prop *prop);
+void door_play_opened_sound(s32 soundtype, struct prop *prop);
+void door_play_closed_sound(s32 soundtype, struct prop *prop);
+void door_start_open(struct doorobj *door);
+void door_start_close(struct doorobj *door);
+u32 decode_xor_aaaaaaaa(u32 value);
+void door_finish_open(struct doorobj *door);
+void door_finish_close(struct doorobj *door);
+void door_set_mode(struct doorobj *door, s32 newmode);
+void doors_request_mode(struct doorobj *door, s32 newmode);
+s32 door_is_closed(struct doorobj *door);
+s32 door_is_open(struct doorobj *door);
 s32 func0f08e5a8(RoomNum *rooms, struct screenbox *box);
-f32 objCalculateFadeDistOpacityFrac(struct prop *prop, f32 modelscale);
-bool posIsInObjFadeDistance(struct coord *coord, f32 modelscale);
+f32 obj_calculate_fade_dist_opacity_frac(struct prop *prop, f32 modelscale);
+bool pos_is_in_obj_fade_distance(struct coord *coord, f32 modelscale);
 bool func0f08e8ac(struct prop *prop, struct coord *pos, f32 arg2, bool arg3);
-bool posIsInDrawDistance(struct coord *arg);
-void doorCreateSparks(struct doorobj *door);
-bool doorCalcIntendedFrac(struct doorobj *door);
-void doorsCalcFrac(struct doorobj *door);
+bool pos_is_in_draw_distance(struct coord *arg);
+void door_create_sparks(struct doorobj *door);
+bool door_calc_intended_frac(struct doorobj *door);
+void doors_calc_frac(struct doorobj *door);
 f32 func0f08f538(f32 x, f32 y);
 void door0f08f604(struct doorobj *door, f32 *arg1, f32 *arg2, f32 *arg3, f32 *arg4, bool altcoordsystem);
 bool func0f08f968(struct doorobj *door, bool altcoordsystem);
-bool doorTestForInteract(struct prop *prop);
-void doorsActivate(struct prop *prop, bool allowliftclose);
-bool posIsInFrontOfDoor(struct coord *pos, struct doorobj *door);
-void doorsChooseSwingDirection(struct prop *chrprop, struct doorobj *door);
-bool propdoorInteract(struct prop *doorprop);
-void alarmStopAudio(void);
-void gasReleaseFromPos(struct coord *pos);
-void gasStopAudio(void);
-bool gasIsActive(void);
-void gasTick(void);
-Gfx *countdownTimerRender(Gfx *gdl);
-void projectilesDebug(void);
-void alarmTick(void);
+bool door_test_for_interact(struct prop *prop);
+void doors_activate(struct prop *prop, bool allowliftclose);
+bool pos_is_in_front_of_door(struct coord *pos, struct doorobj *door);
+void doors_choose_swing_direction(struct prop *chrprop, struct doorobj *door);
+bool propdoor_interact(struct prop *doorprop);
+void alarm_stop_audio(void);
+void gas_release_from_pos(struct coord *pos);
+void gas_stop_audio(void);
+bool gas_is_active(void);
+void gas_tick(void);
+Gfx *countdown_timer_render(Gfx *gdl);
+void projectiles_debug(void);
+void alarm_tick(void);
 void func0f091030(void);
-void currentPlayerDropAllItems(void);
-void weaponCreateForPlayerDrop(s32 weaponnum);
-void projectileCreate(struct prop *fromprop, struct fireslotthing *arg1, struct coord *pos, struct coord *direction, u8 weaponnum, struct prop *targetprop);
-void objSetModelPartVisible(struct defaultobj *obj, s32 partnum, bool visible);
+void current_player_drop_all_items(void);
+void weapon_create_for_player_drop(s32 weaponnum);
+void projectile_create(struct prop *fromprop, struct fireslotthing *arg1, struct coord *pos, struct coord *direction, u8 weaponnum, struct prop *targetprop);
+void obj_set_model_part_visible(struct defaultobj *obj, s32 partnum, bool visible);
 
 #endif

src/include/game/propobjstop.h

@@ -4,6 +4,6 @@
 #include "data.h"
 #include "types.h"
 
-void objsStop(void);
+void objs_stop(void);
 
 #endif

src/include/game/propsnd.h

@@ -4,35 +4,35 @@
 #include "data.h"
 #include "types.h"
 
-void psReset(void);
+void ps_reset(void);
 
-void psStop(void);
+void ps_stop(void);
 
-bool psPropHasSoundWithContext(struct prop *prop, s32 type);
-void psStopSound(struct prop *prop, s32 type, u16 flags);
-s32 psCalculateVolumeFromDistance(f32 playerdist, f32 dist1, f32 dist2, f32 dist3, s32 fullvolume);
-s32 psGetVolume(s32 channelnum);
-void psCreateIfNotDupe(struct prop *prop, s16 soundnum, s32 type);
-void psStopChannel(s32 channelnum);
-void psPrintChannel(struct pschannel *channel);
-s32 psGetSubtitleOpacity(s32 channelnum);
-void psTickChannel(s32 channelnum);
-void psTick(void);
-void psSetPitch(struct prop *prop, f32 targetpitch, s32 changespeed);
-void psSetVolume(struct prop *prop, s32 vol);
-void psStopOneShootChannel(struct prop *prop);
-s16 psCreate(struct pschannel *channel, struct prop *prop, s16 soundnum, s16 padnum, s32 vol, u16 flags, u16 flags2, s32 type, struct coord *pos, f32 pitch, RoomNum *rooms, s32 room, f32 dist1, f32 dist2, f32 dist3);
-s32 psPlayFromProp(s32 channelnum, s16 soundnum, s32 vol, struct prop *prop, s16 type, u16 flags);
-void psMuteChannel(s32 channelnum);
-bool psIsChannelFree(s32 channelnum);
-void psModify(s32 channelnum, s32 arg1, s16 padnum, struct prop *prop, s32 volchangetimer60, s32 dist2, s32 dist3, u16 flags);
-s32 psCalculateVol(struct coord *pos, f32 arg1, f32 arg2, f32 arg3, RoomNum *rooms, s16 soundnum, s32 arg6, f32 *arg7);
-s32 psCalculatePan3(s32 degrees, f32 arg1, struct pschannel *channel);
-s32 psCalculatePan2(struct coord *pos, s32 arg1, f32 arg2, struct pschannel *channel);
-s32 psCalculatePan(struct coord *pos, f32 dist1, f32 dist2, f32 dist3, f32 playerdist, bool arg5, struct pschannel *channel);
-void psGetTheoreticalVolPan(struct coord *pos, RoomNum *rooms, s16 soundnum, s32 *vol, s32 *pan);
-void psApplyVolPan(struct sndstate *handle, struct coord *pos, f32 dist1, f32 dist2, f32 dist3, RoomNum *rooms, s16 soundnum, s32 arg7, f32 *distanceptr);
-s32 psGetRandomSparkSound(void);
-s32 psGetDuration60(s32 channelnum);
+bool ps_prop_has_sound_with_context(struct prop *prop, s32 type);
+void ps_stop_sound(struct prop *prop, s32 type, u16 flags);
+s32 ps_calculate_volume_from_distance(f32 playerdist, f32 dist1, f32 dist2, f32 dist3, s32 fullvolume);
+s32 ps_get_volume(s32 channelnum);
+void ps_create_if_not_dupe(struct prop *prop, s16 soundnum, s32 type);
+void ps_stop_channel(s32 channelnum);
+void ps_print_channel(struct pschannel *channel);
+s32 ps_get_subtitle_opacity(s32 channelnum);
+void ps_tick_channel(s32 channelnum);
+void ps_tick(void);
+void ps_set_pitch(struct prop *prop, f32 targetpitch, s32 changespeed);
+void ps_set_volume(struct prop *prop, s32 vol);
+void ps_stop_one_shoot_channel(struct prop *prop);
+s16 ps_create(struct pschannel *channel, struct prop *prop, s16 soundnum, s16 padnum, s32 vol, u16 flags, u16 flags2, s32 type, struct coord *pos, f32 pitch, RoomNum *rooms, s32 room, f32 dist1, f32 dist2, f32 dist3);
+s32 ps_play_from_prop(s32 channelnum, s16 soundnum, s32 vol, struct prop *prop, s16 type, u16 flags);
+void ps_mute_channel(s32 channelnum);
+bool ps_is_channel_free(s32 channelnum);
+void ps_modify(s32 channelnum, s32 arg1, s16 padnum, struct prop *prop, s32 volchangetimer60, s32 dist2, s32 dist3, u16 flags);
+s32 ps_calculate_vol(struct coord *pos, f32 arg1, f32 arg2, f32 arg3, RoomNum *rooms, s16 soundnum, s32 arg6, f32 *arg7);
+s32 ps_calculate_pan3(s32 degrees, f32 arg1, struct pschannel *channel);
+s32 ps_calculate_pan2(struct coord *pos, s32 arg1, f32 arg2, struct pschannel *channel);
+s32 ps_calculate_pan(struct coord *pos, f32 dist1, f32 dist2, f32 dist3, f32 playerdist, bool arg5, struct pschannel *channel);
+void ps_get_theoretical_vol_pan(struct coord *pos, RoomNum *rooms, s16 soundnum, s32 *vol, s32 *pan);
+void ps_apply_vol_pan(struct sndstate *handle, struct coord *pos, f32 dist1, f32 dist2, f32 dist3, RoomNum *rooms, s16 soundnum, s32 arg7, f32 *distanceptr);
+s32 ps_get_random_spark_sound(void);
+s32 ps_get_duration60(s32 channelnum);
 
 #endif

src/include/game/quaternion.h

@@ -5,12 +5,12 @@
 #include "types.h"
 
 void quaternion0f096ca0(struct coord *arg0, f32 quat[4]);
-void quaternionToMtx(f32 arg0[4], Mtxf *arg1);
+void quaternion_to_mtx(f32 arg0[4], Mtxf *arg1);
 void quaternion0f097044(Mtxf *matrix, f32 arg1[4]);
-void quaternionToTransformMtx(struct coord *pos, f32 rot[4], Mtxf *matrix);
-void quaternionSlerp(f32 q1[4], f32 q2[4], f32 t, f32 result[4]);
+void quaternion_to_transform_mtx(struct coord *pos, f32 rot[4], Mtxf *matrix);
+void quaternion_slerp(f32 q1[4], f32 q2[4], f32 t, f32 result[4]);
 void quaternion0f097518(f32 q[4], f32 t, f32 result[4]);
 void quaternion0f0976c0(f32 q1[4], f32 q2[4]);
-void quaternionMultQuaternion(f32 a[4], f32 b[4], f32 result[4]);
+void quaternion_mult_quaternion(f32 a[4], f32 b[4], f32 result[4]);
 
 #endif

src/include/game/race.h

@@ -4,14 +4,14 @@
 #include "data.h"
 #include "types.h"
 
-void racesInit(void);
+void races_init(void);
 
-u16 raceGetAnimSumAngleAsInt(s16 animnum, s32 frame, s32 endframe);
-s32 raceGetAnimSumForwardAsInt(s16 animnum, s32 startframe, s32 endframe);
-s32 raceInitAnimGroup(struct attackanimconfig *configs);
-void raceInitAnimGroups(struct attackanimgroup **groups);
-s32 raceCountAnims(struct animtablerow *rows);
+u16 race_get_anim_sum_angle_as_int(s16 animnum, s32 frame, s32 endframe);
+s32 race_get_anim_sum_forward_as_int(s16 animnum, s32 startframe, s32 endframe);
+s32 race_init_anim_group(struct attackanimconfig *configs);
+void race_init_anim_groups(struct attackanimgroup **groups);
+s32 race_count_anims(struct animtablerow *rows);
 f32 race0f0005c0(s16 animnum);
-void raceInitAnims(void);
+void race_init_anims(void);
 
 #endif

src/include/game/radar.h

@@ -4,10 +4,10 @@
 #include "data.h"
 #include "types.h"
 
-Gfx *radarRenderBackground(Gfx *gdl, struct textureconfig *tconfig, s32 arg2, s32 arg3, s32 arg4);
-s32 radarGetTeamIndex(s32 team);
-Gfx *radarDrawDot(Gfx *gdl, struct prop *prop, struct coord *dist, u32 colour1, u32 colour2, bool swapcolours);
-Gfx *radarRender(Gfx *gdl);
-Gfx *radarRenderRTrackedProps(Gfx *gdl);
+Gfx *radar_render_background(Gfx *gdl, struct textureconfig *tconfig, s32 arg2, s32 arg3, s32 arg4);
+s32 radar_get_team_index(s32 team);
+Gfx *radar_draw_dot(Gfx *gdl, struct prop *prop, struct coord *dist, u32 colour1, u32 colour2, bool swapcolours);
+Gfx *radar_render(Gfx *gdl);
+Gfx *radar_render_r_tracked_props(Gfx *gdl);
 
 #endif

src/include/game/room.h

@@ -4,19 +4,19 @@
 #include "data.h"
 #include "types.h"
 
-void roomsReset(void);
+void rooms_reset(void);
 
-void roomsTick(void);
+void rooms_tick(void);
 
-void roomSetLastForOffset(s32 room);
-void roomLinkMtx(s32 index, s32 roomnum);
-void roomUnlinkMtx(s32 index, s32 roomnum);
-void roomFreeMtx(s32 index);
-s32 roomAllocateMtx(void);
-void roomPopulateMtx(Mtxf *matrix, s32 roomnum);
-s32 roomTouchMtx(s32 roomnum);
-Gfx *roomApplyMtx(Gfx *gdl, s32 roomnum);
-struct coord *roomGetPosPtr(s32 room);
-void roomGetPos(s32 room, struct coord *pos);
+void room_set_last_for_offset(s32 room);
+void room_link_mtx(s32 index, s32 roomnum);
+void room_unlink_mtx(s32 index, s32 roomnum);
+void room_free_mtx(s32 index);
+s32 room_allocate_mtx(void);
+void room_populate_mtx(Mtxf *matrix, s32 roomnum);
+s32 room_touch_mtx(s32 roomnum);
+Gfx *room_apply_mtx(Gfx *gdl, s32 roomnum);
+struct coord *room_get_pos_ptr(s32 room);
+void room_get_pos(s32 room, struct coord *pos);
 
 #endif

src/include/game/savebuffer.h

@@ -10,20 +10,20 @@ Gfx *func0f0d479c(Gfx *gdl);
 Gfx *func0f0d49c8(Gfx *gdl);
 Gfx *func0f0d4a3c(Gfx *gdl, s32 arg1);
 Gfx *func0f0d4c80(Gfx *gdl);
-Gfx *menugfxDrawPlane(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2, s32 type);
-void savebufferOr(struct savebuffer *buffer, u32 arg1, s32 arg2);
-void savebufferWriteBits(struct savebuffer *buffer, u32 value, s32 numbits, u8 *dst);
-u32 savebufferReadBits(struct savebuffer *buffer, s32 offset);
-void savebufferClear(struct savebuffer *buffer);
+Gfx *menugfx_draw_plane(Gfx *gdl, s32 x1, s32 y1, s32 x2, s32 y2, u32 colour1, u32 colour2, s32 type);
+void savebuffer_or(struct savebuffer *buffer, u32 arg1, s32 arg2);
+void savebuffer_write_bits(struct savebuffer *buffer, u32 value, s32 numbits, u8 *dst);
+u32 savebuffer_read_bits(struct savebuffer *buffer, s32 offset);
+void savebuffer_clear(struct savebuffer *buffer);
 void func0f0d5484(struct savebuffer *buffer, u8 *data, u8 len);
 void func0f0d54c4(struct savebuffer *buffer);
-void savebufferReadString(struct savebuffer *buffer, char *dst, bool addlinebreak);
+void savebuffer_read_string(struct savebuffer *buffer, char *dst, bool addlinebreak);
 void func0f0d55a4(struct savebuffer *buffer, char *src);
 void func0f0d564c(u8 *data, char *dst, bool addlinebreak);
 void func0f0d5690(u8 *dst, char *buffer);
-void savebufferWriteGuid(struct savebuffer *buffer, struct fileguid *guid);
-void savebufferReadGuid(struct savebuffer *buffer, struct fileguid *guid);
-void formatTime(char *dst, s32 time60, s32 precision);
+void savebuffer_write_guid(struct savebuffer *buffer, struct fileguid *guid);
+void savebuffer_read_guid(struct savebuffer *buffer, struct fileguid *guid);
+void format_time(char *dst, s32 time60, s32 precision);
 void func0f0d5a7c(void);
 
 #endif

src/include/game/setup.h

@@ -4,35 +4,35 @@
 #include "data.h"
 #include "types.h"
 
-void setupPreparePads(void);
-void setupLoadWaypoints(void);
-void setupPrepareCover(void);
+void setup_prepare_pads(void);
+void setup_load_waypoints(void);
+void setup_prepare_cover(void);
 
-void propsReset(void);
-void setupCreateLiftDoor(struct linkliftdoorobj *link);
-void setupCreatePadlockedDoor(struct padlockeddoorobj *link);
-void setupCreateSafeItem(struct safeitemobj *link);
-void setupCreateConditionalScenery(struct linksceneryobj *link);
-void setupCreateBlockedPath(struct blockedpathobj *link);
-void setupReset0f00cc8c(void);
-void setupResetProxyMines(void);
-s32 setupCountCommandType(u32 type);
-void setupCreateObject(struct defaultobj *obj, s32 cmdindex);
-void setupPlaceWeapon(struct weaponobj *weapon, s32 cmdindex);
-void setupCreateHat(struct hatobj *hat, s32 cmdindex);
-void setupCreateKey(struct keyobj *key, s32 cmdindex);
-void setupCreateMine(struct mineobj *mine, s32 cmdindex);
-void setupCreateCctv(struct cctvobj *camera, s32 cmdindex);
-void setupCreateAutogun(struct autogunobj *autogun, s32 cmdindex);
-void setupCreateHangingMonitors(struct hangingmonitorsobj *monitors, s32 cmdindex);
-void setupCreateSingleMonitor(struct singlemonitorobj *monitor, s32 cmdindex);
-void setupCreateMultiMonitor(struct multimonitorobj *monitor, s32 cmdindex);
-s32 setupGetPortalByPad(s32 padnum);
-s32 setupGetPortalByDoorPad(s32 padnum);
-void setupCreateDoor(struct doorobj *door, s32 cmdindex);
-void setupCreateHov(struct defaultobj *obj, struct hov *hov);
-void setupLoadBriefing(s32 stagenum, u8 *buffer, s32 bufferlen, struct briefing *briefing);
-void setupLoadFiles(s32 stagenum);
-void setupCreateProps(s32 stagenum);
+void props_reset(void);
+void setup_create_lift_door(struct linkliftdoorobj *link);
+void setup_create_padlocked_door(struct padlockeddoorobj *link);
+void setup_create_safe_item(struct safeitemobj *link);
+void setup_create_conditional_scenery(struct linksceneryobj *link);
+void setup_create_blocked_path(struct blockedpathobj *link);
+void setup_reset_0f00cc8c(void);
+void setup_reset_proxy_mines(void);
+s32 setup_count_command_type(u32 type);
+void setup_create_object(struct defaultobj *obj, s32 cmdindex);
+void setup_place_weapon(struct weaponobj *weapon, s32 cmdindex);
+void setup_create_hat(struct hatobj *hat, s32 cmdindex);
+void setup_create_key(struct keyobj *key, s32 cmdindex);
+void setup_create_mine(struct mineobj *mine, s32 cmdindex);
+void setup_create_cctv(struct cctvobj *camera, s32 cmdindex);
+void setup_create_autogun(struct autogunobj *autogun, s32 cmdindex);
+void setup_create_hanging_monitors(struct hangingmonitorsobj *monitors, s32 cmdindex);
+void setup_create_single_monitor(struct singlemonitorobj *monitor, s32 cmdindex);
+void setup_create_multi_monitor(struct multimonitorobj *monitor, s32 cmdindex);
+s32 setup_get_portal_by_pad(s32 padnum);
+s32 setup_get_portal_by_door_pad(s32 padnum);
+void setup_create_door(struct doorobj *door, s32 cmdindex);
+void setup_create_hov(struct defaultobj *obj, struct hov *hov);
+void setup_load_briefing(s32 stagenum, u8 *buffer, s32 bufferlen, struct briefing *briefing);
+void setup_load_files(s32 stagenum);
+void setup_create_props(s32 stagenum);
 
 #endif

src/include/game/setuputils.h

@@ -4,16 +4,16 @@
 #include "data.h"
 #include "types.h"
 
-u32 setupGetCmdLength(u32 *cmd);
-u32 *setupGetCmdByIndex(s32 cmdindex);
-s32 setupGetCmdIndexByTag(struct tag *tag);
-u32 setupGetCmdIndexByProp(struct prop *prop);
-bool setupLoadModeldef(s32 modelnum);
-bool setupGetObjBbox(struct defaultobj *obj, struct coord *pos, f32 realrot[3][3], struct coord *arg3, struct coord *arg4);
+u32 setup_get_cmd_length(u32 *cmd);
+u32 *setup_get_cmd_by_index(s32 cmdindex);
+s32 setup_get_cmd_index_by_tag(struct tag *tag);
+u32 setup_get_cmd_index_by_prop(struct prop *prop);
+bool setup_load_modeldef(s32 modelnum);
+bool setup_get_obj_bbox(struct defaultobj *obj, struct coord *pos, f32 realrot[3][3], struct coord *arg3, struct coord *arg4);
 bool setup0f092304(struct defaultobj *obj, struct coord *arg1, struct coord *arg2);
 void setup0f09233c(struct defaultobj *obj, struct coord *pos, f32 realrot[3][3], RoomNum *rooms);
 void setup0f0923d4(struct defaultobj *obj);
-struct defaultobj *setupGetObjByCmdIndex(u32 cmdindex);
-struct defaultobj *setupFindObjForReuse(s32 type, struct defaultobj **arg1, struct defaultobj **arg2, bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
+struct defaultobj *setup_get_obj_by_cmd_index(u32 cmdindex);
+struct defaultobj *setup_find_obj_for_reuse(s32 type, struct defaultobj **arg1, struct defaultobj **arg2, bool musthaveprop, bool musthavemodel, struct modeldef *modeldef);
 
 #endif

src/include/game/shards.h

@@ -4,10 +4,10 @@
 #include "data.h"
 #include "types.h"
 
-void shardsCreate(struct coord *pos, f32 *rotx, f32 *roty, f32 *rotz, f32 xmin, f32 xmax, f32 ymin, f32 ymax, s32 type, struct prop *prop);
-void shardsReset(void);
-Gfx *shardsRender(Gfx *gdl);
-void shardsStop(void);
-void shardsTick(void);
+void shards_create(struct coord *pos, f32 *rotx, f32 *roty, f32 *rotz, f32 xmin, f32 xmax, f32 ymin, f32 ymax, s32 type, struct prop *prop);
+void shards_reset(void);
+Gfx *shards_render(Gfx *gdl);
+void shards_stop(void);
+void shards_tick(void);
 
 #endif

src/include/game/sight.h

@@ -4,25 +4,25 @@
 #include "data.h"
 #include "types.h"
 
-bool sightIsPropFriendly(struct prop *prop);
-bool sightCanTargetProp(struct prop *prop, s32 max);
-bool sightIsReactiveToProp(struct prop *prop);
-s32 sightFindFreeTargetIndex(s32 max);
+bool sight_is_prop_friendly(struct prop *prop);
+bool sight_can_target_prop(struct prop *prop, s32 max);
+bool sight_is_reactive_to_prop(struct prop *prop);
+s32 sight_find_free_target_index(s32 max);
 void func0f0d7364(void);
-void sightTick(bool sighton);
-s32 sightCalculateBoxBound(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
-Gfx *sightDrawTargetBox(Gfx *gdl, struct trackedprop *trackedprop, s32 textid, s32 time);
-Gfx *sightDrawAimer(Gfx *gdl, s32 x, s32 y, s32 radius, s32 cornergap, u32 colour);
-Gfx *sightDrawDelayedAimer(Gfx *gdl, s32 x, s32 y, s32 radius, s32 cornergap, u32 colour);
-Gfx *sightDrawDefault(Gfx *gdl, bool sighton);
-Gfx *sightDrawClassic(Gfx *gdl, bool sighton);
-Gfx *sightDrawType2(Gfx *gdl, bool sighton);
-Gfx *sightDrawSkedarTriangle(Gfx *gdl, s32 x, s32 y, s32 dir, u32 colour);
-Gfx *sightDrawSkedar(Gfx *gdl, bool sighton);
-Gfx *sightDrawZoom(Gfx *gdl, bool sighton);
-Gfx *sightDrawMaian(Gfx *gdl, bool sighton);
-Gfx *sightDrawTarget(Gfx *gdl);
-bool sightHasTargetWhileAiming(s32 sight);
-Gfx *sightDraw(Gfx *gdl, bool sighton, s32 sight);
+void sight_tick(bool sighton);
+s32 sight_calculate_box_bound(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
+Gfx *sight_draw_target_box(Gfx *gdl, struct trackedprop *trackedprop, s32 textid, s32 time);
+Gfx *sight_draw_aimer(Gfx *gdl, s32 x, s32 y, s32 radius, s32 cornergap, u32 colour);
+Gfx *sight_draw_delayed_aimer(Gfx *gdl, s32 x, s32 y, s32 radius, s32 cornergap, u32 colour);
+Gfx *sight_draw_default(Gfx *gdl, bool sighton);
+Gfx *sight_draw_classic(Gfx *gdl, bool sighton);
+Gfx *sight_draw_type2(Gfx *gdl, bool sighton);
+Gfx *sight_draw_skedar_triangle(Gfx *gdl, s32 x, s32 y, s32 dir, u32 colour);
+Gfx *sight_draw_skedar(Gfx *gdl, bool sighton);
+Gfx *sight_draw_zoom(Gfx *gdl, bool sighton);
+Gfx *sight_draw_maian(Gfx *gdl, bool sighton);
+Gfx *sight_draw_target(Gfx *gdl);
+bool sight_has_target_while_aiming(s32 sight);
+Gfx *sight_draw(Gfx *gdl, bool sighton, s32 sight);
 
 #endif