plugindeveloper.c

Go to the documentation of this file.

typedef Param7<EntityAI, string, float, float, bool, string, FindInventoryLocationType> DevSpawnItemParams;//(target, item_name, health, quantity, special, presetName, locationType );
class PluginDeveloper extends PluginBase
{
 protected bool m_IsWinHolding; 
 protected int m_FeaturesMask;
 UIScriptedMenu m_ScriptConsole;
 
 static PluginDeveloper GetInstance()
 {
 return PluginDeveloper.Cast( GetPlugin( PluginDeveloper ) );
 }
 
 void TeleportAtCursor()
 {
 DeveloperTeleport.TeleportAtCursorEx();
 }
 
 void Teleport(PlayerBase player, vector position)
 {
 DeveloperTeleport.SetPlayerPosition(player, position);
 }
 
 void ToggleFreeCameraBackPos()
 {
 DeveloperFreeCamera.FreeCameraToggle( PlayerBase.Cast( GetGame().GetPlayer() ), false );
 }
 
 void ToggleFreeCamera()
 {
 DeveloperFreeCamera.FreeCameraToggle( PlayerBase.Cast( GetGame().GetPlayer() ), true );
 }
 
 bool IsEnabledFreeCamera()
 {
 return DeveloperFreeCamera.IsFreeCameraEnabled();
 } 
 
 // System Public Events
 void PluginDeveloper()
 {
 
 }
 
 override void OnInit()
 {
 super.OnInit();
 
 DeveloperFreeCamera.OnInit();
 }
 
 void OnRPC(PlayerBase player, int rpc_type, ParamsReadContext ctx)
 {
 #ifdef DIAG_DEVELOPER
 switch (rpc_type)
 {
 case ERPCs.DEV_RPC_SPAWN_ITEM_ON_GROUND:
 {
 OnRPCSpawnEntityOnGround(player, ctx); break;
 }
 case ERPCs.DEV_RPC_SPAWN_ITEM_ON_GROUND_PATTERN_GRID:
 {
 OnRPCSpawnEntityOnGroundPatternGrid(player, ctx); break;
 }
 case ERPCs.DEV_RPC_SPAWN_ITEM_ON_CURSOR:
 {
 OnRPCSpawnEntityOnCursorDir(player, ctx); break;
 }
 case ERPCs.DEV_RPC_SPAWN_ITEM_IN_INVENTORY:
 {
 OnRPCSpawnEntity(player, ctx); break;
 }
 case ERPCs.DEV_RPC_CLEAR_INV:
 {
 OnRPCClearInventory(player); break;
 }
 case ERPCs.DEV_RPC_SEND_SERVER_LOG:
 {
 OnRPCServerLogRecieved( ctx ); break;
 }
 case ERPCs.RPC_SYNC_SCENE_OBJECT:
 {
 OnRPCSyncSceneObject( ctx ); break;
 }
 case ERPCs.DEV_RPC_PLUGIN_DZCREATURE_DEBUG:
 {
 OnRPCPluginDayzCreatureDebug(player, rpc_type, ctx); break;
 }
 case ERPCs.DEV_RPC_SPAWN_PRESET:
 {
 string presetName;
 EntityAI target;
 
 ctx.Read(presetName);
 ctx.Read(target);
 
 HandlePresetSpawn(player,presetName, target); break;
 } 
 case ERPCs.DEV_RPC_SET_TIME:
 {
 HandleSetTime(player,ctx); break;
 }
 }
 
 DeveloperTeleport.OnRPC(player, rpc_type, ctx); 
 #endif
 }
 
 // Public API
 // Send Print to scripted console
 void PrintLogClient(string msg_log)
 { 
 if ( g_Game.GetUIManager().IsMenuOpen(MENU_SCRIPTCONSOLE) )
 {
 Param1<string> msg_p = new Param1<string>(msg_log);
 CallMethod(CALL_ID_SCR_CNSL_ADD_PRINT, msg_p);
 }
 } 
 
