scummvm/engines/icb/session.cpp
2022-08-05 15:23:10 +02:00

1236 lines
40 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* Additional copyright for this file:
* Copyright (C) 1999-2000 Revolution Software Ltd.
* This code is based on source code created by Revolution Software,
* used with permission.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "engines/icb/icb.h"
#include "engines/icb/p4.h"
#include "engines/icb/debug.h"
#include "engines/icb/p4_generic.h"
#include "engines/icb/res_man.h"
#include "engines/icb/common/px_common.h"
#include "engines/icb/common/px_game_object.h"
#include "engines/icb/common/px_scriptengine.h"
#include "engines/icb/common/px_prop_anims.h"
#include "engines/icb/common/px_walkarea_integer.h"
#include "engines/icb/object_structs.h"
#include "engines/icb/session.h"
#include "engines/icb/mission.h"
#include "engines/icb/common/px_linkeddatafile.h"
#include "engines/icb/floors.h"
#include "engines/icb/barriers.h"
#include "engines/icb/global_objects.h"
#include "engines/icb/global_switches.h"
#include "engines/icb/remora.h"
#include "engines/icb/sound_logic.h"
#include "engines/icb/loadscrn.h"
#include "engines/icb/sound.h"
#include "engines/icb/sound_lowlevel.h"
namespace ICB {
// Translation tweaks
LinkedDataFile *LoadTranslatedFile(const char *session, const char *mission);
// prototypes
int32 Fetch_token_value(uint8 *file, uint32 length, uint8 *token);
void ClearTextures();
void _game_session::___init(const char *mission, const char *new_session_name) {
// session object constructor
// set up a game_session object from a session name
uint32 buf_hash;
// begin with no set object
// a camera will be choosen after the first logic cycle based upon the player objects position
set.Reset();
// no special footsteps set
numFloorFootSfx = 0;
specialFootSfx = 0;
ladderFootSfx = 0;
defaultFootSfx = 0;
// setup speech text block pointer
text_bloc = g_text_bloc1;
text_speech_bloc = g_text_bloc2; // pc has second bloc
// If you die when you have an unread email and restart the mission, the email icon continues
// to flash. The Remora should reset this when it initialises but since that happens after all
// the objects have been loaded, I decided it would be safest to reset the flag here. This is
// very much an 11th-hour hack.
g_oRemora->MarkEmailRead();
// first clear out private_session_resman
private_session_resman->Reset();
// tell it that the resources cannot be moved about
private_session_resman->Set_to_no_defrag();
ClearTextures();
if (camera_hack == TRUE8) {
total_objects = 0;
return;
}
// Make the filename equivalent of the hash'ed version of session name
HashFile(new_session_name, session_h_name);
// Put the hash mission and hash session filenames together
char h_mission_name[8];
HashFile(mission, h_mission_name);
sprintf(speech_font_one, FONT_PATH, "font.pcfont");
sprintf(remora_font, FONT_PATH, "futura.pcfont");
if (sprintf(session_name, "%s\\%s\\", mission, new_session_name) > ENGINE_STRING_LEN)
Fatal_error("_game_session::_game_session [%s] string overflow", session_name);
if (sprintf(h_session_name, "%s\\%s", h_mission_name, session_h_name) > ENGINE_STRING_LEN)
Fatal_error("_game_session::_game_session [%s] string overflow", h_session_name);
if (sprintf(session_cluster, SESSION_CLUSTER_PATH, h_mission_name, session_h_name) > ENGINE_STRING_LEN)
Fatal_error("_game_session::_game_session [%s] string overflow", session_cluster);
session_cluster_hash = HashString(session_cluster);
speech_font_one_hash = HashString(speech_font_one);
remora_font_hash = HashString(remora_font);
Zdebug("_game_session %s", (const char *)session_name);
// now setup the session
// load all the fixed name files
// mission<
// session<
// objects.linked
// scripts.linked
// walkgrid.grid
// session.RVanims
// camera-name<
// Jake : so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
StartLoading(new_session_name);
LoadMsg("Session Cluster");
// right, on the psx for the between session sound we need to make sure the
// resman has the mission sound stuff in memory BEFORE we do the
// StartLoading...
LoadMsg("Session Sound");
// setup sound data cluster on psx...
LoadSessionSounds(session_cluster);
// initialise the session game objects
// we can assume all of these in here will be of the game object class!
// When clustered the session files have the base stripped
strcpy(temp_buf, "objects");
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session Objects");
// Make Res_open compute the hash value
buf_hash = NULL_HASH;
objects = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
// set this for convenience
total_objects = LinkedDataObject::Fetch_number_of_items(objects);
Zdebug("total objects %d", total_objects);
if (total_objects >= MAX_session_objects)
Fatal_error("too many objects! max available %d", MAX_session_objects);
// create the prop table
// each object has a prop state - though only objects that are linked to background props will use them
// an objects number maps to the state table
// prop_state_table = new uint32[total_objects+10];
uint32 j;
for (j = 0; j < total_objects; j++)
prop_state_table[j] = 0;
// inititialise the session scripts
// When clustered the session files have the base stripped
strcpy(temp_buf, "scripts");
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session Scripts");
buf_hash = NULL_HASH;
scripts = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
// display script version info
// also available on console
Script_version_check();
// initialise prop animation file
// When clustered the session files have the base stripped
strcpy(temp_buf, PX_FILENAME_PROPANIMS);
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session PropAnims");
buf_hash = NULL_HASH;
prop_anims = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
// Check file version is correct.
if (LinkedDataObject::GetHeaderVersion(prop_anims) != VERSION_PXWGPROPANIMS)
Fatal_error("%s version check failed (file has %d, engine has %d)", temp_buf, LinkedDataObject::GetHeaderVersion(prop_anims), VERSION_PXWGPROPANIMS);
// init features file
// we stick this in the private cache so it hangs around and later in-game references wont cause a main pool reload
// When clustered the session files have the base stripped
strcpy(temp_buf, "pxwgfeatures");
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session Features");
buf_hash = NULL_HASH;
features = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
// engine knows no set/camera chosen
Reset_camera_director();
camera_lock = FALSE8; // move to camera director
// reset the route manager service
Reset_route_manager();
text_bloc->please_render = FALSE8;
text_speech_bloc->please_render = FALSE8;
conv_focus = 0; // no conversation is in focus
total_convs = 0; // no conversations
Tdebug("text_lines.txt", "\n\n---Text Lines---\n");
// text
text = nullptr; // game can exist with this file
char textFileName[100];
// When clustered the session files have the base stripped
strcpy(temp_buf, "text");
buf_hash = HashString(temp_buf);
if (private_session_resman->Test_file(temp_buf, buf_hash, session_cluster, session_cluster_hash)) {
// Jake : so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session Text");
// Special text loading code so the translators can test their stuff
if (tt) {
// Ok, translators mode has been activated
text = LoadTranslatedFile(mission, session_name);
} else
text = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
} else
Fatal_error("Missing Text File \"%s\"", temp_buf);
Tdebug("session.txt", "text lines END");
// A copy of the code above to open the global text file. Feel free to edit this if I've ballsed up
// anywhere.
global_text = nullptr;
char global_cluster[ENGINE_STRING_LEN];
strcpy(global_cluster, GLOBAL_CLUSTER_PATH);
uint32 global_cluster_hash = HashString(global_cluster);
sprintf(textFileName, GLOBAL_TEXT_FILE);
buf_hash = HashString(textFileName);
if (private_session_resman->Test_file(textFileName, buf_hash, global_cluster, global_cluster_hash)) {
LoadMsg(temp_buf);
if (tt) {
// Ok, translators mode has been activated
global_text = LoadTranslatedFile("global", "global\\global\\");
} else
global_text = (LinkedDataFile *)private_session_resman->Res_open(textFileName, buf_hash, global_cluster, global_cluster_hash);
} else {
Fatal_error("Failed to find global text file [%s][%s]", textFileName, global_cluster);
}
// The surface manager needs to know what colour to use for transparency. This comes from a fixed
// reference file which is opened here so the global reference can be set.
g_oIconMenu->SetTransparencyColourKey();
if (g_icb->getGameType() == GType_ICB) {
// Initialise the remora
g_oRemora->InitialiseRemora();
}
// Set the default colour for voice over text.
voice_over_red = VOICE_OVER_DEFAULT_RED;
voice_over_green = VOICE_OVER_DEFAULT_GREEN;
voice_over_blue = VOICE_OVER_DEFAULT_BLUE;
Tdebug("session.txt", "CHI START");
// chi
// players movement history
cur_history = 0;
chi_think_mode = __NOTHING;
is_there_a_chi = FALSE8;
Tdebug("session.txt", "walkareas START");
// setup walkareas
total_was = 0;
// When clustered the session files have the base stripped
strcpy(temp_buf, "walkarea");
buf_hash = HashString(temp_buf);
// Jake : so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
LoadMsg("Session Walkareas");
uint32 len = private_session_resman->Check_file_size(temp_buf, buf_hash, session_cluster, session_cluster_hash);
if (len) {
walk_areas = (LinkedDataFile *)private_session_resman->Res_open(temp_buf, buf_hash, session_cluster, session_cluster_hash);
Tdebug("walkareas.txt", "%d top level walkareas\n", LinkedDataObject::Fetch_number_of_items(walk_areas));
int32 nMissing = 0;
for (uint32 k = 0; k < LinkedDataObject::Fetch_number_of_items(walk_areas); k++) {
INTEGER_WalkAreaFile *inner_wa;
inner_wa = (INTEGER_WalkAreaFile *)LinkedDataObject::Fetch_item_by_number(walk_areas, k);
Tdebug("walkareas.txt", "\nclump %d has %d inner items", k, inner_wa->GetNoAreas());
for (j = 0; j < inner_wa->GetNoAreas(); j++) {
const __aWalkArea *wa;
wa = inner_wa->GetWalkArea(j);
wa_list[total_was++] = wa; // write entry to individual item list
if (total_was == MAX_was)
Fatal_error("total number of walk-areas exceeded - %d", MAX_was);
}
}
if (nMissing > 0)
Fatal_error("%d missing cameras : Game must terminate", nMissing);
Tdebug("walkareas.txt", "\n%d individual walk areas found", total_was);
} else
Tdebug("walkareas.txt", "no walkarea file");
number_of_missing_objects = 0; // start with no missing objects
// structure assignment counters - see fn_create_mega
num_megas = 0;
num_vox_images = 0;
// init conveyors
for (j = 0; j < MAX_conveyors; j++)
conveyors[j].moving = FALSE8;
// init auto interact
for (j = 0; j < MAX_auto_interact; j++)
auto_interact_list[j] = 0; // no entry
// stairs
num_stairs = 0;
// lifts
num_lifts = 0;
// turn off health bar
health_time = 0;
// setup generic asyncer
player_stat_was = __TOTAL_PLAYER_MODES; // for 'prev' check
player_stat_use = __TOTAL_PLAYER_MODES; // for 'prev' check
async_counter = 0; // counts up each frame
async_off = 0; // on by default
// first cycle indicator
first_session_cycle = TRUE8;
Tdebug("session.txt", "session constructor END");
}
void _game_session::Script_version_check() {
uint32 version = LinkedDataObject::GetHeaderVersion(scripts);
if (FN_ROUTINES_DATA_VERSION_ICB != version && FN_ROUTINES_DATA_VERSION_ELDORADO != version) {
error("SCRIPTS AND ENGINE ARE NOT SAME VERSION: %d", version);
}
}
void _game_session::___destruct() {
// session object deconstructor
// kills the current session and removes its resources
Zdebug("*session destructing*");
// turn off all sounds
StopAllSoundsNow();
Zdebug("sounds stopped");
// camview mode
if (camera_hack == TRUE8) {
SetReset();
return;
}
// trash resources
private_session_resman->Reset();
// remove diag bars that have been newed
for (uint32 j = 0; j < total_objects; j++)
if (logic_structs[j]->mega)
logic_structs[j]->mega->m_main_route.___init(); // delete diag bars
// delete current set view
SetReset();
// delete player object
// delete player;
// speech
// if (text_bloc)
// delete text_bloc; //in-case quit during speech
}
void _game_session::Initialise_set(const char *name, const char *cluster_name) {
// initialise a set object for the current session
// stick us into TEMP_NETHACK mode if the set does not physically exist
// place a split point/boundary into the resource loading
rs_bg->Advance_time_stamp();
// init the set
set.Init(name, cluster_name);
// decide which props to sleep and which to wake
Setup_prop_sleep_states();
}
void _game_session::Setup_prop_sleep_states() {
// initialise the new set object
for (uint32 j = 0; j < total_objects; j++)
if (!logic_structs[j]->mega) { // props
logic_structs[j]->prop_on_this_screen = set.DoesPropExist((const char *)logic_structs[j]->GetName());
if (logic_structs[j]->hold_mode == prop_camera_hold) {
if (!logic_structs[j]->prop_on_this_screen) {
logic_structs[j]->camera_held = TRUE8; // not on screen
logic_structs[j]->cycle_time = 0; // accurate for displays
} else {
logic_structs[j]->camera_held = FALSE8; // on screen
}
} else { // not an auto sleep item, but...
// check for sleeping items that are now on screen
if ((logic_structs[j]->camera_held) && (logic_structs[j]->prop_on_this_screen)) { // held AND on screen (a door)
logic_structs[j]->camera_held = FALSE8; // on screen and not a camera_hold_mode item so wake it up - i.e. doors
}
}
}
}
void _game_session::Awaken_doors() {
// called to release doors when entering remora mode
for (uint32 j = 0; j < total_objects; j++)
if ((logic_structs[j]->big_mode == __CUSTOM_BUTTON_OPERATED_DOOR) || (logic_structs[j]->big_mode == __CUSTOM_AUTO_DOOR)) {
logic_structs[j]->camera_held = FALSE8; // awake!
logic_structs[j]->prop_on_this_screen = TRUE8;
}
}
__mega_set_names player_startup_anims[] = {__STAND, __STAND_TO_WALK, __WALK, __WALK_TO_STAND, __TURN_ON_THE_SPOT_CLOCKWISE};
#define NUMBER_player_startup_anims 5
void _game_session::Init_objects() {
char buf[ENGINE_STRING_LEN];
uint32 j, id;
if (!g_mission->inited_globals) {
// init local globals
// only do this at start of mission - never again afterward - i.e. not when returning to first session from another
uint32 script_hash;
Common::String itemName;
if (g_icb->getGameType() == GType_ICB)
itemName = "player";
else
itemName = "scenes";
id = LinkedDataObject::Fetch_item_number_by_name(objects, itemName.c_str()); // returns -1 if object not in existence
if (id == 0xffffffff)
Fatal_error("Init_objects cant find '%s'", itemName.c_str());
Common::String hashString = itemName + "::globals";
script_hash = HashString(hashString.c_str());
const char *pc = (const char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, script_hash);
if (pc) {
object = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, id);
Tdebug("objects_init.txt", " initialising globals", (const char *)buf);
RunScript(pc, object);
}
g_mission->inited_globals = TRUE8;
}
Zdebug("\nInitialise_objects");
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
// this stuff moved here when ammo, bullets etc moved into player struct
InitMsg("Player");
// create a player object
player.___init();
// Now run the InitScript for each object. This has to be done after the line-of-sight end
// event manager have been initialised in case calls get made to these services in any of the
// objects' InitScripts.
for (j = 0; ((j < total_objects)); j++) {
object = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, j);
Tdebug("objects_init.txt", "\n\n---------------------------------------------------\n%d initialising object '%s'", j, CGameObject::GetName(object));
Zdebug("\n\n---------------------------------------------------\n%d initialising object '%s'", j, CGameObject::GetName(object));
Zdebug("[%d]", num_megas);
// fast reference for engine functions
// needed incase structs are referenced by FN_ functions
cur_id = j;
// set L for FN_ functions that may be called
L = logic_structs[j];
I = L->voxel_info;
M = L->mega;
// possibly run the init OR logic context script to kick in a base script ready for running in the logic loop
// the init script is always script 0 for the object
// the init script may or may not be overiden
// get the address of the script we want to run
const char *pc = (const char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, CGameObject::GetScriptNameFullHash(object, OB_INIT_SCRIPT)); // run init script
if (pc) {
RunScript(pc, object);
strcpy(buf, CGameObject::GetName(object));
strcat(buf, "::local_init");
uint32 script_hash;
script_hash = HashString(buf);
// Jso PSX can have nice session loading screen and details (for timing and to stop player getting bored)
InitMsg(CGameObject::GetName(object));
Tdebug("objects_init.txt", "search for [%s]", (const char *)buf);
pc = (const char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, script_hash);
if (pc) {
// set M and I for FN_ functions that may be called
I = L->voxel_info;
M = L->mega;
Tdebug("objects_init.txt", " running optional = [%s]", (const char *)buf);
RunScript(pc, object);
} else
Tdebug("objects_init.txt", " no [%s] found", (const char *)buf);
// setup logic context
// set to start on level 0
logic_structs[j]->logic_level = 0;
// set base logic to logic context script
logic_structs[j]->logic[0] = (char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, CGameObject::GetScriptNameFullHash(object, OB_LOGIC_CONTEXT));
// **note, we dont need to set up the script reference (logic_ref) for level 0
} else
Shut_down_object("by initialise - no init script");
L = logic_structs[j];
I = L->voxel_info;
if (L->image_type == VOXEL) {
for (uint32 i = 0; i < __NON_GENERIC; i++) {
if (I->IsAnimTable(i)) {
#ifdef PRELOAD
rs_anims->Res_open(I->info_name[i], I->info_name_hash[i], I->base_path, I->base_path_hash);
#endif
}
}
}
}
Tdebug("objects_init.txt", "\n\n\ncreating mega list");
// create voxel id list
number_of_voxel_ids = 0;
for (j = 0; j < total_objects; j++) { // object 0 is used
// object must be alive and interactable and a mega
if ((logic_structs[j]->image_type == VOXEL) && (logic_structs[j]->ob_status != OB_STATUS_HELD)) { // not if the object has been manually switched out
Tdebug("objects_init.txt", "%s", (const char *)logic_structs[j]->GetName());
voxel_id_list[number_of_voxel_ids++] = (uint8)j;
}
}
if (number_of_voxel_ids >= MAX_voxel_list)
Fatal_error("Initialise_objects, the voxel id list is too small");
Tdebug("objects_init.txt", "\n\nfound %d voxel characters", number_of_voxel_ids);
if (g_icb->getGameType() == GType_ICB) {
// init the player object number
// get id
id = LinkedDataObject::Fetch_item_number_by_name(objects, "player"); // returns -1 if object not in existence
if (id != 0xffffffff) {
L = logic_structs[id]; // fetch logic struct for player object
I = L->voxel_info;
M = L->mega;
object = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, id);
// not if this object has been shut-down - for not having a map marker for example
if (L->ob_status != OB_STATUS_HELD)
player.Set_player_id(id);
// Preload the player animation to make PSX jerking better
for (uint32 i = 0; i < NUMBER_player_startup_anims; i++)
rs_anims->Res_open(I->get_anim_name(player_startup_anims[i]), I->anim_name_hash[player_startup_anims[i]], I->base_path, I->base_path_hash);
}
}
// done
Zdebug("Init session finished\n");
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
EndLoading();
}
void _game_session::Pre_initialise_objects() {
// prepare gameworld and objects but dont run init scripts yet
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
StartInit(total_objects + 6); // +6 because also floors, barriers, markers, camera_table, plan_view, player
Zdebug("\nPre_Initialise_objects");
Zdebug("[%d]", num_megas);
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
InitMsg("Floors");
// initialise the floor area definition file
// uses the private resman so mission->session-> need to be initialised so this cant be on session contructor
floor_def = g_icb_session_floors;
g_icb_session_floors->___init();
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
InitMsg("Barriers");
// initialise the route barriers
session_barriers = &g_icb_session_barriers;
g_icb_session_barriers.___init();
Zdebug("A[%d]", num_megas);
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
InitMsg("Markers");
// init engine markers
markers.___init();
// so PSX can have nice session loading screen and details (for timing and to stop player getting bored)
InitMsg("Cameras");
// setup the camera system
Build_camera_table();
// First set up the logic structures for the objects. Each begins with a NULL pointer for its vox image.
uint32 j;
for (j = 0; ((j < total_objects)); ++j) {
Zdebug("%d -[%d]", j, num_megas);
object = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, j);
logic_structs[j] = g_logics[j];
logic_structs[j]->___init((const char *)CGameObject::GetName(object));
}
// Set up the event manager for this session. This has to be done after the barrier handler
// has been set up and after the objects have been set up because it relies on information
// from both.
PXTRY
g_oEventManager->Initialise();
PXCATCH
Fatal_error("Exception in _event_manager::Initialise()");
PXENDCATCH
// And set a duty cycle for the line-of-sight manager. Just set default for now.
PXTRY
Zdebug("duty");
g_oLineOfSight->SetDutyCycle(1);
Zdebug("~duty");
PXCATCH
Fatal_error("Exception in g_oLineOfSight->SetDutyCycle()");
PXENDCATCH
// Initialise the sound logic engine.
g_oSoundLogicEngine->Initialise();
player.has_weapon = TRUE8; // called before players init script
}
extern int32 john_number_traces;
extern int32 john_total_traces;
extern int32 fnTimer;
int32 logicTimer;
uint32 script_cycleTimer;
void _game_session::One_logic_cycle() {
// process all the game objects
uint32 j;
// Wind the line-of-sight engine on one position. Note that there is a variable in the line-of-sight engine
// which can be used to make this call return without doing anything a certain percentage of the time.
john_number_traces = 0;
john_total_traces = 0;
uint32 time = GetMicroTimer();
PXTRY
g_oLineOfSight->DutyCycle();
PXCATCH
Fatal_error("Exception in g_oLineOfSight->DutyCycle()");
PXENDCATCH
time = GetMicroTimer() - time;
g_mission->los_time = time;
time = GetMicroTimer();
PXTRY
g_oSoundLogicEngine->Cycle();
PXCATCH
Fatal_error("Exception in g_oSoundLogicEngine->Cycle()");
PXENDCATCH
time = GetMicroTimer() - time;
g_mission->sound_time = time;
time = GetMicroTimer();
// service the speech driver
Service_speech();
// reset route manager
Start_new_router_game_cycle();
// Tell the event manager to process its event timers if it is currently maintaining any.
g_oEventManager->CycleEventManager();
// If the icon menu currently has a holding icon, service its logic.
if (g_oIconListManager->IsHolding())
g_oIconListManager->CycleHoldingLogic();
// If the icon menu is currently flashing added medipacks or clips run the logic for it.
if (g_oIconMenu->IsAdding())
g_oIconMenu->CycleAddingLogic();
time = GetMicroTimer() - time;
g_mission->event_time = time;
// run through all the objects calling their logic
for (j = 0; j < total_objects; j++) { // object 0 is used
// fetch the engine created logic structure for this object
L = logic_structs[j];
if ((L->ob_status != OB_STATUS_HELD) && (!L->camera_held)) { // not if the object has been manually switched out
I = L->voxel_info;
M = L->mega;
cur_id = j; // fast reference for engine functions
// fetch the object that is our current object
// 'object' needed as logic code may ask it for the objects name, etc.
object = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, j);
// run appropriate logic
switch (L->big_mode) {
case __SCRIPT: // just running full scripts
if (g_px->mega_timer)
script_cycleTimer = GetMicroTimer();
Pre_logic_event_check();
Script_cycle();
if (g_px->mega_timer) {
script_cycleTimer = GetMicroTimer() - script_cycleTimer;
L->cycle_time = script_cycleTimer;
}
break;
case __NO_LOGIC: // do nothing
break;
case __CUSTOM_SIMPLE_ANIMATE: // special simple animator logic
if (g_px->mega_timer)
script_cycleTimer = GetMicroTimer();
Custom_simple_animator();
if (g_px->mega_timer) {
script_cycleTimer = GetMicroTimer() - script_cycleTimer;
L->cycle_time = script_cycleTimer;
}
break;
case __CUSTOM_BUTTON_OPERATED_DOOR: // special button operated door
if (g_px->mega_timer)
script_cycleTimer = GetMicroTimer();
Custom_button_operated_door();
if (g_px->mega_timer) {
script_cycleTimer = GetMicroTimer() - script_cycleTimer;
L->cycle_time = script_cycleTimer;
}
break;
case __CUSTOM_AUTO_DOOR:
if (g_px->mega_timer)
script_cycleTimer = GetMicroTimer();
Custom_auto_door();
if (g_px->mega_timer) {
script_cycleTimer = GetMicroTimer() - script_cycleTimer;
L->cycle_time = script_cycleTimer;
}
break;
case __MEGA_SLICE_HELD:
if (M->on_players_floor) {
L->big_mode = __SCRIPT; // in view - alive
g_oEventManager->ClearAllEventsForObject(cur_id);
g_oSoundLogicEngine->ClearHeardFlag(cur_id);
Script_cycle();
}
if (PXfabs(M->actor_xyz.y - logic_structs[player.Fetch_player_id()]->mega->actor_xyz.y) < (int32)(M->slice_hold_tolerance)) {
L->big_mode = __SCRIPT;
g_oEventManager->ClearAllEventsForObject(cur_id);
g_oSoundLogicEngine->ClearHeardFlag(cur_id);
Script_cycle();
}
break;
case __MEGA_PLAYER_FLOOR_HELD:
case __MEGA_INITIAL_FLOOR_HELD:
// waiting for player - release when on our floor
if (M->on_players_floor) {
L->big_mode = __SCRIPT;
g_oEventManager->ClearAllEventsForObject(cur_id);
g_oSoundLogicEngine->ClearHeardFlag(cur_id);
Script_cycle();
} else if (first_session_cycle)
Script_cycle(); // no camera yet
break;
}
// if the character is voxel based then add it to the list of voxel characters that is used by stage draw
if ((L->image_type == VOXEL) && ((L->ob_status != OB_STATUS_HELD))) {
time = GetMicroTimer();
// update some mega related stuff if mega is not sleeping
if (L->big_mode == __SCRIPT) {
// process outstanding auto pan remaining
if (L->auto_panning)
Advance_auto_pan();
Idle_manager(); // heh heh, check for mega just stood around
UpdateFootstep();
UpdateMegaFX();
}
// set floor rect value - used by stage draw to find indexed camera name
floor_def->Set_floor_rect_flag(L);
// check player floor status
if (!first_session_cycle)
Process_player_floor_status(); // sends events when object gains same floor as player
// process hold mode options
// has on-camera-only mode and is not on screen - then sleep again
if ((L->hold_mode == mega_player_floor_hold) && (!M->on_players_floor))
L->big_mode = __MEGA_PLAYER_FLOOR_HELD;
// has slice hold mode and is now off camera - check for shut off tolerance
if ((L->hold_mode == mega_slice_hold) && (!M->on_players_floor)) {
if (PXfabs(M->actor_xyz.y - logic_structs[player.Fetch_player_id()]->mega->actor_xyz.y) > (int32)(M->slice_hold_tolerance))
L->big_mode = __MEGA_SLICE_HELD;
}
// if on screen and stood then lets maybe do a scratch anim
time = GetMicroTimer() - time;
g_mission->xtra_mega_time += time;
}
}
}
// set not first cycle
first_session_cycle = FALSE8;
}
void _game_session::Pre_logic_event_check() {
// Check if there any events pending for the object.
// if so we re-run the logic context which may or may not decide to change the current script
if (((L->do_not_disturb == 1)) || (L->do_not_disturb == 2))
return; // 1 or 2 == fn-do-not-disturb + speech
if (L->do_not_disturb == 3) { // socket_force_new_logic
// clear events
g_oEventManager->ClearAllEventsForObject(cur_id);
L->do_not_disturb = 0; // reset for next cycle
return;
}
// Added call to the sound logic engine to see if any sound events are pending.
if (L->context_request || g_oEventManager->HasEventPending(cur_id) || g_oSoundLogicEngine->SoundEventPendingForID(cur_id)) {
// Yes, the object has an event pending, so rerun its logic context.
if (L->context_request)
Zdebug("[%s] internal request to rerun logic context", CGameObject::GetName(object));
else
Zdebug("[%s] event means rerun logic context", CGameObject::GetName(object));
if ((L->image_type == VOXEL) && (M->interacting)) { // check for megas who are interacting
// interacting, so ignoring LOS event
Zdebug("interacting, so ignoring LOS event");
} else {
L->logic[0] = (char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, (CGameObject::GetScriptNameFullHash(object, OB_LOGIC_CONTEXT)));
// run script - context chooser MAY pick a new L 1 logic
// we call this now so the new script will be setup and ready to run
RunScript(const_cast<const char *&>(L->logic[0]), object);
// reset the crude switch
L->context_request = FALSE8;
}
}
}
void _game_session::Script_cycle() {
int32 ret;
CGame *script_owner;
uint32 inner_cycles;
inner_cycles = 0; // to catch infnite_loops
// inner logic loop
do {
// sort out which object we should run the script with
// this can change within a cycle
if ((L->image_type == VOXEL) && (M->interacting)) { // check for megas who are interacting
// object is running someone elses interaction script
// so get their object and pass to interpretter so that local vars can be accessed correctly
script_owner = (CGame *)LinkedDataObject::Fetch_item_by_number(objects, M->target_id);
} else {
script_owner = object; // object running its own script
}
ret = RunScript(const_cast<const char *&>(L->logic[L->logic_level]), script_owner);
// ret is:
// 0 done enough this cycle
// 1 current script has finished and hit closing brace
// 2 FN_ returned an IR_TERMINATE to interpretter so we just go around - new script or gosub
if (ret == IR_RET_SCRIPT_FINISHED) { // script has finished so drop down a level
if (L->logic_level) { // not on base, so we can just drop down to the script below
L->logic_level--;
// in-case we were running an interaction script then cancel interaction
if (L->image_type == VOXEL) {
M->target_id = 0;
M->interacting = FALSE8;
L->looping = L->old_looping; // safe for return
}
}
if (!L->logic_level) { // restart the object
L->logic_ref[1] = nullptr; // completely reset L 1 so that context choose will select ok
// it is acceptable to choose the logic that had previously been running
// temp reset PC the hard way
L->logic[0] = (char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, CGameObject::GetScriptNameFullHash(object, OB_LOGIC_CONTEXT));
// run script - context chooser will pick a new L 1 logic
RunScript(const_cast<const char *&>(L->logic[0]), object);
// if still on base then nothing chosen - shut down the object and log a warning somewhere
if (!L->logic_level) {
Shut_down_object("by One_logic_cycle - logic context failed to choose");
ret = 0;
}
}
}
// catch infinite loops
inner_cycles++;
// I upped this from 5 to 1000 because the Remora relies on fn_new_script to jump around
// it's menu structure and this was tripping the limit. The player will have to spend ages
// in the Remora's menu's now for it to trip this limit, and genuine infinite loops will
// still be caught.
if (inner_cycles == 1000)
Fatal_error("object [%s] is in an infinite script loop!", CGameObject::GetName(object));
} while (ret); // ret==0 means quit for this object
}
uint32 _game_session::Fetch_prop_state(char *prop_name) {
// return a props state
// if the prop object doesnt exist we create a dummy - the system continues regardless - which is nice
uint32 prop_number;
uint32 j;
if (camera_hack == FALSE8) {
prop_number = LinkedDataObject::Fetch_item_number_by_name(objects, prop_name);
if (prop_number != 0xffffffff)
return (prop_state_table[prop_number]); // get prop state (pc)
}
// prop does not have a owner object - so we create a dummy for it if we havent already
// so, have we already created a dummy?
// search for dummy
// is our object already here?
j = 0;
while ((j < number_of_missing_objects) && (strcmp(missing_obs[j], prop_name)))
++j;
// didnt find the object
if (j == number_of_missing_objects) {
// create entry for the object
if (strcmp(prop_name, "not a prop") && (camera_hack == FALSE8)) // dont report dummy lights
Message_box("object missing for prop [%s]", prop_name);
Set_string(prop_name, missing_obs[number_of_missing_objects], MAX_missing_object_name_length);
Tdebug("missing_objects.txt", "%d [%s]", number_of_missing_objects, missing_obs[number_of_missing_objects]);
missing_ob_prop_states[number_of_missing_objects++] = 0;
return (0);
}
// dummy did exist so return the current dummy prop value
return (missing_ob_prop_states[j]);
}
void _game_session::Set_prop_state(char *prop_name, uint32 value) {
// set a prop state
// if the prop doesnt exist we skip it - and assume it will soon be built
// there is no scope checking
uint32 prop_number;
uint32 j;
if (camera_hack == FALSE8) {
prop_number = LinkedDataObject::Fetch_item_number_by_name(objects, prop_name);
if (prop_number != 0xffffffff)
prop_state_table[prop_number] = value; // set prop state (pc)
}
// have we already created a dummy?
// search for dummy
// is our object already here?
j = 0;
while ((j < number_of_missing_objects) && (strcmp(missing_obs[j], prop_name)))
++j;
// didnt find the object
if (j == number_of_missing_objects)
return;
// found the dummy so set its value
missing_ob_prop_states[j] = (uint8)value;
}
uint32 _game_session::Fetch_named_objects_id(const char *name) const {
uint32 i;
for (i = 0; i < total_objects; ++i) {
if (strcmp(name, logic_structs[i]->GetName()) == 0)
return (i);
}
// The object wasn't found.
Fatal_error("Object %s not found in _game_session::Fetch_named_objects_id()", name);
// This stops a compiler error.
return (0xffffffff);
}
void _game_session::Process_player_floor_status() {
// work out if this object
bool8 result = FALSE8;
uint32 num_extra, j, cam, player_floor;
player_floor = logic_structs[player.Fetch_player_id()]->owner_floor_rect;
// dont need to tell the player he's on the players floor
if (player.Fetch_player_id() == cur_id)
return;
if (floor_to_camera_index[L->owner_floor_rect] == cur_camera_number)
result = TRUE8; //
else { // no exact same
// ok, but is our floor linked to theirs?
cam = floor_to_camera_index[player_floor];
num_extra = cam_floor_list[cam].num_extra_floors;
for (j = 0; j < num_extra; j++)
if (cam_floor_list[cam].extra_floors[j] == L->owner_floor_rect) { // our floor one of players extras?
result = TRUE8; // yes - the floors are linked
break;
}
}
if ((!M->on_players_floor) && (result)) {
g_oEventManager->PostNamedEventToObject("on_floor", cur_id, player.Fetch_player_id()); // send as if from player
}
M->on_players_floor = result; // set to current state
}
void _game_session::Idle_manager() {
// megas only
// is the character idling?
// if so and for a int32 time gosub a script that will do something
uint32 k;
char *ad;
uint32 script_hash;
if ((L->pause) && (L->cur_anim_type == __STAND) && (L->conversation_uid == NO_SPEECH_REQUEST) && (!M->Is_crouched()) && (Object_visible_to_camera(cur_id))) {
M->idle_count++;
if ((M->idle_count > 24) && (L->logic_level == 1)) {
M->idle_count = 0;
script_hash = HashString("idle");
// try and find a script with the passed extention i.e. ???::looping
for (k = 0; k < CGameObject::GetNoScripts(object); k++) {
if (script_hash == CGameObject::GetScriptNamePartHash(object, k)) {
// script k is the one to run
// get the address of the script we want to run
ad = (char *)LinkedDataObject::Try_fetch_item_by_hash(scripts, CGameObject::GetScriptNameFullHash(object, k));
// write actual offset
L->logic[2] = ad;
L->logic_level = 2; //
L->old_looping = L->looping; // safe for return
L->looping = 0; // reset to 0 for new logics
M->custom = FALSE8; // reset
return; // done it
}
}
}
}
}
void _game_session::Set_init_voxel_floors() {
// set all mega characters floors - called after game restore because logics may begin by checking the floor number but it wont be set until end of first cycle
uint32 j;
for (j = 0; j < number_of_voxel_ids; j++)
floor_def->Set_floor_rect_flag(logic_structs[voxel_id_list[j]]);
// setup the players route barriers
MS->M = MS->logic_structs[MS->player.Fetch_player_id()]->mega;
MS->L = MS->logic_structs[MS->player.Fetch_player_id()];
Prepare_megas_route_barriers(TRUE8); // update barriers
}
LinkedDataFile *LoadTranslatedFile(const char *mission, const char *session) {
// Get the actual session name
const char *sessionstart = session + strlen(mission) + 1;
pxString actsession;
actsession.SetString(sessionstart, strlen(sessionstart) - 1);
// Make up the name for the file to be loaded up
pxString fname = pxVString("%s\\data\\%s%s.ttrans", tt_text, mission, (const char *)actsession);
if (!checkFileExists(fname))
Fatal_error("Unable to load file %s", (const char *)fname);
// Load in this file
Common::SeekableReadStream *stream = openDiskFileForBinaryStreamRead(fname.c_str());
if (stream == nullptr) // if it could not be opened
Fatal_error("Unable to load file %s", (const char *)fname);
uint32 len = stream->size();
// make space for file
char *memPtr = new char[len + 1];
// read it in
stream->read(memPtr, len);
delete stream; // close the file
// 0 terminate the string
memPtr[len] = 0;
return ((LinkedDataFile *)memPtr);
}
} // End of namespace ICB