steam-frame/Cesarus85--ringfall-mjolnir-vr
1
0 Fork 0
mirror of https://github.com/Cesarus85/ringfall-mjolnir-vr.git synced 2026-10-21 07:00:27 +02:00
Code Issues Packages Projects Releases 16 Wiki Activity
Files
94de711dc1a2946d4beca9173845142b8a797bb4
Cesarus85--ringfall-mjolnir-vr/source/main/main.c
T

1883 lines
45 KiB
C
Raw Blame History

/*
MAIN.C
symbols in this file:
000EF6F0 0010:
_main_get_seconds_elapsed (0000)
000EF700 0080:
_gamepad_button_is_down (0000)
000EF780 0010:
_game_connection_set (0000)
000EF790 0010:
_game_connection (0000)
000EF7A0 0010:
_main_disallow_persistent_storage (0000)
000EF7B0 0060:
_main_set_map_name (0000)
000EF810 0010:
_main_defer_map_map_change (0000)
000EF820 0030:
_main_set_multiplayer_map_name (0000)
000EF850 0010:
_main_get_map_name (0000)
000EF860 0010:
_main_get_multiplayer_map_name (0000)
000EF870 0020:
_main_set_difficulty (0000)
000EF890 0010:
_main_get_difficulty (0000)
000EF8A0 0040:
_code_000ef8a0 (0000)
000EF8E0 01d0:
_code_000ef8e0 (0000)
000EFAB0 0020:
_main_reset_map (0000)
000EFAD0 0020:
_main_revert_map (0000)
000EFAF0 0020:
_main_skip_cinematic (0000)
000EFB10 0010:
_main_save_map_nonsafe (0000)
000EFB20 0010:
_main_saving_map (0000)
000EFB30 0010:
_main_save_cancel (0000)
000EFB40 0040:
_main_save_map_safe (0000)
000EFB80 0010:
_main_won_map (0000)
000EFB90 0010:
_main_lost_map (0000)
000EFBA0 0020:
_main_respawn (0000)
000EFBC0 0020:
_main_save_core (0000)
000EFBE0 0050:
_main_save_core_name (0000)
000EFC30 0020:
_main_load_core (0000)
000EFC50 0020:
_main_load_core_at_startup (0000)
000EFC70 0050:
_main_load_core_name (0000)
000EFCC0 0050:
_main_load_core_name_at_startup (0000)
000EFD10 0060:
_main_switch_structure_bsp (0000)
000EFD70 0030:
_main_skip (0000)
000EFDA0 0040:
_main_queue_map_name (0000)
000EFDE0 0050:
_code_000efde0 (0000)
000EFE30 0020:
_main_goto_main_menu (0000)
000EFE50 0050:
_main_menu_precache_resources (0000)
000EFEA0 0020:
_main_menu_unload (0000)
000EFEC0 0010:
_main_menu_ensure_player_queues_exist (0000)
000EFED0 0010:
_main_menu_fade_active (0000)
000EFEE0 0010:
_main_menu_switch_to_single_player (0000)
000EFEF0 0010:
_main_set_game_connection_to_film_playback (0000)
000EFF00 0170:
_main_get_solo_level_from_name (0000)
000F0070 0010:
_main_get_current_solo_level (0000)
000F0080 0020:
_main_get_solo_level_name (0000)
000F00A0 0010:
_main_run_demos (0000)
000F00B0 0070:
_code_000f00b0 (0000)
000F0120 01f0:
_compute_window_bounds (0000)
000F0310 0040:
_main_get_window_count (0000)
000F0350 00d0:
_code_000f0350 (0000)
000F0420 0180:
_code_000f0420 (0000)
000F05A0 0020:
_code_000f05a0 (0000)
000F05C0 0030:
_code_000f05c0 (0000)
000F05F0 00b0:
_code_000f05f0 (0000)
000F06A0 0020:
_code_000f06a0 (0000)
000F06C0 00e0:
_code_000f06c0 (0000)
000F07A0 0030:
_code_000f07a0 (0000)
000F07D0 0040:
_code_000f07d0 (0000)
000F0810 0040:
_code_000f0810 (0000)
000F0850 0060:
_code_000f0850 (0000)
000F08B0 0020:
_code_000f08b0 (0000)
000F08D0 0020:
_code_000f08d0 (0000)
000F08F0 0040:
_code_000f08f0 (0000)
000F0930 0010:
_code_000f0930 (0000)
000F0940 0220:
_code_000f0940 (0000)
000F0B60 0050:
_code_000f0b60 (0000)
000F0BB0 0030:
_code_000f0bb0 (0000)
000F0BE0 0010:
_code_000f0be0 (0000)
000F0BF0 05a0:
_code_000f0bf0 (0000)
000F1190 0210:
_main_rasterizer_throttle (0000)
000F13A0 0020:
_code_000f13a0 (0000)
000F13C0 0020:
_main_taking_screenshot (0000)
000F13E0 00b0:
_main_movie_start (0000)
000F1490 0020:
_main_movie_stop (0000)
000F14B0 0010:
_main_stop_time (0000)
000F14C0 0010:
_main_start_time (0000)
000F14D0 0010:
_main_crash (0000)
000F14E0 0010:
_main_print_version (0000)
000F14F0 00c0:
_main_vertical_blank_interrupt_handler (0000)
000F15B0 0070:
_main_save_current_solo_map (0000)
000F1620 00c0:
_main_load_last_solo_map (0000)
000F16E0 0040:
_main_save_map_no_timeout (0000)
000F1720 00e0:
_main_load_ui_scenario (0000)
000F1800 0090:
_main_menu_load (0000)
000F1890 0020:
_main_roll_credits (0000)
000F18B0 0130:
_main_pregame_render (0000)
000F19E0 01b0:
_set_window_camera_values (0000)
000F1B90 0090:
_main_present_frame (0000)
000F1C20 00c0:
_code_000f1c20 (0000)
000F1CE0 0050:
_code_000f1ce0 (0000)
000F1D30 01f0:
_code_000f1d30 (0000)
000F1F20 02a0:
_main_framerate_render (0000)
000F21C0 02a0:
_halt_and_catch_fire (0000)
000F2460 0040:
_main_loop_of_death (0000)
000F24A0 01c0:
_code_000f24a0 (0000)
000F2660 0670:
_main_loop (0000)
002795A8 003a:
??_C@_0DK@GMPCKHNN@button_index?$DO?$DN0?5?$CG?$CG?5button_index?$DM@ (0000)
002795E4 001b:
??_C@_0BL@EKABHJPH@c?3?2halo?2SOURCE?2main?2main?4c?$AA@ (0000)
00279600 0037:
??_C@_0DH@DGKBOONK@?$CIgamepad_index?$DO?$DN0?$CJ?5?$CG?$CG?5?$CIgamepad_i@ (0000)
00279638 0013:
??_C@_0BD@OOOKAGFE@j?$DMMAXIMUM_GAMEPADS?$AA@ (0000)
00279650 0049:
??_C@_0EJ@DIAKEACK@?$CIdesired_controllers?$FLi?$FN?$DO?$DN0?$CJ?5?$CG?$CG?5?$CI@ (0000)
0027969C 002c:
??_C@_0CM@EOEJOPGF@game_connection?$CI?$CJ?5?$DN?$DN?5_game_conne@ (0000)
002796C8 0009:
??_C@_08FLLKDKH@core?4bin?$AA@ (0000)
002796D4 003b:
??_C@_0DL@LKJEADLD@warning?0?5core?5file?5name?5will?5be?5@ (0000)
00279710 002c:
??_C@_0CM@BPJFOCNH@tried?5to?5switch?5to?5invalid?5struc@ (0000)
0027973C 002c:
??_C@_0CM@IOHNOMHF@tried?5to?5switch?5to?5current?5struc@ (0000)
00279768 0030:
??_C@_0DA@FGIPPFOE@cannot?5skip?5more?5than?515?5frames?5@ (0000)
00279798 0029:
??_C@_0CJ@GNBMIDNC@scenario?9?$DOtype?$DN?$DN_scenario_type_m@ (0000)
002797C4 000e:
??_C@_0O@OJNPMJKK@num_players?$DO0?$AA@ (0000)
002797D4 0039:
??_C@_0DJ@LGIIGICN@horizontal_index?$DO?$DN0?5?$CG?$CG?5horizonta@ (0000)
00279810 0033:
??_C@_0DD@NNOBFMAG@vertical_index?$DO?$DN0?5?$CG?$CG?5vertical_in@ (0000)
00279844 0019:
??_C@_0BJ@LDIFOEOI@player_index?$DMnum_players?$AA@ (0000)
00279860 0017:
??_C@_0BH@PGKHPIFN@main_new_map?$CI?$CJ?5failed?4?$AA@ (0000)
00279878 0014:
??_C@_0BE@HPJEDLPC@game_load?$CI?$CJ?5failed?4?$AA@ (0000)
00279890 0041:
??_C@_0EB@NLDLOJCN@manual?5skipping?5doesn?8t?5work?5out@ (0000)
002798D4 000c:
??_C@_0M@NBLPJHAH@unsafe?5save?$AA@ (0000)
002798E0 0017:
??_C@_0BH@JAFGAFKC@gave?5up?5trying?5to?5save?$AA@ (0000)
002798F8 001f:
??_C@_0BP@JOHDPJOL@?$DLcore_load_name_at_startup?5?$CFs?6?$AA@ (0000)
00279918 0004:
??_C@_03CCGKKFHG@a?$CLt?$AA@ (0000)
0027991C 000d:
??_C@_0N@HMFDKLFI@map_name?5?$CFs?6?$AA@ (0000)
0027992C 0003:
??_C@_02BKFDOEMK@wt?$AA@ (0000)
00279930 000f:
??_C@_0P@JFNDGJMB@d?3?2?$CFs_init?4txt?$AA@ (0000)
00279940 001e:
??_C@_0BO@EFIKKGLE@?$CFs_slow_?$CFd_?$CFd_?$CFd_?$CFd_?$CFd_?$CFd?4bin?$AA@ (0000)
00279960 0008:
__real@3fa26e978d4fdf3c (0000)
00279968 0013:
??_C@_0BD@BANPCAEP@?5des?5?$CFd?5targ?$CF6I64d?$AA@ (0000)
0027997C 000d:
??_C@_0N@ONKBMNKN@?5MAINTAIN?5?$CFd?$AA@ (0000)
0027998C 000d:
??_C@_0N@MLBLHBF@?5RESTORE?5?5?$CFd?$AA@ (0000)
0027999C 000d:
??_C@_0N@KHJNGILI@?5FAILDOWN?5?$CFd?$AA@ (0000)
002799AC 000d:
??_C@_0N@KAJPDIPB@?$CI?$CFs?$CF2d?1?$CF2d?$CJ?5?$AA@ (0000)
002799BC 0003:
??_C@_02LEBOADDI@dn?$AA@ (0000)
002799C0 000c:
??_C@_0M@FONKJGHM@?$CIok?5?5?5?$CF2d?$CJ?5?$AA@ (0000)
002799CC 0006:
??_C@_05MPKPLMMK@ignor?$AA@ (0000)
002799D4 0009:
??_C@_08NGBFCLJE@?$CI?$CFs?$CF2d?$CJ?5?$AA@ (0000)
002799E0 0006:
??_C@_05KGKFECIJ@fail?5?$AA@ (0000)
002799E8 003a:
??_C@_0DK@KGLGNIMB@last?$CF6I64d?5init?$CF6I64d?5achv?$CF6I64d@ (0000)
00279A24 0019:
??_C@_0BJ@GBFFHJIM@?$CF6I64d?$CItarg?$CF6I64d?5?$CFs?$CF2d?$CJ?$AA@ (0000)
00279A40 0009:
??_C@_08EEAEDAMO@LAPSED?5?5?$AA@ (0000)
00279A4C 0009:
??_C@_08KMBEHCPI@SYNCED?5?5?$AA@ (0000)
00279A58 0009:
??_C@_08PLAGFMEO@THROTTLE?$AA@ (0000)
00279A68 004a:
??_C@_0EK@OBDHCGCK@stuck?5waiting?5for?5VBLANK?5callbac@ (0000)
00279AB4 0006:
??_C@_05PAONDCEJ@movie?$AA@ (0000)
00279ABC 0019:
??_C@_0BJ@MFOKCFOP@main_globals?4movie?$DN?$DNNULL?$AA@ (0000)
00279AD8 002a:
??_C@_0CK@IJIKLLCA@chucky?5was?5here?$CB?5?5NULL?5belongs?5t@ (0000)
00279B04 0031:
??_C@_0DB@HPIOCFDH@halobeta?5xbox?501?401?414?42342?5Jan?5@ (0000)
00279B38 0038:
??_C@_0DI@IKBOMHNJ@Couldn?8t?5create?5a?5file?5to?5write?5@ (0000)
00279B70 0011:
??_C@_0BB@HAHOOKLD@z?3?2last_solo?4txt?$AA@ (0000)
00279B84 0028:
??_C@_0CI@KPDFMEMF@?$CBmain_globals?4main_menu_scenario@ (0000)
00279BAC 000d:
??_C@_0N@CBIELCEF@levels?2ui?2ui?$AA@ (0000)
00279BBC 0023:
??_C@_0CD@IMDNHNHI@congratulations?0?5you?5won?5the?5gam@ (0000)
00279BE0 0014:
??_C@_0BE@BDDOCJAN@movie?2frame?$CF06d?4tga?$AA@ (0000)
00279BF4 0019:
??_C@_0BJ@CKCGDFO@error?5opening?5saved?5film?$AA@ (0000)
00279C10 0015:
??_C@_0BF@LPIHHLNO@?$CFdscreenshot?$CFd?$CFd?4tif?$AA@ (0000)
00279C28 003b:
??_C@_0DL@LMMABMNB@halobeta?5xbox?501?401?414?42342?5buil@ (0000)
00279C64 001f:
??_C@_0BP@HEAODFIJ@old?5tags?2internal?5system?5plain?$AA@ (0000)
00279C84 0012:
??_C@_0BC@FLAPBDJB@end?5of?5saved?5film?$AA@ (0000)
00279C98 0018:
??_C@_0BI@HBMJOOEK@the?5game?5host?5went?5down?$AA@ (0000)
00307818 0034:
_global_difficulty_level (0000)
_player_spawn_count (0004)
_global_frame_rate_throttle (0006)
_global_screenshot_size (0008)
00455750 0a63:
_bss_00455750 (0000)
_debug_force_frame_rate_update (06d0)
_debug_no_drawing (06d1)
_debug_game_save (06d2)
_debug_frame_rate (06d3)
_display_framerate (06d4)
_display_vblank_deltas (06d5)
_display_precache_progress (06d6)
_global_screenshot_count (06d8)
*/
/* ---------- headers */
#include "cseries.h"
#include "errors.h"
#include "cseries/profile.h"
#include "main.h"
#include "real_math.h"
#include "game.h"
#include "game_engine.h"
#include "game/cheats.h"
#include "game/player_control.h"
#include "game/player_control_runtime.h"
#include "game/players.h"
#include "integer_math.h"
#include "main/main_runtime.h"
#include "input.h"
#include "shell.h"
#include "event_manager.h"
#include "telnet_console.h"
#include "ui_widget.h"
#include "editor_stubs.h"
#include "console.h"
#include "debug_keys.h"
#include "scenario.h"
#include "scenario/scenario_definitions.h"
#include "cache/cache_files.h"
#include "cache/predicted_resources.h"
#include "bitmaps/bitmaps_internal.h"
#include "interface/hud.h"
#include "interface/terminal.h"
#include "saved games/player_profile.h"
#include "saved games/game_state.h"
#include "rasterizer/rasterizer.h"
#include "bink/bink_playback.h"
#include "main/d3d_intimacy.h"
#include "networking/network_game_globals.h"
#include "camera/director.h"
#include "camera/observer.h"
#include "cutscene/cinematics.h"
#include "physics/collision_usage.h"
#include "physics/collision_debug.h"
#include "hs/hs.h"
#include "render/render.h"
#include "tag_files/files.h"
/* ---------- constants */
/* ---------- macros */
/* ---------- structures */
/*
struct _main_globals
{
long long last_time_clocks; // 0x0
unsigned long last_time_msec; // 0x8
long long last_render_clocks; // 0x10
long long last_vblank_index; // 0x18
long long last_initial_vblank_index; // 0x20
long long last_achievable_vblank_index; // 0x28
long long last_present_vblank_index; // 0x30
unsigned char did_time_overflow_occur; // 0x38
float seconds_elapsed; // 0x3C
short connection; // 0x40
unsigned short screenshot_identifier; // 0x42
bitmap_data *movie; // 0x44
long recording_start_tick; // 0x48
long recording_stop_tick; // 0x4C
long recording_frame_index; // 0x50
float recording_dt; // 0x54
unsigned char reset_map; // 0x58
unsigned char rename_map; // 0x59
unsigned char revert_map; // 0x5A
unsigned char skip_cinematic; // 0x5B
unsigned char save_map; // 0x5C
unsigned char save_map_safely; // 0x5D
unsigned char save_map_timeout; // 0x5E
unsigned char saving_map; // 0x5F
long ticks_until_next_save_check; // 0x60
long ticks_unable_to_save; // 0x64
unsigned long map_change_load_timer; // 0x68
short safe_intervals; // 0x6C
unsigned char won_map; // 0x6E
unsigned char lost_map; // 0x6F
unsigned char respawn; // 0x70
unsigned char save_core; // 0x71
unsigned char load_core; // 0x72
unsigned char load_core_at_startup; // 0x73
short switch_to_structure_bsp_index; // 0x74
unsigned char main_menu_scenario_loaded; // 0x76
unsigned char want_to_be_at_main_menu; // 0x77
unsigned char run_xdemos; // 0x78
unsigned char fade_to_dashboard; // 0x79
unsigned char exit_to_dashboard; // 0x7A
unsigned char want_to_exit; // 0x7B
long idle_timeout; // 0x7C
long idle_last_interesting; // 0x80
long idle_last_activity; // 0x84
unsigned char playback_last_recording; // 0x88
unsigned char halt_time_scale; // 0x89
unsigned char restart_time; // 0x8A
unsigned char load_last_solo_level; // 0x8B
unsigned char cutscene_skip; // 0x8C
short skip_ticks; // 0x8E
short loss_timer; // 0x90
short respawn_timer; // 0x92
unsigned char queue_map; // 0x94
unsigned char pad0[3]; // 0x95
unsigned char solo_try_and_load_from_persistent_storage; // 0x98
char soloplayer_map_name[256]; // 0x99
char multiplayer_map_name[256]; // 0x199
char queued_map_name[256]; // 0x299
unsigned char want_to_connect; // 0x399
char connect_address[32]; // 0x39A
char connect_password[9]; // 0x3BA
short vblank_interval_current; // 0x3C4
short vblank_interval_minimum; // 0x3C6
unsigned char vblank_interval_held; // 0x3C8
short vblank_failure_count[6]; // 0x3CA
long long vblank_last_failure_time[6]; // 0x3D8
unsigned long *vblank_flip_counter; // 0x408
short vblank_flip_delta_next_index; // 0x40C
short vblank_flip_deltas[15]; // 0x40E
};
*/
struct _main_globals
{
unsigned long frame_start_milliseconds;
byte reservedB4[4];
unsigned long rasterizer_frame_index;
unsigned long rasterizer_vertical_blank_index;
byte reservedC0[0x18];
real seconds_elapsed;
short connection;
byte __unknownDE[2];
struct bitmap_data *movie;
long recording_start_tick;
long recording_stop_tick;
long recording_frame_index;
real recording_dt;
boolean reset_map;
boolean defer_map_change;
boolean revert_map;
boolean skip_cinematic;
boolean saving_map;
boolean save_map_safely;
boolean save_map_timeout;
boolean save_map_completed;
long ticks_until_next_save_check;
long ticks_unable_to_save;
unsigned long map_change_load_timer;
short safe_intervals;
boolean won_map;
boolean lost_map;
boolean respawn;
boolean save_core;
boolean load_core;
boolean load_core_at_startup;
short switch_to_structure_bsp_index;
boolean main_menu_scenario_loaded;
boolean want_to_be_at_main_menu;
boolean run_xdemos;
byte __unknown115;
boolean halt_time_scale;
boolean restart_time;
boolean load_last_solo_level;
boolean skip;
short skip_ticks;
short loss_timer;
short respawn_timer;
boolean queue_map;
byte __unknown121[0x3];
boolean allow_persistent_storage;
char soloplayer_map_name[256];
char multiplayer_map_name[256];
char queued_map_name[256];
char core_name[64];
byte reserved465[0x43];
volatile unsigned int *d3d_flip_count;
short vblank_flip_delta_index;
short vblank_flip_deltas[15];
byte reserved4CC[0x204];
};
typedef char main_globals_size_assert[
sizeof(struct _main_globals) == 0x620 ? 1 : -1];
typedef char main_globals_frame_start_milliseconds_offset_assert[
offsetof(struct _main_globals, frame_start_milliseconds) == 0x00 ? 1 : -1];
typedef char main_globals_rasterizer_frame_index_offset_assert[
offsetof(struct _main_globals, rasterizer_frame_index) == 0x08 ? 1 : -1];
typedef char main_globals_rasterizer_vertical_blank_index_offset_assert[
offsetof(struct _main_globals, rasterizer_vertical_blank_index) == 0x0C ? 1 : -1];
typedef char main_globals_seconds_elapsed_offset_assert[
offsetof(struct _main_globals, seconds_elapsed) == 0x28 ? 1 : -1];
typedef char main_globals_connection_offset_assert[
offsetof(struct _main_globals, connection) == 0x2C ? 1 : -1];
typedef char main_globals_movie_offset_assert[
offsetof(struct _main_globals, movie) == 0x30 ? 1 : -1];
typedef char main_globals_defer_map_change_offset_assert[
offsetof(struct _main_globals, defer_map_change) == 0x45 ? 1 : -1];
typedef char main_globals_reset_map_offset_assert[
offsetof(struct _main_globals, reset_map) == 0x44 ? 1 : -1];
typedef char main_globals_revert_map_offset_assert[
offsetof(struct _main_globals, revert_map) == 0x46 ? 1 : -1];
typedef char main_globals_skip_cinematic_offset_assert[
offsetof(struct _main_globals, skip_cinematic) == 0x47 ? 1 : -1];
typedef char main_globals_saving_map_offset_assert[
offsetof(struct _main_globals, saving_map) == 0x48 ? 1 : -1];
typedef char main_globals_save_map_safely_offset_assert[
offsetof(struct _main_globals, save_map_safely) == 0x49 ? 1 : -1];
typedef char main_globals_won_map_offset_assert[
offsetof(struct _main_globals, won_map) == 0x5A ? 1 : -1];
typedef char main_globals_halt_time_scale_offset_assert[
offsetof(struct _main_globals, halt_time_scale) == 0x66 ? 1 : -1];
typedef char main_globals_respawn_timer_offset_assert[
offsetof(struct _main_globals, respawn_timer) == 0x6E ? 1 : -1];
typedef char main_globals_loss_timer_offset_assert[
offsetof(struct _main_globals, loss_timer) == 0x6C ? 1 : -1];
typedef char main_globals_allow_persistent_storage_offset_assert[
offsetof(struct _main_globals, allow_persistent_storage) == 0x74 ? 1 : -1];
typedef char main_globals_soloplayer_map_name_offset_assert[
offsetof(struct _main_globals, soloplayer_map_name) == 0x75 ? 1 : -1];
typedef char main_globals_multiplayer_map_name_offset_assert[
offsetof(struct _main_globals, multiplayer_map_name) == 0x175 ? 1 : -1];
typedef char main_globals_core_name_offset_assert[
offsetof(struct _main_globals, core_name) == 0x375 ? 1 : -1];
typedef char main_globals_d3d_flip_count_offset_assert[
offsetof(struct _main_globals, d3d_flip_count) == 0x3F8 ? 1 : -1];
typedef char main_globals_vblank_flip_delta_index_offset_assert[
offsetof(struct _main_globals, vblank_flip_delta_index) == 0x3FC ? 1 : -1];
typedef char main_globals_vblank_flip_deltas_offset_assert[
offsetof(struct _main_globals, vblank_flip_deltas) == 0x3FE ? 1 : -1];
struct game_options
{
unsigned long flags;
short code_version;
short difficulty;
unsigned long random_seed;
char map_name[256];
};
typedef char game_options_size_assert[
sizeof(struct game_options) == 0x10C ? 1 : -1];
struct _main_window_storage
{
struct render_window window;
byte reservedAC[4];
};
/* ---------- prototypes */
extern void create_local_players(
void);
extern void main_setup_connection(void);
extern void main_initialize_time(void);
extern void main_change_map_name(void);
extern void main_skip_private(void);
extern void main_update_time(void);
extern void main_save_map_private(void);
extern void main_game_render(
double time_delta_since_tick_sec);
extern void main_frame_rate_debug(void);
extern void main_new_map(
struct game_options *options);
extern void scripted_camera_set(
word camera_point_index0,
word camera_point_index1,
long transition_time);
extern struct bitmap_data *bitmap_2d_new(
short width,
short height,
short mipmap_count,
short format);
extern char const *tiff_export(
struct file_reference *file,
struct bitmap_data *bitmap);
extern short global_screenshot_count;
extern void hs_runtime_initialize_for_new_map(
void);
extern void main_rasterizer_throttle(void);
extern void main_pregame_render(void);
extern void main_present_frame(void);
/* ---------- globals */
short global_difficulty_level = 1;
short player_spawn_count = 1;
byte global_frame_rate_throttle = 1;
short global_screenshot_size = 1;
static char const *scenario_paths[10] =
{
"levels\\a10\\a10",
"levels\\a30\\a30",
"levels\\a50\\a50",
"levels\\b30\\b30",
"levels\\b40\\b40",
"levels\\c10\\c10",
"levels\\c20\\c20",
"levels\\c40\\c40",
"levels\\d20\\d20",
"levels\\d40\\d40"
};
static struct _main_window_storage window_storage = { 0 };
static struct _main_globals main_globals = { 0 };
boolean debug_force_frame_rate_update = FALSE;
boolean debug_no_drawing = FALSE;
boolean debug_game_save = FALSE;
boolean debug_frame_rate = FALSE;
boolean display_framerate = FALSE;
boolean display_vblank_deltas = FALSE;
boolean display_precache_progress = FALSE;
/* ---------- public code */
real main_get_seconds_elapsed(
void)
{
return main_globals.seconds_elapsed;
}
boolean gamepad_button_is_down(
short button_index)
{
short gamepad_index;
boolean result = FALSE;
match_assert("c:\\halo\\SOURCE\\main\\main.c", 245,
button_index>=0 && button_index<NUMBER_OF_GAMEPAD_BUTTONS);
gamepad_index = 0;
do
{
if (input_has_gamepad(gamepad_index))
break;
gamepad_index++;
}
while (gamepad_index < MAXIMUM_GAMEPADS);
if (gamepad_index < MAXIMUM_GAMEPADS)
{
struct gamepad_state const *gamepad = input_get_gamepad_state(gamepad_index);
result = gamepad->buttons[button_index] > 0;
}
return result;
}
void game_connection_set(
short connection)
{
main_globals.connection = connection;
return;
}
short game_connection(
void)
{
return main_globals.connection;
}
void main_disallow_persistent_storage(
void)
{
main_globals.allow_persistent_storage = FALSE;
return;
}
void main_defer_map_map_change(
void)
{
main_globals.defer_map_change = FALSE;
return;
}
char *main_get_map_name(
void)
{
return main_globals.soloplayer_map_name;
}
char *main_get_multiplayer_map_name(
void)
{
return main_globals.multiplayer_map_name;
}
short main_get_difficulty(
void)
{
return global_difficulty_level;
}
boolean main_saving_map(
void)
{
return main_globals.saving_map;
}
void main_save_cancel(
void)
{
main_globals.saving_map = FALSE;
return;
}
void main_won_map(
void)
{
main_globals.saving_map = FALSE;
main_globals.won_map = TRUE;
return;
}
void main_lost_map(
void)
{
main_globals.saving_map = FALSE;
main_globals.lost_map = TRUE;
return;
}
void main_stop_time(
void)
{
main_globals.halt_time_scale = FALSE;
main_globals.restart_time = FALSE;
return;
}
void main_start_time(
void)
{
main_globals.restart_time = TRUE;
return;
}
void main_reset_map(
void)
{
main_globals.switch_to_structure_bsp_index = NONE;
main_globals.saving_map = FALSE;
main_globals.reset_map = TRUE;
main_globals.lost_map = FALSE;
return;
}
void main_revert_map(
void)
{
main_globals.switch_to_structure_bsp_index = NONE;
main_globals.saving_map = FALSE;
main_globals.revert_map = TRUE;
main_globals.lost_map = FALSE;
return;
}
void main_skip_cinematic(
void)
{
main_globals.switch_to_structure_bsp_index = NONE;
main_globals.saving_map = FALSE;
main_globals.skip_cinematic = TRUE;
return;
}
void main_save_map_nonsafe(
void)
{
main_globals.saving_map = TRUE;
main_globals.save_map_safely = FALSE;
return;
}
void main_respawn(
boolean in_multiplayer)
{
main_globals.respawn = TRUE;
if (in_multiplayer)
main_globals.respawn_timer = 91;
return;
}
void main_save_core(
void)
{
main_globals.save_core = TRUE;
csstrcpy(main_globals.core_name, "core.bin");
return;
}
void main_save_core_name(
char const *core_name)
{
match_vwarn("c:\\halo\\SOURCE\\main\\main.c", 0x3a5, csstrlen(core_name) < 64, "warning, core file name will be truncated to 63 characters");
csstrncpy(main_globals.core_name, core_name, 63);
main_globals.save_core = TRUE;
return;
}
void main_load_core(
void)
{
main_globals.load_core = TRUE;
csstrcpy(main_globals.core_name, "core.bin");
return;
}
void main_load_core_at_startup(
void)
{
main_globals.load_core_at_startup = TRUE;
csstrcpy(main_globals.core_name, "core.bin");
return;
}
void main_load_core_name(
char const *core_name)
{
match_vwarn("c:\\halo\\SOURCE\\main\\main.c", 0x3c9, csstrlen(core_name) < 64, "warning, core file name will be truncated to 63 characters");
csstrncpy(main_globals.core_name, core_name, 63);
main_globals.load_core = TRUE;
return;
}
void main_load_core_name_at_startup(
char const *core_name)
{
match_vwarn("c:\\halo\\SOURCE\\main\\main.c", 0x3d7, csstrlen(core_name) < 64, "warning, core file name will be truncated to 63 characters");
csstrncpy(main_globals.core_name, core_name, 63);
main_globals.load_core_at_startup = TRUE;
return;
}
void main_switch_structure_bsp(
short structure_bsp_index)
{
struct scenario *scenario = global_scenario_get();
if (structure_bsp_index < 0 || structure_bsp_index >= scenario->structure_bsp_references.count)
{
console_warning("tried to switch to invalid structure-bsp %d", structure_bsp_index);
return;
}
if (structure_bsp_index == global_structure_bsp_index)
{
console_warning("tried to switch to current structure-bsp %d", structure_bsp_index);
return;
}
main_globals.switch_to_structure_bsp_index = structure_bsp_index;
hud_load(TRUE);
return;
}
void main_goto_main_menu(
void)
{
main_globals.switch_to_structure_bsp_index = NONE;
main_globals.saving_map = FALSE;
main_globals.want_to_be_at_main_menu = TRUE;
return;
}
void main_queue_map_private(
void)
{
real progress;
if (cache_files_precache_in_progress() && cache_files_precache_map_status(&progress) == 1)
cache_files_precache_map_end();
if (!cache_files_precache_in_progress())
{
cache_files_precache_map_begin(main_globals.queued_map_name, FALSE);
main_globals.queue_map = FALSE;
}
return;
}
void main_menu_precache_resources(
void)
{
struct scenario *scenario = global_scenario_get();
if (scenario)
{
match_assert("c:\\halo\\SOURCE\\main\\main.c", 0x46d, scenario->type==_scenario_type_main_menu);
predicted_resources_precache(&scenario->predicted_ui_resources);
}
return;
}
void main_menu_unload(
void)
{
ui_stop_main_menu_music();
main_menu_active(FALSE);
main_globals.main_menu_scenario_loaded = FALSE;
return;
}
extern void update_server_delete(
void);
extern void update_server_new(
void);
extern void update_server_start(
void);
void main_menu_load(
void)
{
if (!main_globals.main_menu_scenario_loaded)
main_load_ui_scenario(FALSE);
main_screen_shell_load();
main_menu_precache_resources();
update_server_delete();
update_server_new();
update_server_start();
game_time_dispose_from_old_map();
game_time_initialize_for_new_map();
game_time_start();
hs_runtime_dispose_from_old_map();
hs_runtime_initialize_for_new_map();
main_globals.want_to_be_at_main_menu = FALSE;
return;
}
static void screenshot_record(
struct bitmap_data *screen,
struct file_reference *file)
{
char const *error_message = tiff_export(file, screen);
if (error_message)
error(_error_silent, error_message);
return;
}
void main_present_frame(
void)
{
struct file_reference reference;
char path[512];
render_frame_present(NULL, main_globals.movie);
if (global_screenshot_count <= 0 && main_globals.movie)
{
_snprintf(
path,
NUMBEROF(path),
"movie\\frame%06d.tga",
main_globals.recording_frame_index++);
file_reference_create_from_path(&reference, path, FALSE);
screenshot_record(main_globals.movie, &reference);
}
return;
}
void main_menu_ensure_player_queues_exist(
void)
{
update_server_delete();
update_server_new();
update_server_start();
return;
}
boolean main_menu_fade_active(
void)
{
return main_globals.map_change_load_timer != 0;
}
void main_menu_switch_to_single_player(
void)
{
main_globals.defer_map_change = TRUE;
return;
}
void main_set_game_connection_to_film_playback(
void)
{
main_globals.__unknown115 = TRUE;
return;
}
extern short main_get_solo_level_from_name(
char const *name);
short main_get_current_solo_level(
void)
{
return main_get_solo_level_from_name(main_globals.soloplayer_map_name);
}
char const *main_get_solo_level_name(
short level)
{
char const *result = NULL;
if (level >= 0 && level < NUMBEROF(scenario_paths))
result = scenario_paths[level];
return result;
}
void main_run_demos(
void)
{
main_globals.run_xdemos = TRUE;
return;
}
static void compute_subframe_counts(
long num_players,
long *horizontal_count,
long *vertical_count)
{
long horizontal = 1;
long vertical = 1;
match_assert(
"c:\\halo\\SOURCE\\main\\main.c",
1308,
num_players>0);
if (num_players>1)
{
do
{
if (horizontal<vertical)
horizontal++;
else
{
horizontal = 1;
vertical++;
}
}
while (vertical*horizontal<num_players);
}
*horizontal_count = horizontal;
*vertical_count = vertical;
return;
}
void compute_window_bounds(
long player_index,
long num_players,
rectangle2d *pixel_bounds,
rectangle2d *safe_frame_bounds)
{
long vertical_count;
long horizontal_count;
long horizontal_index;
long vertical_index;
long subframe_width;
long subframe_height;
long safe_frame_inset;
boolean first_player_spans_two_columns;
match_assert(
"c:\\halo\\SOURCE\\main\\main.c",
1359,
player_index<num_players);
safe_frame_inset = num_players>1 ? 4 : 0;
first_player_spans_two_columns = FALSE;
compute_subframe_counts(
num_players,
&horizontal_count,
&vertical_count);
if (horizontal_count*vertical_count>num_players)
{
if (!player_index)
first_player_spans_two_columns = TRUE;
else
player_index++;
}
vertical_index = player_index/horizontal_count;
horizontal_index = player_index-vertical_index*horizontal_count;
match_assert(
"c:\\halo\\SOURCE\\main\\main.c",
1390,
vertical_index>=0 && vertical_index<vertical_count);
match_assert(
"c:\\halo\\SOURCE\\main\\main.c",
1391,
horizontal_index>=0 && horizontal_index<horizontal_count);
subframe_height =
(rasterizer_globals.reserved04.frame_bounds.y1-
rasterizer_globals.reserved04.frame_bounds.y0)/vertical_count;
subframe_width =
(rasterizer_globals.reserved04.frame_bounds.x1-
rasterizer_globals.reserved04.frame_bounds.x0)/horizontal_count;
subframe_width *= first_player_spans_two_columns ? 2 : 1;
safe_frame_bounds->x0 =
subframe_width*horizontal_index+
rasterizer_globals.reserved04.frame_bounds.x0;
safe_frame_bounds->x1 =
subframe_width*(horizontal_index+1)+
rasterizer_globals.reserved04.frame_bounds.x0;
safe_frame_bounds->y0 =
subframe_height*vertical_index+
rasterizer_globals.reserved04.frame_bounds.y0;
safe_frame_bounds->y1 =
subframe_height*(vertical_index+1)+
rasterizer_globals.reserved04.frame_bounds.y0;
*pixel_bounds = *safe_frame_bounds;
safe_frame_bounds->x0 += horizontal_index*safe_frame_inset;
safe_frame_bounds->x1 -= (horizontal_index==0)*safe_frame_inset;
safe_frame_bounds->y0 += vertical_index*safe_frame_inset;
safe_frame_bounds->y1 -= (vertical_index==0)*safe_frame_inset;
if (!horizontal_index)
pixel_bounds->x0 = rasterizer_globals.reserved04.screen_bounds.x0;
if ((first_player_spans_two_columns!=FALSE)+horizontal_index+1==horizontal_count)
pixel_bounds->x1 = rasterizer_globals.reserved04.screen_bounds.x1;
if (!vertical_index)
pixel_bounds->y0 = rasterizer_globals.reserved04.screen_bounds.y0;
if (vertical_index+1==vertical_count)
pixel_bounds->y1 = rasterizer_globals.reserved04.screen_bounds.y1;
return;
}
extern void cache_files_give_time_to_precache(
char const *map_name);
void main_set_multiplayer_map_name(
char const *map_name)
{
csstrncpy(main_globals.multiplayer_map_name, map_name, NUMBEROF(main_globals.multiplayer_map_name) - 1);
main_globals.multiplayer_map_name[NUMBEROF(main_globals.multiplayer_map_name) - 1] = 0;
cache_files_give_time_to_precache(main_globals.multiplayer_map_name);
return;
}
void main_set_difficulty(
short difficulty)
{
if (difficulty >= _game_difficulty_level_easy && difficulty < NUMBER_OF_GAME_DIFFICULTY_LEVELS)
global_difficulty_level = difficulty;
return;
}
long sort_controllers_ascending(
short const *a,
short const *b)
{
short value_a = *a;
short value_b = *b;
if (value_a == NONE && value_b != value_a)
return 1;
if (value_a != NONE && value_b == NONE)
return -1;
if (value_a > value_b)
return 1;
return (value_a >= value_b) - 1;
}
void main_save_map_safe(
void)
{
if (!main_globals.saving_map || main_globals.save_map_timeout)
{
main_globals.saving_map = TRUE;
main_globals.save_map_safely = TRUE;
main_globals.save_map_timeout = TRUE;
main_globals.ticks_until_next_save_check = 0;
main_globals.ticks_unable_to_save = 0;
main_globals.safe_intervals = 0;
}
return;
}
void main_save_map_no_timeout(
void)
{
if (!main_globals.saving_map || main_globals.save_map_timeout)
{
main_globals.saving_map = TRUE;
main_globals.save_map_safely = TRUE;
main_globals.ticks_until_next_save_check = 0;
main_globals.ticks_unable_to_save = 0;
main_globals.safe_intervals = 0;
}
main_globals.save_map_timeout = FALSE;
return;
}
void main_skip(
short ticks)
{
if (ticks <= 15)
{
main_globals.skip_ticks = ticks;
main_globals.skip = TRUE;
}
else
{
error(_error_silent, "cannot skip more than 15 frames (half a second)");
}
return;
}
void main_queue_map_name(
char const *map_name)
{
if (map_name)
{
csstrncpy(main_globals.queued_map_name, map_name, NUMBEROF(main_globals.queued_map_name) - 1);
main_globals.queue_map = TRUE;
}
else
{
main_globals.queued_map_name[0] = 0;
main_globals.queue_map = FALSE;
}
return;
}
boolean main_taking_screenshot(
void)
{
return global_screenshot_count > 0 || main_globals.movie != NULL;
}
void main_movie_start(
real frames_per_second)
{
match_assert("c:\\halo\\SOURCE\\main\\main.c", 2715, main_globals.movie==NULL);
main_globals.movie = bitmap_2d_new(640, 480, 0, 10);
if (main_globals.movie)
{
directory_create_or_delete_contents("movie");
main_globals.recording_frame_index = 0;
if (frames_per_second > 0.0001f)
main_globals.recording_dt = 1.0f / frames_per_second;
else
main_globals.recording_dt = 1.0f / 30.0f;
game_time_set_speed(1.0f);
}
return;
}
void main_movie_stop(
void)
{
if (main_globals.movie)
{
bitmap_delete(main_globals.movie);
main_globals.movie = NULL;
}
return;
}
void main_print_version(
void)
{
console_printf(FALSE, "halobeta xbox 01.01.14.2342 Jan 14 2002 12:49:20");
return;
}
void main_save_current_solo_map(
char const *map_name)
{
FILE *file;
if ((short)main_get_solo_level_from_name(map_name) != NONE)
{
file = fopen("z:\\last_solo.txt", "w");
if (file)
{
fwrite(map_name, 1, csstrlen(map_name) + 1, file);
fclose(file);
}
else
{
error(_error_silent, "Couldn't create a file to write the current solo map to");
}
}
return;
}
void main_load_ui_scenario(
boolean precache_resources)
{
struct game_options options;
game_precache_new_map("levels\\ui\\ui", TRUE);
match_assert("c:\\halo\\SOURCE\\main\\main.c", 1092,
!main_globals.main_menu_scenario_loaded);
game_options_new(&options);
csstrncpy(options.map_name, "levels\\ui\\ui", NUMBEROF(options.map_name) - 1);
options.map_name[NUMBEROF(options.map_name) - 1] = 0;
game_precache_new_map(options.map_name, TRUE);
game_dispose_from_old_map();
game_unload();
game_engine_dispose();
game_set_game_variant(NULL);
main_globals.main_menu_scenario_loaded = TRUE;
main_new_map(&options);
director_script_camera(TRUE);
scripted_camera_set(0, 0, NONE);
main_menu_active(TRUE);
main_globals.load_last_solo_level = TRUE;
if (precache_resources)
main_menu_precache_resources();
return;
}
extern void game_end_credits_start(
void);
void main_roll_credits(
void)
{
error(_error_silent, "congratulations, you won the game!");
main_menu_load();
game_end_credits_start();
return;
}
void main_revert_map_private(
void)
{
game_state_revert();
ui_widgets_disable_pause_game(30);
main_globals.revert_map = FALSE;
return;
}
void main_skip_cinematic_private(
void)
{
if (cinematic_can_be_skipped())
{
game_state_revert();
ui_widgets_disable_pause_game(30);
main_globals.revert_map = FALSE;
}
main_globals.skip_cinematic = FALSE;
return;
}
void main_saving_map_private(
void)
{
game_state_save();
hud_autosave(FALSE);
main_globals.save_map_completed = FALSE;
return;
}
void main_switch_to_structure_bsp_private(
void)
{
scenario_switch_structure_bsp(main_globals.switch_to_structure_bsp_index);
main_globals.switch_to_structure_bsp_index = NONE;
hud_load(0);
return;
}
void main_lost_map_private(
void)
{
if (!game_time_get_paused())
{
if (main_globals.loss_timer++ > 90)
{
main_globals.lost_map = FALSE;
main_globals.loss_timer = 0;
game_state_revert();
}
}
return;
}
void main_respawn_private(
void)
{
if (!game_time_get_paused() && !cinematic_in_progress())
{
if (main_globals.respawn_timer++ > 90 && players_respawn_coop())
{
main_globals.respawn = FALSE;
main_globals.respawn_timer = 0;
}
}
return;
}
void main_load_core_private(
void)
{
game_state_load_core(main_globals.core_name);
main_globals.load_core = FALSE;
return;
}
void main_save_core_private(
void)
{
game_state_save_core(main_globals.core_name);
main_globals.save_core = FALSE;
return;
}
void main_run_demos_private(
void)
{
main_globals.run_xdemos = FALSE;
xbox_demos_launch();
return;
}
void main_won_map_private(
void)
{
short level;
short local_player_index;
main_globals.want_to_be_at_main_menu = TRUE;
main_globals.won_map = FALSE;
level = main_get_solo_level_from_name(main_globals.soloplayer_map_name) + 1;
if (level >= 10)
level = NONE;
for (local_player_index = 0; local_player_index < player_spawn_count; local_player_index++)
player_profile_save_level_completed(local_player_index);
ui_set_next_level(level);
return;
}
void main_set_map_name(
char const *map_name)
{
main_globals.want_to_be_at_main_menu = FALSE;
csstrncpy(main_globals.soloplayer_map_name, map_name, NUMBEROF(main_globals.soloplayer_map_name) - 1);
main_globals.soloplayer_map_name[NUMBEROF(main_globals.soloplayer_map_name) - 1] = 0;
main_globals.allow_persistent_storage = TRUE;
if ((game_in_editor() || game_in_progress()) && main_globals.connection == _game_connection_local)
main_globals.defer_map_change = TRUE;
return;
}
void main_exit(
void)
{
switch (main_globals.connection)
{
case _game_connection_network_server:
dispose_global_network_game_client();
dispose_global_network_game_server();
game_dispose_from_old_map();
game_dispose();
debug_keys_dispose();
console_dispose();
break;
case _game_connection_network_client:
dispose_global_network_game_client();
default:
game_dispose_from_old_map();
game_dispose();
debug_keys_dispose();
console_dispose();
break;
}
return;
}
void main_reset_time(
void)
{
unsigned long frame_index;
unsigned long vertical_blank_index;
main_globals.frame_start_milliseconds = system_milliseconds();
frame_index = rasterizer_globals.frame_index;
vertical_blank_index = rasterizer_globals.vertical_blank_index;
main_globals.rasterizer_frame_index = frame_index;
main_globals.rasterizer_vertical_blank_index = vertical_blank_index;
return;
}
boolean code_000f0be0(
void)
{
return rasterizer_globals.framerate_throttle;
}
void main_initialize_time(
void)
{
main_globals.frame_start_milliseconds = system_milliseconds();
main_globals.rasterizer_frame_index = 0;
main_globals.rasterizer_vertical_blank_index = 0;
rasterizer_set_vblank_callback(main_vertical_blank_interrupt_handler);
main_globals.vblank_flip_delta_index = 0;
csmemset(main_globals.vblank_flip_deltas, 0, sizeof(main_globals.vblank_flip_deltas));
main_globals.d3d_flip_count = d3d_find_flipcount();
return;
}
static void main_reset_map_private(
void)
{
if (!game_time_get_paused())
{
scenario_switch_structure_bsp(0);
game_dispose_from_old_map();
input_flush();
game_initialize_for_new_map();
create_local_players();
game_time_start();
game_initial_pulse();
ui_widgets_disable_pause_game(30);
main_globals.reset_map = FALSE;
}
return;
}
void main_loop_of_death(
void)
{
while (TRUE)
{
input_frame_begin();
input_update();
shell_idle();
event_manager_update();
telnet_console_process();
process_ui_widgets();
main_pregame_render();
main_rasterizer_throttle();
main_present_frame();
input_frame_end();
}
return;
}
void main_loop(
void)
{
boolean render_frame;
real precache_progress;
long connection;
if (!game_in_editor())
{
csstrncpy(main_globals.soloplayer_map_name, "levels\\b30\\b30", NUMBEROF(main_globals.soloplayer_map_name)-1);
main_globals.soloplayer_map_name[NUMBEROF(main_globals.soloplayer_map_name)-1] = '\0';
}
main_globals.want_to_be_at_main_menu = !game_in_editor();
main_globals.switch_to_structure_bsp_index = NONE;
main_globals.halt_time_scale = TRUE;
console_initialize();
debug_keys_initialize();
game_initialize();
console_startup();
main_setup_connection();
main_initialize_time();
while (TRUE)
{
if (!game_in_editor())
{
if (main_globals.switch_to_structure_bsp_index!=NONE)
{
scenario_switch_structure_bsp(main_globals.switch_to_structure_bsp_index);
main_globals.switch_to_structure_bsp_index = NONE;
hud_load(FALSE);
}
if (main_globals.lost_map)
{
if (!game_time_get_paused() && main_globals.loss_timer++>90)
{
main_globals.lost_map = FALSE;
main_globals.loss_timer = 0;
game_state_revert();
}
}
if (main_globals.won_map)
{
main_won_map_private();
}
if (main_globals.respawn)
{
if (!game_time_get_paused() && !cinematic_in_progress() && main_globals.respawn_timer++>90 && players_respawn_coop())
{
main_globals.respawn = FALSE;
main_globals.respawn_timer = 0;
}
}
if (main_globals.save_map_completed)
{
game_state_save();
hud_autosave(FALSE);
main_globals.save_map_completed = FALSE;
}
if (main_globals.defer_map_change)
{
main_change_map_name();
}
if (main_globals.revert_map)
{
game_state_revert();
ui_widgets_disable_pause_game(30);
main_globals.revert_map = FALSE;
}
if (main_globals.skip_cinematic)
{
if (cinematic_can_be_skipped())
{
game_state_revert();
ui_widgets_disable_pause_game(30);
main_globals.revert_map = FALSE;
}
main_globals.skip_cinematic = FALSE;
}
if (main_globals.reset_map)
{
main_reset_map_private();
}
if (main_globals.save_core)
{
game_state_save_core(main_globals.core_name);
main_globals.save_core = FALSE;
}
if (main_globals.load_core)
{
game_state_load_core(main_globals.core_name);
main_globals.load_core = FALSE;
}
if (main_globals.want_to_be_at_main_menu)
{
main_menu_load();
}
if (main_globals.load_last_solo_level)
{
main_load_last_solo_map();
}
if (main_globals.run_xdemos)
{
main_globals.run_xdemos = FALSE;
xbox_demos_launch();
}
if (main_globals.skip)
{
main_skip_private();
}
if (main_globals.queue_map)
{
if (cache_files_precache_in_progress() && cache_files_precache_map_status(&precache_progress)==1)
{
cache_files_precache_map_end();
}
if (!cache_files_precache_in_progress())
{
cache_files_precache_map_begin(main_globals.queued_map_name, FALSE);
main_globals.queue_map = FALSE;
}
}
}
else if (main_globals.reset_map)
{
main_reset_map_private();
}
profile_frame_start();
input_frame_begin();
input_update();
input_abstraction_update();
shell_idle();
event_manager_update();
telnet_console_process();
if (!shell_application_is_paused())
{
render_frame = TRUE;
connection = main_globals.connection;
if (connection==_game_connection_network_client)
{
if (!network_game_client_start_frame())
{
display_error_when_main_menu_loaded(6);
error(_error_silent, "the game host went down");
network_game_abort();
}
}
else if (connection==_game_connection_network_server)
{
if (!network_game_client_start_frame())
{
display_error_when_main_menu_loaded(1);
error(_error_silent, "the game host went down");
network_game_abort();
}
else if (!network_game_server_start_frame())
{
display_error_when_main_menu_loaded(1);
error(_error_silent, "the game host went down");
network_game_abort();
}
}
else if (connection==_game_connection_film_playback)
{
break;
}
main_update_time();
process_ui_widgets();
bink_playback_update();
if ((!game_in_editor() && (input_key_is_down(_key_end) || input_key_is_down(_key_escape))) || editor_should_exit())
{
main_movie_stop();
if (!game_engine_running())
{
main_reset_map();
}
}
if (game_in_progress())
{
terminal_update();
if (!console_update() || main_globals.connection!=_game_connection_local)
{
debug_keys_update();
cheats_update();
player_control_update((real)main_globals.halt_time_scale*main_globals.seconds_elapsed);
connection = main_globals.connection;
if (connection>_game_connection_local && connection<=_game_connection_network_server && !network_game_client_end_frame())
{
display_error_when_main_menu_loaded(1);
network_game_abort();
}
game_time_update((real)main_globals.halt_time_scale*main_globals.seconds_elapsed);
render_frame = main_globals.main_menu_scenario_loaded ||
(main_globals.halt_time_scale &&
(game_time_get_paused() || game_time_get_elapsed()>0 || game_time_get_speed()<1.0f));
render_frame &= !game_engine_running() || game_time_get()>=3;
collision_log_continue_period(1);
director_update((real)main_globals.halt_time_scale*main_globals.seconds_elapsed);
observer_update((real)main_globals.halt_time_scale*main_globals.seconds_elapsed);
collision_log_end_period();
game_engine_update_non_deterministic((real)main_globals.halt_time_scale*main_globals.seconds_elapsed);
}
if (main_globals.saving_map)
{
main_save_map_private();
}
if (render_frame && !debug_no_drawing)
{
profile_render_start();
main_game_render((double)main_globals.seconds_elapsed);
profile_render_end();
}
}
else
{
profile_render_start();
main_pregame_render();
profile_render_end();
}
main_rasterizer_throttle();
if (render_frame && !debug_no_drawing)
{
main_present_frame();
}
}
input_frame_end();
profile_frame_end();
main_frame_rate_debug();
if (main_globals.restart_time)
{
main_globals.restart_time = FALSE;
main_reset_time();
main_globals.halt_time_scale = TRUE;
}
}
error(_error_silent, "end of saved film");
switch (main_globals.connection)
{
case _game_connection_network_server:
dispose_global_network_game_client();
dispose_global_network_game_server();
break;
case _game_connection_network_client:
dispose_global_network_game_client();
break;
}
game_dispose_from_old_map();
game_dispose();
debug_keys_dispose();
console_dispose();
return;
}
/* ---------- private code */
Reference in new issue View Git Blame Copy Permalink