 // Server Log Synch: Server Side
 void SendServerLogToClient(string msg)
 {
 if ( GetGame() )
 {
 array<Man> players = new array<Man>;
 GetGame().GetPlayers( players );
 
 for ( int i = 0; i < players.Count(); ++i )
 {
 Param1<string> param = new Param1<string>( msg );
 Man player = players.Get(i);
 
 if ( player && player.HasNetworkID() )
 {
 player.RPCSingleParam(ERPCs.DEV_RPC_SEND_SERVER_LOG, param, true, player.GetIdentity());
 }
 }
 }
 }
 
 void OnRPCSyncSceneObject( ParamsReadContext ctx )
 {
 Param3<string, EntityAI, Param> par = new Param3<string, EntityAI, Param>( "", NULL, new Param );
 
 if ( ctx.Read( par ) )
 { 
 PluginSceneManager module_scene_editor = PluginSceneManager.Cast( GetPlugin( PluginSceneManager ) );
 SceneData scene_data = module_scene_editor.GetLoadedScene();
 SceneObject scene_object = scene_data.GetSceneObjectByEntityAI( par.param2 );
 
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallByName( scene_object, par.param1, par.param3 );
 }
 }
 
 void OnRPCPluginDayzCreatureDebug(PlayerBase player, int rpc_type, ParamsReadContext ctx)
 {
 PluginDayZCreatureAIDebug pluginDZCreatureDebug = PluginDayZCreatureAIDebug.Cast( GetPlugin( PluginDayZCreatureAIDebug ) );
 if (pluginDZCreatureDebug)
 {
 pluginDZCreatureDebug.OnRpc(player, rpc_type, ctx);
 }
 }
 
 void HandleSetTime(PlayerBase player, ParamsReadContext ctx)
 {
 #ifdef DEVELOPER
 
 Param5<int,int,int,int,int> p5 = new Param5<int,int,int,int,int>(0,0,0,0,0);
 
 if ( ctx.Read( p5 ) )
 { 
 //float time01 = p5.param4 / 100;
 //int time_minutes = Math.Lerp(0, 24*60, time01 );
 
 int year = p5.param1;
 int month = p5.param2;
 int day = p5.param3;
 int hour = p5.param4;
 int minute = p5.param5;
 
 
 
 GetGame().GetWorld().SetDate(year,month, day, hour, minute);
 /*
 Debug.Log("year:" + year);
 Debug.Log("month:" + month);
 Debug.Log("day:" + day);
 Debug.Log("hour:" + hour);
 Debug.Log("minute:" + minute);
 */
 }
 
 #endif
 }
 
 void HandlePresetSpawn(PlayerBase player, string presetName, EntityAI target)
 {
 #ifdef DEVELOPER
 
 PlayerBase targetPlayer = player;
 
 if (target)
 { 
 targetPlayer = PlayerBase.Cast(target);
 }
 if (!targetPlayer)
 return;
 
 targetPlayer.m_PresetSpawned = true;
 string class_name = presetName + "_Preset";
 typename type = class_name.ToType();
 
 if (type)
 {
 PresetSpawnBase presetObj = PresetSpawnBase.Cast(type.Spawn());
 
 if (presetObj)
 {
 presetObj.Init(targetPlayer);
 }
 }
 
 #endif
 }
 
 // RPC Events
 // Server Log Synch: Client Side
 void OnRPCServerLogRecieved(ParamsReadContext ctx)
 {
 Param1<string> param = new Param1<string>( "" );
 
 if ( ctx.Read(param) && param.param1 != "" )
 {
 Debug.ReceivedLogMessageFromServer(param.param1);
 }
 }
 
 void OnRPCClearInventory(PlayerBase player)
 {
 ClearInventory(player);
 }
 
