1673 lines
40 KiB
Ucode
1673 lines
40 KiB
Ucode
// BUGS:
|
|
// 1. Clicking at the void space of actors list doesn't refresh actor's info
|
|
// 2. CullDistance can't be selected if moCheckBox under it was clicked before
|
|
// 3. Cam't select cullDistance with just typing it and licking hitbox (the single way now - to press enter)
|
|
|
|
// IDEAS
|
|
// 1. Allow to use projectile as a spec
|
|
// 2. Disable skybox?
|
|
// 3. Highlighting of the save button depends on editBox
|
|
|
|
class a_VisibilityHandler extends Actor
|
|
config(HideMut);
|
|
|
|
var() GUIList cachedActors; // The most important array here
|
|
|
|
var() Actor pickedActor;
|
|
|
|
var() bool pickedActorOriginalBHidden; //this variable is needed if bSelectActor is true
|
|
//since timer change bHidden all the time
|
|
//original bHidden have to be stored here
|
|
|
|
var() bool bShowDirectionToActor,
|
|
bSelectActor,
|
|
bProjCollidesWithHiddenActor,
|
|
bDiscoveryMode,
|
|
bShowBlockingVolumes,
|
|
bShowZombieZoneVolumes,
|
|
bShowZombieVolumes,
|
|
bShowAnotherVolumes,
|
|
bShowSpriteActors,
|
|
bApplyCullDistanceForEngineActors,
|
|
bHideTerrain,
|
|
bHideCoronas,
|
|
bDisableFog,
|
|
bApplyCullDistanceForMeshActors;
|
|
|
|
var() config bool bHideEmitters,
|
|
bHideActorsWithMeshes,
|
|
bShowPresetsForCurrentMapOnly;
|
|
|
|
var() HideShopVolume navigationShop;
|
|
var() ShopVolume originalShop;
|
|
|
|
var() GUIScrollText discoveryLog, presetInsides;
|
|
|
|
struct IntAndActor
|
|
{
|
|
var Actor a;
|
|
var int i;
|
|
};
|
|
|
|
var() array<IntAndActor> cachedEngineActors; //cull distance
|
|
var() array<IntAndActor> cachedMeshActors; //cull distance
|
|
var() array<NavigationPoint> cachedNavPoints; // navigartion points
|
|
|
|
var() config int cullDistanceEngineActors;
|
|
var() config int cullDistanceMeshActors;
|
|
|
|
struct OriginalValues
|
|
{
|
|
var Actor a;
|
|
var bool bBlockActors;
|
|
var bool bBlockZeroExtentTraces;
|
|
var bool bCollideActors;
|
|
};
|
|
|
|
var() array<OriginalValues> changedActors;
|
|
|
|
struct ZoneInfoBackup
|
|
{
|
|
var ZoneInfo zoneInfo;
|
|
var int distanceFogStart;
|
|
var int distanceFogEnd;
|
|
};
|
|
|
|
var() array<TerrainInfo.DecorationLayer> terrainBackup;
|
|
var() array<Actor> coronasBackup;
|
|
var() array<ZoneInfoBackup> fogBackup;
|
|
|
|
var string colorR, colorG, colorB, colorY, colorN;
|
|
|
|
var() GUIList presetsList;
|
|
|
|
|
|
simulated function postBeginPlay()
|
|
{
|
|
super.postBeginPlay();
|
|
|
|
colorR = chr(27)$chr(255)$chr(70)$chr(70);
|
|
colorY = chr(27)$chr(255)$chr(255)$chr(70);
|
|
colorG = chr(27)$chr(70)$chr(255)$chr(70);
|
|
colorB = chr(27)$chr(70)$chr(70)$chr(255);
|
|
colorN = chr(27)$chr(70)$chr(70)$chr(70);
|
|
|
|
navigationShop = spawn(class'HideShopVolume');
|
|
|
|
cachedActors = new(none) class'GUIList';
|
|
discoveryLog = new(none) class'GUIScrollText';
|
|
presetsList = new(none) class'GUIList';
|
|
presetInsides = new(none) class'GUIScrollText';
|
|
|
|
initPresetsList();
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// WORKING WITH PRESETS
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function deletePreset(string presetName)
|
|
{
|
|
local HideMenuPreset presetToDelete;
|
|
local string actualPresetName, dev_null;
|
|
|
|
if(presetName == "")
|
|
{
|
|
logMessage("You haven't type a single character of the preset's name.");
|
|
return;
|
|
}
|
|
|
|
presetToDelete = new(none, presetName) class'HideMenuPreset';
|
|
presetToDelete.clearConfig();
|
|
|
|
initPresetsList();
|
|
|
|
presetInsides.setContent("");
|
|
presetInsides.newText = "";
|
|
|
|
divide(presetName, "@", actualPresetName, dev_null);
|
|
logMessage("Preset \""$actualPresetName$"\" was successfully deleted.");
|
|
}
|
|
|
|
|
|
simulated function bool savePreset(string presetName)
|
|
{
|
|
local HideMenuPreset presetToSave;
|
|
local int i;
|
|
local string presetDescription;
|
|
|
|
if(presetName == "")
|
|
{
|
|
logMessage("You haven't type a single character of the preset's name.");
|
|
return false;
|
|
}
|
|
|
|
if(inStr(presetName, " //") != -1)
|
|
divide(presetName, " //", presetName, presetDescription);
|
|
else
|
|
divide(presetName, "//", presetName, presetDescription);
|
|
|
|
if(inStr(presetName, " ") != -1 || inStr(presetName, "[") != -1 ||
|
|
inStr(presetName, "]") != -1 || inStr(presetName, "@") != -1)
|
|
{
|
|
logMessage("Preset's name can't contain spaces and characters '@', '[', ']'.");
|
|
return false;
|
|
}
|
|
|
|
presetToSave = new(none, presetName$"@"$getCurrentMapName()) class'HideMenuPreset';
|
|
presetToSave.clearConfig();
|
|
|
|
if(presetDescription != "")
|
|
presetToSave.presetDescription = presetDescription;
|
|
|
|
for (i = 0; i < cachedActors.elements.length; i++)
|
|
{
|
|
if(cachedActors.elements[i].extraData != none)
|
|
presetToSave.uselessActors[presetToSave.uselessActors.length] = getActorName(actor(cachedActors.elements[i].extraData));
|
|
}
|
|
|
|
presetToSave.SaveConfig();
|
|
|
|
initPresetsList();
|
|
|
|
logMessage("Preset \""$presetName$"\" was successfully saved.");
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
simulated function selectCurrentPreset()
|
|
{
|
|
local string presetName;
|
|
local HideMenuPreset currentPreset;
|
|
local int i;
|
|
local bool bFirstString; // thanks TWI for inspiring me to create my own bicycle
|
|
|
|
// User selected nothing
|
|
if(presetsList.calculateIndex(true) == -1)
|
|
{
|
|
presetInsides.setContent("");
|
|
presetInsides.newText = "";
|
|
return;
|
|
}
|
|
|
|
presetName = presetsList.elements[presetsList.calculateIndex(true)].ExtraStrData;
|
|
|
|
currentPreset = new(none, presetName) class'HideMenuPreset';
|
|
|
|
presetInsides.setContent("");
|
|
presetInsides.newText = "";
|
|
|
|
if(currentPreset.presetDescription != "")
|
|
{
|
|
presetInsides.setContent(currentPreset.presetDescription$"|-----------------|");
|
|
bFirstString = false;
|
|
}
|
|
|
|
for (i = 0; i < currentPreset.uselessActors.length; i++)
|
|
{
|
|
if(bFirstString)
|
|
presetInsides.setContent(currentPreset.uselessActors[i]$"|");
|
|
else
|
|
presetInsides.newText $= currentPreset.uselessActors[i]$"|";
|
|
}
|
|
}
|
|
|
|
|
|
simulated function loadPreset(string presetName)
|
|
{
|
|
local HideMenuPreset currentPreset;
|
|
local int i;
|
|
local Actor a;
|
|
local string actorName;
|
|
|
|
currentPreset = new(none, presetName) class'HideMenuPreset';
|
|
|
|
if(currentPreset == none)
|
|
{
|
|
debugMessage("loadPreset(): Preset \""$presetName$"\" can't be loaded.");
|
|
return;
|
|
}
|
|
|
|
foreach AllActors(class'actor', a)
|
|
{
|
|
if(!a.bHidden)
|
|
if(a.mesh != none || a.staticMesh != none || a.drawType == DT_Particle)
|
|
if((a.bNoDelete || a.bStatic) && !a.bDeleteMe)
|
|
{
|
|
actorName = getActorName(a);
|
|
|
|
for(i = currentPreset.uselessActors.length - 1; i >= 0; i--)
|
|
if(actorName == currentPreset.uselessActors[i])
|
|
{
|
|
hideActor(a);
|
|
currentPreset.uselessActors.remove(i, 1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
simulated function string getCurrentMapName()
|
|
{
|
|
local string mapName;
|
|
local int i;
|
|
|
|
mapName = class'KFGameType'.static.getCurrentMapName(getController().level);
|
|
|
|
//in case of 255.255.225.228:8080/KF-WestLondon
|
|
i = (inStr(mapName, "/") + 1);
|
|
mapName = mid(mapName, i, len(mapName) - i);
|
|
|
|
return mapName;
|
|
}
|
|
|
|
|
|
simulated function initPresetsList()
|
|
{
|
|
local array<string> presetsNames;
|
|
local int i;
|
|
local string presetName, presetMap, currentMap;
|
|
|
|
currentMap = getCurrentMapName();
|
|
|
|
presetsNames = getPerObjectNames("HideMut", string(class'HideMenuPreset'.name));
|
|
|
|
presetsList.clear();
|
|
|
|
for(i = 0; i < presetsNames.length; i++)
|
|
{
|
|
divide(presetsNames[i], "@", presetName, presetMap);
|
|
|
|
if(bShowPresetsForCurrentMapOnly)
|
|
{
|
|
if(caps(presetMap) == caps(currentMap))
|
|
presetsList.add(presetName, , presetsNames[i]);
|
|
}
|
|
else
|
|
{
|
|
presetsList.add(presetName@colorN$"["$presetMap$"]", , presetsNames[i]);
|
|
}
|
|
}
|
|
|
|
presetsList.index = -1;
|
|
clearPresetInsides();
|
|
}
|
|
|
|
|
|
simulated function linkListsToMenu(GUIList newCachedActors, GUIList newPresetsList, GUIScrollText newDiscoveryLog, GUIScrollText newPresetInsides)
|
|
{
|
|
local int i;
|
|
|
|
if(cachedActors != newCachedActors)
|
|
{
|
|
for (i = 0; i < cachedActors.elements.length; i++)
|
|
{
|
|
newCachedActors.add(cachedActors.elements[i].item, , cachedActors.elements[i].extraStrData);
|
|
}
|
|
cachedActors.clear();
|
|
cachedActors = newCachedActors;
|
|
}
|
|
|
|
if(presetsList != newPresetsList)
|
|
{
|
|
for (i = 0; i < presetsList.elements.length; i++)
|
|
{
|
|
newPresetsList.add(presetsList.elements[i].item, , presetsList.elements[i].extraStrData);
|
|
}
|
|
presetsList.clear();
|
|
presetsList = newPresetsList;
|
|
}
|
|
|
|
if(discoveryLog != newDiscoveryLog)
|
|
{
|
|
newDiscoveryLog.setContent(discoveryLog.newText);
|
|
discoveryLog.setContent("");
|
|
discoveryLog = newDiscoveryLog;
|
|
}
|
|
|
|
if(presetInsides != newPresetInsides)
|
|
{
|
|
newPresetInsides.setContent(presetInsides.newText);
|
|
presetInsides.setContent("");
|
|
presetInsides = newPresetInsides;
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// HELPING FUNCTIONS
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function debugMessage(string e)
|
|
{
|
|
if(discoveryLog.newText != "")
|
|
discoveryLog.newText $= "|";
|
|
discoveryLog.NewText $= stripColor(e);
|
|
|
|
getController().myHUD.AddTextMessage(colorR$e, class'LocalMessage', getController().playerReplicationInfo);
|
|
}
|
|
|
|
|
|
simulated function logMessage(string e)
|
|
{
|
|
if(discoveryLog.newText != "")
|
|
discoveryLog.newText $= "|";
|
|
discoveryLog.NewText $= stripColor(e);
|
|
|
|
getController().myHUD.AddTextMessage(e, class'LocalMessage', getController().playerReplicationInfo);
|
|
}
|
|
|
|
|
|
function string stripColor(string s)
|
|
{
|
|
local int p;
|
|
|
|
p = inStr(s, chr(27));
|
|
while(p >= 0)
|
|
{
|
|
s = left(s, p)$mid(s, p + 4);
|
|
p = inStr(s, chr(27));
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
simulated function bool isEverythingAlright()
|
|
{
|
|
if(KFPlayerController(owner) != none)
|
|
return true;
|
|
else
|
|
{
|
|
setOwner(KFPlayerController(level.getLocalPlayerController()));
|
|
if(KFPlayerController(owner) != none)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
simulated function KFPlayerController getController()
|
|
{
|
|
return KFPlayerController(owner);
|
|
}
|
|
|
|
|
|
simulated function bool isCached(Actor a)
|
|
{
|
|
local int i;
|
|
|
|
for(i = 0; i < cachedActors.elements.length; i++)
|
|
if(cachedActors.elements[i].extraData == a)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
simulated function int findCachedActor(Actor a)
|
|
{
|
|
local int i;
|
|
|
|
for(i = 0; i < cachedActors.elements.length; i++)
|
|
if(cachedActors.elements[i].extraData == a)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
simulated function string getActorName(Actor a)
|
|
{
|
|
local string actorName, dev_null;
|
|
|
|
divide(string(a), ".", dev_null, actorName);
|
|
|
|
return actorName;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// HIDING SHIT
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function setCullDistanceForMeshActors(int i)
|
|
{
|
|
cullDistanceMeshActors = i;
|
|
applyCullDistanceForMeshActors();
|
|
}
|
|
|
|
|
|
simulated function applyCullDistanceForMeshActors()
|
|
{
|
|
local int i;
|
|
local Actor a;
|
|
|
|
if(bApplyCullDistanceForMeshActors)
|
|
{
|
|
if(cachedMeshActors.length > 0)
|
|
{
|
|
if(cachedMeshActors[0].a.cullDistance == cullDistanceMeshActors)
|
|
return; //this cull distance is already applied. No need to do it for 2nd time
|
|
|
|
for (i = 0; i < cachedMeshActors.length; i++)
|
|
cachedMeshActors[i].a.cullDistance = cullDistanceMeshActors;
|
|
}
|
|
else
|
|
foreach allActors(class'actor', a)
|
|
if(a.mesh != none || a.staticMesh != none)
|
|
if((a.bNoDelete || a.bStatic) && !a.bDeleteMe)
|
|
{
|
|
cachedMeshActors.length = i + 1;
|
|
cachedMeshActors[i].i = a.cullDistance;
|
|
cachedMeshActors[i].a = a;
|
|
a.cullDistance = cullDistanceMeshActors;
|
|
i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0; i < cachedMeshActors.length; i++)
|
|
{
|
|
cachedMeshActors[i].a.cullDistance = cachedMeshActors[i].i;
|
|
}
|
|
|
|
cachedMeshActors.remove(0, cachedMeshActors.length);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function disableFog()
|
|
{
|
|
local ZoneInfo zi;
|
|
local int i;
|
|
|
|
if(bDisableFog)
|
|
{
|
|
if(fogBackup.length > 0)
|
|
return;
|
|
|
|
foreach allActors(class'ZoneInfo', zi)
|
|
{
|
|
fogBackup.length = i + 1;
|
|
|
|
fogBackup[i].distanceFogStart = zi.distanceFogStart;
|
|
fogBackup[i].distanceFogEnd = zi.distanceFogEnd;
|
|
fogBackup[i].zoneInfo = zi;
|
|
zi.distanceFogStart = 0;
|
|
zi.distanceFogEnd = 100000;
|
|
|
|
i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < fogBackup.length; i++)
|
|
{
|
|
fogBackup[i].zoneInfo.distanceFogStart = fogBackup[i].distanceFogStart;
|
|
fogBackup[i].zoneInfo.distanceFogEnd = fogBackup[i].distanceFogEnd;
|
|
}
|
|
fogBackup.remove(0, fogBackup.length);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function hideCoronas()
|
|
{
|
|
local Actor a;
|
|
local int i;
|
|
|
|
if(bHideCoronas)
|
|
{
|
|
foreach allActors(class'Actor', a)
|
|
{
|
|
if(a.bCorona)
|
|
{
|
|
a.bCorona = false;
|
|
coronasBackup[coronasBackup.length] = a;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < coronasBackup.length; i++)
|
|
{
|
|
coronasBackup[i].bCorona = true;
|
|
}
|
|
coronasBackup.remove(0, coronasBackup.length);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function hideTerrain()
|
|
{
|
|
local TerrainInfo ti;
|
|
local int i;
|
|
|
|
forEach allActors(class'TerrainInfo', ti)
|
|
break;
|
|
|
|
if(ti == none)
|
|
{
|
|
logMessage("There's no terrain on this map.");
|
|
return;
|
|
}
|
|
|
|
if(bHideTerrain)
|
|
{
|
|
terrainBackup.length = ti.decolayers.length;
|
|
|
|
for(i = ti.decolayers.length - 1; i >= 0 ; i--)
|
|
{
|
|
terrainBackup[i] = ti.decolayers[i];
|
|
ti.decolayers.remove(i, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ti.decolayers.length = terrainBackup.length;
|
|
|
|
for(i = terrainBackup.length - 1; i >= 0 ; i--)
|
|
{
|
|
ti.decolayers[i] = terrainBackup[i];
|
|
terrainBackup.remove(i, 1);
|
|
}
|
|
}
|
|
|
|
// terrainBackup
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// ENGINE ACTORS
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function setCullDistanceForEngineActors(int i)
|
|
{
|
|
cullDistanceEngineActors = i;
|
|
applyCullDistanceForEngineActors();
|
|
}
|
|
|
|
|
|
simulated function applyCullDistanceForEngineActors()
|
|
{
|
|
local int i;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
{
|
|
for(i = 0; i < cachedEngineActors.length; i++)
|
|
{
|
|
cachedEngineActors[i].a.cullDistance = cullDistanceEngineActors;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i = 0; i < cachedEngineActors.length; i++)
|
|
{
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showBlockingVolumes()
|
|
{
|
|
local BlockingVolume bv;
|
|
local int i, j;
|
|
|
|
if(bShowBlockingVolumes)
|
|
{
|
|
i = cachedEngineActors.length;
|
|
forEach allActors(class'BlockingVolume', bv)
|
|
{
|
|
if(KFZombieZoneVolume(bv) != none)
|
|
continue;
|
|
|
|
if(bv.bHidden)
|
|
{
|
|
cachedEngineActors.length = i + 1;
|
|
cachedEngineActors[i].i = bv.cullDistance;
|
|
cachedEngineActors[i].a = bv;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
bv.cullDistance = cullDistanceEngineActors;
|
|
|
|
bv.bHidden = false;
|
|
bv.resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
}
|
|
logMessage(j@"BlockingVolumes were unhided.");
|
|
}
|
|
else
|
|
for(i = cachedEngineActors.length - 1; i >= 0; i--)
|
|
if(BlockingVolume(cachedEngineActors[i].a) != none)
|
|
{
|
|
if(KFZombieZoneVolume(cachedEngineActors[i].a) != none)
|
|
continue;
|
|
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
|
|
cachedEngineActors[i].a.bHidden = true;
|
|
cachedEngineActors[i].a.resetStaticFilterState();
|
|
|
|
cachedEngineActors.remove(i, 1);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showZombieZoneVolumes()
|
|
{
|
|
local KFZombieZoneVolume zzv;
|
|
local int i, j;
|
|
|
|
if(bShowZombieZoneVolumes)
|
|
{
|
|
i = cachedEngineActors.length;
|
|
forEach allActors(class'KFZombieZoneVolume', zzv)
|
|
{
|
|
if(zzv.bHidden)
|
|
{
|
|
cachedEngineActors.length = i + 1;
|
|
cachedEngineActors[i].i = zzv.cullDistance;
|
|
cachedEngineActors[i].a = zzv;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
zzv.cullDistance = cullDistanceEngineActors;
|
|
|
|
zzv.bHidden = false;
|
|
zzv.resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
}
|
|
logMessage(j@"KFZombieZoneVolumes were unhided.");
|
|
}
|
|
else
|
|
for(i = cachedEngineActors.length - 1; i >= 0; i--)
|
|
if(KFZombieZoneVolume(cachedEngineActors[i].a) != none)
|
|
{
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
|
|
cachedEngineActors[i].a.bHidden = true;
|
|
cachedEngineActors[i].a.resetStaticFilterState();
|
|
|
|
cachedEngineActors.remove(i, 1);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showZombieVolumes()
|
|
{
|
|
local ZombieVolume zv;
|
|
local int i, j;
|
|
|
|
if(bShowZombieVolumes)
|
|
{
|
|
i = cachedEngineActors.length;
|
|
forEach allActors(class'ZombieVolume', zv)
|
|
{
|
|
if(zv.bHidden)
|
|
{
|
|
cachedEngineActors.length = i + 1;
|
|
cachedEngineActors[i].i = zv.cullDistance;
|
|
cachedEngineActors[i].a = zv;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
zv.cullDistance = cullDistanceEngineActors;
|
|
|
|
zv.bHidden = false;
|
|
zv.resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
}
|
|
logMessage(j@"ZombieVolumes were unhided.");
|
|
}
|
|
else
|
|
for(i = cachedEngineActors.length - 1; i >= 0; i--)
|
|
if(ZombieVolume(cachedEngineActors[i].a) != none)
|
|
{
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
|
|
cachedEngineActors[i].a.bHidden = true;
|
|
cachedEngineActors[i].a.resetStaticFilterState();
|
|
|
|
cachedEngineActors.remove(i, 1);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showAnotherVolumes()
|
|
{
|
|
local Volume v;
|
|
local int i, j;
|
|
|
|
if(bShowAnotherVolumes)
|
|
{
|
|
i = cachedEngineActors.length;
|
|
forEach allActors(class'Volume', v)
|
|
{
|
|
if(BlockingVolume(v) != none || ZombieVolume(v) != none)
|
|
continue;
|
|
|
|
if(v.bHidden)
|
|
{
|
|
cachedEngineActors.length = i + 1;
|
|
cachedEngineActors[i].i = v.cullDistance;
|
|
cachedEngineActors[i].a = v;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
v.cullDistance = cullDistanceEngineActors;
|
|
|
|
v.bHidden = false;
|
|
v.resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
}
|
|
logMessage(j@"another volumes were unhided.");
|
|
}
|
|
else
|
|
for(i = cachedEngineActors.length - 1; i >= 0; i--)
|
|
if(Volume(cachedEngineActors[i].a) != none)
|
|
{
|
|
if(BlockingVolume(cachedEngineActors[i].a) != none || ZombieVolume(cachedEngineActors[i].a) != none)
|
|
continue;
|
|
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
|
|
cachedEngineActors[i].a.bHidden = true;
|
|
cachedEngineActors[i].a.resetStaticFilterState();
|
|
|
|
cachedEngineActors.remove(i, 1);
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showSpriteActors()
|
|
{
|
|
local Actor a;
|
|
local int i, j;
|
|
|
|
if(bShowSpriteActors)
|
|
{
|
|
i = cachedEngineActors.length;
|
|
forEach allActors(class'Actor', a)
|
|
{
|
|
if(a.DrawType != DT_Sprite)
|
|
continue;
|
|
|
|
if(a.bHidden)
|
|
{
|
|
cachedEngineActors.length = i + 1;
|
|
cachedEngineActors[i].i = a.cullDistance;
|
|
cachedEngineActors[i].a = a;
|
|
|
|
if(bApplyCullDistanceForEngineActors)
|
|
a.cullDistance = cullDistanceEngineActors;
|
|
|
|
a.bHidden = false;
|
|
a.resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
}
|
|
logMessage(j@"sprite actors were unhided.");
|
|
}
|
|
else
|
|
{
|
|
for (i = cachedEngineActors.length - 1; i >= 0; i--)
|
|
{
|
|
if (cachedEngineActors[i].a.DrawType == DT_Sprite)
|
|
{
|
|
cachedEngineActors[i].a.cullDistance = cachedEngineActors[i].i;
|
|
cachedEngineActors[i].a.bHidden = true;
|
|
cachedEngineActors[i].a.resetStaticFilterState();
|
|
cachedEngineActors.remove(i, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
simulated function showPathNodes(optional bool b)
|
|
{
|
|
local NavigationPoint np;
|
|
local int i, j;
|
|
|
|
if (b)
|
|
{
|
|
forEach allActors(class'NavigationPoint', np)
|
|
{
|
|
if (np == none)
|
|
continue;
|
|
|
|
cachedNavPoints.length = i + 1;
|
|
cachedNavPoints[i] = np;
|
|
cachedNavPoints[i].bHidden = false;
|
|
cachedNavPoints[i].resetStaticFilterState();
|
|
|
|
j++;
|
|
i++;
|
|
}
|
|
logMessage(j $ " pathnodes were unhided.");
|
|
}
|
|
else
|
|
{
|
|
for (i = cachedNavPoints.length - 1; i >= 0; i--)
|
|
{
|
|
cachedNavPoints[i].bHidden = true;
|
|
cachedNavPoints[i].resetStaticFilterState();
|
|
cachedNavPoints.remove(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// RANDOM SHIT
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function sortCachedActors()
|
|
{
|
|
local Object extraData;
|
|
local string item;
|
|
local int i, j;
|
|
local string actorName1, actorName2, dev_null;
|
|
|
|
if(cachedActors.elements.length <= 1)
|
|
return;
|
|
|
|
for (i = 0; i < cachedActors.elements.length - 1; i++)
|
|
for (j = i + 1; j < cachedActors.elements.length; j++)
|
|
{
|
|
if(cachedActors.elements[i].extraData.class == cachedActors.elements[j].extraData.class)
|
|
{
|
|
divide(string(cachedActors.elements[i].extraData.class), ".", dev_null, actorName1);
|
|
divide(string(cachedActors.elements[j].extraData.class), ".", dev_null, actorName2);
|
|
if(int(repl(stripColor(cachedActors.elements[i].item), actorName1, "")) >
|
|
int(repl(stripColor(cachedActors.elements[j].item), actorName2, "")))
|
|
{
|
|
extraData = cachedActors.elements[i].extraData;
|
|
item = cachedActors.elements[i].item;
|
|
|
|
cachedActors.elements[i].extraData = cachedActors.elements[j].extraData;
|
|
cachedActors.elements[i].item = cachedActors.elements[j].item;
|
|
|
|
cachedActors.elements[j].extraData = extraData;
|
|
cachedActors.elements[j].item = item;
|
|
}
|
|
}
|
|
else if(cachedActors.elements[i].item > cachedActors.elements[j].item)
|
|
{
|
|
extraData = cachedActors.elements[i].extraData;
|
|
item = cachedActors.elements[i].item;
|
|
|
|
cachedActors.elements[i].extraData = cachedActors.elements[j].extraData;
|
|
cachedActors.elements[i].item = cachedActors.elements[j].item;
|
|
|
|
cachedActors.elements[j].extraData = extraData;
|
|
cachedActors.elements[j].item = item;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// DISCOVERING MODE & PICKING ACTORS
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function pickActor()
|
|
{
|
|
local PickActorProj pap;
|
|
pap = getController().spawn(class'PickActorProj', getController(), , getController().pawn.location + getController().pawn.eyeHeight * vect(0, 0, 1), getController().rotation);
|
|
|
|
pap.a_visibilityHandler = self;
|
|
}
|
|
|
|
|
|
simulated function discoveryMode()
|
|
{
|
|
local Actor a;
|
|
local int i;
|
|
|
|
if(bDiscoveryMode)
|
|
{
|
|
|
|
if(changedActors.length > 0)
|
|
{
|
|
debugMessage("discoveryMode(): seems like function was called 2 times in a row"@
|
|
"with bDiscoveryMode=true");
|
|
return;
|
|
}
|
|
|
|
forEach getController().allActors(class'Actor', a)
|
|
{
|
|
if(a.mesh != none || a.staticMesh != none)
|
|
if((a.bNoDelete || a.bStatic) && !a.bDeleteMe)
|
|
{
|
|
changedActors.length = i + 1;
|
|
|
|
changedActors[i].a = a;
|
|
changedActors[i].bBlockActors = a.bBlockActors;
|
|
changedActors[i].bBlockZeroExtentTraces = a.bBlockZeroExtentTraces;
|
|
changedActors[i].bCollideActors = a.bCollideActors;
|
|
|
|
if(!a.bHidden || bProjCollidesWithHiddenActor)
|
|
{
|
|
a.bBlockZeroExtentTraces = true;
|
|
a.setCollision(true, true);
|
|
}
|
|
else
|
|
{
|
|
a.bBlockZeroExtentTraces = false;
|
|
a.setCollision(false, false);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
logMessage("Discovery mode is enabled.");
|
|
}
|
|
else
|
|
{
|
|
if(changedActors.length == 0)
|
|
{
|
|
debugMessage("discoveryMode(): seems like function was called 2 times in a row"@
|
|
"with bDiscoveryMode=false");
|
|
return;
|
|
}
|
|
for(i = 0; i < changedActors.length; i++)
|
|
{
|
|
changedActors[i].a.bBlockZeroExtentTraces = changedActors[i].bBlockZeroExtentTraces;
|
|
changedActors[i].a.setCollision(changedActors[i].bCollideActors, changedActors[i].bBlockActors);
|
|
}
|
|
changedActors.remove(0, changedActors.length);
|
|
logMessage("Discovery mode is disabled.");
|
|
}
|
|
}
|
|
|
|
|
|
simulated function bool isActorChanged(Actor a)
|
|
{
|
|
local int i;
|
|
|
|
for(i = 0; i < changedActors.length; i++)
|
|
if(changedActors[i].a == a)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
simulated function discoveryModeShowActor(Actor a)
|
|
{
|
|
if(!bDiscoveryMode)
|
|
return;
|
|
|
|
if(!isActorChanged(a))
|
|
return;
|
|
|
|
a.bBlockZeroExtentTraces = true;
|
|
a.setCollision(true, true);
|
|
}
|
|
|
|
|
|
simulated function discoveryModeHideActor(Actor a)
|
|
{
|
|
if(!bDiscoveryMode)
|
|
return;
|
|
|
|
if(bProjCollidesWithHiddenActor)
|
|
return;
|
|
|
|
if(!isActorChanged(a))
|
|
return;
|
|
|
|
a.bBlockZeroExtentTraces = false;
|
|
a.setCollision(false, false);
|
|
}
|
|
|
|
|
|
simulated function discoveryModeChangeCollision()
|
|
{
|
|
local int i;
|
|
|
|
if(bProjCollidesWithHiddenActor)
|
|
{
|
|
for (i = 0; i < changedActors.length; i++)
|
|
{
|
|
if(changedActors[i].a.bHidden)
|
|
{
|
|
changedActors[i].a.bBlockZeroExtentTraces = true;
|
|
changedActors[i].a.setCollision(true, true);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < changedActors.length; i++)
|
|
{
|
|
if(changedActors[i].a.bHidden)
|
|
{
|
|
changedActors[i].a.bBlockZeroExtentTraces = false;
|
|
changedActors[i].a.setCollision(false, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
simulated function clearLog()
|
|
{
|
|
discoveryLog.setContent("");
|
|
discoveryLog.newText = "";
|
|
}
|
|
|
|
|
|
simulated function clearPresetInsides()
|
|
{
|
|
presetInsides.setContent("");
|
|
presetInsides.newText = "";
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// SHOW ACTOR'S LOCATION & SELECT ACTOR SHIT
|
|
////////////////////////////////////////////////////////////
|
|
|
|
// changes gri.currentShop to special shop volume
|
|
// which has the same location as "pickedActor"
|
|
// so the trader arrow show location of "pickedActor"
|
|
simulated function showDirectionToActor()
|
|
{
|
|
if(!bShowDirectionToActor)
|
|
{
|
|
if(KFGameReplicationInfo(getController().gameReplicationInfo).currentShop == navigationShop)
|
|
{
|
|
KFGameReplicationInfo(getController().gameReplicationInfo).currentShop = originalShop;
|
|
HUDKillingFloor(getController().myHud).traderString = "Trader";
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(pickedActor == none)
|
|
{
|
|
debugMessage("showDirectionToActor(): pickedActor == none");
|
|
return;
|
|
}
|
|
|
|
// "if" to avoid sudden adding "navigationShop" to "originalShop"
|
|
if(HideShopVolume(KFGameReplicationInfo(getController().gameReplicationInfo).currentShop) == none)
|
|
originalShop = KFGameReplicationInfo(getController().gameReplicationInfo).currentShop;
|
|
|
|
navigationShop.setLocation(pickedActor.location);
|
|
HUDKillingFloor(getController().myHud).traderString = getActorName(pickedActor);
|
|
KFGameReplicationInfo(getController().gameReplicationInfo).currentShop = navigationShop;
|
|
}
|
|
|
|
|
|
// "pickedActor" starts to change its "bHidden" value every second
|
|
simulated function selectActor()
|
|
{
|
|
if(bSelectActor)
|
|
{
|
|
pickedActorOriginalBHidden = pickedActor.bHidden;
|
|
setTimer(1.0, true);
|
|
}
|
|
else
|
|
{
|
|
setTimer(0, false);
|
|
pickedActor.bHidden = pickedActorOriginalBHidden;
|
|
|
|
if(pickedActor.bStatic)
|
|
pickedActor.resetStaticFilterState();
|
|
}
|
|
}
|
|
|
|
|
|
simulated function Timer()
|
|
{
|
|
if(bSelectActor)
|
|
{
|
|
pickedActor.bHidden = !pickedActor.bHidden;
|
|
|
|
if(pickedActor.bStatic)
|
|
pickedActor.resetStaticFilterState();
|
|
}
|
|
|
|
if(bShowDirectionToActor)
|
|
{
|
|
if(KFGameReplicationInfo(getController().gameReplicationInfo).currentShop != navigationShop)
|
|
{
|
|
originalShop = KFGameReplicationInfo(getController().gameReplicationInfo).currentShop;
|
|
KFGameReplicationInfo(getController().gameReplicationInfo).currentShop = navigationShop;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// USEFUL STUFF
|
|
////////////////////////////////////////////////////////////
|
|
|
|
simulated function removeActorFromList(Actor a)
|
|
{
|
|
local int index;
|
|
|
|
if(a == none)
|
|
{
|
|
debugMessage("removeActorFromList(): There's no input actor.");
|
|
return;
|
|
}
|
|
|
|
index = findCachedActor(a);
|
|
|
|
if(index == -1)
|
|
{
|
|
debugMessage("removeActorFromList():"@getActorName(a)@
|
|
"wasn't found in cached actors list. That's weird.");
|
|
return;
|
|
}
|
|
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
pickedActorOriginalBHidden = false;
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(a.bHidden)
|
|
{
|
|
a.bHidden = false;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeShowActor(a);
|
|
}
|
|
|
|
cachedActors.remove(index);
|
|
}
|
|
|
|
|
|
simulated function showActor(Actor a)
|
|
{
|
|
local int index;
|
|
local string actorName;
|
|
|
|
if(a == none)
|
|
{
|
|
debugMessage("showActor(): There's no input actor.");
|
|
return;
|
|
}
|
|
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
pickedActorOriginalBHidden = false;
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(a.bHidden)
|
|
{
|
|
a.bHidden = false;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeShowActor(a);
|
|
}
|
|
|
|
actorName = colorB$getActorName(a);
|
|
|
|
index = findCachedActor(a);
|
|
|
|
if(index > -1)
|
|
{
|
|
cachedActors.elements[index].item = actorName;
|
|
cachedActors.setIndex(index);
|
|
cachedActors.selectedItems[0] = index;
|
|
return;
|
|
}
|
|
|
|
cachedActors.add(actorName, a);
|
|
cachedActors.setIndex(cachedActors.elements.length - 1);
|
|
cachedActors.selectedItems[0] = cachedActors.elements.length - 1;
|
|
}
|
|
|
|
|
|
simulated function hideActor(Actor a)
|
|
{
|
|
local int index;
|
|
local string actorName;
|
|
|
|
if(a == none)
|
|
{
|
|
debugMessage("hideActor(): There's no input actor.");
|
|
return;
|
|
}
|
|
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
pickedActorOriginalBHidden = true;
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(!a.bHidden)
|
|
{
|
|
a.bHidden = true;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeHideActor(a);
|
|
}
|
|
|
|
actorName = colorG$getActorName(a);
|
|
|
|
index = findCachedActor(a);
|
|
|
|
if(index > -1)
|
|
{
|
|
cachedActors.elements[index].item = actorName;
|
|
cachedActors.setIndex(index);
|
|
cachedActors.selectedItems[0] = index;
|
|
return;
|
|
}
|
|
|
|
cachedActors.add(actorName, a);
|
|
cachedActors.setIndex(cachedActors.elements.length - 1);
|
|
cachedActors.selectedItems[0] = cachedActors.elements.length - 1;
|
|
}
|
|
|
|
|
|
simulated function bool selectActorFromList()
|
|
{
|
|
local int selectedSctringNumber;
|
|
local Actor a;
|
|
|
|
selectedSctringNumber = cachedActors.calculateIndex(true);
|
|
|
|
// if(selectedSctringNumber > cachedActors.elements.length)
|
|
if(selectedSctringNumber == -1)
|
|
return false;
|
|
|
|
a = Actor(cachedActors.elements[selectedSctringNumber].extraData);
|
|
if(a == none)
|
|
{
|
|
debugMessage("selectActorFromList(): For some reason it turned out that"@
|
|
StripColor(cachedActors.elements[selectedSctringNumber].item)@"== none."@
|
|
"The item was removed from the list");
|
|
cachedActors.remove(selectedSctringNumber);
|
|
return false;
|
|
}
|
|
|
|
// this whole shit just to change actors without pain
|
|
// so old actor will be reseted to the old state
|
|
// and new actor will recieve attention of selectActor() and showDirectionToActor()
|
|
if(pickedActor != a)
|
|
{
|
|
if(bSelectActor)
|
|
{
|
|
bSelectActor = false;
|
|
selectActor();
|
|
pickedActor = a;
|
|
bSelectActor = true;
|
|
selectActor();
|
|
}
|
|
else
|
|
{
|
|
pickedActor = a;
|
|
}
|
|
showDirectionToActor();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
simulated function pickActorWithProjectile(Actor a)
|
|
{
|
|
local int index, i;
|
|
local bool bBlockActorsActual, bBlockZeroExtentTracesActual, bCollideActorsActual;
|
|
|
|
if(pickedActor != a || !bSelectActor)
|
|
{
|
|
if(bSelectActor)
|
|
{
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
pickedActor = a;
|
|
bSelectActor = true;
|
|
selectActor();
|
|
}
|
|
showDirectionToActor();
|
|
|
|
index = findCachedActor(a);
|
|
|
|
if(index > -1)
|
|
{
|
|
cachedActors.setIndex(index);
|
|
cachedActors.selectedItems[0] = index;
|
|
}
|
|
|
|
if(bDiscoveryMode)
|
|
{
|
|
if(isActorChanged(a))
|
|
for(i = 0; i < changedActors.length; i++)
|
|
if(changedActors[i].a == a)
|
|
{
|
|
bBlockActorsActual = changedActors[i].bBlockActors;
|
|
bBlockZeroExtentTracesActual = changedActors[i].bBlockZeroExtentTraces;
|
|
bCollideActorsActual = changedActors[i].bCollideActors;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bBlockActorsActual = a.bBlockActors;
|
|
bBlockZeroExtentTracesActual = a.bBlockZeroExtentTraces;
|
|
bCollideActorsActual = a.bCollideActors;
|
|
}
|
|
|
|
if(bBlockActorsActual && bCollideActorsActual)
|
|
logMessage(getActorName(a)@colorR$"[blocks everything]");
|
|
else if(bBlockZeroExtentTracesActual && bCollideActorsActual)
|
|
logMessage(getActorName(a)@colorY$"[blocks projectiles]");
|
|
else
|
|
logMessage(getActorName(a)@colorG$"[blocks nothing]");
|
|
}
|
|
|
|
|
|
simulated function removeAllActorsFromList()
|
|
{
|
|
local int i, j;
|
|
local Actor a;
|
|
|
|
for(i = cachedActors.elements.length - 1; i >= 0 ; i--)
|
|
{
|
|
a = Actor(cachedActors.elements[i].extraData);
|
|
if(a != none)
|
|
{
|
|
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
pickedActorOriginalBHidden = false;
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(a.bHidden)
|
|
{
|
|
a.bHidden = false;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeShowActor(a);
|
|
}
|
|
|
|
cachedActors.remove(i);
|
|
j++;
|
|
}
|
|
else
|
|
{
|
|
debugMessage("removeAllUnhidedActorsFromList(): For some reason it turned out that"@
|
|
StripColor(cachedActors.elements[i].item)@"== none."@
|
|
"The item was removed from the list");
|
|
cachedActors.remove(i);
|
|
}
|
|
}
|
|
|
|
if(j > 0)
|
|
logMessage("[Remove all actors]:"@j@"actors were removed from the list.");
|
|
}
|
|
|
|
|
|
simulated function removeAllUnhidedActorsFromList()
|
|
{
|
|
local int i, j;
|
|
local Actor a;
|
|
|
|
|
|
for(i = cachedActors.elements.length - 1; i >= 0 ; i--)
|
|
{
|
|
a = Actor(cachedActors.elements[i].extraData);
|
|
if(a != none)
|
|
{
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(!a.bHidden)
|
|
{
|
|
cachedActors.remove(i);
|
|
j++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debugMessage("removeAllUnhidedActorsFromList(): For some reason it turned out that"@
|
|
StripColor(cachedActors.elements[i].item)@"== none."@
|
|
"The item was removed from the list");
|
|
cachedActors.remove(i);
|
|
}
|
|
}
|
|
|
|
if(j > 0)
|
|
logMessage("[Remove all unhided actors]:"@j@"actors were removed from the list.");
|
|
}
|
|
|
|
|
|
simulated function showAllActorsInList()
|
|
{
|
|
local int i, j;
|
|
local string actorName;
|
|
local Actor a;
|
|
|
|
for(i = cachedActors.elements.length - 1; i >= 0 ; i--)
|
|
{
|
|
a = Actor(cachedActors.elements[i].extraData);
|
|
if(a != none)
|
|
{
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(a.bHidden)
|
|
{
|
|
a.bHidden = false;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeShowActor(a);
|
|
|
|
actorName = colorB$getActorName(a);
|
|
|
|
cachedActors.elements[i].item = actorName;
|
|
|
|
j++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debugMessage("showAllActorsInList(): For some reason it turned out that"@
|
|
StripColor(cachedActors.elements[i].item)@"== none."@
|
|
"The item was removed from the list");
|
|
cachedActors.remove(i);
|
|
}
|
|
}
|
|
|
|
if(j > 0)
|
|
logMessage("[Show all]:"@j@"actors were unhided.");
|
|
}
|
|
|
|
|
|
simulated function hideAllActorsInList()
|
|
{
|
|
local int i, j;
|
|
local string actorName;
|
|
local Actor a;
|
|
|
|
for(i = cachedActors.elements.length - 1; i >= 0 ; i--)
|
|
{
|
|
a = Actor(cachedActors.elements[i].extraData);
|
|
if(a != none)
|
|
{
|
|
if(a == pickedActor)
|
|
if(bSelectActor)
|
|
{
|
|
bSelectActor = false;
|
|
selectActor();
|
|
}
|
|
|
|
if(!a.bHidden)
|
|
{
|
|
a.bHidden = true;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
discoveryModeHideActor(a);
|
|
|
|
actorName = colorG$getActorName(a);
|
|
|
|
cachedActors.elements[i].item = actorName;
|
|
|
|
j++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debugMessage("hideAllActorsInList(): For some reason it turned out that"@
|
|
StripColor(cachedActors.elements[i].item)@"== none."@
|
|
"The item was removed from the list");
|
|
cachedActors.remove(i);
|
|
}
|
|
}
|
|
if(j > 0)
|
|
logMessage("[Hida all]:"@j@"actors were hided.");
|
|
}
|
|
|
|
|
|
simulated function doTheMagic()
|
|
{
|
|
local Actor a;
|
|
local string actorName, dev_null;
|
|
local bool bCheckIfCached;
|
|
local int j;
|
|
|
|
if(!isEverythingAlright())
|
|
{
|
|
debugMessage("doTheMagic(): Can't find player controller");
|
|
return;
|
|
}
|
|
|
|
if(cachedActors.elements.length > 0)
|
|
bCheckIfCached = true;
|
|
|
|
forEach getController().allActors(class'Actor', a)
|
|
{
|
|
if(bHideActorsWithMeshes)
|
|
if(a.mesh != none || a.staticMesh != none)
|
|
{
|
|
if(!a.bHidden)
|
|
if((a.bNoDelete || a.bStatic) && !a.bDeleteMe) //actors which will be deleted soon are not allowed
|
|
if(!((a.bBlockActors || a.bBlockZeroExtentTraces) && a.bCollideActors))
|
|
if(Pickup(a) == none)
|
|
{
|
|
if(bCheckIfCached)
|
|
if(isCached(a))
|
|
continue;
|
|
|
|
a.bHidden = true;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
divide(string(a), ".", dev_null, actorName);
|
|
actorName = colorG$actorName;
|
|
|
|
cachedActors.add(actorName, a);
|
|
|
|
j++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(bHideEmitters)
|
|
if(a.drawType == DT_Particle)
|
|
{
|
|
if(!a.bHidden)
|
|
if((a.bNoDelete || a.bStatic) && !a.bDeleteMe)
|
|
{
|
|
if(bCheckIfCached)
|
|
if(isCached(a))
|
|
continue;
|
|
|
|
a.bHidden = true;
|
|
if(a.bStatic)
|
|
a.resetStaticFilterState();
|
|
|
|
divide(string(a), ".", dev_null, actorName);
|
|
actorName = colorG$actorName;
|
|
|
|
cachedActors.add(actorName, a);
|
|
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(j > 0)
|
|
logMessage("[Magic button]:"@j@"actors were hided.");
|
|
|
|
}
|
|
|
|
|
|
simulated function destroyed()
|
|
{
|
|
cachedActors.clear();
|
|
cachedActors = none;
|
|
|
|
presetsList.clear();
|
|
presetsList = none;
|
|
|
|
discoveryLog.newText = "";
|
|
discoveryLog.setContent("");
|
|
discoveryLog = none;
|
|
|
|
presetInsides.newText = "";
|
|
presetInsides.setContent("");
|
|
presetInsides = none;
|
|
|
|
setTimer(0, false);
|
|
super.destroyed();
|
|
}
|
|
|
|
|
|
defaultproperties
|
|
{
|
|
bHideEmitters=True
|
|
bHideActorsWithMeshes=True
|
|
bShowPresetsForCurrentMapOnly=True
|
|
bHidden=True
|
|
} |