Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c971d568a112e5bec2e45ab389375b07c6914a6e
GTASource/game/script/Handlers/GameScriptMgr.cpp

2981 lines
99 KiB
C++
Raw Normal View History

init
2025-02-23 17:40:52 +08:00
// netScriptMgrBase.cpp
//
// Copyright (C) 1999-2009 Rockstar Games. All Rights Reserved.
//
#include "script/handlers/GameScriptMgr.h"
// rage includes
#include "bank/bank.h"
#include "grcore/debugdraw.h"
#include "fwsys/timer.h"
#include "fwscript/scriptguid.h"
// game includes
#include "modelinfo/PedModelInfo.h"
#include "modelinfo/VehicleModelInfo.h"
#include "network/Arrays/NetworkArrayMgr.h"
#include "network/Bandwidth/NetworkBandwidthManager.h"
#include "network/Events/NetworkEventTypes.h"
#include "network/NetworkInterface.h"
#include "network/Network.h"
#include "network/Objects/NetworkObjectMgr.h"
#include "network/Players/NetGamePlayer.h"
#include "network/Sessions/NetworkSession.h"
#include "peds/ped.h"
#include "peds/PlayerInfo.h"
#include "scene/streamer/StreamVolume.h"
#include "scene/world/GameWorld.h"
#include "script/handlers/GameScriptEntity.h"
#include "script/handlers/GameScriptHandler.h"
#include "script/handlers/GameScriptHandlerNetwork.h"
#include "script/handlers/GameScriptResources.h"
#include "script/gta_thread.h"
#include "script/script.h"
#include "script/script_channel.h"
#include "script/streamedscripts.h"
#include "streaming/populationstreaming.h"
#include "streaming/streamingdebug.h"
#include "streaming/streamingengine.h"
#include "streaming/streaminginfo.h"
#include "vfx/misc/MovieManager.h"
#include "Event/EventGroup.h"
#if __DEV
#include "network/NetworkInterface.h"
#include "network/objects/NetworkObjectMgr.h"
#include "network/Players/NetworkPlayerMgr.h"
#include "rline/rlgamerinfo.h"
#endif
SCRIPT_OPTIMISATIONS()
NETWORK_OPTIMISATIONS()
XPARAM(override_script);
XPARAM(dontCrashOnScriptValidation);
PARAM(scriptLogMemoryPeaks, "[MEMORY] Log the memory peaks for the scripts physical and virtual usage.");
#if __BANK
bkCombo* CGameScriptHandlerMgr::ms_pHandlerCombo = NULL;
const char* CGameScriptHandlerMgr::ms_Handlers[CGameScriptHandler::MAX_NUM_SCRIPT_HANDLERS];
unsigned int CGameScriptHandlerMgr::ms_NumHandlers = 0;
int CGameScriptHandlerMgr::ms_HandlerComboIndex = 0;
bool CGameScriptHandlerMgr::ms_DisplayHandlerInfo = false;
bool CGameScriptHandlerMgr::ms_DisplayAllMPHandlers = false;
#endif // __BANK
u32 CGameScriptHandlerMgr::ms_validNetworkScriptHashes[] =
{
ATSTRINGHASH("act_cinema", 0x8961d933),
ATSTRINGHASH("activity_creator_prototype_launcher", 0x4fb9c566),
ATSTRINGHASH("am_agency_suv", 0x12117cf0),
ATSTRINGHASH("am_airstrike", 0x060cd733),
ATSTRINGHASH("am_ammo_drop", 0xa7c6571d),
ATSTRINGHASH("am_armwrestling", 0x3c77f4aa),
ATSTRINGHASH("am_armwrestling_apartment", 0x69bdb2d8),
ATSTRINGHASH("am_armybase", 0x4efb7452),
ATSTRINGHASH("am_backup_heli", 0xddb3aada),
ATSTRINGHASH("am_beach_washup_cinematic", 0xE720B4A4),
ATSTRINGHASH("am_boat_taxi", 0xd8133249),
ATSTRINGHASH("am_bru_box", 0x48600c01),
ATSTRINGHASH("am_car_mod_tut", 0x83a66932),
ATSTRINGHASH("am_casino_limo", 0x3A5BBA05),
ATSTRINGHASH("am_casino_luxury_car", 0xb93135a6),
ATSTRINGHASH("am_casino_peds", 0x1C0F96E7),
ATSTRINGHASH("am_challenges", 0x59de0357),
ATSTRINGHASH("am_cp_collection", 0x0544b90b),
ATSTRINGHASH("am_crate_drop", 0x240f2e7b),
ATSTRINGHASH("am_criminal_damage", 0xc62526f5),
ATSTRINGHASH("am_darts", 0x2a10cf0c),
ATSTRINGHASH("am_darts_apartment", 0xab14f1f2),
ATSTRINGHASH("am_dead_drop", 0x9497de5d),
ATSTRINGHASH("am_destroy_veh", 0xeab28126),
ATSTRINGHASH("am_distract_cops", 0x81dc676e),
ATSTRINGHASH("am_doors", 0xc80b3112),
ATSTRINGHASH("am_ferriswheel", 0xe4e0cbce),
ATSTRINGHASH("am_ga_pickups", 0xa77e5305),
ATSTRINGHASH("am_gang_call", 0x0266ce78),
ATSTRINGHASH("am_heist_int", 0xc74cc971),
ATSTRINGHASH("am_heist_island_plane_land_cinematic", 0x560E198),
ATSTRINGHASH("am_heist_island_plane_take_off_cinematic", 0x1984610C),
ATSTRINGHASH("am_heli_taxi", 0x4840fef0),
ATSTRINGHASH("am_hi_plane_take_off_cinematic", 0x418795CC),
ATSTRINGHASH("am_hi_plane_land_cinematic", 0x9782808A),
ATSTRINGHASH("am_hold_up", 0x0c6dac46),
ATSTRINGHASH("am_hot_property", 0x95335193),
ATSTRINGHASH("am_hot_target", 0x3c04751e),
ATSTRINGHASH("am_hs4_isd_take_vel", 0x9B9330A1),
ATSTRINGHASH("am_hs4_lsa_land_nimb_arrive",0x2941F161),
ATSTRINGHASH("am_hs4_lsa_land_vel", 0xC288DE3E),
ATSTRINGHASH("am_hs4_lsa_take_vel", 0x7BD40072),
ATSTRINGHASH("am_hs4_nimb_isd_lsa_leave", 0x85398B65),
ATSTRINGHASH("am_hs4_nimb_lsa_isd_leave", 0xC2F73739),
ATSTRINGHASH("am_hs4_nimb_lsa_isd_arrive", 0x39DB7A9C),
ATSTRINGHASH("am_hs4_vel_lsa_isd", 0x1FF4E6A9),
ATSTRINGHASH("am_hunt_the_beast", 0x7e76f859),
ATSTRINGHASH("am_lsia_land_cinematic", 0xAEA5F533),
ATSTRINGHASH("am_imp_exp", 0x1961b859),
ATSTRINGHASH("am_island_backup_heli", 0x68867AF7),
ATSTRINGHASH("am_joyrider", 0xe1bc7b99),
ATSTRINGHASH("am_kill_list", 0xa8d5e84c),
ATSTRINGHASH("am_king_of_the_castle", 0x7a9a3349),
ATSTRINGHASH("am_launcher", 0x57c919e1),
ATSTRINGHASH("am_lester_cut", 0x1edd4ad1),
ATSTRINGHASH("am_lowrider_int", 0x4250943e),
ATSTRINGHASH("am_lsia_take_off_cinematic", 0x849DBDF1),
ATSTRINGHASH("am_luxury_showroom", 0xf4ab6fb5),
ATSTRINGHASH("am_mission_launch", 0x8fa27332),
ATSTRINGHASH("am_mp_acid_lab", 0x480e7a1a),
ATSTRINGHASH("am_mp_arc_cab_manager", 0x4ee41f75),
ATSTRINGHASH("am_mp_arcade", 0x500b732f),
ATSTRINGHASH("am_mp_arcade_love_meter", 0x39245013),
ATSTRINGHASH("am_mp_arcade_strength_test", 0x7488fe33),
ATSTRINGHASH("am_mp_arcade_fortune_teller", 0xf4c6d398),
ATSTRINGHASH("am_mp_arcade_claw_crane", 0xa54f9693),
ATSTRINGHASH("am_mp_arena_box", 0x8C9C5FB8),
ATSTRINGHASH("am_mp_arena_garage", 0x26EBCE20),
ATSTRINGHASH("am_mp_armory_aircraft", 0x9c6f5716),
ATSTRINGHASH("am_mp_armory_truck", 0x5b9b0272),
ATSTRINGHASH("am_mp_auto_shop", 0xba18b4c),
ATSTRINGHASH("am_mp_biker_warehouse", 0x504ebb57),
ATSTRINGHASH("am_mp_boardroom_seating", 0x70fc43a2),
ATSTRINGHASH("am_mp_bunker", 0x89d486f8),
ATSTRINGHASH("am_mp_business_hub", 0xC85B5BEF),
ATSTRINGHASH("am_mp_car_meet_property", 0x2385bdc4),
ATSTRINGHASH("am_mp_car_meet_sandbox", 0x5158A9E4),
ATSTRINGHASH("am_mp_casino", 0x7166BD4A),
ATSTRINGHASH("am_mp_casino_apartment", 0xD76D873D),
ATSTRINGHASH("am_mp_casino_dj_room", 0x12daa5f1),
ATSTRINGHASH("am_mp_casino_nightclub", 0x700869D),
ATSTRINGHASH("am_mp_casino_valet_garage", 0x6cc29c20),
ATSTRINGHASH("am_mp_creator_aircraft", 0xd4dddde0),
ATSTRINGHASH("am_mp_creator_trailer", 0xcbd05bfb),
ATSTRINGHASH("am_mp_defunct_base", 0xcab8a943),
ATSTRINGHASH("am_mp_dj", 0xb369e47f),
ATSTRINGHASH("am_mp_drone", 0x230D1E0D),
ATSTRINGHASH("am_mp_fixer_hq", 0x995f4ea5),
ATSTRINGHASH("am_mp_garage_control", 0xfd4b7439),
ATSTRINGHASH("am_mp_hacker_truck", 0x349B7463),
ATSTRINGHASH("am_mp_hangar", 0xefc0d4ec),
ATSTRINGHASH("am_mp_ie_warehouse", 0xb7a8f8db),
ATSTRINGHASH("am_mp_island", 0x1C2A2AF8),
ATSTRINGHASH("am_mp_juggalo_hideout", 0xedfd243e),
ATSTRINGHASH("am_mp_multistorey_garage", 0x679a06a1),
ATSTRINGHASH("am_mp_music_studio", 0xfd3397ae),
ATSTRINGHASH("am_mp_mission", 0x626b9c51),
ATSTRINGHASH("am_mp_nightclub", 0x8C56B7FE),
ATSTRINGHASH("am_mp_orbital_cannon", 0x6c25dccb),
ATSTRINGHASH("am_mp_peds", 0xBC350B6D),
ATSTRINGHASH("am_mp_property_ext", 0x72ee09f2),
ATSTRINGHASH("am_mp_property_int", 0x95b61b3c),
ATSTRINGHASH("am_mp_rc_vehicle", 0xd1894172),
ATSTRINGHASH("am_mp_shooting_range", 0xaa3368fc),
ATSTRINGHASH("am_mp_simeon_showroom", 0x1ed5a03d),
ATSTRINGHASH("am_mp_smoking_activity", 0x121a26b9),
ATSTRINGHASH("am_mp_smpl_interior_ext", 0xe0a7b7ad),
ATSTRINGHASH("am_mp_smpl_interior_int", 0x05973129),
ATSTRINGHASH("am_mp_solomon_office", 0x220A2BF3),
ATSTRINGHASH("am_mp_submarine", 0xE16957F2),
ATSTRINGHASH("am_mp_vehicle_reward", 0x692F8E30),
ATSTRINGHASH("am_mp_vehicle_weapon", 0x322bad51),
ATSTRINGHASH("am_mp_warehouse", 0x2262ddf0),
ATSTRINGHASH("am_mp_yacht", 0xc930c939),
ATSTRINGHASH("am_npc_invites", 0x529d545f),
ATSTRINGHASH("am_pass_the_parcel", 0x8dd957aa),
ATSTRINGHASH("am_patrick", 0xb70b6f22),
ATSTRINGHASH("am_penned_in", 0x9fd87720),
ATSTRINGHASH("am_penthouse_peds", 0x5c0238a9),
ATSTRINGHASH("am_plane_takedown", 0x990a9196),
ATSTRINGHASH("am_prison", 0x70da15b8),
ATSTRINGHASH("am_prostitute", 0x62773681),
ATSTRINGHASH("am_rollercoaster", 0xa8f75ae1),
ATSTRINGHASH("am_rontrevor_cut", 0xe895e13e),
ATSTRINGHASH("am_taxi", 0x455fe4de),
ATSTRINGHASH("am_vehicle_spawn", 0xb726fc82),
ATSTRINGHASH("apartment_minigame_launcher", 0xc4382362),
ATSTRINGHASH("arcade_seating", 0xA0B1239B),
ATSTRINGHASH("arena_box_bench_seats", 0x63905267),
ATSTRINGHASH("arena_carmod", 0xdafc0911),
ATSTRINGHASH("arena_workshop_seats", 0x7030f53f),
ATSTRINGHASH("armory_aircraft_carmod", 0x78ddb08f),
ATSTRINGHASH("atm_trigger", 0x1ab4168d),
ATSTRINGHASH("auto_shop_seating", 0x7A4A46AE),
ATSTRINGHASH("base_carmod", 0x00e813dd),
ATSTRINGHASH("base_corridor_seats", 0x16833adb),
ATSTRINGHASH("base_entrance_seats", 0x8d055fe8),
ATSTRINGHASH("base_heist_seats", 0xc5c0aa16),
ATSTRINGHASH("base_lounge_seats", 0xddf302ec),
ATSTRINGHASH("base_quaters_seats", 0x01aa9982),
ATSTRINGHASH("base_reception_seats", 0x6b938b1b),
ATSTRINGHASH("beach_exterior_seating", 0x3DE90B7C),
ATSTRINGHASH("blackjack", 0xD378365E),
ATSTRINGHASH("business_battles", 0xA6526FA9),
ATSTRINGHASH("business_battles_defend", 0x6FA239A5),
ATSTRINGHASH("business_battles_sell", 0xF3F871DA),
ATSTRINGHASH("business_hub_carmod", 0x6E6F052),
ATSTRINGHASH("business_hub_garage_seats", 0x7d5dee96),
ATSTRINGHASH("camhedz_arcade", 0xE81212C6),
ATSTRINGHASH("car_meet_carmod", 0xBB3D7E9D),
ATSTRINGHASH("car_meet_exterior_seating", 0x581858D7),
ATSTRINGHASH("car_meet_interior_seating", 0xAEC3C263),
ATSTRINGHASH("carmod_shop", 0x1dc6b680),
ATSTRINGHASH("cashisking", 0xaa69fdd3),
ATSTRINGHASH("casino_bar_seating", 0x6e6fc95f),
ATSTRINGHASH("casino_exterior_seating", 0x38C0DADF),
ATSTRINGHASH("casino_interior_seating", 0xc2c12122),
ATSTRINGHASH("casino_lucky_wheel", 0xbdf0ccff),
ATSTRINGHASH("casino_main_lounge_seating", 0x3339c03a),
ATSTRINGHASH("casino_nightclub_seating", 0xF8881E62),
ATSTRINGHASH("casino_penthouse_seating", 0x5a1b8571),
ATSTRINGHASH("casino_slots", 0x5f1459d7),
ATSTRINGHASH("casinoroulette", 0x05e86d0d),
ATSTRINGHASH("clothes_shop_mp", 0xc0f0bbc3),
ATSTRINGHASH("copscrooks_holdup_instance", 0x70871f89),
ATSTRINGHASH("copscrooks_job_instance", 0xF28DD9D9),
ATSTRINGHASH("dont_cross_the_line", 0x85db1b5a),
ATSTRINGHASH("endlesswinter", 0xe237f748),
ATSTRINGHASH("fixer_hq_carmod", 0x41f74a04),
ATSTRINGHASH("fixer_hq_seating", 0x1a207399),
ATSTRINGHASH("fixer_hq_seating_op_floor", 0xc6bd80fc),
ATSTRINGHASH("fixer_hq_seating_pq", 0x15dac453),
ATSTRINGHASH("fm_bj_race_controler", 0xbe3e7d03),
ATSTRINGHASH("fm_content_acid_lab_sell", 0x92772b1f),
ATSTRINGHASH("fm_content_acid_lab_setup", 0x61ff0c31),
ATSTRINGHASH("fm_content_acid_lab_source", 0x701beffb),
ATSTRINGHASH("fm_content_auto_shop_delivery", 0xfc4970dc),
ATSTRINGHASH("fm_content_ammunation", 0x4537E4CA),
ATSTRINGHASH("fm_content_bank_shootout", 0x3f21df40),
ATSTRINGHASH("fm_content_bar_resupply", 0x2363D09D),
ATSTRINGHASH("fm_content_business_battles", 0x62EA78D0),
ATSTRINGHASH("fm_content_bike_shop_delivery", 0x3ff69732),
ATSTRINGHASH("fm_content_cargo", 0x035d0edc),
ATSTRINGHASH("fm_content_cerberus", 0xe05f49f1),
ATSTRINGHASH("fm_content_club_management", 0xa14222b3),
ATSTRINGHASH("fm_content_club_odd_jobs", 0xdf2e4655),
ATSTRINGHASH("fm_content_club_source", 0x2b88e6a1),
ATSTRINGHASH("fm_content_clubhouse_contracts", 0x5a98b2be),
ATSTRINGHASH("fm_content_convoy", 0x4b293c1f),
ATSTRINGHASH("fm_content_crime_scene", 0x5CA3449B),
ATSTRINGHASH("fm_content_dispatch", 0xBC0EB82E),
ATSTRINGHASH("fm_content_drug_lab_work", 0x0bf710af),
ATSTRINGHASH("fm_content_drug_vehicle", 0x5B3F117),
ATSTRINGHASH("fm_content_export_cargo", 0xee7c5974),
ATSTRINGHASH("fm_content_golden_gun", 0xA7CBD213),
ATSTRINGHASH("fm_content_gunrunning", 0x1a160b48),
ATSTRINGHASH("fm_content_island_dj", 0xBE590E09),
ATSTRINGHASH("fm_content_island_heist", 0xF2A65E92),
ATSTRINGHASH("fm_content_metal_detector", 0xEEDDF72E),
ATSTRINGHASH("fm_content_movie_props", 0x9BF88E0E),
ATSTRINGHASH("fm_content_payphone_hit", 0xF7F8D71A),
ATSTRINGHASH("fm_content_payphone_intro", 0x2F916684),
ATSTRINGHASH("fm_content_phantom_car", 0xF699F9CD),
ATSTRINGHASH("fm_content_security_contract", 0x26EA9F66),
ATSTRINGHASH("fm_content_serve_and_protect", 0xFF78189D),
ATSTRINGHASH("fm_content_sightseeing", 0x975e5d41),
ATSTRINGHASH("fm_content_skydive", 0x3d946731),
ATSTRINGHASH("fm_content_slasher", 0xD45729DB),
ATSTRINGHASH("fm_content_smuggler_plane", 0xb8140067),
ATSTRINGHASH("fm_content_smuggler_trail", 0x277b17b6),
ATSTRINGHASH("fm_content_source_research", 0xe3e84b48),
ATSTRINGHASH("fm_content_sprint", 0x51C051E7),
ATSTRINGHASH("fm_content_stash_house", 0x29513dec),
ATSTRINGHASH("fm_content_taxi_driver", 0xb7782ad4),
ATSTRINGHASH("fm_content_tuner_robbery", 0xB5278C95),
ATSTRINGHASH("fm_content_vehicle_list", 0x9E4931D3),
ATSTRINGHASH("fm_content_vip_contract_1", 0x75C7E0D3),
ATSTRINGHASH("fm_content_xmas_mugger", 0x6cfc0084),
ATSTRINGHASH("fm_deathmatch_controler", 0xe62128cb),
ATSTRINGHASH("fm_hideout_controler", 0x055ede8c),
ATSTRINGHASH("fm_hold_up_tut", 0x75804856),
ATSTRINGHASH("fm_horde_controler", 0x514a6d17),
ATSTRINGHASH("fm_impromptu_dm_controler", 0xad453307),
ATSTRINGHASH("fm_intro", 0xefe7c380),
ATSTRINGHASH("fm_mission_controller", 0x6c2ce225),
ATSTRINGHASH("fm_mission_controller_2020", 0xBF461AD0),
ATSTRINGHASH("fm_race_controler", 0xeb004e0e),
ATSTRINGHASH("fm_street_dealer", 0xbc8a3c3e),
ATSTRINGHASH("fm_survival_controller", 0x1D477306),
ATSTRINGHASH("fmmc_launcher", 0xa3fb8a5e),
ATSTRINGHASH("fmmc_playlist_controller", 0x56e10d97),
ATSTRINGHASH("freemode", 0xc875557d),
ATSTRINGHASH("freemodearcade", 0xff3cad99),
ATSTRINGHASH("freemodeLite", 0x1CA0CF36),
ATSTRINGHASH("gb_airfreight", 0x59e32892),
ATSTRINGHASH("gb_amphibious_assault", 0x31dc55bb),
ATSTRINGHASH("gb_assault", 0xc3961a05),
ATSTRINGHASH("gb_bank_job", 0x929CEFED),
ATSTRINGHASH("gb_bellybeast", 0xd4d41110),
ATSTRINGHASH("gb_biker_bad_deal", 0x2334f600),
ATSTRINGHASH("gb_biker_burn_assets", 0xd9ee6178),
ATSTRINGHASH("gb_biker_contraband_defend", 0x56a1412c),
ATSTRINGHASH("gb_biker_contraband_sell", 0xdffc4863),
ATSTRINGHASH("gb_biker_contract_killing", 0x1c8463b3),
ATSTRINGHASH("gb_biker_criminal_mischief", 0x3e927a10),
ATSTRINGHASH("gb_biker_destroy_vans", 0x6a5fc4cc),
ATSTRINGHASH("gb_biker_driveby_assassin", 0x2898b9e6),
ATSTRINGHASH("gb_biker_free_prisoner", 0x966afe8f),
ATSTRINGHASH("gb_biker_joust", 0xa9165795),
ATSTRINGHASH("gb_biker_last_respects", 0x63389db5),
ATSTRINGHASH("gb_biker_race_p2p", 0xd4caa546),
ATSTRINGHASH("gb_biker_rescue_contact", 0x8403149b),
ATSTRINGHASH("gb_biker_rippin_it_up", 0x64ad4306),
ATSTRINGHASH("gb_biker_safecracker", 0xfc5f9481),
ATSTRINGHASH("gb_biker_search_and_destroy", 0x6d5e1016),
ATSTRINGHASH("gb_biker_shuttle", 0xd41e6264),
ATSTRINGHASH("gb_biker_stand_your_ground", 0x9e4e7734),
ATSTRINGHASH("gb_biker_steal_bikes", 0xdd56dc62),
ATSTRINGHASH("gb_biker_unload_weapons", 0xb31a0796),
ATSTRINGHASH("gb_biker_wheelie_rider", 0xb3e837ff),
ATSTRINGHASH("gb_carjacking", 0xa29e8148),
ATSTRINGHASH("gb_cashing_out", 0xaa79b0eb),
ATSTRINGHASH("gb_casino", 0x13645DC3),
ATSTRINGHASH("gb_casino_heist", 0x8ef7e740),
ATSTRINGHASH("gb_collect_money", 0x206c6c4b),
ATSTRINGHASH("gb_contraband_buy", 0xeb04de05),
ATSTRINGHASH("gb_contraband_defend", 0x2055a1a4),
ATSTRINGHASH("gb_contraband_sell", 0x7b3e31d2),
ATSTRINGHASH("gb_data_hack", 0x45154B11),
ATSTRINGHASH("gb_deathmatch", 0x9f42b34b),
ATSTRINGHASH("gb_delivery", 0x6e9955cb),
ATSTRINGHASH("gb_finderskeepers", 0xa6320c4d),
ATSTRINGHASH("gb_fivestar", 0x8dc43a99),
ATSTRINGHASH("gb_fortified", 0x51925081),
ATSTRINGHASH("gb_fragile_goods", 0x2382af03),
ATSTRINGHASH("gb_fully_loaded", 0xda508d57),
ATSTRINGHASH("gb_gangops", 0xfb30320a),
ATSTRINGHASH("gb_gang_ops_planning", 0x6d20caab),
ATSTRINGHASH("gb_gunrunning", 0x8cd0bff0),
ATSTRINGHASH("gb_gunrunning_defend", 0x14b421aa),
ATSTRINGHASH("gb_gunrunning_delivery", 0x29a28ed8),
ATSTRINGHASH("gb_headhunter", 0x71c13b55),
ATSTRINGHASH("gb_hunt_the_boss", 0x52d21ba4),
ATSTRINGHASH("gb_ie_delivery_cutscene", 0x9114379b),
ATSTRINGHASH("gb_illicit_goods_resupply", 0x9d9d13ec),
ATSTRINGHASH("gb_infiltration", 0x610BE6A0),
ATSTRINGHASH("gb_jewel_store_grab", 0xB0BCBA60),
ATSTRINGHASH("gb_ploughed", 0x14611265),
ATSTRINGHASH("gb_point_to_point", 0x45bd5447),
ATSTRINGHASH("gb_ramped_up", 0x506cc782),
ATSTRINGHASH("gb_rob_shop", 0xb4901ab2),
ATSTRINGHASH("gb_salvage", 0x4eff43a1),
ATSTRINGHASH("gb_security_van", 0xE8DA8C5F),
ATSTRINGHASH("gb_sightseer", 0x724eba87),
ATSTRINGHASH("gb_smuggler", 0xabd3de17),
ATSTRINGHASH("gb_stockpiling", 0xf60a885b),
ATSTRINGHASH("gb_target_pursuit", 0x5D94ED7B),
ATSTRINGHASH("gb_terminate", 0xf2095bfd),
ATSTRINGHASH("gb_transporter", 0x0b87dc63),
ATSTRINGHASH("gb_vehicle_export", 0xd9751e61),
ATSTRINGHASH("gb_velocity", 0x5f6c2123),
ATSTRINGHASH("gb_yacht_rob", 0x7fa4662e),
ATSTRINGHASH("ggsm_arcade", 0x2AEDCDFB),
ATSTRINGHASH("grid_arcade_cabinet", 0xD5597100),
ATSTRINGHASH("golf_mp", 0xcf654b49),
ATSTRINGHASH("gunclub_shop", 0x1beb0bf6),
ATSTRINGHASH("gunslinger_arcade", 0xDB23F3DC),
ATSTRINGHASH("hacker_truck_carmod", 0xCE27944E),
ATSTRINGHASH("hairdo_shop_mp", 0xb57685c9),
ATSTRINGHASH("hangar_carmod", 0x34141a78),
ATSTRINGHASH("heist_island_planning", 0x55EC87F4),
ATSTRINGHASH("heistislandtempcinematicfadeout", 0x32ABF33D),
ATSTRINGHASH("heistislandtempcinematicfadein", 0xC1508DAB),
ATSTRINGHASH("heli_gun", 0xba023427),
ATSTRINGHASH("juggalo_hideout_carmod", 0x05760f53),
ATSTRINGHASH("lobby", 0x5a8cb6b1),
ATSTRINGHASH("luxe_veh_activity", 0x304094ed),
ATSTRINGHASH("mg_race_to_point", 0x804da739),
ATSTRINGHASH("missioniaaturret", 0x0c5e8432),
ATSTRINGHASH("mp_bed_high", 0x272557eb),
ATSTRINGHASH("mptestbed", 0x62c09cc6),
ATSTRINGHASH("mptutorial", 0xa1cb0fb5),
ATSTRINGHASH("mptutorial old", 0xe79e6d99),
ATSTRINGHASH("music_studio_seating", 0x95f729db),
ATSTRINGHASH("music_studio_seating_external", 0xdbabae79),
ATSTRINGHASH("music_studio_smoking", 0xa5c68a5b),
ATSTRINGHASH("net_activity_creator_ui", 0x184b4e09),
ATSTRINGHASH("net_apartment_activity", 0xdd40b31d),
ATSTRINGHASH("net_apartment_activity_light", 0xf3e2dd79),
ATSTRINGHASH("net_combat_soaktest", 0xf159fe54),
ATSTRINGHASH("net_jacking_soaktest", 0x74fa8e62),
ATSTRINGHASH("net_test_drive", 0x4eb46ff0),
ATSTRINGHASH("net_session_soaktest", 0xe696faf1),
ATSTRINGHASH("nightclub_ground_floor_seats", 0x8e55be9d),
ATSTRINGHASH("nightclub_office_seats", 0xfd519148),
ATSTRINGHASH("nightclub_vip_seats", 0xdf1e929f),
ATSTRINGHASH("nightclubpeds", 0x9a821400),
ATSTRINGHASH("ob_bong", 0x57439d64),
ATSTRINGHASH("ob_cashregister", 0x0e1819bf),
ATSTRINGHASH("ob_drinking_shots", 0x000269eb),
ATSTRINGHASH("ob_franklin_beer", 0xb1b4d0ed),
ATSTRINGHASH("ob_franklin_wine", 0x00eb926e),
ATSTRINGHASH("ob_jukebox", 0xD044BED0),
ATSTRINGHASH("ob_mp_bed_high", 0xe003b72c),
ATSTRINGHASH("ob_mp_bed_low", 0x0d798ec5),
ATSTRINGHASH("ob_mp_bed_med", 0x51c89b45),
ATSTRINGHASH("ob_mp_shower_med", 0x96c72262),
ATSTRINGHASH("ob_mp_stripper", 0x5a6f3a5f),
ATSTRINGHASH("ob_telescope", 0x5202cf8c),
ATSTRINGHASH("ob_vend1", 0xa39c1f72),
ATSTRINGHASH("ob_vend2", 0x11c77bc7),
ATSTRINGHASH("pb_prostitute", 0x6a96798a),
ATSTRINGHASH("personal_carmod_shop", 0xdef103d2),
ATSTRINGHASH("pilot_school_mp", 0xc5a00edd),
ATSTRINGHASH("range_modern_mp", 0x1f538c61),
ATSTRINGHASH("road_arcade", 0x7ae86e42),
ATSTRINGHASH("sclub_front_bouncer", 0xe79ae0ef),
ATSTRINGHASH("simeon_showroom_seating", 0x23802fd8),
ATSTRINGHASH("specialgarage", 0xbc24c116),
ATSTRINGHASH("specialgaragevehicles", 0x583f311f),
ATSTRINGHASH("streaming", 0xd3ac6be7),
ATSTRINGHASH("stripclub_drinking", 0xede89eb0),
ATSTRINGHASH("stripclub_mp", 0x97cd8e78),
ATSTRINGHASH("stripperhome", 0xb8b48b62),
ATSTRINGHASH("tattoo_shop", 0xc0d26565),
ATSTRINGHASH("tempofficegarage", 0x738b3a59),
ATSTRINGHASH("tennis_network_mp", 0xe3940b1c),
ATSTRINGHASH("testtutorialforproperties", 0x311fd06a),
ATSTRINGHASH("testtutorialproperties", 0x011e64ab),
ATSTRINGHASH("testvehiclespawning", 0x2f07d2ae),
ATSTRINGHASH("testvehiclespawning2", 0x0c093898),
ATSTRINGHASH("Three_Card_Poker", 0xc8608f32),
ATSTRINGHASH("tuner_planning", 0x1BE25EB4),
ATSTRINGHASH("tuner_property_carmod", 0x70b10f84),
ATSTRINGHASH("tuner_sandbox_activity", 0x8758ef91),
ATSTRINGHASH("turret_cam_script", 0xe6511181),
ATSTRINGHASH("vehiclespawning", 0x70f5ddd6),
ATSTRINGHASH("xml_menus", 0x164e8dee),
};
unsigned CGameScriptHandlerMgr::NUM_VALID_NETWORK_SCRIPTS = (sizeof(CGameScriptHandlerMgr::ms_validNetworkScriptHashes) / sizeof(u32));
CGameScriptHandlerMgr::CGameScriptHandlerMgr(CNetworkBandwidthManager* bandwidthMgr)
: scriptHandlerMgr(static_cast<netBandwidthMgr*>(bandwidthMgr))
{
}
bool CGameScriptHandlerMgr::CRemoteScriptInfo::IsTerminated() const
{
unsigned timeout = CNetwork::GetTimeoutTime();
if (m_ActiveParticipants == 0 && timeout > 0)
{
return (gnetVerify(m_TimeInactive != 0) && GetCurrentTime() - m_TimeInactive > (timeout+1000));
}
return false;
}
void CGameScriptHandlerMgr::CRemoteScriptInfo::AddActiveParticipant( PhysicalPlayerIndex player )
{
gnetAssert(player < MAX_NUM_PHYSICAL_PLAYERS);
m_ActiveParticipants |= (1<<player);
m_TimeInactive = 0;
}
void CGameScriptHandlerMgr::CRemoteScriptInfo::RemoveParticipant( PhysicalPlayerIndex player )
{
gnetAssert(player < MAX_NUM_PHYSICAL_PLAYERS);
m_ActiveParticipants &= ~(1<<player);
if (m_ActiveParticipants == 0 && m_TimeInactive == 0)
m_TimeInactive = GetCurrentTime();
}
void CGameScriptHandlerMgr::CRemoteScriptInfo::UpdateInfo( const CRemoteScriptInfo& that )
{
gnetAssert(that.GetScriptId() == m_ScriptId);
SetParticipants(that.m_ActiveParticipants);
m_HostToken = that.m_HostToken;
m_Host = that.m_Host;
m_ReservedPeds = that.m_ReservedPeds;
m_ReservedVehicles = that.m_ReservedVehicles;
m_ReservedObjects = that.m_ReservedObjects;
}
void CGameScriptHandlerMgr::CRemoteScriptInfo::Serialise(CSyncDataBase& serialiser)
{
static const unsigned SIZEOF_RESERVATION = 7;
m_ScriptId.Serialise(serialiser);
SERIALISE_UNSIGNED(serialiser, m_ActiveParticipants, sizeof(PlayerFlags)<<3, "Active Participants");
SERIALISE_UNSIGNED(serialiser, m_HostToken, sizeof(HostToken)<<3, "Host Token");
if (m_ActiveParticipants != 0)
{
bool bHasReservedPeds = m_ReservedPeds != 0;
bool bHasReservedVehicles = m_ReservedVehicles != 0;
bool bHasReservedObjects = m_ReservedObjects != 0;
SERIALISE_BOOL(serialiser, bHasReservedPeds);
SERIALISE_BOOL(serialiser, bHasReservedVehicles);
SERIALISE_BOOL(serialiser, bHasReservedObjects);
if (bHasReservedPeds || serialiser.GetIsMaximumSizeSerialiser())
{
u32 reservedPeds = m_ReservedPeds;
SERIALISE_UNSIGNED(serialiser, reservedPeds, SIZEOF_RESERVATION, "Reserved peds");
m_ReservedPeds = (u8) reservedPeds;
}
else
{
m_ReservedPeds = 0;
}
if (bHasReservedVehicles || serialiser.GetIsMaximumSizeSerialiser())
{
u32 reservedVehicles = m_ReservedVehicles;
SERIALISE_UNSIGNED(serialiser, reservedVehicles, SIZEOF_RESERVATION, "Reserved vehicles");
m_ReservedVehicles = (u8) reservedVehicles;
}
else
{
m_ReservedVehicles = 0;
}
if (bHasReservedObjects || serialiser.GetIsMaximumSizeSerialiser())
{
u32 reservedObjects = m_ReservedObjects;
SERIALISE_UNSIGNED(serialiser, reservedObjects, SIZEOF_RESERVATION, "Reserved objects");
m_ReservedObjects = (u8) reservedObjects;
}
else
{
m_ReservedObjects = 0;
}
}
else
{
m_ReservedPeds = 0;
m_ReservedVehicles = 0;
m_ReservedObjects = 0;
}
}
u32 CGameScriptHandlerMgr::CRemoteScriptInfo::GetCurrentTime() const
{
return fwTimer::GetSystemTimeInMilliseconds();
}
scriptIdBase& CGameScriptHandlerMgr::GetScriptId(const scrThread& scriptThread) const
{
static CGameScriptId scrId;
scrId = CGameScriptId(scriptThread);
return scrId;
}
scriptHandler* CGameScriptHandlerMgr::CreateScriptHandler(scrThread& scriptThread)
{
return rage_new CGameScriptHandler(const_cast<scrThread&>(scriptThread));
}
void CGameScriptHandlerMgr::Init()
{
if (scriptVerify(!m_IsInitialised))
{
CGameScriptHandler::InitPool( MEMBUCKET_SYSTEM );
CGameScriptHandlerNetwork::InitPool( MEMBUCKET_SYSTEM );
CGameScriptHandlerNetComponent::InitPool( MEMBUCKET_SYSTEM );
fwScriptGuid::InitPool( MEMBUCKET_SYSTEM );
CScriptEntityExtension::InitPool( MEMBUCKET_SYSTEM );
#if __DEV
CScriptEntityExtension::GetPool()->RegisterPoolCallback(CScriptEntityExtension::PoolFullCallback);
#endif // __DEV
CGameScriptResource::InitPool( MEMBUCKET_SYSTEM );
scriptHandlerMgr::Init();
}
#if __SCRIPT_MEM_CALC
m_ArrayOfModelsUsedByMovieMeshes.Reset();
m_MapOfMoviesUsedByMovieMeshes.Reset();
m_MapOfRenderTargetsUsedByMovieMeshes.Reset();
m_bTrackMemoryForMovieMeshes = false;
m_TotalScriptVirtualMemory = 0;
m_TotalScriptPhysicalMemory = 0;
m_TotalScriptVirtualMemoryPeak = 0;
m_TotalScriptPhysicalMemoryPeak = 0;
#endif // __SCRIPT_MEM_CALC
scriptHandlerNetComponent::ms_useNoHostFix = Tunables::GetInstance().TryAccess(CD_GLOBAL_HASH, ATSTRINGHASH("USE_NO_HOST_FIX", 0x318526f9), scriptHandlerNetComponent::ms_useNoHostFix);
}
void CGameScriptHandlerMgr::NetworkInit()
{
if (gnetVerify(!m_IsNetworkInitialised))
{
m_remoteActiveScripts.Reset();
m_remoteTerminatedScripts.Reset();
scriptHandlerMgr::NetworkInit();
}
#if __SCRIPT_MEM_CALC
m_TotalScriptVirtualMemoryPeak = 0;
m_TotalScriptPhysicalMemoryPeak = 0;
#endif // __SCRIPT_MEM_CALC
}
void CGameScriptHandlerMgr::NetworkShutdown()
{
scriptHandlerMgr::NetworkShutdown();
#if __SCRIPT_MEM_CALC
m_TotalScriptVirtualMemoryPeak = 0;
m_TotalScriptPhysicalMemoryPeak = 0;
#endif // __SCRIPT_MEM_CALC
}
void CGameScriptHandlerMgr::Shutdown()
{
if (m_IsInitialised)
{
scriptHandlerMgr::Shutdown();
CGameScriptResource::ShutdownPool();
fwScriptGuid::ShutdownPool();
CScriptEntityExtension::ShutdownPool();
CGameScriptHandlerNetComponent::ShutdownPool();
CGameScriptHandlerNetwork::ShutdownPool();
CGameScriptHandler::ShutdownPool();
}
}
void CGameScriptHandlerMgr::Update()
{
scriptHandlerMgr::Update();
}
void CGameScriptHandlerMgr::NetworkUpdate()
{
scriptHandlerMgr::NetworkUpdate();
u32 i=0;
while (i < m_remoteActiveScripts.GetCount())
{
if (m_remoteActiveScripts[i].IsTerminated())
{
MoveActiveScriptToTerminatedQueue(i);
}
else
{
i++;
}
}
}
void CGameScriptHandlerMgr::PlayerHasLeft(const netPlayer& player)
{
scriptHandlerMgr::PlayerHasLeft(player);
// remove the player from the participant flags in all active scripts
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
CRemoteScriptInfo* pInfo = &m_remoteActiveScripts[i];
if (pInfo->IsPlayerAParticipant(player.GetPhysicalPlayerIndex()))
{
pInfo->RemoveParticipant(player.GetPhysicalPlayerIndex());
}
if (pInfo->GetHost() == &player)
{
pInfo->SetHost(NULL);
}
}
}
#if __BANK
void Bank_ForceResend()
{
CGameScriptHandlerMgr* pMgr = &CTheScripts::GetScriptHandlerMgr();
const CGameScriptHandler* handler = pMgr->GetScriptHandlerFromComboName(pMgr->ms_Handlers[pMgr->ms_HandlerComboIndex]);
if (handler && handler->GetNetworkComponent())
{
handler->GetNetworkComponent()->ForceResendOfAllBroadcastData();
}
}
void Bank_HostRequest()
{
CGameScriptHandlerMgr* pMgr = &CTheScripts::GetScriptHandlerMgr();
const CGameScriptHandler* handler = pMgr->GetScriptHandlerFromComboName(pMgr->ms_Handlers[pMgr->ms_HandlerComboIndex]);
if (handler && handler->GetNetworkComponent())
{
handler->GetNetworkComponent()->RequestToBeHost();
}
}
void CGameScriptHandlerMgr::InitWidgets(bkBank* pBank)
{
if (scriptVerify(pBank))
{
ms_Handlers[0] = "-- none --";
ms_NumHandlers = 1;
pBank->PushGroup("Script Handlers",false);
ms_pHandlerCombo = pBank->AddCombo("Active Handlers", &ms_HandlerComboIndex, ms_NumHandlers, (const char **)ms_Handlers);
pBank->AddToggle("Display handler info", &ms_DisplayHandlerInfo);
pBank->AddButton("Resend all broadcast data", Bank_ForceResend);
pBank->AddButton("Request to be host", Bank_HostRequest);
pBank->AddToggle("Display all MP handlers", &ms_DisplayAllMPHandlers);
pBank->PopGroup();
}
}
// CGameScriptHandlerMgr::ShutdownWidgets
// Since ms_pHandlerCombo is created within the script bank, make sure that we remove the combo and set ms_pHandlerCombo to NULL
// before the script bank is deleted so that ms_pHandlerCombo doesn't have an invalid address
void CGameScriptHandlerMgr::ShutdownWidgets(bkBank* pBank)
{
if (scriptVerify(pBank))
{
pBank->Remove(*ms_pHandlerCombo);
ms_pHandlerCombo = NULL;
ms_HandlerComboIndex = 0;
ms_DisplayHandlerInfo = false;
ms_DisplayAllMPHandlers = false;
}
}
#endif // __BANK
void CGameScriptHandlerMgr::RegisterScript(scrThread& scriptThread)
{
scriptHandlerMgr::RegisterScript(scriptThread);
#if __BANK
UpdateScriptHandlerCombo();
#endif
}
void CGameScriptHandlerMgr::UnregisterScript(scrThread& scriptThread)
{
GtaThread& gtaThread = static_cast<GtaThread&>(scriptThread);
CGameScriptHandler* handler = gtaThread.m_Handler;
if (AssertVerify(handler) && handler->Terminate())
{
DeleteHandlerWithHash(handler->GetScriptId().GetScriptIdHash());
}
gtaThread.m_Handler = NULL;
#if __BANK
UpdateScriptHandlerCombo();
#endif
}
bool CGameScriptHandlerMgr::IsScriptValidForNetworking(atHashValue scriptName)
{
#if !__FINAL
if (PARAM_dontCrashOnScriptValidation.Get())
{
return true;
}
#endif // !__FINAL
for (u32 scriptHash = 0; scriptHash < NUM_VALID_NETWORK_SCRIPTS; scriptHash++)
{
if (ms_validNetworkScriptHashes[scriptHash] == scriptName)
{
return true;
}
}
return false;
}
void CGameScriptHandlerMgr::SetScriptAsANetworkScript(GtaThread& scriptThread, int instanceId)
{
CGameScriptId& scriptId = static_cast<CGameScriptId&>(GetScriptId(scriptThread));
atHashValue hash = scriptId.GetScriptIdHash();
netLoggingInterface *log = CTheScripts::GetScriptHandlerMgr().GetLog();
if (log)
{
CGameScriptId logId = scriptId;
logId.SetInstanceId(instanceId);
NetworkLogUtils::WriteLogEvent(*log, "SET_SCRIPT_AS_NETWORK_SCRIPT", "%s", logId.GetScriptName());
}
// find network handler for this thread, destroy it and replace with a network handler
scriptHandler** ppHandler = m_scriptHandlers.Access(hash);
if (ppHandler)
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(*ppHandler);
scriptAssertf(handler->GetNumRegisteredNetworkedObjects() == 0, "CGameScriptHandlerMgr::SetScriptAsANetworkScript : Script %s has registered networked objects", handler->GetScriptName());
if (scriptVerifyf(!handler->RequiresANetworkComponent(), "CGameScriptHandlerMgr::SetScriptAsANetworkScript : Script %s has already been set as a network script", handler->GetScriptName()))
{
if (!IsScriptValidForNetworking(scriptId.GetScriptNameHash()))
{
#if !__FINAL
NETWORK_QUITF(0, "CGameScriptHandlerMgr::SetScriptAsANetworkScript : Cannot network script %s - it has no entry in the valid network scripts allowlist", handler->GetScriptName());
#endif
return;
}
if (CGameScriptHandlerNetwork::GetPool()->GetNoOfFreeSpaces() == 0)
{
Displayf("** TOO MANY NETWORKED SCRIPTS RUNNING!! **\n");
Displayf("Active networked scripts:\n");
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
scriptHandler* handler = entry.GetData();
if (handler && handler->GetNetworkComponent())
{
Displayf("%s\n", handler->GetLogName());
}
}
CNetwork::FlushAllLogFiles(true);
NETWORK_QUITF(0, "CGameScriptHandlerMgr::SetScriptAsANetworkScript : Cannot network this script - too many networked scripts running (max %d)", MAX_NUM_ACTIVE_NETWORK_SCRIPTS);
return;
}
scriptHandlerObject* aUnnetworkedObjects[CGameScriptHandler::MAX_UNNETWORKED_OBJECTS];
u32 numUnnetworkedObjects = 0;
handler->DetachAllUnnetworkedObjects(aUnnetworkedObjects, numUnnetworkedObjects);
DeleteHandlerWithHash(hash);
scriptThread.bSafeForNetworkGame = true;
scriptThread.InstanceId = instanceId;
if (instanceId != -1)
{
#if __ASSERT
scriptHandler* pHandler = GetScriptHandler(GetScriptId(scriptThread));
// we can't have 2 network script handlers with the same id
NETWORK_QUITF(!pHandler, "SetScriptAsANetworkScript - a network script already exists with this instance id (%s)", pHandler->GetLogName());
#endif
}
CGameScriptHandlerNetwork* netHandler = rage_new CGameScriptHandlerNetwork(scriptThread);
#if !__NO_OUTPUT
scriptHandler** ppHandler = m_scriptHandlers.Access(netHandler->GetScriptId().GetScriptIdHash());
if (ppHandler)
{
char logNameOfNewHandler[200];
safecpy(logNameOfNewHandler, netHandler->GetLogName(), NELEM(logNameOfNewHandler)); // CGameScriptId::GetLogName() fills in a static string internally so I need to make a copy of one of the LogName's to display in the assert below
#if __ASSERT
CGameScriptHandler *pGameScriptHandler = static_cast<CGameScriptHandler*>(*ppHandler);
Assertf(false, "CGameScriptHandlerMgr::SetScriptAsANetworkScript - about to add %s(%p) script with hash %u. %s(%p) already exists in the map with this hash",
logNameOfNewHandler, netHandler, netHandler->GetScriptId().GetScriptIdHash().GetHash(),
pGameScriptHandler->GetLogName(), pGameScriptHandler);
#endif
}
#endif // !__NO_OUTPUT
m_scriptHandlers.Insert(netHandler->GetScriptId().GetScriptIdHash(), netHandler);
if (m_IsNetworkInitialised)
{
netHandler->CreateNetworkComponent();
}
#if __BANK
UpdateScriptHandlerCombo();
#endif
for (u32 i=0; i<numUnnetworkedObjects; i++)
{
if (instanceId != -1)
{
static_cast<CGameScriptId&>(aUnnetworkedObjects[i]->GetScriptInfo()->GetScriptId()).SetInstanceId(instanceId);
}
netHandler->RegisterExistingScriptObject(*aUnnetworkedObjects[i]);
}
}
}
else
{
scriptAssertf(0, "CGameScriptHandlerMgr::SetScriptAsANetworkScript : The script handler for %s was not found", scriptId.GetLogName());
}
}
bool CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript(GtaThread& scriptThread, int instanceId)
{
CGameScriptId& singlePlayerScriptId = static_cast<CGameScriptId&>(GetScriptId(scriptThread));
atHashValue singlePlayerHash = singlePlayerScriptId.GetScriptIdHash();
// find existing handler for this thread and attempt to replace it with a network handler
scriptHandler** ppHandler = m_scriptHandlers.Access(singlePlayerHash);
if (ppHandler)
{
CGameScriptHandler* pSinglePlayerHandler = static_cast<CGameScriptHandler*>(*ppHandler);
scriptAssertf(pSinglePlayerHandler->GetNumRegisteredObjects() == 0, "CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript : Script %s has registered objects", pSinglePlayerHandler->GetScriptName());
if (scriptVerifyf(!pSinglePlayerHandler->RequiresANetworkComponent(), "CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript : Script %s has already been set as a network script", pSinglePlayerHandler->GetScriptName()))
{
if (CGameScriptHandlerNetwork::GetPool()->GetNoOfFreeSpaces() == 0)
{
Displayf("** TOO MANY NETWORKED SCRIPTS RUNNING!! **\n");
Displayf("Active networked scripts:\n");
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
scriptHandler* handler = entry.GetData();
if (handler && handler->GetNetworkComponent())
{
Displayf("%s\n", handler->GetLogName());
}
}
CNetwork::FlushAllLogFiles(true);
FatalAssertf(0, "CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript : Cannot network this script - too many networked scripts running (max %d)", MAX_NUM_ACTIVE_NETWORK_SCRIPTS);
return false;
}
if (!m_scriptHandlers.Delete(singlePlayerHash))
{
FatalAssertf(0, "CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript : failed to delete handler %s at key %u (%p)\n", pSinglePlayerHandler->GetLogName(), singlePlayerHash.GetHash(), pSinglePlayerHandler);
return false;
}
bool bFailedToCreateNetworkHandler = false;
CGameScriptHandlerNetwork* pNetHandler = NULL;
bool singlePlayerSafeForNetworkGame = scriptThread.bSafeForNetworkGame;
int singlePlayerInstanceId = scriptThread.InstanceId;
scriptThread.bSafeForNetworkGame = true;
if (instanceId != -1)
{
scriptThread.InstanceId = instanceId;
scriptHandler* pHandler = GetScriptHandler(GetScriptId(scriptThread));
// we can't have 2 network script handlers with the same id
if (pHandler)
{
Displayf("CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript - a network script already exists with this instance id (%s)", pHandler->GetLogName());
bFailedToCreateNetworkHandler = true;
}
}
if (!bFailedToCreateNetworkHandler)
{
pNetHandler = rage_new CGameScriptHandlerNetwork(scriptThread);
scriptHandler** ppHandler = m_scriptHandlers.Access(pNetHandler->GetScriptId().GetScriptIdHash());
if (ppHandler)
{
#if !__NO_OUTPUT
char logNameOfNewHandler[200];
safecpy(logNameOfNewHandler, pNetHandler->GetLogName(), NELEM(logNameOfNewHandler)); // CGameScriptId::GetLogName() fills in a static string internally so I need to make a copy of one of the LogName's to display in the assert below
CGameScriptHandler *pGameScriptHandler = static_cast<CGameScriptHandler*>(*ppHandler);
Displayf("CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript - about to add %s(%p) script with hash %u. %s(%p) already exists in the map with this hash",
logNameOfNewHandler, pNetHandler, pNetHandler->GetScriptId().GetScriptIdHash().GetHash(),
pGameScriptHandler->GetLogName(), pGameScriptHandler);
#endif // !__NO_OUTPUT
bFailedToCreateNetworkHandler = true;
}
}
if (bFailedToCreateNetworkHandler)
{
if (pNetHandler)
{ // I don't need to Delete pNetHandler from m_scriptHandlers because it hasn't been Inserted at this stage
m_DeletingHandlers = true;
pNetHandler->Shutdown();
delete pNetHandler;
pNetHandler = NULL;
m_DeletingHandlers = false;
}
// deleting pNetHandler will have cleared scriptThread.m_Handler (in ~CGameScriptHandler()) so make sure it points to pSinglePlayerHandler
scriptThread.m_Handler = pSinglePlayerHandler;
// Put the original single player handler back to the way it was
scriptThread.bSafeForNetworkGame = singlePlayerSafeForNetworkGame;
scriptThread.InstanceId = singlePlayerInstanceId;
m_scriptHandlers.Insert(singlePlayerHash, pSinglePlayerHandler);
}
else
{
if (pSinglePlayerHandler)
{ // We've already Deleted pSinglePlayerHandler from m_scriptHandlers so now we just need to delete pSinglePlayerHandler itself
m_DeletingHandlers = true;
pSinglePlayerHandler->Shutdown();
delete pSinglePlayerHandler;
pSinglePlayerHandler = NULL;
m_DeletingHandlers = false;
}
// deleting pSinglePlayerHandler will have cleared scriptThread.m_Handler (in ~CGameScriptHandler()) so make sure it points to pNetHandler
scriptThread.m_Handler = pNetHandler;
m_scriptHandlers.Insert(pNetHandler->GetScriptId().GetScriptIdHash(), pNetHandler);
if (m_IsNetworkInitialised)
{
pNetHandler->CreateNetworkComponent();
}
}
#if __BANK
UpdateScriptHandlerCombo();
#endif
return !bFailedToCreateNetworkHandler;
}
}
else
{
scriptAssertf(0, "CGameScriptHandlerMgr::TryToSetScriptAsANetworkScript : The script handler for %s was not found", singlePlayerScriptId.GetLogName());
}
return false;
}
void CGameScriptHandlerMgr::SetScriptAsSafeToRunInMP(GtaThread& scriptThread)
{
CGameScriptId& scriptId = static_cast<CGameScriptId&>(GetScriptId(scriptThread));
atHashValue hash = scriptId.GetScriptIdHash();
// find network handler for this thread and change its script id
scriptHandler** ppHandler = m_scriptHandlers.Access(hash);
if (ppHandler)
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(*ppHandler);
if (!m_scriptHandlers.Delete(hash))
{
FatalAssertf(0, "CGameScriptHandlerMgr::SetScriptAsSafeToRunInMP - failed to remove handler %s from map", handler->GetLogName());
}
scriptThread.bSafeForNetworkGame = true;
// recalculate the script id as the hash will now be altered
static_cast<CGameScriptId&>(handler->GetScriptId()).InitGameScriptId(scriptThread);
#if !__NO_OUTPUT
scriptHandler** ppHandler = m_scriptHandlers.Access(handler->GetScriptId().GetScriptIdHash());
if (ppHandler)
{
char logNameOfNewHandler[200];
safecpy(logNameOfNewHandler, handler->GetLogName(), NELEM(logNameOfNewHandler)); // CGameScriptId::GetLogName() fills in a static string internally so I need to make a copy of one of the LogName's to display in the assert below
CGameScriptHandler *pGameScriptHandler = static_cast<CGameScriptHandler*>(*ppHandler);
Quitf("CGameScriptHandlerMgr::SetScriptAsSafeToRunInMP - about to add %s(%p) script with hash %u. %s(%p) already exists in the map with this hash",
logNameOfNewHandler, handler, handler->GetScriptId().GetScriptIdHash().GetHash(),
pGameScriptHandler->GetLogName(), pGameScriptHandler);
}
#endif // !__NO_OUTPUT
m_scriptHandlers.Insert(handler->GetScriptId().GetScriptIdHash(), handler);
}
else
{
scriptAssertf(0, "CGameScriptHandlerMgr::SetScriptAsSafeToRunInMP : The script handler for %s was not found", scriptId.GetLogName());
}
}
u32 CGameScriptHandlerMgr::GetAllScriptHandlerEntities(CEntity* entityArray[], u32 arrayLen)
{
u32 numEntities = 0;
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler)
{
numEntities += handler->GetAllEntities(&entityArray[numEntities], arrayLen-numEntities);
}
}
return numEntities;
}
void CGameScriptHandlerMgr::GetNumReservedScriptEntities(u32 &numPeds, u32 &numVehicles, u32 &numObjects) const
{
numPeds = numVehicles = numObjects = 0;
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->RequiresANetworkComponent())
{
const CGameScriptHandlerNetwork* netHandler = static_cast<const CGameScriptHandlerNetwork*>(handler);
numPeds += netHandler->GetTotalNumReservedPeds();
numVehicles += netHandler->GetTotalNumReservedVehicles();
numObjects += netHandler->GetTotalNumReservedObjects();
}
}
}
void CGameScriptHandlerMgr::GetNumCreatedScriptEntities(u32 &numPeds, u32 &numVehicles, u32 &numObjects) const
{
numPeds = numVehicles = numObjects = 0;
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->RequiresANetworkComponent())
{
const CGameScriptHandlerNetwork* netHandler = static_cast<const CGameScriptHandlerNetwork*>(handler);
numPeds += netHandler->GetNumCreatedPeds();
numVehicles += netHandler->GetNumCreatedVehicles();
numObjects += netHandler->GetNumCreatedObjects();
}
}
}
void CGameScriptHandlerMgr::GetNumRequiredScriptEntities(u32 &numPeds, u32 &numVehicles, u32 &numObjects, CGameScriptHandler* pHandlerToIgnore) const
{
numPeds = numVehicles = numObjects = 0;
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler != pHandlerToIgnore && handler->GetNetworkComponent() && handler->GetNetworkComponent()->IsPlaying())
{
const CGameScriptHandlerNetwork* netHandler = static_cast<const CGameScriptHandlerNetwork*>(handler);
u32 peds = 0;
u32 vehs = 0;
u32 objs = 0;
netHandler->GetNumRequiredEntities(peds, vehs, objs);
numPeds += peds;
numVehicles += vehs;
numObjects += objs;
}
}
u32 remoteReservedPeds = 0;
u32 remoteReservedVehs = 0;
u32 remoteReservedObjs = 0;
u32 remoteCreatedPeds = 0;
u32 remoteCreatedVehs = 0;
u32 remoteCreatedObjs = 0;
GetRemoteScriptEntityReservations(remoteReservedPeds, remoteReservedVehs, remoteReservedObjs, remoteCreatedPeds, remoteCreatedVehs, remoteCreatedObjs);
if (remoteReservedPeds > remoteCreatedPeds)
{
numPeds += remoteReservedPeds-remoteCreatedPeds;
}
if (remoteReservedVehs > remoteCreatedVehs)
{
numVehicles += remoteReservedVehs-remoteCreatedVehs;
}
if (remoteReservedObjs > remoteCreatedObjs)
{
numObjects += remoteReservedObjs-remoteCreatedObjs;
}
}
//PURPOSE
// Adds info on a new script running remotely but not locally
void CGameScriptHandlerMgr::AddRemoteScriptInfo(CRemoteScriptInfo& scriptInfo, const netPlayer* sendingPlayer)
{
CGameScriptHandler* pHandler = SafeCast(CGameScriptHandler, GetScriptHandler(scriptInfo.GetScriptId()));
if (gnetVerifyf(scriptInfo.GetScriptId().GetTimeStamp() != 0, "CGameScriptHandlerMgr::AddRemoteScriptInfo: can't add a remote script info with a timestamp of 0"))
{
if (sendingPlayer)
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Got a remote script info update from %s. Participants: %u, Host token: %u. Reservations: peds(%d), vehicles(%d), objects(%d)", sendingPlayer->GetLogName(), scriptInfo.GetActiveParticipants(), scriptInfo.GetHostToken(), scriptInfo.GetReservedPeds(), scriptInfo.GetReservedVehicles(), scriptInfo.GetReservedObjects());
// the sending player is the current host
scriptInfo.SetHost(sendingPlayer);
if (pHandler && !pHandler->IsTerminated())
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Ignore: script is running locally");
return;
}
}
else
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Locally update remote script info. Participants: %u, Host token: %u. Reservations: peds(%d), vehicles(%d), objects(%d)", scriptInfo.GetActiveParticipants(), scriptInfo.GetHostToken(), scriptInfo.GetReservedPeds(), scriptInfo.GetReservedVehicles(), scriptInfo.GetReservedObjects());
}
if (scriptInfo.GetActiveParticipants() == 0)
{
// this script has terminated, so remove from active queue and add to terminated queue
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptInfo.m_ScriptId)
{
// if the host token is less than the one we currently have, then this info is from a previous host and is ignored.
if (scriptInfo.m_HostToken < m_remoteActiveScripts[i].m_HostToken)
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Host token out of date (most recent: %u). Ignore.", m_remoteActiveScripts[i].m_HostToken);
}
else
{
MoveActiveScriptToTerminatedQueue(i);
}
break;
}
}
}
else
{
bool bAddActiveScript = true;
// make sure all players still exist (they may have left before we received this update)
for (PhysicalPlayerIndex i=0; i<MAX_NUM_PHYSICAL_PLAYERS; i++)
{
if (scriptInfo.IsPlayerAParticipant(i) && !NetworkInterface::GetPhysicalPlayerFromIndex(i))
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Removed a non-existent player %d from the remote script info update.", i);
scriptInfo.RemoveParticipant(i);
if (scriptInfo.GetActiveParticipants() == 0)
return;
}
}
// check to see if this script is on the terminated queue. This can happen when we are the host and terminate the script, and another player temporarily
// becomes the host and sends another remote script info update back to us before shutting down the script not long after. Once a script is on the terminated
// queue it must stay there.
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptInfo.m_ScriptId)
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Remote script info is already on terminated queue. Ignore update.");
return;
}
}
// see if we already have an info for this script in the active queue
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptInfo.m_ScriptId)
{
// if the host token is less than the one we currently have, then this info is from a previous host and is ignored.
if (scriptInfo.m_HostToken < m_remoteActiveScripts[i].m_HostToken)
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Host token out of date (most recent: %u). Ignore.", m_remoteActiveScripts[i].m_HostToken);
}
else
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Update existing remote script info");
// update the existing entry with the latest info
m_remoteActiveScripts[i].UpdateInfo(scriptInfo);
}
bAddActiveScript = false;
break;
}
}
if (bAddActiveScript && sendingPlayer)
{
// possibly handle the case where we have 2 identical scripts running with different timestamps
bAddActiveScript = HandleTimestampConflict(scriptInfo);
}
if (bAddActiveScript)
{
// we don't want to fill up the queue for the active list.
gnetAssertf(m_remoteActiveScripts.GetAvailable() > 0, "Ran out of active remote script infos");
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Add new active remote script info");
// add a new info to the active queue
if (!m_remoteActiveScripts.Push(scriptInfo))
{
Assertf(0, "The remote active script queue is full");
}
}
}
}
}
void CGameScriptHandlerMgr::AddPlayerToRemoteScript(const CGameScriptId& scriptId, const netPlayer& player)
{
if (gnetVerifyf(scriptId.GetTimeStamp() != 0, "CGameScriptHandlerMgr::AddPlayerToRemoteScript: scriptId has a timestamp of 0"))
{
WriteRemoteScriptHeader(scriptId, "Add remote player %s (%d) to remote script", player.GetLogName(), player.GetPhysicalPlayerIndex());
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
m_remoteActiveScripts[i].AddActiveParticipant(player.GetPhysicalPlayerIndex());
WriteRemoteScriptHeader(scriptId, "Participants now = %d", m_remoteActiveScripts[i].GetActiveParticipants());
return;
}
}
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptId)
{
gnetAssertf(0, "Trying to add a participant to a terminated remote script");
return;
}
}
WriteRemoteScriptHeader(scriptId, "Active remote script not found. Ignore");
}
}
void CGameScriptHandlerMgr::RemovePlayerFromRemoteScript(const CGameScriptId& scriptId, const netPlayer& player, bool bCalledFromHandler)
{
if (gnetVerifyf(scriptId.GetTimeStamp() != 0, "CGameScriptHandlerMgr::RemovePlayerFromRemoteScript: scriptId %s has a timestamp of 0", scriptId.GetLogName()))
{
WriteRemoteScriptHeader(scriptId, "Remove remote player %s (%d) from remote script", player.GetLogName(), player.GetPhysicalPlayerIndex());
if (!bCalledFromHandler)
{
scriptHandler* pHandler = GetScriptHandler(scriptId);
if (pHandler && !pHandler->IsTerminated())
{
WriteRemoteScriptHeader(scriptId, "Ignore: script is running locally");
return;
}
}
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
m_remoteActiveScripts[i].RemoveParticipant(player.GetPhysicalPlayerIndex());
WriteRemoteScriptHeader(scriptId, "Participants now = %d", m_remoteActiveScripts[i].GetActiveParticipants());
if (m_remoteActiveScripts[i].GetActiveParticipants() == 0)
{
MoveActiveScriptToTerminatedQueue(i);
}
return;
}
}
#if ENABLE_NETWORK_LOGGING
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptId)
{
WriteRemoteScriptHeader(scriptId, "Remote script has already been terminated. Ignore.");
return;
}
}
WriteRemoteScriptHeader(scriptId, "No remote script found. Ignore");
#endif
}
}
void CGameScriptHandlerMgr::TerminateActiveScriptInfo(const CGameScriptId& scriptId)
{
CGameScriptId idNoTimestamp = scriptId;
// reset the timestamp so that comparisons will find matching scripts
idNoTimestamp.ResetTimestamp();
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].GetScriptId() == idNoTimestamp &&
m_remoteActiveScripts[i].m_ScriptId.GetTimeStamp() != scriptId.GetTimeStamp())
{
WriteRemoteScriptHeader(m_remoteActiveScripts[i].GetScriptId(), "Terminate existing active id");
MoveActiveScriptToTerminatedQueue(i);
break;
}
}
}
void CGameScriptHandlerMgr::SetNewHostOfRemoteScript(const CGameScriptId& scriptId, const netPlayer& newHost, HostToken newHostToken, PlayerFlags participantFlags)
{
if (gnetVerifyf(scriptId.GetTimeStamp() != 0, "CGameScriptHandlerMgr::SetNewHostOfRemoteScript: scriptId has a timestamp of 0"))
{
WriteRemoteScriptHeader(scriptId, "Setting new host %s (%d) of remote script. Host token: %u", newHost.GetLogName(), newHost.GetPhysicalPlayerIndex(), newHostToken);
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
m_remoteActiveScripts[i].SetHostToken(newHostToken);
m_remoteActiveScripts[i].SetParticipants(participantFlags);
return;
}
}
WriteRemoteScriptHeader(scriptId, "Active remote script not found. Ignore");
}
}
//PURPOSE
// Returns the closest participant of the given remote script
CNetGamePlayer* CGameScriptHandlerMgr::GetClosestParticipantOfRemoteScript(const CRemoteScriptInfo& remoteScriptInfo)
{
CNetGamePlayer* pClosestPlayer = NULL;
float closestDist = 0.0f;
Vector3 localPlayerPos = VEC3V_TO_VECTOR3(CGameWorld::FindLocalPlayer()->GetTransform().GetPosition());
PlayerFlags participantFlags = remoteScriptInfo.GetActiveParticipants();
for (u32 i=0; i<MAX_NUM_PHYSICAL_PLAYERS; i++)
{
if (participantFlags & (1<<i))
{
CNetGamePlayer* pPlayer = static_cast<CNetGamePlayer*>(NetworkInterface::GetPlayerMgr().GetPhysicalPlayerFromIndex((PhysicalPlayerIndex)i));
if (pPlayer->GetPlayerPed() && !pPlayer->IsMyPlayer())
{
Vector3 playerPos = VEC3V_TO_VECTOR3(pPlayer->GetPlayerPed()->GetTransform().GetPosition());
Vector3 diff = playerPos - localPlayerPos;
float playerDist = diff.XYMag2();
if (!pClosestPlayer || playerDist < closestDist)
{
pClosestPlayer = pPlayer;
closestDist = playerDist;
}
}
}
}
return pClosestPlayer;
}
//PURPOSE
// Gets info on a new script running remotely but not locally
CGameScriptHandlerMgr::CRemoteScriptInfo* CGameScriptHandlerMgr::GetRemoteScriptInfo(const CGameScriptId& scriptId, bool bActiveOnly)
{
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
if (!bActiveOnly || m_remoteActiveScripts[i].GetActiveParticipants() > 0)
return &m_remoteActiveScripts[i];
else
return NULL;
}
}
if (!bActiveOnly)
{
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptId)
{
return &m_remoteTerminatedScripts[i];
}
}
}
return NULL;
}
const CGameScriptHandlerMgr::CRemoteScriptInfo* CGameScriptHandlerMgr::GetRemoteScriptInfo(const CGameScriptId& scriptId, bool bActiveOnly) const
{
return const_cast<CGameScriptHandlerMgr*>(this)->GetRemoteScriptInfo(scriptId, bActiveOnly);
}
// returns true if the given script is running, either locally or remotely
bool CGameScriptHandlerMgr::IsScriptActive(const CGameScriptId& scriptId, bool bMatchOnNameOnly)
{
bool bScriptActive = false;
if (GetScriptHandler(scriptId))
{
bScriptActive = true;
}
else
{
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].GetActiveParticipants() > 0)
{
if (bMatchOnNameOnly)
{
// only match using the script name
if (m_remoteActiveScripts[i].m_ScriptId.EqualivalentScriptName(scriptId))
{
bScriptActive = true;
break;
}
}
else if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
bScriptActive = true;
break;
}
}
}
}
return bScriptActive;
}
// returns true if the given script has been terminated
bool CGameScriptHandlerMgr::IsScriptTerminated(const CGameScriptId& scriptId)
{
if (GetScriptHandler(scriptId) && !GetScriptHandler(scriptId)->IsTerminated())
{
return false;
}
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptId)
{
return true;
}
}
return false;
}
// returns true if the given player is a participant in the given script, either local or remote
bool CGameScriptHandlerMgr::IsPlayerAParticipant(const CGameScriptId& scriptId, const netPlayer& player)
{
scriptHandler* pHandler = GetScriptHandler(scriptId);
if (pHandler && pHandler->GetNetworkComponent() && pHandler->GetNetworkComponent()->IsPlayerAParticipant(player))
{
return true;
}
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId && m_remoteActiveScripts[i].IsPlayerAParticipant(player.GetPhysicalPlayerIndex()))
{
return true;
}
}
return false;
}
bool CGameScriptHandlerMgr::IsNetworkHost(const CGameScriptId& scriptId)
{
bool isHost = false;
scriptHandler *handler = GetScriptHandler(scriptId);
scriptHandlerNetComponent* netComponent = handler ? handler->GetNetworkComponent() : NULL;
if (netComponent && netComponent->GetState() == scriptHandlerNetComponent::NETSCRIPT_PLAYING)
{
const netPlayer* pHost = netComponent->GetHost();
if (pHost && pHost->IsMyPlayer())
{
isHost = true;
}
}
return isHost;
}
u32 CGameScriptHandlerMgr::GetNumParticipantsOfScript(const CGameScriptId& scriptId)
{
u32 numParticipants = 0;
scriptHandler* pHandler = GetScriptHandler(scriptId);
if (pHandler && pHandler->GetNetworkComponent())
{
numParticipants = pHandler->GetNetworkComponent()->GetNumParticipants();
}
else
{
u32 i = 0;
for (i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == scriptId)
{
numParticipants = m_remoteActiveScripts[i].GetNumParticipants();
break;
}
}
Assertf(i<m_remoteActiveScripts.GetCount(), "GetNumParticipantsOfScript: Remote script not running");
}
return numParticipants;
}
void CGameScriptHandlerMgr::RecalculateScriptId(CGameScriptHandler& handler)
{
if (!m_scriptHandlers.Delete(handler.GetScriptId().GetScriptIdHash()))
{
FatalAssertf(0, "CGameScriptHandlerMgr::RecalculateScriptId - failed to remove handler %s from map", handler.GetLogName());
}
#if __ASSERT
if (NetworkInterface::IsGameInProgress())
{
CGameScriptId scriptId(*handler.GetThread());
Assert(!GetScriptHandler(scriptId));
}
#endif
static_cast<CGameScriptId&>(handler.GetScriptId()).InitGameScriptId(*handler.GetThread());
#if !__NO_OUTPUT
scriptHandler** ppHandler = m_scriptHandlers.Access(handler.GetScriptId().GetScriptIdHash());
if (ppHandler)
{
char logNameOfNewHandler[200];
safecpy(logNameOfNewHandler, handler.GetLogName(), NELEM(logNameOfNewHandler)); // CGameScriptId::GetLogName() fills in a static string internally so I need to make a copy of one of the LogName's to display in the assert below
CGameScriptHandler *pGameScriptHandler = static_cast<CGameScriptHandler*>(*ppHandler);
Quitf("CGameScriptHandlerMgr::RecalculateScriptId - about to add %s(%p) script with hash %u. %s(%p) already exists in the map with this hash",
logNameOfNewHandler, &handler, handler.GetScriptId().GetScriptIdHash().GetHash(),
pGameScriptHandler->GetLogName(), pGameScriptHandler);
}
#endif // !__NO_OUTPUT
m_scriptHandlers.Insert(handler.GetScriptId().GetScriptIdHash(), &handler);
}
void CGameScriptHandlerMgr::SetNotInMPCutscene()
{
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->RequiresANetworkComponent())
{
CGameScriptHandlerNetwork* netHandler = static_cast<CGameScriptHandlerNetwork*>(handler);
netHandler->SetInMPCutscene(false);
}
}
}
void CGameScriptHandlerMgr::AddToReservationCount(CNetObjGame& scriptEntityObj)
{
if (!scriptEntityObj.IsLocalFlagSet(CNetObjGame::LOCALFLAG_COUNTED_BY_RESERVATIONS))
{
CEntity* pEntity = scriptEntityObj.GetEntity();
if (pEntity)
{
bool bPed = pEntity->GetIsTypePed();
bool bVeh = pEntity->GetIsTypeVehicle();
bool bObj = pEntity->GetIsTypeObject() && scriptEntityObj.GetObjectType() == NET_OBJ_TYPE_OBJECT; // ignore doors and pickups
if (bPed || bVeh || bObj)
{
CScriptEntityExtension* pExtension = pEntity->GetExtension<CScriptEntityExtension>();
const CGameScriptId* pScriptId = NULL;
if (pExtension)
{
pScriptId = static_cast<const CGameScriptId*>(&pExtension->GetScriptInfo()->GetScriptId());
}
if (pScriptId)
{
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == *pScriptId)
{
if (bPed)
{
m_remoteActiveScripts[i].AddCreatedPed();
}
else if (bVeh)
{
m_remoteActiveScripts[i].AddCreatedVehicle();
}
else if (bObj)
{
m_remoteActiveScripts[i].AddCreatedObject();
}
scriptEntityObj.SetLocalFlag(CNetObjGame::LOCALFLAG_COUNTED_BY_RESERVATIONS, true);
netLoggingInterface* log = CTheScripts::GetScriptHandlerMgr().GetLog();
if (log)
{
NetworkLogUtils::WriteLogEvent(*log, "RESERVATION_ENTITY_ADDED", "%s %s", pScriptId->GetLogName(), scriptEntityObj.GetLogName());
LogCurrentReservations(*log);
}
break;
}
}
}
}
}
}
}
void CGameScriptHandlerMgr::RemoveFromReservationCount(CNetObjGame& scriptEntityObj)
{
if (scriptEntityObj.IsLocalFlagSet(CNetObjGame::LOCALFLAG_COUNTED_BY_RESERVATIONS))
{
CEntity* pEntity = scriptEntityObj.GetEntity();
if (gnetVerifyf(pEntity, "Failed to remove reservation count for %s. Gameobject is missing", scriptEntityObj.GetLogName()))
{
bool bPed = pEntity->GetIsTypePed();
bool bVeh = pEntity->GetIsTypeVehicle();
bool bObj = pEntity->GetIsTypeObject() && scriptEntityObj.GetObjectType() == NET_OBJ_TYPE_OBJECT; // ignore doors and pickups
CScriptEntityExtension* pExtension = pEntity->GetExtension<CScriptEntityExtension>();
const CGameScriptId* pScriptId = NULL;
if (pExtension && pExtension->GetScriptInfo())
{
pScriptId = static_cast<const CGameScriptId*>(&pExtension->GetScriptInfo()->GetScriptId());
}
if (pScriptId)
{
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == *pScriptId)
{
if (bPed)
{
m_remoteActiveScripts[i].RemoveCreatedPed();
}
else if (bVeh)
{
m_remoteActiveScripts[i].RemoveCreatedVehicle();
}
else if (bObj)
{
m_remoteActiveScripts[i].RemoveCreatedObject();
}
scriptEntityObj.SetLocalFlag(CNetObjGame::LOCALFLAG_COUNTED_BY_RESERVATIONS, false);
netLoggingInterface* log = CTheScripts::GetScriptHandlerMgr().GetLog();
if (log)
{
NetworkLogUtils::WriteLogEvent(*log, "RESERVATION_ENTITY_REMOVED", "%s %s", pScriptId->GetLogName(), scriptEntityObj.GetLogName());
LogCurrentReservations(*log);
}
break;
}
}
}
}
}
}
void CGameScriptHandlerMgr::GetRemoteScriptEntityReservations(u32& reservedPeds, u32& reservedVehicles, u32& reservedObjects, u32& createdPeds, u32& createdVehicles, u32& createdObjects, Vector3* pScopePosition) const
{
reservedPeds = 0;
reservedVehicles = 0;
reservedObjects = 0;
createdPeds = 0;
createdVehicles = 0;
createdObjects = 0;
PlayerFlags playersNearby = 0;
PlayerFlags playersNearbyInPedScope = 0;
PlayerFlags playersNearbyInVehScope = 0;
PlayerFlags playersNearbyInObjScope = 0;
bool playersNearbyCalculated = false;
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
const CRemoteScriptInfo* pInfo = &m_remoteActiveScripts[i];
if (!pInfo->GetRunningLocally())
{
u32 peds = 0;
u32 vehs = 0;
u32 objs = 0;
pInfo->GetReservations(peds, vehs, objs);
if (peds != 0 || vehs != 0 || objs != 0)
{
if (!playersNearbyCalculated)
{
NetworkInterface::GetObjectManager().GetPlayersNearbyInScope(playersNearbyInPedScope, playersNearbyInVehScope, playersNearbyInObjScope, pScopePosition);
playersNearby = playersNearbyInPedScope | playersNearbyInVehScope | playersNearbyInObjScope;
playersNearbyCalculated = true;
}
if (playersNearby != 0)
{
bool bParticipantNearbyInPedScope = false;
bool bParticipantNearbyInVehScope = false;
bool bParticipantNearbyInObjScope = false;
for (u32 p=0; p<MAX_NUM_PHYSICAL_PLAYERS; p++)
{
u32 playerIndex = (1<<p);
if ((playersNearby & playerIndex) && (pInfo->GetActiveParticipants() & playerIndex))
{
Assert(playersNearbyCalculated);
if (playersNearbyInPedScope & playerIndex)
{
bParticipantNearbyInPedScope = true;
}
if (playersNearbyInVehScope & playerIndex)
{
bParticipantNearbyInVehScope = true;
}
if (playersNearbyInObjScope & playerIndex)
{
bParticipantNearbyInObjScope = true;
}
}
if (bParticipantNearbyInPedScope == (peds != 0) &&
bParticipantNearbyInVehScope == (vehs != 0) &&
bParticipantNearbyInObjScope == (objs != 0))
{
break;
}
}
if (bParticipantNearbyInPedScope)
{
reservedPeds += peds;
createdPeds += pInfo->GetCreatedPeds();
}
if (bParticipantNearbyInVehScope)
{
reservedVehicles += vehs;
createdVehicles += pInfo->GetCreatedVehicles();
}
if (bParticipantNearbyInObjScope)
{
reservedObjects += objs;
createdObjects += pInfo->GetCreatedObjects();
}
}
}
}
}
}
#if ENABLE_NETWORK_LOGGING
void CGameScriptHandlerMgr::LogCurrentReservations(netLoggingInterface& log) const
{
u32 reservedPeds = 0;
u32 reservedVehs = 0;
u32 reservedObjs = 0;
bool bLogLocal = false;
bool bLogRemote = false;
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->RequiresANetworkComponent() && !handler->IsTerminated())
{
const CGameScriptHandlerNetwork* netHandler = static_cast<const CGameScriptHandlerNetwork*>(handler);
reservedPeds = netHandler->GetTotalNumReservedPeds();
reservedVehs = netHandler->GetTotalNumReservedVehicles();
reservedObjs = netHandler->GetTotalNumReservedObjects();
if (reservedPeds > 0 || reservedVehs > 0 || reservedObjs > 0)
{
if (!bLogLocal)
{
NetworkLogUtils::WriteLogEvent(log, "LOCAL_SCRIPT_RESERVATIONS", "");
bLogLocal = true;
}
log.WriteDataValue(netHandler->GetScriptId().GetLogName(), "%d/%d peds, %d/%d vehicles, %d/%d objects", netHandler->GetNumCreatedPeds(), reservedPeds, netHandler->GetNumCreatedVehicles(), reservedVehs, netHandler->GetNumCreatedObjects(), reservedObjs);
}
}
}
PlayerFlags playersNearby = 0;
PlayerFlags playersNearbyInPedScope = 0;
PlayerFlags playersNearbyInVehScope = 0;
PlayerFlags playersNearbyInObjScope = 0;
bool playersNearbyCalculated = false;
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
const CRemoteScriptInfo* pInfo = &m_remoteActiveScripts[i];
if (!pInfo->GetRunningLocally())
{
reservedPeds = 0;
reservedVehs = 0;
reservedObjs = 0;
pInfo->GetReservations(reservedPeds, reservedVehs, reservedObjs);
if (reservedPeds != 0 || reservedVehs != 0 || reservedObjs != 0)
{
if (!playersNearbyCalculated)
{
NetworkInterface::GetObjectManager().GetPlayersNearbyInScope(playersNearbyInPedScope, playersNearbyInVehScope, playersNearbyInObjScope);
playersNearby = playersNearbyInPedScope | playersNearbyInVehScope | playersNearbyInObjScope;
playersNearbyCalculated = true;
}
if (playersNearby != 0)
{
bool bParticipantNearbyInPedScope = false;
bool bParticipantNearbyInVehScope = false;
bool bParticipantNearbyInObjScope = false;
for (u32 p=0; p<MAX_NUM_PHYSICAL_PLAYERS; p++)
{
u32 playerIndex = (1<<p);
if ((playersNearby & playerIndex) && (pInfo->GetActiveParticipants() & playerIndex))
{
Assert(playersNearbyCalculated);
if (playersNearbyInPedScope & playerIndex)
{
bParticipantNearbyInPedScope = true;
}
if (playersNearbyInVehScope & playerIndex)
{
bParticipantNearbyInVehScope = true;
}
if (playersNearbyInObjScope & playerIndex)
{
bParticipantNearbyInObjScope = true;
}
}
}
if (!bParticipantNearbyInPedScope)
{
reservedPeds = 0;
}
if (!bParticipantNearbyInVehScope)
{
reservedVehs = 0;
}
if (!bParticipantNearbyInObjScope)
{
reservedObjs = 0;
}
}
}
if (reservedPeds>0 || reservedVehs>0 || reservedObjs>0)
{
if (!bLogRemote)
{
NetworkLogUtils::WriteLogEvent(log, "REMOTE_SCRIPT_RESERVATIONS", "");
bLogRemote = true;
}
log.WriteDataValue(m_remoteActiveScripts[i].GetScriptId().GetLogName(), "%d/%d peds, %d/%d vehicles, %d/%d objects", pInfo->GetCreatedPeds(), reservedPeds, pInfo->GetCreatedVehicles(), reservedVehs, pInfo->GetCreatedObjects(), reservedObjs);
}
}
}
}
#else
void CGameScriptHandlerMgr::LogCurrentReservations(netLoggingInterface&) const
{
}
#endif // ENABLE_NETWORK_LOGGING
#if __BANK
void CGameScriptHandlerMgr::DisplayScriptHandlerInfo() const
{
if (ms_DisplayHandlerInfo)
{
const CGameScriptHandler* handler = GetScriptHandlerFromComboName(ms_Handlers[ms_HandlerComboIndex]);
if (handler)
{
handler->DisplayScriptHandlerInfo();
grcDebugDraw::AddDebugOutput("");
grcDebugDraw::AddDebugOutput("");
}
}
if (ms_DisplayAllMPHandlers && NetworkInterface::GetLocalPlayer())
{
grcDebugDraw::AddDebugOutput("");
grcDebugDraw::AddDebugOutput("Local net array data: %u (Cached value: %u)", NetworkInterface::GetArrayManager().GetSizeOfLocallyArbitratedArrayData(), NetworkInterface::GetLocalPlayer()->GetSizeOfNetArrayData());
grcDebugDraw::AddDebugOutput("");
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
scriptHandler* handler = entry.GetData();
if (handler && handler->GetNetworkComponent())
{
char name[80];
sprintf(name, "%-80s", handler->GetLogName());
u32 size = handler->GetNetworkComponent()->GetSizeOfHostBroadcastData();
if (handler->GetNetworkComponent()->IsHostMigrating())
{
grcDebugDraw::AddDebugOutput("%s (Size: %u. Host: ** migrating to %s **)", name, size, handler->GetNetworkComponent()->GetPendingHost()->IsLocal() ? "us" : handler->GetNetworkComponent()->GetPendingHost()->GetLogName());
}
else if (!handler->GetNetworkComponent()->GetHost())
{
grcDebugDraw::AddDebugOutput("%s (Size: %u. Host: --none--)", name, size);
}
else
{
if (handler->GetNetworkComponent()->GetHost()->IsLocal())
{
grcDebugDraw::AddDebugOutput("%s (Size: %u. Host: us)", name, size);
}
else
{
grcDebugDraw::AddDebugOutput("%s (Size: %u. Host: %s)", name, size, handler->GetNetworkComponent()->GetHost()->GetLogName());
}
}
}
}
grcDebugDraw::AddDebugOutput("");
}
}
void CGameScriptHandlerMgr::DisplayObjectAndResourceInfo() const
{
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler)
{
handler->DisplayObjectAndResourceInfo();
}
}
}
void CGameScriptHandlerMgr::DisplayReservationInfo() const
{
u32 reservedPeds = 0;
u32 reservedVehs = 0;
u32 reservedObjs = 0;
grcDebugDraw::AddDebugOutput("-- LOCAL SCRIPTS --");
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->RequiresANetworkComponent() && !handler->IsTerminated())
{
const CGameScriptHandlerNetwork* netHandler = static_cast<const CGameScriptHandlerNetwork*>(handler);
reservedPeds = netHandler->GetTotalNumReservedPeds();
reservedVehs = netHandler->GetTotalNumReservedVehicles();
reservedObjs = netHandler->GetTotalNumReservedObjects();
if (reservedPeds > 0 || reservedVehs > 0 || reservedObjs > 0)
{
grcDebugDraw::AddDebugOutput("%s: %d/%d peds, %d/%d vehicles, %d/%d objects", netHandler->GetScriptName(), netHandler->GetNumCreatedPeds(), reservedPeds, netHandler->GetNumCreatedVehicles(), reservedVehs, netHandler->GetNumCreatedObjects(), reservedObjs);
}
}
}
grcDebugDraw::AddDebugOutput("-- REMOTE SCRIPTS --");
PlayerFlags playersNearby = 0;
PlayerFlags playersNearbyInPedScope = 0;
PlayerFlags playersNearbyInVehScope = 0;
PlayerFlags playersNearbyInObjScope = 0;
bool playersNearbyCalculated = false;
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
const CRemoteScriptInfo* pInfo = &m_remoteActiveScripts[i];
if (!pInfo->GetRunningLocally())
{
reservedPeds = 0;
reservedVehs = 0;
reservedObjs = 0;
pInfo->GetReservations(reservedPeds, reservedVehs, reservedObjs);
if (reservedPeds != 0 || reservedVehs != 0 || reservedObjs != 0)
{
if (!playersNearbyCalculated)
{
NetworkInterface::GetObjectManager().GetPlayersNearbyInScope(playersNearbyInPedScope, playersNearbyInVehScope, playersNearbyInObjScope);
playersNearby = playersNearbyInPedScope | playersNearbyInVehScope | playersNearbyInObjScope;
playersNearbyCalculated = true;
}
if (playersNearby != 0)
{
bool bParticipantNearbyInPedScope = false;
bool bParticipantNearbyInVehScope = false;
bool bParticipantNearbyInObjScope = false;
for (u32 p=0; p<MAX_NUM_PHYSICAL_PLAYERS; p++)
{
u32 playerIndex = (1<<p);
if ((playersNearby & playerIndex) && (pInfo->GetActiveParticipants() & playerIndex))
{
Assert(playersNearbyCalculated);
if (playersNearbyInPedScope & playerIndex)
{
bParticipantNearbyInPedScope = true;
}
if (playersNearbyInVehScope & playerIndex)
{
bParticipantNearbyInVehScope = true;
}
if (playersNearbyInObjScope & playerIndex)
{
bParticipantNearbyInObjScope = true;
}
}
}
if (!bParticipantNearbyInPedScope)
{
reservedPeds = 0;
}
if (!bParticipantNearbyInVehScope)
{
reservedVehs = 0;
}
if (!bParticipantNearbyInObjScope)
{
reservedObjs = 0;
}
}
}
if (reservedPeds>0 || reservedVehs>0 || reservedObjs>0)
{
grcDebugDraw::AddDebugOutput("%s: %d/%d peds, %d/%d vehicles, %d/%d objects", pInfo->GetScriptId().GetScriptName(), pInfo->GetCreatedPeds(), reservedPeds, pInfo->GetCreatedVehicles(), reservedVehs, pInfo->GetCreatedObjects(), reservedObjs);
}
}
}
}
#endif // __BANK
#if __SCRIPT_MEM_CALC
void CGameScriptHandlerMgr::CalculateMemoryUsage()
{
const strIndex* ignoreList = NULL;
s32 numIgnores = 0;
GetResourceIgnoreList(&ignoreList, numIgnores);
m_TotalScriptVirtualMemory = 0;
m_TotalScriptPhysicalMemory = 0;
u32 TotalVirtualForResourcesWithoutStreamingIndex = 0;
u32 TotalPhysicalForResourcesWithoutStreamingIndex = 0;
const int maxLoadedInt = strStreamingEngine::GetInfo().GetLoadedInfoMap()->GetNumSlots() + strStreamingEngine::GetInfo().GetLoadedPersistentInfoMap()->GetNumSlots()
+ strStreamingEngine::GetInfo().GetRequestInfoMap()->GetNumSlots() + strStreamingEngine::GetInfo().GetLoadingInfoMap().GetNumSlots();
// Fixes B* 2175673
const int maxLoadedCount = CStreamVolumeMgr::GetStreamingIndicesCount();
const u16 maxLoaded = (u16) Min(maxLoadedInt + maxLoadedCount, 0xffff);
strIndex *streamingIndicesForAllScriptsBackingStore = Alloca(strIndex, maxLoaded);
atUserArray<strIndex> streamingIndicesForAllScripts(streamingIndicesForAllScriptsBackingStore, maxLoaded);
strIndex *streamingIndicesForThisScriptBackingStore = Alloca(strIndex, maxLoaded);
atUserArray<strIndex> streamingIndicesForThisScript(streamingIndicesForThisScriptBackingStore, maxLoaded);
u32 ScriptThreadId = 0;
bool bDisplayScriptDetails = true;
bool bFilterScriptObjectDisplay = false;
bool bExcludeScripts = false;
#if __SCRIPT_MEM_DISPLAY
bDisplayScriptDetails = CScriptDebug::GetDisplayDetailedScriptMemoryUsage();
bFilterScriptObjectDisplay = CScriptDebug::GetDisplayDetailedScriptMemoryUsageFiltered();
bExcludeScripts = CScriptDebug::GetExcludeScriptFromScriptMemoryUsage();
#endif // __SCRIPT_MEM_DISPLAY
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (!handler) continue;
streamingIndicesForThisScript.Resize(0);
u32 VirtualForResourcesWithoutStreamingIndexInThisScript = 0;
u32 PhysicalForResourcesWithoutStreamingIndexInThisScript = 0;
ClearMemoryDebugInfoForMovieMeshes(true);
handler->CalculateMemoryUsage(streamingIndicesForThisScript, ignoreList, numIgnores,
VirtualForResourcesWithoutStreamingIndexInThisScript, PhysicalForResourcesWithoutStreamingIndexInThisScript,
bDisplayScriptDetails, bFilterScriptObjectDisplay, 0); //STRFLAG_DONTDELETE);
CalculateMemoryUsageForMovieMeshes(handler, VirtualForResourcesWithoutStreamingIndexInThisScript, PhysicalForResourcesWithoutStreamingIndexInThisScript, bDisplayScriptDetails);
ScriptThreadId = 0;
if (handler->GetThread())
{
ScriptThreadId = (u32) handler->GetThread()->GetThreadId();
}
if (ScriptThreadId != 0)
{
if (CStreamVolumeMgr::IsThereAVolumeOwnedBy((scrThreadId) ScriptThreadId))
{
CStreamVolumeMgr::GetStreamingIndices(streamingIndicesForThisScript);
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
atArray<strIndex> streamingIndicesForStreamingVolume;
CStreamVolumeMgr::GetStreamingIndices(streamingIndicesForStreamingVolume);
u32 VirtualMemForVolume = 0;
u32 PhysicalMemForVolume = 0;
strStreamingEngine::GetInfo().GetObjectAndDependenciesSizes(streamingIndicesForStreamingVolume, VirtualMemForVolume, PhysicalMemForVolume, NULL, 0, true);
grcDebugDraw::AddDebugOutput("%s(%u) Stream Volume %dK %dK", handler->GetScriptName(), ScriptThreadId, VirtualMemForVolume>>10, PhysicalMemForVolume>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
}
// Display the memory used by render targets for normal Bink movies (not mesh sets)
CalculateMemoryUsageForNamedRenderTargets(handler,
VirtualForResourcesWithoutStreamingIndexInThisScript, PhysicalForResourcesWithoutStreamingIndexInThisScript,
bDisplayScriptDetails);
#if __SCRIPT_MEM_DISPLAY
if (CScriptDebug::GetDisplayScriptMemoryUsage())
{
u32 VirtualMemForThisScript = 0;
u32 PhysicalMemForThisScript = 0;
strStreamingEngine::GetInfo().GetObjectAndDependenciesSizes(streamingIndicesForThisScript,
VirtualMemForThisScript, PhysicalMemForThisScript, ignoreList, numIgnores, true);
VirtualMemForThisScript += VirtualForResourcesWithoutStreamingIndexInThisScript;
PhysicalMemForThisScript += PhysicalForResourcesWithoutStreamingIndexInThisScript;
if (VirtualMemForThisScript > 0 || PhysicalMemForThisScript > 0)
{
grcDebugDraw::AddDebugOutput("%s(%u) Virtual %dK Physical %dK (for all resources, including deps)",
handler->GetScriptName(), ScriptThreadId,
VirtualMemForThisScript>>10, PhysicalMemForThisScript>>10);
}
}
#endif // __SCRIPT_MEM_DISPLAY
// Add all entries from streamingIndicesForThisScript to streamingIndicesForAllScripts
// Should I remove duplicates at this stage?
s32 indexCount = streamingIndicesForThisScript.GetCount();
for (s32 i=0; i<indexCount; i++)
{
streamingIndicesForAllScripts.Append() = streamingIndicesForThisScript[i];
}
TotalVirtualForResourcesWithoutStreamingIndex += VirtualForResourcesWithoutStreamingIndexInThisScript;
TotalPhysicalForResourcesWithoutStreamingIndex += PhysicalForResourcesWithoutStreamingIndexInThisScript;
}
strStreamingEngine::GetInfo().GetObjectAndDependenciesSizes(streamingIndicesForAllScripts,
m_TotalScriptVirtualMemory, m_TotalScriptPhysicalMemory, ignoreList, numIgnores, true);
m_TotalScriptVirtualMemory += TotalVirtualForResourcesWithoutStreamingIndex;
m_TotalScriptPhysicalMemory += TotalPhysicalForResourcesWithoutStreamingIndex;
//looks for all the path nodes loaded for scripts
u32 nTotalPathNodeVirtualMemory = 0;
u32 nTotalPathNodePhysicalMemory = 0;
ThePaths.CountScriptMemoryUsage(nTotalPathNodeVirtualMemory, nTotalPathNodePhysicalMemory);
m_TotalScriptVirtualMemory += nTotalPathNodeVirtualMemory;
m_TotalScriptPhysicalMemory += nTotalPathNodePhysicalMemory;
//looks for all the navmeshes loaded for scripts
u32 nTotalNavmeshVirtualMemory = 0;
u32 nTotalNavmeshPhysicalMemory = 0;
CPathServer::CountScriptMemoryUsage(nTotalNavmeshVirtualMemory, nTotalNavmeshPhysicalMemory);
m_TotalScriptVirtualMemory += nTotalNavmeshVirtualMemory;
m_TotalScriptPhysicalMemory += nTotalNavmeshPhysicalMemory;
//looks for all the loaded scripts
if(!bExcludeScripts)
{
u32 nTotalScriptVirtualMemory = 0;
u32 nTotalScriptPhysicalMemory = 0;
g_StreamedScripts.CalculateMemoryUsage(nTotalScriptVirtualMemory, nTotalScriptPhysicalMemory, bDisplayScriptDetails);
m_TotalScriptVirtualMemory += nTotalScriptVirtualMemory;
m_TotalScriptPhysicalMemory += nTotalScriptPhysicalMemory;
}
if (m_TotalScriptVirtualMemory > m_TotalScriptVirtualMemoryPeak)
{
m_TotalScriptVirtualMemoryPeak = m_TotalScriptVirtualMemory;
if (PARAM_scriptLogMemoryPeaks.Get())
Displayf("CGameScriptHandlerMgr : [SCRIPT][MEM_PEAK] : Virtual : %s : %10dK", NetworkInterface::IsInFreeMode() ? "MP" : "SP", m_TotalScriptVirtualMemoryPeak>>10);
}
if (m_TotalScriptPhysicalMemory > m_TotalScriptPhysicalMemoryPeak)
{
m_TotalScriptPhysicalMemoryPeak = m_TotalScriptPhysicalMemory;
if (PARAM_scriptLogMemoryPeaks.Get())
Displayf("CGameScriptHandlerMgr : [SCRIPT][MEM_PEAK] : Physical : %s : %10dK", NetworkInterface::IsInFreeMode() ? "MP" : "SP", m_TotalScriptPhysicalMemoryPeak>>10);
}
#if __SCRIPT_MEM_DISPLAY
if (CScriptDebug::GetDisplayScriptMemoryUsage())
{
if (nTotalPathNodeVirtualMemory > 0 || nTotalPathNodePhysicalMemory > 0)
{
grcDebugDraw::AddDebugOutput("%s(%d) Virtual %dK Physical %dK",
"Script Path Nodes", -1,
nTotalPathNodeVirtualMemory>>10, nTotalPathNodePhysicalMemory>>10);
}
}
#endif // __SCRIPT_MEM_DISPLAY
// periodically do a test to see if the script streaming memory has exceeded its limit
if (m_streamingMemTestTimer.GetMsTime() > static_cast<float>(STREAMING_MEM_CHECK_TIME))
{
#if __FINAL
size_t virtualLimit = VIRTUAL_STREAMING_MEMORY_LIMIT;
size_t physicalLimit = PHYSICAL_STREAMING_MEMORY_LIMIT;
#else
size_t virtualLimit = VIRTUAL_STREAMING_MEMORY_LIMIT_DBG;
size_t physicalLimit = PHYSICAL_STREAMING_MEMORY_LIMIT_DBG;
const char *overrideScriptRpfName = NULL;
PARAM_override_script.Get(overrideScriptRpfName);
if(overrideScriptRpfName && !stricmp(overrideScriptRpfName, "script_rel"))
{
virtualLimit = VIRTUAL_STREAMING_MEMORY_LIMIT;
physicalLimit = PHYSICAL_STREAMING_MEMORY_LIMIT;
}
#endif
if (NetworkInterface::IsInFreeMode() && !CPauseMenu::GetCurrenMissionActive() && !NetworkInterface::IsInSpectatorMode())
{
virtualLimit = VIRTUAL_STREAMING_FREEMODE_MEMORY_LIMIT;
physicalLimit = PHYSICAL_STREAMING_FREEMODE_MEMORY_LIMIT;
}
#if !ONE_STREAMING_HEAP
if (((m_TotalScriptVirtualMemory>>10) > virtualLimit) || ((m_TotalScriptPhysicalMemory>>10) > physicalLimit))
#else
if (((m_TotalScriptVirtualMemory>>10) + (m_TotalScriptPhysicalMemory>>10)) > virtualLimit +physicalLimit)
#endif
{
m_lastStreamingEmergencyTimer.Reset();
}
// check if streaming is trying to request too much data at once
CPlayerInfo *pPlayerInfo = CGameWorld::GetMainPlayerInfo();
if (pPlayerInfo && !pPlayerInfo->AreControlsDisabled())
{
bool emergencyHit = false;
s32 indexCount = streamingIndicesForAllScripts.GetCount();
for (s32 i = 0; i < indexCount; ++i)
{
const strStreamingInfo& info = strStreamingEngine::GetInfo().GetStreamingInfoRef(streamingIndicesForAllScripts[i]);
if (info.GetStatus() != STRINFO_LOADING && info.GetStatus() != STRINFO_LOADREQUESTED)
{
streamingIndicesForAllScripts[i] = strIndex(strIndex::INVALID_INDEX);
}
}
u32 virt = 0;
u32 phys = 0;
strStreamingEngine::GetInfo().GetObjectAndDependenciesSizes(streamingIndicesForAllScripts, virt, phys, ignoreList, numIgnores, true);
if ((virt + phys) >> 10 > TOTAL_STREAMING_REQUEST_TOTAL_LIMIT)
{
m_lastStreamingReqEmergencyTimer.Reset();
emergencyHit = true;
}
// check priority requests only
if (!emergencyHit)
{
for (s32 i = 0; i < indexCount; ++i)
{
if (streamingIndicesForAllScripts[i] == strIndex(strIndex::INVALID_INDEX))
continue;
const strStreamingInfo& info = strStreamingEngine::GetInfo().GetStreamingInfoRef(streamingIndicesForAllScripts[i]);
if ((info.GetFlags() & STRFLAG_PRIORITY_LOAD) == 0)
{
streamingIndicesForAllScripts[i] = strIndex(strIndex::INVALID_INDEX);
}
}
u32 virt = 0;
u32 phys = 0;
strStreamingEngine::GetInfo().GetObjectAndDependenciesSizes(streamingIndicesForAllScripts, virt, phys, ignoreList, numIgnores, true);
if ((virt + phys) >> 10 > TOTAL_STREAMING_REQUEST_PRIO_LIMIT)
{
m_lastStreamingReqEmergencyTimer.Reset();
}
}
m_streamingMemTestTimer.Reset();
}
}
}
void CGameScriptHandlerMgr::ClearMemoryDebugInfoForMovieMeshes(bool bTrackMemoryForMovieMeshes) const
{
m_bTrackMemoryForMovieMeshes = bTrackMemoryForMovieMeshes;
m_ArrayOfModelsUsedByMovieMeshes.Reset();
m_MapOfMoviesUsedByMovieMeshes.Reset();
m_MapOfRenderTargetsUsedByMovieMeshes.Reset();
}
void CGameScriptHandlerMgr::CalculateMemoryUsageForMovieMeshes(const CGameScriptHandler* SCRIPT_MEM_DISPLAY_ONLY(pScriptHandler), u32 &VirtualTotal, u32 &PhysicalTotal, bool SCRIPT_MEM_DISPLAY_ONLY(bDisplayScriptDetails)) const
{
// Models
u32 NumberOfModels = m_ArrayOfModelsUsedByMovieMeshes.GetCount();
if (NumberOfModels > 0)
{
s32 totalPhysicalMemory = 0;
s32 totalVirtualMemory = 0;
s32 drawablePhysicalMemory = 0;
s32 drawableVirtualMemory = 0;
s32 texturePhysicalMemory = 0;
s32 textureVirtualMemory = 0;
s32 boundsPhysicalMemory = 0;
s32 boundsVirtualMemory = 0;
CStreamingDebug::GetMemoryStatsByAllocation(m_ArrayOfModelsUsedByMovieMeshes, totalPhysicalMemory, totalVirtualMemory, drawablePhysicalMemory, drawableVirtualMemory,
texturePhysicalMemory, textureVirtualMemory, boundsPhysicalMemory, boundsVirtualMemory);
VirtualTotal += totalVirtualMemory;
PhysicalTotal += totalPhysicalMemory;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("%s(%d) Total For %u Models in Mesh Sets : Virtual %dK Physical %dK",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId(),
NumberOfModels,
totalVirtualMemory>>10, totalPhysicalMemory>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
// Movies
u32 virtualSize = 0;
u32 physicalSize = 0;
u32 NumberOfMovies = m_MapOfMoviesUsedByMovieMeshes.GetNumUsed();
if (NumberOfMovies > 0)
{
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("%s(%d) Movies used in Mesh Sets",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId());
}
#endif // __SCRIPT_MEM_DISPLAY
atMap<u32,u32>::Iterator MovieMapIterator = m_MapOfMoviesUsedByMovieMeshes.CreateIterator();
while (!MovieMapIterator.AtEnd())
{
u32 movieHandle = MovieMapIterator.GetKey();
// Is there a way to get the name of the movie from its handle?
u32 virtSizeForThisMovie = g_movieMgr.GetMemoryUsage(movieHandle);
virtualSize += virtSizeForThisMovie;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("Movie Handle=%u: used %d times : Virtual %dK",
movieHandle, MovieMapIterator.GetData(),
virtSizeForThisMovie>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
MovieMapIterator.Next();
}
VirtualTotal += virtualSize;
PhysicalTotal += physicalSize;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("%s(%d) Total For Movies in Mesh Sets : Virtual %dK",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId(),
virtualSize>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
// Render Targets
virtualSize = 0;
physicalSize = 0;
u32 NumberOfRenderTargets = m_MapOfRenderTargetsUsedByMovieMeshes.GetNumUsed();
if (NumberOfRenderTargets > 0)
{
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("%s(%d) Render Targets used in Mesh Sets",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId());
}
#endif // __SCRIPT_MEM_DISPLAY
atMap<CRenderTargetMgr::namedRendertarget*, u32>::Iterator RenderTargetIterator = m_MapOfRenderTargetsUsedByMovieMeshes.CreateIterator();
while (!RenderTargetIterator.AtEnd())
{
CRenderTargetMgr::namedRendertarget *pRenderTarget = RenderTargetIterator.GetKey();
if (pRenderTarget)
{
u32 SizeForThisMovie = pRenderTarget->GetMemoryUsage();
physicalSize += SizeForThisMovie;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("Render Target=%x: used %d times : Physical %dK",
pRenderTarget, RenderTargetIterator.GetData(),
SizeForThisMovie>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
RenderTargetIterator.Next();
}
VirtualTotal += virtualSize;
PhysicalTotal += physicalSize;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails)
{
grcDebugDraw::AddDebugOutput("%s(%d) Total For RenderTargets in Mesh Sets : Physical %dK",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId(),
physicalSize>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
ClearMemoryDebugInfoForMovieMeshes(false);
}
// Display the memory used by render targets for normal Bink movies (not mesh sets)
void CGameScriptHandlerMgr::CalculateMemoryUsageForNamedRenderTargets(const CGameScriptHandler* pScriptHandler, u32& UNUSED_PARAM(virtualMemory), u32 &physicalMemory, bool SCRIPT_MEM_DISPLAY_ONLY(bDisplayScriptDetails)) const
{
if (pScriptHandler->GetThread())
{
u32 physicalMemoryForThisThread = gRenderTargetMgr.GetMemoryUsageForNamedRenderTargets(pScriptHandler->GetThread()->GetThreadId());
physicalMemory += physicalMemoryForThisThread;
#if __SCRIPT_MEM_DISPLAY
if (bDisplayScriptDetails && (physicalMemoryForThisThread > 0))
{
grcDebugDraw::AddDebugOutput("%s(%d) Total For RenderTargets in Movies (excluding movies used by mesh sets) : Physical %dK",
pScriptHandler->GetScriptName(), pScriptHandler->GetThread()->GetThreadId(),
physicalMemoryForThisThread>>10);
}
#endif // __SCRIPT_MEM_DISPLAY
}
}
void CGameScriptHandlerMgr::AddToModelsUsedByMovieMeshes(u32 ModelIndex)
{
if (m_bTrackMemoryForMovieMeshes)
{
m_ArrayOfModelsUsedByMovieMeshes.PushAndGrow(ModelIndex);
}
}
void CGameScriptHandlerMgr::AddToMoviesUsedByMovieMeshes(u32 MovieHandle)
{
if (m_bTrackMemoryForMovieMeshes)
{
u32 *pNumberOfTimesUsed = m_MapOfMoviesUsedByMovieMeshes.Access(MovieHandle);
if (pNumberOfTimesUsed)
{
m_MapOfMoviesUsedByMovieMeshes[MovieHandle] = 1 + *pNumberOfTimesUsed;
}
else
{
m_MapOfMoviesUsedByMovieMeshes.Insert(MovieHandle, 1);
}
}
}
void CGameScriptHandlerMgr::AddToRenderTargetsUsedByMovieMeshes(CRenderTargetMgr::namedRendertarget *pNamedRenderTarget)
{
if (m_bTrackMemoryForMovieMeshes)
{
u32 *pNumberOfTimesUsed = m_MapOfRenderTargetsUsedByMovieMeshes.Access(pNamedRenderTarget);
if (pNumberOfTimesUsed)
{
m_MapOfRenderTargetsUsedByMovieMeshes[pNamedRenderTarget] = 1 + *pNumberOfTimesUsed;
}
else
{
m_MapOfRenderTargetsUsedByMovieMeshes.Insert(pNamedRenderTarget, 1);
}
}
}
#endif // __SCRIPT_MEM_CALC
#if __BANK
void CGameScriptHandlerMgr::GetScriptDependencyList(atArray<strIndex> &theArray)
{
atArray<strIndex> localIndices;
const strIndex* ignoreList = NULL;
s32 numIgnores = 0;
GetResourceIgnoreList(&ignoreList, numIgnores);
// ignore vehicle resident texture dictionaries. Not sure why (copied from old mission cleanup code)
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler)
{
handler->GetStreamingIndices(localIndices, STRFLAG_DONTDELETE);
}
}
for(int i=0;i<localIndices.size();i++)
{
strStreamingEngine::GetInfo().GetObjectAndDependencies(localIndices[i], theArray, ignoreList, numIgnores);
}
}
void CGameScriptHandlerMgr::UpdateScriptHandlerCombo()
{
#if __DEV
if (ms_pHandlerCombo)
{
ms_NumHandlers = 0;
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->GetScriptName() && AssertVerify(ms_NumHandlers<CGameScriptHandler::MAX_NUM_SCRIPT_HANDLERS))
{
ms_Handlers[ms_NumHandlers++] = handler->GetScriptName();
}
}
if (ms_NumHandlers == 0)
{
ms_Handlers[0] = "-- none --";
ms_NumHandlers = 1;
}
ms_pHandlerCombo->UpdateCombo("Script Handlers", &ms_HandlerComboIndex, ms_NumHandlers, (const char **)ms_Handlers);
}
#endif // __DEV
}
const CGameScriptHandler* CGameScriptHandlerMgr::GetScriptHandlerFromComboName(const char* scriptName) const
{
scriptHandlerMap::ConstIterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->GetScriptName() && !strcmp(handler->GetScriptName(), scriptName))
{
return handler;
}
}
return NULL;
}
CGameScriptHandler* CGameScriptHandlerMgr::GetScriptHandlerFromComboName(const char* scriptName)
{
scriptHandlerMap::Iterator entry = m_scriptHandlers.CreateIterator();
for (entry.Start(); !entry.AtEnd(); entry.Next())
{
CGameScriptHandler* handler = static_cast<CGameScriptHandler*>(entry.GetData());
if (handler && handler->GetScriptName() && !strcmp(handler->GetScriptName(), scriptName))
{
return handler;
}
}
return NULL;
}
#endif // __BANK
// gets the streaming objects to ignore when calculating or displaying resource memory usage
void CGameScriptHandlerMgr::GetResourceIgnoreList(const strIndex** ignoreList, s32& numIgnores) const
{
const atArray<strIndex>& residentIgnoreList = gPopStreaming.GetResidentObjectList();
*ignoreList = residentIgnoreList.GetElements();
numIgnores = residentIgnoreList.GetCount();
}
void CGameScriptHandlerMgr::WriteRemoteScriptHeader(const CGameScriptId& LOGGING_ONLY(scriptId), const char *LOGGING_ONLY(headerText), ...)
{
#if ENABLE_NETWORK_LOGGING
char buffer[netLog::MAX_LOG_STRING];
va_list args;
va_start(args, headerText);
vsprintf(buffer, headerText, args);
va_end(args);
if(GetLog())
{
GetLog()->Log("\t<remote script update> %s: %s\r\n", scriptId.GetLogName(), buffer);
}
#endif // #if ENABLE_NETWORK_LOGGING
}
bool CGameScriptHandlerMgr::HandleTimestampConflict(const CRemoteScriptInfo& scriptInfo)
{
bool bAddInfo = true;
bool bDeleteExistingInfo = false;
// watches out for 2 identical scripts running at once with the same timestamp.
// this can happen for 2 reasons:
// 1) a joining machine starts up and hosts a script immediately before being aware of other machines in the session (and the real host).
// This really shouldn't happen: the joining machine should wait for the timeout time before starting up any scripts but we still need to handle
// this problem in case it does arise.
// 2) a new player is accepted by a host running the script on his own, who drops out immediately. The new player loses the host during the joining
// process and starts a new session. The host has not broadcast a remote script info with 0 participants as he thinks there is a remaining
// participant (the new player).
CGameScriptId remoteScriptId = scriptInfo.GetScriptId();
unsigned remoteTimeStamp = remoteScriptId.GetTimeStamp();
const CGameScriptId* pExistingScriptId = NULL;
u32 existingInfoSlot = 0;
// set timestamp to 0 so that it matches ids of existing script handlers with differing timestamps
remoteScriptId.ResetTimestamp();
// find an existing remote script info for this script
for (u32 i=0; i<m_remoteActiveScripts.GetCount(); i++)
{
if (m_remoteActiveScripts[i].m_ScriptId == remoteScriptId && m_remoteActiveScripts[i].GetActiveParticipants() != 0)
{
pExistingScriptId = &m_remoteActiveScripts[i].GetScriptId();
unsigned existingTimestamp = pExistingScriptId->GetTimeStamp();
if (gnetVerify(existingTimestamp != remoteTimeStamp))
{
WriteRemoteScriptHeader(*pExistingScriptId, "** TIMESTAMP CONFLICT (Remote timestamp: %d) **", remoteTimeStamp);
if (remoteTimeStamp > existingTimestamp)
{
#if __ASSERT
// we should not have an active handler when we get a timestamp conflict
scriptHandler* pHandler = GetScriptHandler(*pExistingScriptId);
if (pHandler &&
pHandler->GetNetworkComponent() &&
pHandler->GetNetworkComponent()->GetState() == scriptHandlerNetComponent::NETSCRIPT_PLAYING)
{
gnetAssertf(0, "Two versions of script %s active with different timestamps! (Remote timestamp: %d)", pExistingScriptId->GetLogName(), remoteTimeStamp);
return true;
}
#endif
WriteRemoteScriptHeader(*pExistingScriptId, "Info removed");
bDeleteExistingInfo = true;
existingInfoSlot = i;
}
else
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Info not added");
// don't add this script info
bAddInfo = false;
}
}
break;
}
}
if (bDeleteExistingInfo)
{
MoveActiveScriptToTerminatedQueue(existingInfoSlot);
}
return bAddInfo;
}
void CGameScriptHandlerMgr::MoveActiveScriptToTerminatedQueue(u32 activeScriptSlot)
{
CRemoteScriptInfo scriptInfo = m_remoteActiveScripts[activeScriptSlot];
scriptInfo.SetParticipants(0);
scriptInfo.SetHost(NULL);
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Remote script has terminated, move to terminated queue");
m_remoteActiveScripts.Delete(activeScriptSlot);
scriptHandler* pScriptHandler = GetScriptHandler(scriptInfo.GetScriptId());
// ignore the handler if it is running with a 0 timestamp. We only care about the previous instance of the script.
bool bIgnoreZeroTimestamp = Tunables::GetInstance().TryAccess(CD_GLOBAL_HASH, ATSTRINGHASH("CLEANUP_SCRIPT_OBJECTS_FIX", 0x03bfbf68), true);
if (!pScriptHandler || (bIgnoreZeroTimestamp && static_cast<const CGameScriptId&>(pScriptHandler->GetScriptId()).GetTimeStamp() == 0))
{
WriteRemoteScriptHeader(scriptInfo.GetScriptId(), "Cleanup objects, script not running locally");
// inform the object mgr that this script has terminated, so it can clean up any script objects that belonged to the script
NetworkInterface::GetObjectManager().CleanupScriptObjects(scriptInfo.GetScriptId());
}
#if __ASSERT
for (u32 i=0; i<m_remoteTerminatedScripts.GetCount(); i++)
{
if (m_remoteTerminatedScripts[i].m_ScriptId == scriptInfo.GetScriptId())
{
Assertf(0, "Remote script info %s already on terminated queue", scriptInfo.GetScriptId().GetLogName());
return;
}
}
#endif // __ASSERT
if (m_remoteTerminatedScripts.IsFull())
m_remoteTerminatedScripts.Pop();
if (!m_remoteTerminatedScripts.Push(scriptInfo))
{
Assertf(0, "Failed to add a terminated script to the remote terminated script queue");
}
}
Reference in New Issue Copy Permalink