 // Client -> Server Spawning: Server Side
 void OnRPCSpawnEntityOnCursorDir(PlayerBase player, ParamsReadContext ctx)
 {
 Param7<string, float, float, float, bool, string, bool> p = new Param7<string, float, float, float, bool, string, bool>("", 0, 0, 0, false, "", false);
 if ( ctx.Read(p) )
 {
 SpawnEntityOnCursorDir(player, p.param1, p.param2, p.param3, p.param4, p.param5, p.param6, p.param7);
 }
 }
 
 void OnRPCSpawnEntityOnGround(PlayerBase player, ParamsReadContext ctx)
 {
 Param6<string, float, float, vector, bool, bool> p = new Param6<string, float, float, vector, bool, bool>("", 0, 0, "0 0 0", false, false);
 if ( ctx.Read(p) )
 {
 SpawnEntityOnGroundPos(player, p.param1, p.param2, p.param3, p.param4, p.param5, p.param6);
 }
 }
 
 void OnRPCSpawnEntityOnGroundPatternGrid(PlayerBase player, ParamsReadContext ctx)
 {
 auto p = new Param10<string,int, float, float, int, int, float, float, bool, bool>("",0,0,0,0,0,0,0, false, false);
 if ( ctx.Read(p) )
 {
 SpawnEntityOnGroundPatternGrid(player, p.param1, p.param2, p.param3, p.param4, p.param5, p.param6, p.param7, p.param8, p.param9, p.param10);
 }
 }
 void OnRPCSpawnEntity(PlayerBase player, ParamsReadContext ctx)
 {
 #ifdef DEVELOPER
 DevSpawnItemParams p = new DevSpawnItemParams(null,"", 0, 0, false, "", FindInventoryLocationType.ANY);
 if ( ctx.Read(p) )
 {
 EntityAI target = EntityAI.Cast(p.param1);
 PlayerBase playerTarget = PlayerBase.Cast(target);
 
 EntityAI ent = SpawnEntityInInventory( target, p.param2, p.param3, p.param4, p.param5, "", p.param7);
 if (playerTarget && p.param5)
 {
 if (playerTarget.m_PresetSpawned)
 {
 playerTarget.m_PresetSpawned = false;
 playerTarget.m_PresetItems.Clear();
 }
 if (ent)
 {
 playerTarget.m_PresetItems.Insert(ent);
 }
 }
 }
 #endif
 }
 
 void OnSetFreeCameraEvent( PlayerBase player, FreeDebugCamera camera )
 {
 DeveloperFreeCamera.OnSetFreeCameraEvent( player, camera );
 }
 
 void OnSpawnErrorReport (string name)
 {
 PrintString("PluginDeveloper.SpawnEntity() Warning- Cant spawn object: " + name);
 //DumpStack();
 PrintString("PluginDeveloper.SpawnEntity() Warning END");
 }
 
 void SetupSpawnedEntity(PlayerBase player, EntityAI entity, float health, float quantity = -1, bool special = false, string presetName = "")
 {
 #ifdef DEVELOPER
 if (presetName && player.m_PresetSpawned)//this is how we ascertain this is the first item being spawned from a new preset after a previous preset was already spawned in
 {
 player.m_PresetItems.Clear();
 player.m_PresetSpawned = false;//is set to 'true' elsewhere after all the items have been spawned in
 }
 if ( entity.IsInherited( PlayerBase ) ) 
 {
 PlayerBase plr = PlayerBase.Cast( entity );
 plr.OnSpawnedFromConsole();
 }
 else if ( entity.IsInherited(ItemBase) )
 {
 ItemBase item = ItemBase.Cast( entity );
 SetupSpawnedItem(item, health, quantity);
 }
 else if (entity.IsInherited(House))
 {
 entity.PlaceOnSurface();
 vector pos = entity.GetPosition();
 vector ori = GetGame().GetSurfaceOrientation(pos[0], pos[2]);
 entity.SetOrientation(ori);
 }
 if (presetName)
 {
 player.m_PresetItems.Insert(entity);
 }
 
 if ( special )
 {
 auto debugParams = DebugSpawnParams.WithPlayer(player);
 entity.OnDebugSpawnEx(debugParams);
 }
 #endif
 }
 
 
 void SpawnEntityOnGroundPatternGrid( PlayerBase player, string item_name, int count, float health, float quantity, int rows, int columns, float gapRow = 1, float gapColumn = 1, bool special= false, bool withPhysics = false)
 {
 if (!item_name)
 {
 return;
 }
 if ( GetGame().IsServer() )
 { 
 float rowDist = 0; 
 float columnDist = 0;
 
 vector playerPos = player.GetPosition();
 vector camDirForward = player.GetDirection();
 vector camDirRight = camDirForward.Perpend() * -1;
 int countLoop = 0;
 for (int i = 0; i < rows; i++)
 {
 vector posRow = playerPos + camDirForward * rowDist;
 vector offsetSide;
 columnDist = 0;
 for (int j = 0; j < columns; j++)
 {
 offsetSide = camDirRight * columnDist;
 vector placement = posRow + offsetSide;
 float hlth = health * MiscGameplayFunctions.GetTypeMaxGlobalHealth( item_name );
 EntityAI ent = SpawnEntityOnGroundPos(player, item_name, hlth, quantity, placement, special );
 ent.PlaceOnSurface();
 
 InventoryItem item;
 if (Class.CastTo(item, ent) && withPhysics)
 item.ThrowPhysically(null, "0 0 0");
 
 countLoop++;
 if (countLoop == count)
 {
 return;
 }
 columnDist += gapColumn;
 }
 rowDist += gapRow;
 }
 }
 else
 {
 auto params = new Param10<string, int, float, float, int, int, float, float, bool, bool>(item_name, count, health, quantity, rows, columns, gapRow, gapColumn, special, withPhysics);
 player.RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_ON_GROUND_PATTERN_GRID, params, true);
 }
 }
 
 void SpawnItemOnCrosshair(notnull PlayerBase player, string itemName, float health, float quantity, float maxDist = 100, bool allowFreeflight = false, bool special = false, bool withPhysics = false)
 {
 vector from, to;
 if (allowFreeflight && FreeDebugCamera.GetInstance().IsActive())
 {
 from = FreeDebugCamera.GetInstance().GetPosition();
 to = from + FreeDebugCamera.GetInstance().GetDirection() * maxDist;
 }
 else
 {
 from = GetGame().GetCurrentCameraPosition();
 to = from + GetGame().GetCurrentCameraDirection() * maxDist; 
 }
 
 float hitFraction;
 vector start, end;
 vector direction;
 
 vector hitPos, hitNormal;
 Object obj;
 
 PhxInteractionLayers hitMask = PhxInteractionLayers.BUILDING | PhxInteractionLayers.DOOR | PhxInteractionLayers.VEHICLE | PhxInteractionLayers.ROADWAY | PhxInteractionLayers.TERRAIN | PhxInteractionLayers.CHARACTER | PhxInteractionLayers.AI | PhxInteractionLayers.RAGDOLL | PhxInteractionLayers.RAGDOLL_NO_CHARACTER;
 DayZPhysics.RayCastBullet(from, to, hitMask, player, obj, hitPos, hitNormal, hitFraction);
 
 // something is hit
 if (hitPos != vector.Zero)
 {
 SpawnEntityOnGroundPos(player, itemName, health, quantity, hitPos, special, withPhysics);
 }
 }
 
 EntityAI SpawnEntityOnGroundPos( PlayerBase player, string item_name, float health, float quantity, vector pos, bool special = false, bool withPhysics = false)
 {
 if ( GetGame().IsServer() )
 { 
 EntityAI entity = player.SpawnEntityOnGroundPos(item_name, pos);
 if (entity)
 SetupSpawnedEntity(player, entity, health, quantity, special);
 else
 OnSpawnErrorReport(item_name);
 
 InventoryItem item;
 if (Class.CastTo(item, entity) && withPhysics)
 item.ThrowPhysically(null, "0 0 0");
 
 return entity;
 }
 else
 { 
 Param6<string, float, float, vector, bool, bool> params = new Param6<string, float, float, vector, bool, bool>(item_name, health, quantity, pos, special, withPhysics);
 player.RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_ON_GROUND, params, true);
 }
 return NULL;
 }
 EntityAI SpawnEntityOnCursorDir( PlayerBase player, string item_name, float quantity, float distance, float health = -1, bool special = false, string presetName = "", bool withPhysics = false)
 {
 
 if ( GetGame().IsServer() )
 { 
 // Client -> Server Spawning: Server Side
 EntityAI entity = player.SpawnEntityOnGroundOnCursorDir(item_name, distance);
 
 if ( entity )
 {
 if ( !entity.IsBuilding() && health < 0 && entity.GetMaxHealth() > 0)//check for default (-1)
 {
 health = entity.GetMaxHealth();
 }
 SetupSpawnedEntity( player,entity, health, quantity, special, presetName );
 }
 else
 OnSpawnErrorReport( item_name );
 
 InventoryItem item;
 if (Class.CastTo(item, entity) && withPhysics)
 item.ThrowPhysically(null, "0 0 0");
 
 return entity;
 }
 else
 { 
 // Client -> Server Spawning: Client Side
 Param7<string, float, float, float, bool, string, bool> params = new Param7<string, float, float, float, bool, string, bool>(item_name, quantity, distance, health, special, presetName, withPhysics);
 player.RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_ON_CURSOR, params, true);
 }
 return NULL;
 }
 EntityAI SpawnEntityInInventory( notnull EntityAI target, string className, float health, float quantity, bool special = false, string presetName = "", FindInventoryLocationType locationType = FindInventoryLocationType.ANY)
 {
 if (target.IsPlayer())
 {
 return SpawnEntityInPlayerInventory(PlayerBase.Cast(target), className, health, quantity, special, presetName, locationType);
 }
 if ( GetGame().IsServer() )
 {
 InventoryLocation il = new InventoryLocation;
 if (target.GetInventory() && target.GetInventory().FindFirstFreeLocationForNewEntity(className, FindInventoryLocationType.ANY, il))
 {
 EntityAI eai = SpawnEntity(className, il, ECE_IN_INVENTORY, RF_DEFAULT);
 if ( eai && eai.IsInherited(ItemBase) )
 {
 if ( health < 0 )//check for default (-1)
 {
 health = eai.GetMaxHealth();
 }
 ItemBase i = ItemBase.Cast( eai );
 SetupSpawnedItem(i, health, quantity);
 if ( special )
 {
 auto debugParams = DebugSpawnParams.WithPlayer(null);
 eai.OnDebugSpawnEx(debugParams);
 }
 }
 return eai;
 }
 }
 else
 {
 DevSpawnItemParams params = new DevSpawnItemParams(target, className, health, quantity, special, presetName, 0 );
 GetGame().GetPlayer().RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_IN_INVENTORY, params, true, GetGame().GetPlayer().GetIdentity());
 }
 return null;
 }
 
 EntityAI SpawnEntityInPlayerInventory(PlayerBase player, string item_name, float health, float quantity, bool special = false, string presetName = "", FindInventoryLocationType locationType = FindInventoryLocationType.ANY)
 {
 if ( player )
 {
 if ( GetGame().IsServer() )
 {
 if (locationType == FindInventoryLocationType.HANDS && player.GetItemInHands())
 {
 if (!GetGame().IsMultiplayer())
 player.DropItem(player.GetItemInHands());
 else
 player.ServerDropEntity(player.GetItemInHands());
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(SpawnEntityInPlayerInventory,100, false, player, item_name, health, quantity, special, presetName, locationType);
 return null;
 }
 
 
 #ifdef DEVELOPER
 if (GetGame().IsKindOf(item_name, "Transport"))
 {
 EntityAI car = SpawnEntityOnGroundPos(player, item_name, 1, quantity, player.GetPosition());
 
 auto debugParams = DebugSpawnParams.WithPlayer(player);
 car.OnDebugSpawnEx(debugParams);
 
 if (GetGame().IsMultiplayer())
 {
 DayZPlayerSyncJunctures.SendGetInCar(player, car);
 }
 else
 {
 player.SetGetInVehicleDebug(car);
 }
 
 return car;
 }
 #endif
 
 InventoryLocation il = new InventoryLocation;
 if (player.GetInventory() && player.GetInventory().FindFirstFreeLocationForNewEntity(item_name, locationType, il))
 {
 Weapon_Base wpn = Weapon_Base.Cast(il.GetParent());
 bool is_mag = il.GetSlot() == InventorySlots.MAGAZINE || il.GetSlot() == InventorySlots.MAGAZINE2 || il.GetSlot() == InventorySlots.MAGAZINE3;
 if (wpn && is_mag)
 {
 vector pos = player.GetPosition();
 EntityAI eai_gnd = SpawnEntityOnGroundPos(player, item_name, health, quantity, pos);
 Magazine mag_gnd = Magazine.Cast(eai_gnd);
 if (mag_gnd && player.GetWeaponManager().CanAttachMagazine(wpn, mag_gnd))
 {
 player.GetWeaponManager().AttachMagazine(mag_gnd);
 }
 return eai_gnd;
 }
 else
 {
 EntityAI eai = SpawnEntity(item_name, il, ECE_IN_INVENTORY, RF_DEFAULT);
 if ( eai && eai.IsInherited(ItemBase) )
 {
 if ( health < 0 )//check for default (-1)
 {
 health = eai.GetMaxHealth();
 }
 ItemBase i = ItemBase.Cast( eai );
 SetupSpawnedItem(i, health, quantity);
 if ( special )
 {
 auto debugParams2 = DebugSpawnParams.WithPlayer(player);
 eai.OnDebugSpawnEx(debugParams2);
 }
 }
 return eai;
 }
 }
 else
 OnSpawnErrorReport(item_name);
 return NULL;
 }
 else
 { 
 // Client -> Server Spawning: Client Side
 DevSpawnItemParams params = new DevSpawnItemParams(player, item_name, health, quantity, special, presetName, locationType );
 player.RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_IN_INVENTORY, params, true);
 }
 }
 return NULL;
 }
 EntityAI SpawnEntityAsAttachment (PlayerBase player, EntityAI parent, string att_name, float health, float quantity)
 {
 if ( GetGame().IsServer() )
 {
 Weapon_Base wpn = Weapon_Base.Cast(parent);
 if (wpn)
 {
 GameInventory inventory = parent.GetInventory();
 return inventory.CreateInInventory(att_name);
 /*
 vector pos = player.GetPosition();
 EntityAI eai_gnd = SpawnEntityOnGroundPos(player, att_name, health, quantity, pos);
 Magazine mag_gnd = Magazine.Cast(eai_gnd);
 if (mag_gnd && player.GetWeaponManager().CanAttachMagazine(wpn, mag_gnd))
 {
 player.GetWeaponManager().AttachMagazine(mag_gnd);
 }
 return eai_gnd;
 */
 }
 else
 {
 EntityAI eai = parent.GetInventory().CreateAttachment(att_name);
 if (eai)
 {
 if ( eai.IsInherited(ItemBase) )
 {
 ItemBase i = ItemBase.Cast( eai );
 SetupSpawnedItem(ItemBase.Cast( eai ), health, quantity);
 }
 return eai;
 }
 else
 OnSpawnErrorReport(att_name);
 }
 return NULL;
 }
 else
 { 
 // Client -> Server Spawning: Client Side
 Param3<string, float, float> params = new Param3<string, float, float>(att_name, health, quantity);
 player.RPCSingleParam(ERPCs.DEV_RPC_SPAWN_ITEM_AS_ATTACHMENT, params, true);
 }
 return NULL;
 }
 
 EntityAI SpawnFromClipboard()
 {
 UIScriptedMenu menu_curr = GetGame().GetUIManager().GetMenu();
 
 if ( menu_curr == NULL )
 { 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if ( player )
 {
 if ( !GetGame().GetWorld().Is3rdPersonDisabled() )
 {
 player.SetIsInThirdPerson(!player.IsInThirdPerson());//this counters the effect of switching camera through pressing the 'V' key
 }
 
 vector pos_player = player.GetPosition();
 
 // Get item from clipboard
 string clipboard;
 GetGame().CopyFromClipboard(clipboard);
 
 if (!clipboard.Contains(","))
 {
 //single item
 if (DeveloperFreeCamera.IsFreeCameraEnabled())
 SpawnItemOnCrosshair(player, clipboard.Trim(), -1, 1, 40, true );
 else
 SpawnEntityOnCursorDir(player, clipboard.Trim(), 1, 1);
 }
 else
 {
 TStringArray items = new TStringArray;
 clipboard.Split( ",", items );
 
 foreach (string item:items)
 {
 if (DeveloperFreeCamera.IsFreeCameraEnabled())
 SpawnItemOnCrosshair(player, item.Trim(), -1, 1, 40, true );
 else
 SpawnEntityOnCursorDir(player, item.Trim(), 1, 1);
 }
 }
 
 }
 }
 
 return NULL;
 }
 
 // Clear Entity Inventory
 void ClearInventory(EntityAI entity)
 {
 if ( GetGame().IsServer() )
 {
 entity.ClearInventory();
 }
 else
 {
 Param1<int> params = new Param1<int>(0);
 entity.RPCSingleParam(ERPCs.DEV_RPC_CLEAR_INV, params, true);
 }
 } 
 
 void ToggleHelpScreen()
 {
 if ( g_Game.GetUIManager().GetMenu() == NULL )
 {
 g_Game.GetUIManager().EnterScriptedMenu(MENU_HELP_SCREEN, NULL);
 }
 else if ( g_Game.GetUIManager().IsMenuOpen(MENU_HELP_SCREEN) )
 {
 g_Game.GetUIManager().Back();
 }
 }
 
 void ToggleScriptConsole()
 {
 if (GetGame() != null && !g_Game.IsLoading() && GetGame().GetMission())
 {
 if ( g_Game.GetUIManager().GetMenu() == NULL )
 {
 m_ScriptConsole = g_Game.GetUIManager().EnterScriptedMenu(MENU_SCRIPTCONSOLE, NULL);
 GetGame().GetMission().AddActiveInputExcludes({"menu"});
 
 }
 else if ( g_Game.GetUIManager().IsMenuOpen(MENU_SCRIPTCONSOLE) )
 {
 g_Game.GetUIManager().Back();
 GetGame().GetMission().RemoveActiveInputExcludes({"menu"},true);
 }
 }
 }
 
 // Mission Editor
 void ToggleMissionLoader()
 {
 if ( g_Game.GetUIManager().IsMenuOpen(MENU_MISSION_LOADER) )
 {
 g_Game.GetUIManager().Back();
 GetGame().GetMission().RemoveActiveInputExcludes({"menu"},true);
 return;
 }
 
 if ( g_Game.GetUIManager().GetMenu() )
 g_Game.GetUIManager().GetMenu().Close();
 
 g_Game.GetUIManager().EnterScriptedMenu(MENU_MISSION_LOADER, NULL);
 GetGame().GetMission().AddActiveInputExcludes({"menu"});
 
 
 }
 
 // Script Editor History
 private void ScriptHistoryNext()
 {
 // Console key press
 if ( g_Game.GetUIManager().IsMenuOpen(MENU_SCRIPTCONSOLE) )
 {
 CallMethod(CALL_ID_SCR_CNSL_HISTORY_NEXT, NULL);
 }
 }
 
 private void ScriptHistoryBack()
 {
 // Console key press
 if ( g_Game.GetUIManager().IsMenuOpen(MENU_SCRIPTCONSOLE) )
 {
 CallMethod(CALL_ID_SCR_CNSL_HISTORY_BACK, NULL);
 }
 }
 
 private bool IsIngame()
 {
 UIScriptedMenu menu_curr = GetGame().GetUIManager().GetMenu();
 
 if ( menu_curr == NULL )
 { 
 return true;
 }
 
 return false;
 }
 
 private bool IsInConsole()
 {
 UIScriptedMenu menu_curr = GetGame().GetUIManager().GetMenu();
 
 if ( menu_curr != NULL && menu_curr.GetID() == MENU_SCRIPTCONSOLE )
 { 
 return true;
 }
 
 return false;
 }
 
 // Tools
 int QuickSortPartition( TStringArray arr, int left, int right )
 {
 string pivot = arr.Get( left );
 int i = left;
 int j = right + 1;
 string temp;
 
 while ( true )
 {
 while ( true )
 { 
 i++; 
 if ( i > right || arr.Get(i) > pivot )
 {
 break;
 }
 }
 
 while ( true )
 {
 j--; 
 if ( arr.Get(j) <= pivot )
 {
 break;
 }
 }
 
 if ( i >= j ) 
 {
 break;
 }
 
 temp = arr.Get( i ); 
 arr.Set( i, arr.Get(j) ); 
 arr.Set( j, temp );
 }
 
 temp = arr.Get( left ); 
 arr.Set( left, arr.Get(j) );
 arr.Set( j, temp );
 
 return j;
 }
 
 void QuickSort( TStringArray arr, int left, int right )
 {
 int j;
 
 if ( left < right ) 
 {
 j = QuickSortPartition( arr, left, right );
 QuickSort( arr, left, j - 1 );
 QuickSort( arr, j + 1, right );
 }
 }
 
 void SortStringArray( TStringArray arr )
 {
 QuickSort( arr, 0, arr.Count() - 1 );
 }
 
 void ResetGUI()
 {
 if ( GetGame() && GetGame().GetMission() )
 {
 GetGame().GetMission().ResetGUI();
 }
 }
 
 static void SetDeveloperItemClientEx(notnull Object entity, bool getFocus = false)
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 if (getFocus)
 {
 GetGame().GetInput().ChangeGameFocus(1);
 GetGame().GetUIManager().ShowUICursor(true);
 }
 
 if (GetGame().IsMultiplayer())
 {
 GetGame().RPCSingleParam(GetGame().GetPlayer(), ERPCs.DEV_SET_DEV_ITEM, new Param1<Object>(entity), true, GetGame().GetPlayer().GetIdentity());
 }
 else
 {
 PluginItemDiagnostic mid2 = PluginItemDiagnostic.Cast(GetPlugin(PluginItemDiagnostic));
 mid2.RegisterDebugItem(entity, player);
 }
 #ifdef DEVELOPER
 SetDebugDeveloper_item(entity);
 #endif
 }
 
 void SetDeveloperItemClient()
 {
 #ifdef DEVELOPER
 Object entity;
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 FreeDebugCamera debugCam = FreeDebugCamera.GetInstance();
 if (debugCam && debugCam.GetCurrentCamera())
 {
 entity = debugCam.GetCrosshairObject();
 }
 else
 {
 
 if (player && player.GetActionManager())
 {
 ActionTarget at = player.GetActionManager().FindActionTarget();
 entity = at.GetObject();
 }
 }
 
 if (entity)
 {
 SetDeveloperItemClientEx(entity, true);
 }
 #endif
 }
}