1
0
KF2-Dev-Scripts/Engine/Classes/WorldInfo.uc
2020-12-13 18:01:13 +03:00

2052 lines
79 KiB
Ucode

/**
* WorldInfo
*
* Actor containing all script accessible world properties.
*
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
*/
class WorldInfo extends ZoneInfo
native(GameEngine)
config(game)
hidecategories(Actor,Advanced,Display,Events,Object,Attachment)
//hidecategories(PhysicsAdvanced)
nativereplication
notplaceable
dependson(PostProcessEffect)
dependson(MusicTrackDataStructures);
/** Maximum number of bookmarks */
const MAX_BOOKMARK_NUMBER = 10;
`if(`__TW_)
var const private bool UseCheckbackMatchmaking;
`endif
/** Default post process settings used by post processing volumes. */
`if(`__TW_POSTPROCESS_)
var(Rendering) PostProcessSettings DefaultPostProcessSettings;
`else
var(Rendering) config PostProcessSettings DefaultPostProcessSettings;
`endif
/** The post process chain for the entire world*/
var(Rendering) PostProcessChain WorldPostProcessChain;
/** Whether or not post process effects should persist when this level is unloaded */
var(Rendering) config bool bPersistPostProcessToNextLevel;
/** Squint mode kernel size (same as DOF). */
var(Rendering) config float SquintModeKernelSize;
`if(`__TW_)
var(Rendering) float LevelShadowDepthBias;
/** Use this setting to turn off WholeSceneDominantShadows for the map. This can be used to circumvent the shadow graphics setting for certain maps in order to meet the performance benchmarks.
USE CASE: Set the light to cast WholeSceneShadows, and check bDisableWholeSceneDominantShadow. Whole scene shadows can then be enabled based on bOverrideMapWholeSceneDominantShadowSetting system setting.
*/
var(Rendering) bool bDisableWholeSceneDominantShadow;
`endif
/** Linked list of post processing volumes, sorted in descending order of priority. */
var const noimport transient PostProcessVolume HighestPriorityPostProcessVolume;
/** Default reverb settings used by reverb volumes. */
var(Audio) config ReverbSettings DefaultReverbSettings;
/** Default interior settings used by reverb volumes. */
var(Audio) config InteriorSettings DefaultAmbientZoneSettings;
/** Mobile only: Enables distance-based fog globally for this level */
var(Mobile) bool bFogEnabled;
/** Mobile only: Sets the distance fog start distance. Can be negative. */
var(Mobile) float FogStart;
/** Mobile only: Sets the distance fog end distance. Must be larger than FogStart. */
var(Mobile) float FogEnd;
/** Mobile only: Sets the distance fog color */
var(Mobile) color FogColor;
/** Mobile only: Enables bump offset mapping for this level for mobile materials that use that */
var(Mobile) bool bBumpOffsetEnabled;
/* Mobile only: Sets the bump offset threshold for mobile materials that use that */
var(Mobile) float BumpEnd;
/** Mobile: True to enable gamma correction for all shaders when rendering this level. Enabling this will yield lighting that more closely resembles other platforms, but may reduce rendering performance slightly. */
var(Mobile) bool bUseGammaCorrection;
/** Linked list of reverb volumes, sorted in descending order of priority. */
var const noimport transient ReverbVolume HighestPriorityReverbVolume;
/** Array of AMassiveLODOverrideVolume's in the world. */
var const noimport transient array<MassiveLODOverrideVolume> MassiveLODOverrideVolumes;
/** A array of portal volumes */
var const noimport transient array<PortalVolume> PortalVolumes;
/** An array of environment volumes */
var const noimport transient array<EnvironmentVolume> EnvironmentVolumes;
/** Level collection. ULevels are referenced by FName (Package name) to avoid serialized references. Also contains offsets in world units */
var(WorldInfo) const editconst editinline array<LevelStreaming> StreamingLevels;
/**
* This is a bool on the level which is set when a light that needs to have lighting rebuilt
* is moved. This is then checked in CheckMap for errors to let you know that this level should
* have lighting rebuilt.
**/
var bool bMapNeedsLightingFullyRebuilt;
/** Set to true when one or primitives are affected by multiple dominant lights. */
var bool bMapHasMultipleDominantLightsAffectingOnePrimitive;
/** Time in appSeconds unbuilt time was last encountered. 0 means not yet. */
var transient double LastTimeUnbuiltLightingWasEncountered;
/**
* This is a bool on the level which is set when the AI detects that paths are either not set up correctly
* or need to be rebuilt. If set the HUD will display a warning message on the screen.
*/
var bool bMapHasPathingErrors;
/** Whether it was requested that the engine bring up a loading screen and block on async loading. */
var bool bRequestedBlockOnAsyncLoading;
var(Editor) editoronly BookMark BookMarks[MAX_BOOKMARK_NUMBER]; // Level bookmarks
var(Editor) editoronly KismetBookMark KismetBookMarks[MAX_BOOKMARK_NUMBER]; // Kismet bookmarks
var(Editor) editoronly editinline array<ClipPadEntry> ClipPadEntries; // Clip pad entries
var float TimeDilation; // Normally 1 - scales real time passage.
var float DemoPlayTimeDilation; // additional TimeDilation applied only during demo playback
var transient float TimeSeconds; // Time in seconds since level began play, but IS paused when the game is paused, and IS dilated/clamped.
var transient float RealTimeSeconds; // Time in seconds since level began play, but is NOT paused when the game is paused, and is NOT dilated/clamped.
var transient float AudioTimeSeconds; // Time in seconds since level began play, but IS paused when the game is paused, and is NOT dilated/clamped.
var transient const float DeltaSeconds; // Frame delta time in seconds adjusted by e.g. time dilation.
var transient float PauseDelay; // time at which to start pause
var transient float RealTimeToUnPause; // If non-zero, when RealTimeSeconds reaches this, unpause the game.
var PlayerReplicationInfo Pauser; // If paused, name of person pausing the game.
var editoronly deprecated string VisibleGroups; // List of the group names which were checked when the level was last saved
var editoronly string VisibleLayers; // List of the layer names which were checked when the level was last saved
var bool bBegunPlay; // Whether gameplay has begun.
var bool bPlayersOnly; // Only update players.
var bool bPlayersOnlyPending; // Only update players. Next frame will set bPlayersOnly
var bool bSuspendAI; // Hook for game-specific suspension of AI processing
var transient bool bDropDetail; // frame rate is below DesiredFrameRate, so drop high detail actors
var transient bool bAggressiveLOD; // frame rate is well below DesiredFrameRate, so make LOD more aggressive
var bool bStartup; // Starting gameplay.
var bool bPathsRebuilt; // True if path network is valid
var bool bHasPathNodes;
/** That map is default map or not **/
var transient const bool bIsMenuLevel;
// Kismet debugging flags
var const editoronly transient bool bDebugPauseExecution;
var const editoronly transient bool bDebugStepExecution;
/**
* Bool that indicates that 'console' input is desired. This flag is mis named as it is used for a lot of gameplay related things
* (e.g. increasing collision size, changing vehicle turning behavior, modifying put down/up weapon speed, bot behavior)
*
* currently set when you are running a console build (implicitly or explicitly via ?param on the commandline)
*/
var transient bool bUseConsoleInput;
var Texture2D DefaultTexture;
var Texture2D WireframeTexture;
var Texture2D WhiteSquareTexture;
var Texture2D LargeVertex;
var Texture2D BSPVertex;
`if(`__TW_PERSISTENT_SPLATTER_SYSTEM_)
/**
* This is a bool on the level which is set when a splatter maps need to be rebuilt
**/
var bool bMapNeedsSplatterMapsRebuilt;
`endif
`if(`__TW_PRECOMPUTED_VISIBILITY_)
/**
* This is a bool on the level which is set when precomputed visibility needs to be rebuilt
**/
var bool bMapNeedsPrecomputedVisibilityRebuilt;
`endif
/**
* This is the array of string which will be called after a tick has occurred. This allows
* functions which GC and/or delete objects to be executed from .uc land!
**/
var array<string> DeferredExecs;
var transient GameReplicationInfo GRI;
var enum ENetMode
{
NM_Standalone, // Standalone game.
NM_DedicatedServer, // Dedicated server, no local client.
NM_ListenServer, // Listen server.
NM_Client // Client only, no local server.
} NetMode;
var string ComputerName; // Machine's name according to the OS.
var string EngineVersion; // Engine version.
var string MinNetVersion; // Min engine version that is net compatible.
var GameInfo Game;
var(ZoneInfo) float StallZ; // vehicles stall if they reach this
var transient float WorldGravityZ; // current gravity actually being used
var const globalconfig float DefaultGravityZ; // default gravity (game specific) - set in defaultgame.ini
var(ZoneInfo) float GlobalGravityZ; // optional level specific gravity override set by level designer
var globalconfig float RBPhysicsGravityScaling; // used to scale gravity for rigid body physics
var transient const private NavigationPoint NavigationPointList;
var const private Controller ControllerList;
var const Pawn PawnList;
var transient const CoverLink CoverList;
var transient const private Pylon PylonList;
var float MoveRepSize;
/** stores information on a viewer that actors need to be checked against for relevancy */
struct native NetViewer
{
var PlayerController InViewer;
var Actor Viewer;
var vector ViewLocation;
var vector ViewDir;
structcpptext
{
FNetViewer(UNetConnection* InConnection, FLOAT DeltaSeconds);
}
};
/** valid only during replication - information about the player(s) being replicated to
* (there could be more than one in the case of a splitscreen client)
*/
var const array<NetViewer> ReplicationViewers;
var string NextURL;
var float NextSwitchCountdown;
/** The type of travel to perform next when doing a server travel */
var ETravelType NextTravelType;
/** Maximum size of textures for packed light and shadow maps */
var(Rendering) int PackedLightAndShadowMapTextureSize;
/**
* Causes the BSP build to generate as few sections as possible.
* This is useful when you need to reduce draw calls but can reduce texture streaming efficiency and effective lightmap resolution.
* Note - changes require a rebuild to propagate. Also, be sure to select all surfaces and make sure they all have the same flags to minimize section count.
*/
var(Rendering) bool bMinimizeBSPSections;
/** Default color scale for the level */
var(Rendering) vector DefaultColorScale;
/** if true, do not grant player with default inventory (presumably, the LD's will be setting it manually) */
var() bool bNoDefaultInventoryForPlayer;
/** The default game type to use when starting this map in the game. If this value is NULL, the INI setting for default game type is used. */
var(GameType) class<GameInfo> DefaultGameType;
/**
* This is the list of GameTypes which this map can support. This is used for SeekFree loading
* code so the map has a reference to the game type it will be played with so it can cook
* all of the specific assets
**/
var(GameType) array< class<GameInfo> > GameTypesSupportedOnThisMap;
/**
* This is the gametype that should be used when starting the map in PIE.
* Note: if this value is not NULL it will override the DefaultGameType value when running PIE
*/
var(GameType) editoronly class<GameInfo> GameTypeForPIE;
/** list of objects referenced by Actors that will be destroyed by the client on load (because they have bStatic and bNoDelete == false)
* this is so that they will persist in memory on the client in case the server needs to replicate them
* (generated at editor time so that server and client memory usage is more consistent)
*/
var const editconst array<Object> ClientDestroyedActorContent;
/** array of levels that were loaded into this map via PrepareMapChange() / CommitMapChange() (to inform newly joining clients) */
var const transient array<name> PreparingLevelNames;
var const transient name CommittedPersistentLevelName;
var objectreferencer PersistentMapForcedObjects;
/** Audio component used for playing music tracks via SeqAct_PlayMusicTrack */
var transient AudioComponent MusicComp;
/** Param information for the currently playing MusicComp */
var transient MusicTrackStruct CurrentMusicTrack;
/** Version of a new music track request replicated to clients */
var transient repnotify MusicTrackStruct ReplicatedMusicTrack;
/** If true, don't add "no paths from" warnings to map error list in editor. Useful for maps that don't need AI support, but still have a few NavigationPoint actors in them. */
var() bool bNoPathWarnings;
/** Flag for controlling whether Mobile warnings are shown in map checks */
var(WorldInfo) config bool bNoMobileMapWarnings;
/** title of the map displayed in the UI */
var() localized string Title;
/** Who created this map */
var() string Author;
/** when this flag is set, more time is allocated to background loading (replicated) */
var bool bHighPriorityLoading;
/** copy of bHighPriorityLoading that is not replicated, for clientside-only loading operations */
var bool bHighPriorityLoadingLocal;
/** game specific map information - access through GetMapInfo()/SetMapInfo() */
var() protected{protected} instanced MapInfo MyMapInfo;
`if(`__TW_)
var string EmitterPoolClassPath;
`else
/** particle emitter pool for gameplay effects that are spawned independent of their owning Actor */
var globalconfig string EmitterPoolClassPath;
`endif
var transient EmitterPool MyEmitterPool;
/** decal pool and lifetime manager */
var globalconfig string DecalManagerClassPath;
var transient DecalManager MyDecalManager;
`if(`__TW_)
var string FractureManagerClassPath;
`else
/** fractured mesh manager */
var global config string FractureManagerClassPath;
`endif
var transient FractureManager MyFractureManager;
`if(`__TW_)
var string ParticleEventManagerClassPath;
`else
/** Particle event manager **/
var globalconfig string ParticleEventManagerClassPath;
`endif
var transient ParticleEventManager MyParticleEventManager;
/**
* Overriding is useful for doing perf testing / load testing / being able to overcome memory issues in other tools until they are fixed
* withOUT compromising the RuleSet creation process and the application of the rulesets in the level
*/
var(ProcBuildings) bool bUseProcBuildingRulesetOverride;
var(ProcBuildings) ProcBuildingRuleset ProcBuildingRulesetOverride;
/** Used by SkeletalMeshComponent Ticking optimization. */
var const transient int SkelMeshCompTickTagCount;
/** TRUE if player is in Interactive mode. */
var const transient bool bInteractiveMode;
/** For specifying which compartments should run on a given frame */
struct native CompartmentRunList
{
/** The rigid body compartment will run on this frame */
var() bool RigidBody;
/** The fluid compartment will run on this frame */
var() bool Fluid;
/** The cloth compartment will run on this frame */
var() bool Cloth;
/** The soft body compartment will run on this frame */
var() bool SoftBody;
structdefaultproperties
{
RigidBody=true
Fluid=true
Cloth=true
SoftBody=true
}
};
/** Parameters used for a PhysX primary scene or compartment */
struct native PhysXSimulationProperties
{
/**
Whether or not to put the scene (or compartment) in PhysX hardware, if available.
*/
var() bool bUseHardware;
/**
If true, substep sizes are fixed equal to TimeStep.
If false, substep sizes are varied to fit an integer number of times into the frame time.
*/
var() bool bFixedTimeStep;
/** The fixed or maximum substep size, depending on the value of bFixedTimeStep. */
var() float TimeStep;
/** The maximum number of substeps allowed per frame. */
var() int MaxSubSteps;
structdefaultproperties
{
bUseHardware=false
bFixedTimeStep=false
TimeStep=0.02
MaxSubSteps=5
}
};
/** Timings for primary and compartments. */
struct native PhysXSceneProperties
{
/** Timing settings for the PhysX primary scene */
var() editinline PhysXSimulationProperties PrimaryScene;
/** Timing settings for the PhysX rigid body compartment */
var() editinline PhysXSimulationProperties CompartmentRigidBody;
/** Timing settings for the PhysX fluid compartment */
var() editinline PhysXSimulationProperties CompartmentFluid;
/** Timing settings for the PhysX cloth compartment */
var() editinline PhysXSimulationProperties CompartmentCloth;
/** Timing settings for the PhysX soft body compartment */
var() editinline PhysXSimulationProperties CompartmentSoftBody;
structdefaultproperties
{
CompartmentRigidBody=(bUseHardware=false,bFixedTimeStep=false,TimeStep=0.02,MaxSubSteps=2)
CompartmentFluid=(bUseHardware=true,bFixedTimeStep=false,TimeStep=0.02,MaxSubSteps=1)
CompartmentCloth=(bUseHardware=true,bFixedTimeStep=true,TimeStep=0.02,MaxSubSteps=2)
CompartmentSoftBody=(bUseHardware=true,bFixedTimeStep=true,TimeStep=0.02,MaxSubSteps=2)
}
};
/** Timings for primary and compartments. */
/** Double buffered physics compartments enabled */
var(PhysicsAdvanced) bool bSupportDoubleBufferedPhysics;
/** The maximum frame time allowed for physics calculations */
var(PhysicsAdvanced) float MaxPhysicsDeltaTime;
/** The maximum number of substeps allowed in any physics scene/partition. */
var config int MaxPhysicsSubsteps;
/** If TRUE, physics simulation will ignore time elapsed between frames, and use (0.033 * TimeDilation) */
var(Physics) bool bPhysicsIgnoreDeltaTime;
/** Timing parameters for the scene, primary and compartments. */
var(PhysicsAdvanced) editinline PhysXSceneProperties PhysicsProperties;
/** Which compartments run on which frames (list is cyclic). An empty list means all compartments run on all frames. */
var(PhysicsAdvanced) array< CompartmentRunList > CompartmentRunFrames;
/** Default skin width */
var(PhysicsAdvanced) float DefaultSkinWidth;
/** Global APEX resource budget override. If negative the INI setting will be used instead. */
var(PhysicsAdvanced) float ApexLODResourceBudget;
// NVCHANGE_BEGIN: KHA - Expose Apex Module LOD Benefit Value
/** A higher value would increase the amount of resources allocated to Apex Destruction */
var(PhysicsAdvanced) float ApexDestructionLODResourceValue;
/** A higher value would increase the amount of resources allocated to Apex Clothing */
var(PhysicsAdvanced) float ApexClothingLODResourceValue;
// NVCHANGE_END: KHA - Expose Apex Module LOD Benefit Value
/** APEX **/
struct native ApexModuleDestructibleSettings
{
/** The maximum number of active PhysX actors which represent dynamic groups of chunks (islands). If a
fracturing event would cause more islands to be created, then oldest islands are released and the chunks
they represent destroyed. If negative the INI setting will be used instead. */
var() int MaxChunkIslandCount;
/** The maximum number of PhysX shapes which represent destructible chunks.
If a fracturing event would cause more shapes to be created, then oldest islands are released
and the chunks they represent destroyed.*/
var() int MaxShapeCount;
/** Reserved for future use. */
var int MaxRrbActorCount;
/** Every destructible asset defines a min and max lifetime, and maximum separation distance for its chunks.
Chunk islands are destroyed after this time or separation from their origins. This parameter sets the
lifetimes and max separations within their min-max ranges. The valid range is [0,1]. */
var() float MaxChunkSeparationLOD<ClampMin=0.0|ClampMax=1.0>;
/** If set, override the INI setting with Max Chunk Separation LOD in the WorldInfo properties. */
var() bool bOverrideMaxChunkSeparationLOD;
structdefaultproperties
{
MaxShapeCount=-1
MaxChunkIslandCount=-1
MaxRrbActorCount=-1
MaxChunkSeparationLOD=1.0
bOverrideMaxChunkSeparationLOD=false
}
};
var(PhysicsAdvanced) ApexModuleDestructibleSettings DestructibleSettings;
/** Verticals */
var PhysicsLODVerticalEmitter EmitterVertical;
/** Parameters for emitter vertical */
struct native PhysXEmitterVerticalProperties
{
var() bool bDisableLod;
/**
Min value for particle LOD range.
*/
var() int ParticlesLodMin;
/**
Max value for particle LOD range.
*/
var() int ParticlesLodMax;
/**
Limit for packets per PhysXParticleSystem. Caped to 900.
*/
var() int PacketsPerPhysXParticleSystemMax;
/** Selects either cylindrical or spherical packet range culling. */
var() bool bApplyCylindricalPacketCulling;
/**
Parameter for scaling spawn lod impact. 1.0: As much as possible lod through
emitter spawn rate/lifetime control. 0.0: Lod constraint handled only through
fifo control.
*/
var() float SpawnLodVsFifoBias;
structdefaultproperties
{
bDisableLod=true
ParticlesLodMin=0
ParticlesLodMax=15000
PacketsPerPhysXParticleSystemMax=500
bApplyCylindricalPacketCulling=true
SpawnLodVsFifoBias=1.0
}
};
struct native PhysXVerticalProperties
{
/** Parameters for Emitter Vertical */
var() editinline PhysXEmitterVerticalProperties Emitters;
structdefaultproperties
{
}
};
/** Vertical parameters. */
var(PhysicsAdvanced) editinline PhysXVerticalProperties VerticalProperties;
var native private array<pointer> WorldAttractors{class AWorldAttractor};
enum EConsoleType
{
CONSOLE_Any,
CONSOLE_Xbox360,
CONSOLE_PS3,
CONSOLE_Mobile,
CONSOLE_IPhone,
CONSOLE_Android,
CONSOLE_WiiU,
CONSOLE_Flash,
//@HSL_BEGIN_PS4
CONSOLE_Orbis,
//@HSL_END_PS4
//@HSL_BEGIN_XBOX
CONSOLE_Durango,
//@HSL_END_XBOX
};
/** Struct used for passing back results from GetWorldFractureSettings */
struct native WorldFractureSettings
{
var float ChanceOfPhysicsChunkOverride;
var bool bEnableChanceOfPhysicsChunkOverride;
var bool bLimitExplosionChunkSize;
var float MaxExplosionChunkSize;
var bool bLimitDamageChunkSize;
var float MaxDamageChunkSize;
var int MaxNumFacturedChunksToSpawnInAFrame;
var float FractureExplosionVelScale;
};
// DO NOT READ THESE FRACTURE VALUES DIRECTLY - USE GetWorldFractureSettings FUNCTION TO HANDLE STREAMING CORRECTLY
/** Allows global override of the ChanceOfPhysicsChunk setting. */
var(Fracture) private{private} config float ChanceOfPhysicsChunkOverride;
/** If TRUE, uses ChanceOfPhysicsChunkOverride instead of that set in the FracturedStaticMesh. */
var(Fracture) private{private} config bool bEnableChanceOfPhysicsChunkOverride;
/** If TRUE, limit the max dimension of the bounding box of a fracture chunk due to explosion to MaxExplosionChunkSize */
var(Fracture) private{private} config bool bLimitExplosionChunkSize;
/** Max dimension of the bounding box of a fracture chunk due to explosion. */
var(Fracture) private{private} config float MaxExplosionChunkSize;
/** If TRUE, limit the max dimension of the bounding box of a fracture chunk due to weapon damage to bLimitDamageChunkSize */
var(Fracture) private{private} config bool bLimitDamageChunkSize;
/** Max dimension of the bounding box of a fracture chunk due to weapon damage. */
var(Fracture) private{private} config float MaxDamageChunkSize;
/** Scaling for chunk thrown out during explosion on a fractured mesh */
var(Fracture) private{private} config float FractureExplosionVelScale;
/** Max number of Fractured Chunks to Spawn in a frame. **/
var(Fracture) private{private} int MaxNumFacturedChunksToSpawnInAFrame;
/** Number of chunks already spawned this frame **/
var transient int NumFacturedChunksSpawnedThisFrame;
/** How much damage weapons do to fractured static meshes. */
var config float FracturedMeshWeaponDamage;
`if(`__TW_PRECOMPUTED_VISIBILITY_)
/**
* Whether to place visibility cells inside Precomputed Visibility Volumes and along camera tracks in this level.
* Precomputing visibility reduces rendering thread time at the cost of some runtime memory and somewhat increased lighting build times.
*/
var (PrecomputedVisibility) bool bPrecomputeVisibility;
/**
* Whether to place visibility cells on shadow casting surfaces only, or everywhere inside Precomputed Visibility Volumes.
* Placing cells everywhere in the volumes is useful for games where the camera is not restrained to an area around the ground,
* But generates a lot more cells than just placing on surfaces, so build times and memory usage will increase.
*/
var (PrecomputedVisibility) editconst bool bPlaceCellsOnSurfaces;
/**
* World space size of precomputed visibility cells in x and y.
* Smaller sizes produce more effective occlusion culling at the cost of increased runtime memory usage and lighting build times.
*/
var (PrecomputedVisibility) editconst int VisibilityCellSize;
/** How much to jitter results from neighboring cells. Controls precomputed visibility aggresiveness */
var(PrecomputedVisibility) editconst int VisibilitySpreadingIterations;
/** How much to scale mesh bounds for visibility calculations. Controls precomputed visibility aggresiveness */
var(PrecomputedVisibility) editconst float MeshBoundsScale;
/** Max player height. Used for precomputed visibility calculations */
var(PrecomputedVisibility) editconst float PlayAreaHeight;
/** Whether to place visibility cells on opaque surfaces only */
var(PrecomputedVisibility) editconst bool bPlaceCellsOnOpaqueOnly;
/** Whether to store visibility data in compressed form */
var(PrecomputedVisibility) editconst bool bCompressVisibilityData;
/** Hidden settings used for visibility calculations */
var int MinMeshSamples;
var int MaxMeshSamples;
var int NumCellSamples;
var int NumImportanceSamples;
var int CellRenderingBucketSize;
var int NumCellRenderingBuckets;
var int NumCellDistributionBuckets;
enum EVisibilityAggressiveness
{
VIS_LeastAggressive,
VIS_ModeratelyAggressive,
VIS_MostAggressive,
VIS_Max
};
/**
* Deprecated. Used by Lightmass only.
*/
var EVisibilityAggressiveness VisibilityAggressiveness;
`else
/**
* Whether to place visibility cells inside Precomputed Visibility Volumes and along camera tracks in this level.
* Precomputing visibility reduces rendering thread time at the cost of some runtime memory and somewhat increased lighting build times.
*/
var (PrecomputedVisibility) bool bPrecomputeVisibility;
/**
* Whether to place visibility cells on shadow casting surfaces only, or everywhere inside Precomputed Visibility Volumes.
* Placing cells everywhere in the volumes is useful for games where the camera is not restrained to an area around the ground,
* But generates a lot more cells than just placing on surfaces, so build times and memory usage will increase.
*/
var (PrecomputedVisibility) bool bPlaceCellsOnSurfaces;
/**
* World space size of precomputed visibility cells in x and y.
* Smaller sizes produce more effective occlusion culling at the cost of increased runtime memory usage and lighting build times.
*/
var (PrecomputedVisibility) int VisibilityCellSize;
`endif
/** Brightness applied to the indirect lighting of character light environments that are lit by any dominant light. */
var (LightEnvironment) float CharacterLitIndirectBrightness <UIMin=0.1 | UIMax=1.0 | ClampMin=0.0 | ClampMax=5.0>;
/** Contrast factor applied to the indirect lighting of character light environments that are lit by any dominant light. */
var (LightEnvironment) float CharacterLitIndirectContrastFactor <UIMin=1.0 | UIMax=2.0 | ClampMin=0.5 | ClampMax=5.0>;
/** Brightness applied to the indirect lighting of character light environments that are shadowed by all dominant lights. */
var (LightEnvironment) float CharacterShadowedIndirectBrightness <UIMin=0.1 | UIMax=1.0 | ClampMin=0.0 | ClampMax=5.0>;
/** Contrast factor applied to the indirect lighting of character light environments that are shadowed by all dominant lights. */
var (LightEnvironment) float CharacterShadowedIndirectContrastFactor <UIMin=1.0 | UIMax=2.0 | ClampMin=0.5 | ClampMax=5.0>;
/**
* Increases the contrast of light environment lighting on characters by scaling up the brightest directions and scaling down the rest by this factor.
* Note that this setting only affects light environments completely in shadow from all dominant lights.
*/
var (LightEnvironment) float CharacterLightingContrastFactor <UIMin=1.0 | UIMax=2.0 | ClampMin=0.5 | ClampMax=5.0>;
/** Whether to allow temporal AA. */
var (Rendering) globalconfig bool bAllowTemporalAA;
/**
* Panoramic environment texture for image reflections.
* The texture should be laid out so that the horizon is along the bottom (v = 0) and straight up in world space is along the top (v = 1).
* The u direction of the texture then corresponds to rotation around the Z world axis.
*/
var (Rendering) Texture2D ImageReflectionEnvironmentTexture <bShowOnlyWhenTrue=bShowD3D11Properties>;
/** Color to be multiplied against ImageReflectionEnvironmentTexture. Alpha controls brightness. */
var (Rendering) LinearColor ImageReflectionEnvironmentColor <bShowOnlyWhenTrue=bShowD3D11Properties>;
/** Angle to rotate the environment texture around the world Z axis, in degrees. */
var (Rendering) float ImageReflectionEnvironmentRotation <bShowOnlyWhenTrue=bShowD3D11Properties>;
/** The type of lightmaps to use on this map for mobile platforms */
enum EPreferredLightmapType
{
EPLT_Default,
EPLT_Directional,
EPLT_Simple
};
/**
* Which lightmap type to use on this level.
* EPLT_Default Use the platform default.
* EPLT_Directional Force directional lightmaps (provided the platform supports them)
* EPLT_Simple Force simple lightmaps
*/
var EPreferredLightmapType PreferredLightmapType;
/** On-screen debug message handling */
/** Helper struct for tracking on screen messages. */
struct transient native ScreenMessageString
{
/** The 'key' for this message. */
var transient qword Key;
/** The message to display. */
var transient string ScreenMessage;
/** The color to display the message in. */
var transient color DisplayColor;
/** The number of frames to display it. */
var transient float TimeToDisplay;
/** The number of frames it has been displayed so far. */
var transient float CurrentTimeDisplayed;
};
/** A collection of messages to display on-screen. */
var transient native Map_Mirror ScreenMessages{TMap<INT, FScreenMessageString>};
/** A collection of messages to display on-screen. */
var transient native array<ScreenMessageString> PriorityScreenMessages;
`if(`__TW_LIGHTING_MODIFICATIONS_)
// Hide this option from the editor since we are not using lightmass
var editoronly bool bUseGlobalIllumination;
`else
/** Whether this level should be using fully-featured global illumination. If not, it will use old-style direct lightmaps. */
var(Lightmass) editoronly bool bUseGlobalIllumination;
`endif
/**
* Whether to force lightmaps and other precomputed lighting to not be created even when the engine thinks they are needed.
* This is useful for improving iteration in levels with fully dynamic lighting and shadowing.
* Note that any lighting and shadowing interactions that are usually precomputed will be lost if this is enabled.
*/
var(Lightmass) bool bForceNoPrecomputedLighting;
/** The number of triangles per leaf of the kdop tree in lightmass*/
var editoronly int MaxTrianglesPerLeaf <FixedIncrement=4|ClampMin=4|Multiple=4>;
/** The Lightmass-related settings for this level */
var deprecated editoronly instanced LightmassLevelSettings LMLevelSettings;
var editoronly transient native map{FGuid, class ULandscapeInfo*} LandscapeInfoMap;
struct native LightmassWorldInfoSettings
{
/**
* Scale of the level relative to Gears of War 2 levels.
* All scale-dependent Lightmass setting defaults have been tweaked to work well in Gears 2 levels,
* Any levels with a different scale should use this scale to compensate.
*/
var(General) float StaticLightingLevelScale;
/**
* Number of times light is allowed to bounce off of surfaces, starting from the light source.
* 0 is direct lighting only, 1 is one bounce, etc.
* Bounce 1 takes the most time to calculate and contributes the most to visual quality, followed by bounce 2.
* Successive bounces are nearly free, but have a much lower impact.
*/
var(General) int NumIndirectLightingBounces;
/**
* Color that rays which miss the scene will pick up.
* This is effectively a light surrounding the entire level that is shadowed, but doesn't emit indirect lighting.
*/
var(General) color EnvironmentColor;
/** Scales EnvironmentColor to allow independent color and brightness controls. */
var(General) float EnvironmentIntensity;
/**
* In advanced mode the color that rays which miss the scen will pick up depends on 'sun'.
* The closer ray's direction is to the direction of sun the more color of sun is blended/added into picked color.
*/
var(AdvancedEnvironmentColor) bool bEnableAdvancedEnvironmentColor;
/** Color of the sun */
var(AdvancedEnvironmentColor) color EnvironmentSunColor;
/** Scales EnvironmentSunColor to allow independent color and brightness controls. */
var(AdvancedEnvironmentColor) float EnvironmentSunIntensity;
var(AdvancedEnvironmentColor) float EnvironmentLightTerminatorAngle<ToolTip=In degrees. Range of sun color.>;
var(AdvancedEnvironmentColor) Vector EnvironmentLightDirection<ToolTip=If this value is zeroed, the direction of dominant directional light on current scene will be used>;
/** Scales the emissive contribution of all materials in the scene. */
var(General) float EmissiveBoost;
/** Scales the diffuse contribution of all materials in the scene. */
var(General) float DiffuseBoost;
/** Scales the specular contribution of all materials in the scene. */
var float SpecularBoost;
/**
* Lerp factor that controls the influence of normal maps with directional lightmaps on indirect lighting.
* A value of 0 gives a physically correct distribution of light, which may result in little normal influence in areas only lit by indirect lighting, but less lightmap compression artifacts.
* A value of .8 results in 80% of the lighting being redistributed in the dominant incident lighting direction, which effectively increases the per-pixel normal's influence,
* But causes more severe lightmap compression artifacts.
*/
var(General) float IndirectNormalInfluenceBoost;
/** If TRUE, AmbientOcclusion will be enabled. */
var(Occlusion) bool bUseAmbientOcclusion;
/** If TRUE, Lightmass will generate static shadowing information for image reflections. */
var(Occlusion) bool bEnableImageReflectionShadowing;
/** How much of the AO to apply to direct lighting. */
var(Occlusion) float DirectIlluminationOcclusionFraction;
/** How much of the AO to apply to indirect lighting. */
var(Occlusion) float IndirectIlluminationOcclusionFraction;
/** Higher exponents increase contrast. */
var(Occlusion) float OcclusionExponent;
/** Fraction of samples taken that must be occluded in order to reach full occlusion. */
var(Occlusion) float FullyOccludedSamplesFraction;
/** Maximum distance for an object to cause occlusion on another object. */
var(Occlusion) float MaxOcclusionDistance;
/** If TRUE, override normal direct and indirect lighting with just the exported diffuse term. */
var(Debug) bool bVisualizeMaterialDiffuse;
/** If TRUE, override normal direct and indirect lighting with just the AO term. */
var(Debug) bool bVisualizeAmbientOcclusion;
/** If TRUE, compress shadowmap with DXT1. */
var(General) bool bCompressShadowmap;
// Default diffuse boost to a high value since diffuse textures are often authored centering around a value of .1 or so
// Change this to default closer to 1 if your game's diffuse textures average to closer to .5
structdefaultproperties
{
StaticLightingLevelScale=1
NumIndirectLightingBounces=3
EnvironmentColor=(R=0,G=0,B=0)
EnvironmentIntensity=1.0
bEnableAdvancedEnvironmentColor=false
EnvironmentSunColor=(R=0,G=0,B=0)
EnvironmentSunIntensity=1.0
EnvironmentLightTerminatorAngle=90.0
EmissiveBoost=1.0
DiffuseBoost=5.0
SpecularBoost=1.0
IndirectNormalInfluenceBoost=0.3
bUseAmbientOcclusion=false
DirectIlluminationOcclusionFraction=0.5
IndirectIlluminationOcclusionFraction=1.0
OcclusionExponent=1.0
FullyOccludedSamplesFraction=1.0
MaxOcclusionDistance=200.0
bVisualizeMaterialDiffuse=false
bVisualizeAmbientOcclusion=false
bCompressShadowmap=false
}
};
var(Lightmass) LightmassWorldInfoSettings LightmassSettings <ScriptOrder=true>;
/**
* Path constraint path goal evaluator pools
* - we don't want to new/delete these every time we path.. so we pool them here
*/
/** Path constraint */
const MAX_INSTANCES_PER_CLASS = 5;
struct native NavMeshPathConstraintCacheDatum
{
var int ListIdx;
var NavMeshPathConstraint List[MAX_INSTANCES_PER_CLASS];
};
var native map{UClass*, FNavMeshPathConstraintCacheDatum} NavMeshPathConstraintCache;
/** Path Goal evaluator pool */
struct native NavMeshPathGoalEvaluatorCacheDatum
{
// the current free index
var int ListIdx;
// the list of constraints
var NavMeshPathGoalEvaluator List[MAX_INSTANCES_PER_CLASS];
};
var native map{UClass*, FNavMeshPathGoalEvaluatorCacheDatum} NavMeshPathGoalEvaluatorCache;
/** Set if any CrowdAgents are currently spawned in this world - needs to be set when agent is spawned */
var bool bHaveActiveCrowd;
/** Population manager being used by this level */
var CrowdPopulationManagerBase PopulationManager;
/** The lighting quality the level was last built with */
var(Lightmass) editconst ELightingBuildQuality LevelLightingQuality;
/** Steps in host migration progression */
enum EHostMigrationProgress
{
/** Not migrating */
HostMigration_None,
/** Client peer is waiting to find the new host */
HostMigration_FindingNewHost,
/** Client peer is starting migration as new host */
HostMigration_MigratingAsHost,
/** Client peer is starting migration as a client */
HostMigration_MigratingAsClient,
/** Client peer is traveling as a client */
HostMigration_ClientTravel,
/** New host has been selected and is waiting to travel. HostMigrationTravelCountdown begins */
HostMigration_HostReadyToTravel,
/** Migration process started but failed due to timeout */
HostMigration_Failed
};
/** State of host migration */
struct native HostMigrationState
{
/** Current progress of host migration process for client peers */
var EHostMigrationProgress HostMigrationProgress;
/** Elapsed time since host migration has started. Ie. transitioned from HostMigration_None */
var float HostMigrationElapsedTime;
/** Countdown begins ticking once new host has been selected. When it hits 0 then the new host will travel */
var float HostMigrationTravelCountdown;
/** URL to be used by the newly selected host to travel */
var string HostMigrationTravelURL;
/** if TRUE then host migration is currently enabled */
var bool bHostMigrationEnabled;
};
/** Info relevant to migrating a client peer to new host */
var const transient HostMigrationState PeerHostMigration;
/** Config if TRUE then host migration is allowed to occur */
var config bool bAllowHostMigration;
/** Started as soon as a client peer disconnects. If migration does succeed within this time then fall back to server disconnect failure */
var config float HostMigrationTimeout;
var transient PhysicsVolume FirstPhysicsVolume;
/** Allow gameplay frame pauses that IB does on hits (allow pause to not cut out the audio) */
var bool bGameplayFramePause;
`if(`__TW_)
/** If set, uses physX raycasts for visibility traces */
var(Physics) editconst bool bUsePxVisibilityCollision;
/** See `BalanceLog() */
var private FileWriter GameBalanceLog;
// ---------------------------------------------
// Light Animation
/** Curve patterns for supported light animation types */
var InterpCurveFloat FlickerCurve;
var InterpCurveFloat PulseCurve;
var InterpCurveFloat StrobeCurve;
var InterpCurveFloat ChaoticFlickerCurve;
var InterpCurveFloat InverseChaoticFlickerCurve;
/** The lower bound to which the light brightness curves should be clamped.
By default, the brightness can go to 0 (fully dark). This value will prevent the
brightness to drop below a specified value */
var(LightAnimation) float FlickerBrightnessLowerBoundClamp<UIMin=0.0|UIMax=1.0|ClampMin=0.0|ClampMax=1.0>;
var(LightAnimation) float PulseBrightnessLowerBoundClamp<UIMin=0.0|UIMax=1.0|ClampMin=0.0|ClampMax=1.0>;
var(LightAnimation) float StrobeBrightnessLowerBoundClamp<UIMin=0.0|UIMax=1.0|ClampMin=0.0|ClampMax=1.0>;
var(LightAnimation) float ChaoticFlickerBrightnessLowerBoundClamp<UIMin=0.0|UIMax=1.0|ClampMin=0.0|ClampMax=1.0>;
var(LightAnimation) float InverseChaoticFlickerBrightnessLowerBoundClamp<UIMin=0.0|UIMax=1.0|ClampMin=0.0|ClampMax=1.0>;
// ---------------------------------------------
// Misc VFX
/** MICs modified by zed time */
var(Rendering) array<MaterialInstanceConstant> ZedTimeMICs;
/** Used to increase/decrease the size of emitter pools */
var globalconfig float EmitterPoolScale;
/** Used to scale the lifetime of destructibles */
var globalconfig float DestructionLifetimeScale;
/** Whether explosion lights are supported or not */
var globalconfig bool bAllowExplosionLights;
/** Like bDropDetail, but with a higher DesiredFrameRate threshold for high detail FX */
var transient bool bDropHighDetail;
// ---------------------------------------------
// Manager (singleton) objects
/** Gameplay pool manager */
var string GameplayPoolManagerClassPath;
var transient Actor MyGameplayPoolManager;
/** Impact Effect manager **/
var string ImpactEffectManagerClassPath;
var transient Actor MyImpactEffectManager;
/** Gore Effect manager **/
var string GoreEffectManagerClassPath;
var transient Actor MyGoreEffectManager;
/** Light Pool Manager **/
var string LightPoolClassPath;
var transient Actor MyLightPool;
/** DeferredWorkManager **/
var string TWDeferredWorkManagerClassPath;
var transient Actor DeferredWorkManager;
/** Turbulence effect pool **/
var string TurbEffectPoolClassPath;
var transient Actor MyTurbEffectPool;
/** Custom particle pools */
var string GroundFireEmitterPoolClassPath;
var transient EmitterPool GroundFireEmitterPool;
var string ImpactFXEmitterPoolClassPath;
var transient EmitterPool ImpactFXEmitterPool;
/** Custom decal managers */
var globalconfig int MaxExplosionDecals;
var transient DecalManager ExplosionDecalManager;
/** Realtime timer helper */
var string TimerHelperClassPath;
var transient Actor TimerHelper;
// ---------------------------------------------
// Editor
/** Tracks time of last successful paths rebuild */
var string LastSuccessfulPathBuildTime;
`endif // __TW_ End
// NVCHANGE_BEGIN: Flex Mesh contact for the persistent splatter
struct native FlexMeshContactInfo
{
var vector ContactPosition;
var vector ContactNormal;
structcpptext
{
FFlexMeshContactInfo(const FVector& InContactPosition, const FVector& InContactNormal)
: ContactPosition(InContactPosition)
, ContactNormal(InContactNormal)
{
}
}
};
var transient array<FlexMeshContactInfo> FlexMeshContacts;
// NVCHANGE_END: Flex Mesh contact for the persistent splatter
cpptext
{
// UObject interface.
/**
* Called when a property on this object has been modified externally
*
* @param PropertyThatChanged the property that was modified
*/
virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent);
virtual void Serialize(FArchive& Ar);
virtual void PostLoad();
/**
* Called after GWorld has been set. Used to load, but not associate, all
* levels in the world in the Editor and at least create linkers in the game.
* Should only be called against GWorld::PersistentLevel's WorldInfo.
*/
void LoadSecondaryLevels();
/** Utility for returning the ULevelStreaming object for a particular sub-level, specified by package name */
ULevelStreaming* GetLevelStreamingForPackageName(FName PackageName);
// AActor interface.
INT* GetOptimizedRepList( BYTE* InDefault, FPropertyRetirement* Retire, INT* Ptr, UPackageMap* Map, UActorChannel* Channel );
#if WITH_EDITOR
virtual void CheckForErrors();
#endif
// Level functions
void SetZone( UBOOL bTest, UBOOL bForceRefresh );
void SetVolumes();
virtual void SetVolumes(const TArray<class AVolume*>& Volumes);
APhysicsVolume* GetDefaultPhysicsVolume();
APhysicsVolume* GetPhysicsVolume(const FVector& Loc, AActor *A, UBOOL bUseTouch);
FLOAT GetRBGravityZ();
/**
* Finds the post process settings to use for a given view location, taking into account the world's default
* settings and the post process volumes in the world.
* @param ViewLocation Current view location.
* @param bUseVolumes Whether to use the world's post process volumes
* @param OutPostProcessSettings Upon return, the post process settings for a camera at ViewLocation.
* @return If the settings came from a post process volume, the post process volume is returned.
*/
APostProcessVolume* GetPostProcessSettings(const FVector& ViewLocation,UBOOL bUseVolumes,FPostProcessSettings& OutPostProcessSettings);
/** Checks whether temporal AA is allowed. */
UBOOL GetAllowTemporalAA() const;
FLinearColor GetEnvironmentColor() const;
/**
* Finds the reverb settings to use for a given view location, taking into account the world's default
* settings and the reverb volumes in the world.
*
* @param ViewLocation Current view location.
* @param OutReverbSettings [out] Upon return, the reverb settings for a camera at ViewLocation.
* @param OutInteriorSettings [out] Upon return, the interior settings for a camera at ViewLocation.
* @return If the settings came from a reverb volume, the reverb volume's object index is returned.
*/
INT GetAudioSettings( const FVector& ViewLocation, struct FReverbSettings* OutReverbSettings, struct FInteriorSettings* OutInteriorSettings );
#if __TW_WWISE_
/**
* Finds the environment (auxiliary bus) settings to use for a given view location,
* taking into account the reverb volumes in the world.
*
* @param ViewLocation Current view location.
*/
void SetAkEnvironment( const FVector& ViewLocation );
#endif // __TW_WWISE_
/**
* Finds the portal volume actor at a given location
*/
APortalVolume* GetPortalVolume( const FVector& Location );
/** Returns TRUE if the given position is inside any AMassiveLODOverrideVolume in the world. */
UBOOL IsInsideMassiveLODVolume(const FVector& Location) const;
/**
* Remap sound locations through portals
*/
FVector RemapLocationThroughPortals( const FVector& SourceLocation, const FVector& ListenerLocation );
/**
* Sets bMapNeedsLightingFullyRebuild to the specified value. Marks the worldinfo package dirty if the value changed.
*
* @param bInMapNeedsLightingFullyRebuild The new value.
*/
void SetMapNeedsLightingFullyRebuilt(UBOOL bInMapNeedsLightingFullyRebuild);
#if __TW_PERSISTENT_SPLATTER_SYSTEM_
/**
* Sets bMapNeedsSplatterMapsRebuilt to the specified value. Marks the worldinfo package dirty if the value changed.
*
* @param bInMapNeedsSplatterMapsRebuilt The new value.
*/
void SetMapNeedsSplatterMapsRebuilt(UBOOL bInMapNeedsSplatterMapsRebuilt);
#endif
#if __TW_PRECOMPUTED_VISIBILITY_
/**
* Sets bMapNeedsPrecomputedVisibilityRebuilt to the specified value. Marks the worldinfo package dirty if the value changed.
*
* @param bInMapNeedsPrecomputedVisibilityRebuilt The new value.
*/
void SetMapNeedsPrecomputedVisibilityRebuilt(UBOOL bInMapNeedsPrecomputedVisibilityRebuilt);
#endif
/**
* @return Whether or not we can spawn more fractured chunks this frame
**/
UBOOL CanSpawnMoreFracturedChunksThisFrame() const;
/**
* Determines whether a map is the default local map.
*
* @param MapName if specified, checks whether MapName is the default local map; otherwise, checks the currently loaded map.
*
* @return TRUE if the map is the default local (or front-end) map.
*/
UBOOL IsMenuLevel( FString MapName=TEXT("") );
/** Add a string to the On-screen debug message system */
void AddOnScreenDebugMessage(QWORD Key,FLOAT TimeToDisplay,FColor DisplayColor,const FString& DebugMessage);
/** Retrieve the message for the given key */
UBOOL OnScreenDebugMessageExists(QWORD Key);
/**
* overidden to track references of pooled path constraints
*/
virtual void AddReferencedObjects( TArray<UObject*>& ObjectArray );
/**
* Update the current host migration progress
*
* @param NewState current host migration state to set
*/
void UpdateHostMigrationState(EHostMigrationProgress NewState);
/**
* Registers an attractor and returns TRUE if it was added successfully.
*/
UBOOL RegisterAttractor(AWorldAttractor* Attractor);
/**
* Unregisters an attractor and returns TRUE if it was already registered and removed.
*/
UBOOL UnregisterAttractor(AWorldAttractor* Attractor);
typedef TIndexedContainerIterator< TArray<AWorldAttractor*> > AWorldAttractorIter;
/**
* Gets a non-const iterator for the list of attractors.
*/
AWorldAttractorIter GetAttractorIter();
#if __TW_
virtual void PreBeginPlay();
#endif
}
//-----------------------------------------------------------------------------
// Functions.
/** ==== NAV MESH PATH CONSTRAINT/GOAL EVALUATOR POOLING ==== */
/**
* will go through all the pools for each constraint/evaluator class that has been added so far and reset
* the instance index to 0 (call this after the search is complete to indicate you're done
* with the constraints from the pool)
*/
native function ReleaseCachedConstraintsAndEvaluators();
/**
* Will search for an existing free constraint from the cache, and return it if one is found
* otherwise it will add a new instance to the cache and return that
* @param ConstraintClass - the class of the constraint to grab from the cache
* @param Requestor - the handle that needs this constraint
*/
native function NavMeshPathConstraint GetNavMeshPathConstraintFromCache(class<NavMeshPathConstraint> ConstraintClass, NavigationHandle Requestor);
/**
* Will search for an existing free Evaluator from the cache, and return it if one is found
* otherwise it will add a new instance to the cache and return that
* @param GoalEvalClass - the class of the evaluator to grab from the cache
* @param Requestor - the handle that needs this constraint
*/
native function NavMeshPathGoalEvaluator GetNavMeshPathGoalEvaluatorFromCache(class<NavMeshPathGoalEvaluator> GoalEvalClass, NavigationHandle Requestor);
simulated event ReplicatedEvent(Name VarName)
{
if (VarName == 'ReplicatedMusicTrack')
{
UpdateMusicTrack(ReplicatedMusicTrack);
}
Super.ReplicatedEvent(VarName);
}
/** Add a string to the On-screen debug message system */
native final function AddOnScreenDebugMessage(INT Key, FLOAT TimeToDisplay, Color DisplayColor, String DebugMessage);
/**
* Determines whether a map is the default local map.
*
* @param MapName if specified, checks whether MapName is the default local map; otherwise, checks the currently loaded map.
*
* @return TRUE if the map is the default local (or front-end) map.
*/
static native noexport final function bool IsMenuLevel( optional string MapName );
/**
* Sets the volume scale for music only (excludes sound effects). For Mobile, these are
* mp3 files, for PC/Console these are any AudioComponents where "bIsMusic" is true.
*
* @param VolumeMultiplier - Value between 0.0 and 1.0 to scale the volume
*/
native final function SetMusicVolume(float VolumeMultiplier);
native final function UpdateMusicTrack(MusicTrackStruct NewMusicTrack);
/**
* Returns the Z component of the current world gravity and initializes it to the default
* gravity if called for the first time.
*
* @return Z component of current world gravity.
*/
native function float GetGravityZ();
/**
* Grabs the default game sequence and returns it.
*
* @return the default game sequence object
*/
native simulated final function Sequence GetGameSequence() const;
/** Go over all loaded levels and get each root sequence */
native simulated final function array<Sequence> GetAllRootSequences() const;
native final function SetLevelRBGravity(vector NewGrav);
//
// Return the URL of this level on the local machine.
//
native simulated function string GetLocalURL() const;
//
// Demo build flag
//
native simulated static final function bool IsDemoBuild() const; // True if this is a demo build.
//@HSL_BEGIN - BWJ - 3-16-16 - Support for console dedicated servers
native static final function bool IsConsoleDedicatedServer() const;
// return TRUE if this is for an E3 demo
native simulated static final function bool IsE3Build() const;
//@HSL_END
//@SABER_EGS_BEGIN
// return TRUE if this is EOS build
native simulated static final function bool IsEOSBuild() const;
// return TRUE if this is EOS Server build
native simulated static final function bool IsEOSDedicatedServer() const;
//@SABER_EGS_END
native static final function bool IsNeoCheckerboardRendering() const;
/**
* Returns whether we are running on a console platform or on the PC.
* @param ConsoleType - if specified, only returns true if we're running on the specified platform
*
* @return TRUE if we're on a console, FALSE if we're running on a PC
*/
native simulated static final function bool IsConsoleBuild(optional EConsoleType ConsoleType=CONSOLE_Any) const;
/** Scale to apply to HUD (currently only used for 4K handling) */
native static final function FLOAT GetResolutionBasedHUDScale() const;
/** Returns whether Scaleform is compiled in. */
native simulated static final function bool IsWithGFx() const;
/** Returns whether script is executing within the editor. */
native simulated static final function bool IsPlayInEditor() const;
/** Returns whether script is executing within a preview window */
native simulated static final function bool IsPlayInPreview() const;
/** Returns whether script is executing within a mobile preview window */
native simulated static final function bool IsPlayInMobilePreview() const;
native simulated final function ForceGarbageCollection( optional bool bFullPurge );
native simulated final function VerifyNavList();
//
// Return the URL of this level, which may possibly
// exist on a remote machine.
//
native simulated function string GetAddressURL() const;
simulated function class<GameInfo> GetGameClass()
{
if(WorldInfo.Game != None)
return WorldInfo.Game.Class;
if (GRI != None && GRI.GameClass != None)
return GRI.GameClass;
return None;
}
/**
* Jumps the server to new level. If bAbsolute is true and we are using seemless traveling, we
* will do an absolute travel (URL will be flushed).
*
* @param URL the URL that we are traveling to
* @param bAbsolute whether we are using relative or absolute travel
* @param bShouldSkipGameNotify whether to notify the clients/game or not
*/
simulated event ServerTravel(string URL, optional bool bAbsolute, optional bool bShouldSkipGameNotify)
{
if ( InStr(url,"%")>=0 )
{
`log("URL Contains illegal character '%'.");
return;
}
if (InStr(url,":")>=0 || InStr(url,"/")>=0 || InStr(url,"\\")>=0)
{
`log("URL blocked");
return;
}
// Check for an error in the server's connection
if (Game != None && Game.bHasNetworkError)
{
`Log("Not traveling because of network error");
return;
}
// Set the next travel type to use
NextTravelType = bAbsolute ? TRAVEL_Absolute : TRAVEL_Relative;
// if we're not already in a level change, start one now
// If the bShouldSkipGameNotify is there, then don't worry about seamless travel recursion
// and accept that we really want to travel
if (NextURL == "" && (!IsInSeamlessTravel() || bShouldSkipGameNotify))
{
NextURL = URL;
if (Game != None)
{
// Skip notifying clients if requested
if (!bShouldSkipGameNotify)
{
Game.ProcessServerTravel(URL, bAbsolute);
}
}
else
{
NextSwitchCountdown = 0;
}
}
}
//
// ensure the DefaultPhysicsVolume class is loaded.
//
function ThisIsNeverExecuted(DefaultPhysicsVolume P)
{
P = None;
}
simulated function PreBeginPlay()
{
local class<EmitterPool> PoolClass;
local class<DecalManager> DecalManagerClass;
local class<FractureManager> FractureManagerClass;
local class<ParticleEventManager> ParticleEventManagerClass;
`if(`__TW_)
local class<Actor> ImpactEffectManagerClass;
local class<Actor> GoreEffectManagerClass;
local class<Actor> TurbEffectPoolClass;
local class<Actor> GameplayPoolManagerClass;
local class<Actor> LightPoolClass;
local class<Actor> TimerHelperClass;
`endif
Super.PreBeginPlay();
// create the emitter pool, decal manager, and fracture manager
// we only need to do this for the persistent level's WorldInfo as sublevel actors will have their WorldInfo set to it on association
if (WorldInfo.NetMode != NM_DedicatedServer && IsInPersistentLevel())
{
if (EmitterPoolClassPath != "")
{
PoolClass = class<EmitterPool>(DynamicLoadObject(EmitterPoolClassPath, class'Class'));
if (PoolClass != None)
{
MyEmitterPool = Spawn(PoolClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (DecalManagerClassPath != "")
{
DecalManagerClass = class<DecalManager>(DynamicLoadObject(DecalManagerClassPath, class'Class'));
if (DecalManagerClass != None)
{
MyDecalManager = Spawn(DecalManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (FractureManagerClassPath != "")
{
FractureManagerClass = class<FractureManager>(DynamicLoadObject(FractureManagerClassPath, class'Class'));
if (FractureManagerClass != None)
{
MyFractureManager = Spawn(FractureManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (ParticleEventManagerClassPath != "")
{
ParticleEventManagerClass = class<ParticleEventManager>(DynamicLoadObject(ParticleEventManagerClassPath, class'Class'));
if (ParticleEventManagerClass != None)
{
MyParticleEventManager = Spawn(ParticleEventManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
`if(`__TW_)
if (GroundFireEmitterPoolClassPath != "")
{
PoolClass = class<EmitterPool>(DynamicLoadObject(GroundFireEmitterPoolClassPath, class'Class'));
if (PoolClass != None)
{
GroundFireEmitterPool = Spawn(PoolClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (ImpactFXEmitterPoolClassPath != "")
{
PoolClass = class<EmitterPool>(DynamicLoadObject(ImpactFXEmitterPoolClassPath, class'Class'));
if (PoolClass != None)
{
ImpactFXEmitterPool = Spawn(PoolClass, self,, vect(0,0,0), rot(0,0,0));
ImpactFXEmitterPool.MaxActiveEffects *= EmitterPoolScale;
}
}
if (ImpactEffectManagerClassPath != "")
{
ImpactEffectManagerClass = class<Actor>(DynamicLoadObject(ImpactEffectManagerClassPath, class'Class'));
if (ImpactEffectManagerClass != None)
{
MyImpactEffectManager = Spawn(ImpactEffectManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (GoreEffectManagerClassPath != "")
{
GoreEffectManagerClass = class<Actor>(DynamicLoadObject(GoreEffectManagerClassPath, class'Class'));
if (GoreEffectManagerClass != None)
{
MyGoreEffectManager = Spawn(GoreEffectManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (LightPoolClassPath != "")
{
LightPoolClass = class<Actor>(DynamicLoadObject(LightPoolClassPath, class'Class'));
if (LightPoolClass != None)
{
MyLightPool = Spawn(LightPoolClass, self,, vect(0,0,0), rot(0,0,0));
}
}
if (TurbEffectPoolClassPath != "")
{
TurbEffectPoolClass = class<Actor>(DynamicLoadObject(TurbEffectPoolClassPath, class'Class'));
if (TurbEffectPoolClass != None)
{
MyTurbEffectPool = Spawn(TurbEffectPoolClass, self,, vect(0,0,0), rot(0,0,0));
}
}
// Create decal managers
ExplosionDecalManager = Spawn(class'DecalManager', self,, vect(0,0,0), rot(0,0,0));
ExplosionDecalManager.MaxActiveDecals = MaxExplosionDecals;
`endif
}
`if(`__TW_)
if(IsInPersistentLevel())
{
// Manager that defers work from during async to post asycn runs on both client and server.
DeferredWorkManager = Spawn(class'TWDeferredWorkManager', self,, vect(0,0,0), rot(0,0,0));
// We want the timer helper to exist on both client and server
if( TimerHelperClassPath != "" )
{
TimerHelperClass = class<Actor>( DynamicLoadObject(TimerHelperClassPath, class'Class') );
if( TimerHelperClass != None )
{
TimerHelper = Spawn( TimerHelperClass, self,, vect(0,0,0), rot(0,0,0) );
}
}
// Instance gameplay pool manager
if( WorldInfo.NetMode != NM_Client )
{
if (GameplayPoolManagerClassPath != "")
{
GameplayPoolManagerClass = class<Actor>(DynamicLoadObject(GameplayPoolManagerClassPath, class'Class'));
if (GameplayPoolManagerClass != None)
{
MyGameplayPoolManager = Spawn(GameplayPoolManagerClass, self,, vect(0,0,0), rot(0,0,0));
}
}
}
}
`endif
}
simulated function PostBeginPlay()
{
Super.PostBeginPlay();
if (IsConsoleBuild())
{
bUseConsoleInput = true;
}
}
/**
* Reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
// perform garbage collection of objects (not done during gameplay)
//ConsoleCommand("OBJ GARBAGE");
Super.Reset();
}
//-----------------------------------------------------------------------------
// Network replication.
replication
{
if( bNetDirty && Role==ROLE_Authority )
Pauser, TimeDilation, WorldGravityZ, bHighPriorityLoading, ReplicatedMusicTrack;
}
/** returns all NavigationPoints in the NavigationPointList that are of the specified class or a subclass
* @note this function cannot be used during level startup because the NavigationPointList is created in C++ ANavigationPoint::PreBeginPlay()
* @param BaseClass the base class of NavigationPoint to return
* @param (out) N the returned NavigationPoint for each iteration
*/
native final iterator function AllNavigationPoints(class<NavigationPoint> BaseClass, out NavigationPoint N);
/** returns all NavigationPoints whose cylinder intersects with a sphere of the specified radius at the specified point
* this function uses the navigation octree and is therefore fast for reasonably small radii
* @note this function cannot be used during level startup because the navigation octree is populated in C++ ANavigationPoint::PreBeginPlay()
* @param BaseClass the base class of NavigationPoint to return
* @param (out) N the returned NavigationPoint for each iteration
* @param Radius the radius to search in
*/
native final iterator function RadiusNavigationPoints(class<NavigationPoint> BaseClass, out NavigationPoint N, vector Point, float Radius);
/** returns a list of NavigationPoints and ReachSpecs that intersect with the given point and extent
* @param Point point to check
* @param Extent box extent to check
* @param (optional, out) Navs list of NavigationPoints that intersect
* @param (optional, out) Specs list of ReachSpecs that intersect
*/
native final noexport function NavigationPointCheck(vector Point, vector Extent, optional out array<NavigationPoint> Navs, optional out array<ReachSpec> Specs);
/** returns all Controllers in the ControllerList that are of the specified class or a subclass
* @note this function is only useful on the server; if you need the local player on a client, use Actor::LocalPlayerControllers()
* @param BaseClass the base class of Controller to return
* @param (out) C the returned Controller for each iteration
*/
native final iterator function AllControllers(class<Controller> BaseClass, out Controller C);
/** returns all Pawns in the PawnList that are of the specified class or a subclass
* @note: useful on both client and server; pawns are added/removed from pawnlist in PostBeginPlay (on clients, only relevant pawns will be available)
* @param BaseClass the base class of Pawn to return
* @param (out) P the returned Pawn for each iteration
* @param (optional) TestLocation is the world location used if
* TestRadius > 0
* @param (optional) TestRadius is the radius checked against
* using TestLocation, skipping any pawns not within that
* value
*/
native final iterator function AllPawns(class<Pawn> BaseClass, out Pawn P, optional vector TestLocation, optional float TestRadius);
/**
* Returns all NetConnections in the NetDriver ClientConnections list, along with their IP and Port
* NOTE: Serverside only
*
* @param ClientConnection The returned NetConnection
* @param ClientIP The IP of the NetConnection
* @param ClientPort The port the net connection is on
*/
//@HSL_BEGIN_XBOX
native final iterator function AllClientConnections(out Player ClientConnection, out IpAddr ClientIP, out int ClientPort);
//@HSL_END_XBOX
/**
* Called by GameInfo.StartMatch, used to notify native classes of match startup (such as Kismet).
*/
native final function NotifyMatchStarted(optional bool bShouldActivateLevelStartupEvents=true, optional bool bShouldActivateLevelBeginningEvents=true, optional bool bShouldActivateLevelLoadedEvents=false);
/** asynchronously loads the given levels in preparation for a streaming map transition.
* This codepath is designed for worlds that heavily use level streaming and gametypes where the game state should
* be preserved through a transition.
* @param LevelNames the names of the level packages to load. LevelNames[0] will be the new persistent (primary) level
*/
native final function PrepareMapChange(const out array<name> LevelNames);
/** returns whether there's a map change currently in progress */
native final function bool IsPreparingMapChange();
/** if there is a map change being prepared, returns whether that change is ready to be committed
* (if no change is pending, always returns false)
*/
native final function bool IsMapChangeReady();
/** cancels pending map change (@note: we can't cancel pending async loads, so this won't immediately free the memory) */
native final function CancelPendingMapChange();
/** actually performs the map transition prepared by PrepareMapChange()
* it happens in the next tick to avoid GC issues
* if a map change is being prepared but isn't ready yet, the transition code will block until it is
* wait until IsMapChangeReady() returns true if this is undesired behavior
*/
native final function CommitMapChange();
/** seamlessly travels to the given URL by first loading the entry level in the background,
* switching to it, and then loading the specified level. Does not disrupt network communication or disconnet clients.
* You may need to implement GameInfo::GetSeamlessTravelActorList(), PlayerController::GetSeamlessTravelActorList(),
* GameInfo::PostSeamlessTravel(), and/or GameInfo::HandleSeamlessTravelPlayer() to handle preserving any information
* that should be maintained (player teams, etc)
* This codepath is designed for worlds that use little or no level streaming and gametypes where the game state
* is reset/reloaded when transitioning. (like UT)
* @param URL - the URL to travel to; must be on the same server as the current URL
* @param bAbsolute (opt) - if true, URL is absolute, otherwise relative
* @param MapPackageGuid (opt) - the GUID of the map package to travel to - this is used to find the file when it has been autodownloaded,
* so it is only needed for clients
*/
native final function SeamlessTravel(string URL, optional bool bAbsolute, optional init Guid MapPackageGuid);
/** @return whether we're currently in a seamless transition */
native final function bool IsInSeamlessTravel();
/** this function allows pausing the seamless travel in the middle,
* right before it starts loading the destination (i.e. while in the transition level)
* this gives the opportunity to perform any other loading tasks before the final transition
* this function has no effect if we have already started loading the destination (you will get a log warning if this is the case)
* @param bNowPaused - whether the transition should now be paused
*/
native final function SetSeamlessTravelMidpointPause(bool bNowPaused);
/** @return the current MapInfo that should be used. May return one of the inner StreamingLevels' MapInfo if a streaming level
* transition has occurred via PrepareMapChange()
*/
native final function MapInfo GetMapInfo();
/** sets the current MapInfo to the passed in one */
native final function SetMapInfo(MapInfo NewMapInfo);
/**
* @Returns the name of the current map
*/
native final function string GetMapName(optional bool bIncludePrefix);
/** @return the current detail mode */
native final function EDetailMode GetDetailMode();
/** @return whether a demo is being recorded */
native final function bool IsRecordingDemo();
/** @return whether a demo is being played back */
native final function bool IsPlayingDemo();
/** if playing back a demo, returns the frame information for that demo
* @param CurrentFrame (optional, out) - current frame the demo playback is on
* @param TotalFrames (optional, out) - total number of frames in the demo
*/
native final function GetDemoFrameInfo(optional out int CurrentFrame, optional out int TotalFrames);
/** @return if a demo is being played back and rewinding is enabled, returns the list of rewind points that are available
* the values correspond to demo frames, relative to the return value of GetNumDemoFrames()
*/
native final function bool GetDemoRewindPoints(out array<int> OutRewindPoints);
/**
* This function will do what ever memory tracking we have enabled. Basically there are a myriad of memory tracking/leak detection
* methods and this function abstracts all of that.
**/
native final function DoMemoryTracking();
/** Get the current fracture settings for the loaded world - handles streaming correctly. */
native final function WorldFractureSettings GetWorldFractureSettings() const;
/** @return Allows non-actor derived classes to get access to the world info easily */
native final static function WorldInfo GetWorldInfo();
/** Returns an Environment Volume if one is found at given location. If many are overlapping, only the first one found will be returned. */
native final function EnvironmentVolume FindEnvironmentVolume(Vector TestLocation);
/**
* Verifies that all players can be part of host migration
*
* @return TRUE if the host migration process can be started
*/
simulated event bool CanBeginHostMigration()
{
local PlayerController PC;
foreach LocalPlayerControllers(class'PlayerController', PC)
{
if (PC.IsPrimaryPlayer())
{
// make sure all players allowed to play online
if (!PC.CanAllPlayersPlayOnline() ||
// make sure there is a potential host to migrate to
PC.BestNextHostPeers.Length == 0)
{
return false;
}
}
}
return true;
}
/**
* Try to start the process of host migration. This is called when server disconnect is detected.
* If host migration can't be started then fall back to the normal disconnect process.
* Also notify peers through peer net driver RPC that server connection has been lost.
*
* @return TRUE if the host migration process was initiated successfully
*/
native function bool BeginHostMigration();
/**
* Notification when host migration state has changed
*
* @param NewState current host migration state
* @param OldState previous host migration state
*/
simulated event NotifyHostMigrationStateChanged(EHostMigrationProgress NewState,EHostMigrationProgress OldState)
{
local PlayerController PC;
// Detect initial start of host migration process
if (OldState == HostMigration_None &&
NewState != HostMigration_None)
{
foreach LocalPlayerControllers(class'PlayerController', PC)
{
if (PC.IsPrimaryPlayer())
{
PC.NotifyHostMigrationStarted();
break;
}
}
}
}
/**
* Enable or disable host migration.
*
* @param bEnabled TRUE if host migration should be enabled.
*/
native function ToggleHostMigration(bool bEnabled);
/**
* Tells the world to compact the current Physics instance pools to return memory to general availability
*/
native final function ClearObjectPools();
`if(`isdefined(__TW_WWISE_))
/**
* Retrieves highest-priority ReverbVolume that encompasses AtLocation
*/
native function ReverbVolume GetReverbVolume( vector AtLocation );
/**
* Retrieves name of AK environment at AtLocation
*/
native function name GetAkEnvironmentName( vector AtLocation );
`endif
`if(`__TW_)
/** See `BalanceLog() */
native function LogGameBalance(coerce string S);
native function TWLogsInit(); // resets the millisecond diff timer
/** More than 9 params? do some manual concatination */
native function TWLogEvent( string EventName,
PlayerReplicationInfo info,
optional coerce string P1,
optional coerce string P2,
optional coerce string P3,
optional coerce string P4,
optional coerce string P5,
optional coerce string P6,
optional coerce string P7,
optional coerce string P8,
optional coerce string P9 );
native function TWPushLogs();
`endif
defaultproperties
{
Components.Remove(Sprite)
RemoteRole=ROLE_SimulatedProxy
bAlwaysRelevant=true
TimeDilation=1.0
DemoPlayTimeDilation=1.0
bHiddenEd=True
DefaultTexture=Texture2D'EngineResources.DefaultTexture'
WhiteSquareTexture=WhiteSquareTexture
LargeVertex=Texture2D'EditorResources.LargeVertex'
BSPVertex=Texture2D'EditorResources.BSPVertex'
bWorldGeometry=true
VisibleGroups="None"
VisibleLayers="None"
MoveRepSize=+42.0
bBlockActors=true
StallZ=+1000000.0
PackedLightAndShadowMapTextureSize=1024
`if(`__TW_LIGHTING_MODIFICATIONS_)
bUseGlobalIllumination=false
`else
bUseGlobalIllumination=true
`endif
MaxTrianglesPerLeaf=4
DefaultColorScale=(X=1.f,Y=1.f,Z=1.f)
bPlaceCellsOnSurfaces=True
VisibilityCellSize=200
VisibilityAggressiveness=VIS_LeastAggressive
ImageReflectionEnvironmentColor=(R=1.f,G=1.f,B=1.f,A=1.f)
`if(`__TW_PRECOMPUTED_VISIBILITY_)
VisibilitySpreadingIterations=1
MeshBoundsScale=1.1f
PlayAreaHeight=172.f
MinMeshSamples=28
MaxMeshSamples=80
NumCellSamples=24
NumImportanceSamples=40
CellRenderingBucketSize=5
NumCellRenderingBuckets=5
NumCellDistributionBuckets=800
bPlaceCellsOnOpaqueOnly=false
bCompressVisibilityData=true
`endif
`if(`__TW_)
LevelShadowDepthBias=0.012
`endif
CharacterLitIndirectBrightness=1
CharacterLitIndirectContrastFactor=1
CharacterShadowedIndirectBrightness=1
CharacterShadowedIndirectContrastFactor=1
CharacterLightingContrastFactor=1.5
MaxPhysicsDeltaTime=0.33333333
DefaultSkinWidth=0.025
ApexLODResourceBudget=-1
ApexDestructionLODResourceValue = 1000
ApexClothingLODResourceValue = 1000
MaxNumFacturedChunksToSpawnInAFrame=12
Begin Object Class=PhysicsLODVerticalEmitter Name=PhysicsLODVerticalEmitter0
End Object
EmitterVertical=PhysicsLODVerticalEmitter0
// Server travel is relative by default
NextTravelType=TRAVEL_Relative
bMovable=FALSE
// mobile fog settings
bFogEnabled=false
FogStart=400.0
FogEnd=4000.0
FogColor=(R=128,G=128,B=255,A=192)
// mobile bump offset settings
bBumpOffsetEnabled=true
BumpEnd=1000.0
// Gamma correction on mobile defaults to off
bUseGammaCorrection=false
// Set level lighting quality to invalid for new maps with no built lighting or old maps where
// quaility cant be determined. The cooker will not warn when the quality is invalid
LevelLightingQuality = Quality_MAX;
`if(`__TW_LIGHTING_MODIFICATIONS_) // Light Animation
// Light brightness animation curves
FlickerCurve={(
Points={(
(InVal=0.0,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.1,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.15,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.3,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.5,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.55,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.6,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.65,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.8,OutVal=1.0,InterpMode=CIM_Constant)
)})}
PulseCurve={(
Points={(
(InVal=0.0,OutVal=0.0,InterpMode=CIM_CurveAuto),
(InVal=0.25,OutVal=1.0,InterpMode=CIM_CurveAuto),
(InVal=0.50,OutVal=0.0,InterpMode=CIM_CurveAuto),
(InVal=0.75,OutVal=1.0,InterpMode=CIM_CurveAuto),
(InVal=1.0,OutVal=0.0,InterpMode=CIM_CurveAuto)
)})}
StrobeCurve={(
Points={(
(InVal=0.0,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.25,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.50,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.75,OutVal=0.0,InterpMode=CIM_Constant)
)})}
ChaoticFlickerCurve={(
Points={(
(InVal=0.0,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.8,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.812,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.824,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.832,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.84,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.86,OutVal=0.0,InterpMode=CIM_Constant)
)})}
InverseChaoticFlickerCurve={(
Points={(
(InVal=0.0,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.8,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.812,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.824,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.832,OutVal=1.0,InterpMode=CIM_Constant),
(InVal=0.84,OutVal=0.0,InterpMode=CIM_Constant),
(InVal=0.86,OutVal=1.0,InterpMode=CIM_Constant)
)})}
`endif
`if(`__TW_)
// Override DefaultGravityZ so it's not user configurable
GlobalGravityZ=-1150
LastSuccessfulPathBuildTime="Never!"
GameplayPoolManagerClassPath="KFGame.KFGameplayPoolManager"
EmitterPoolClassPath="Engine.EmitterPool"
GroundFireEmitterPoolClassPath="KFGame.GroundFireEmitterPool"
ImpactFXEmitterPoolClassPath="KFGame.KFImpactFXEmitterPool"
FractureManagerClassPath="Engine.FractureManager"
ImpactEffectManagerClassPath="KFGame.KFImpactEffectManager"
GoreEffectManagerClassPath="KFGame.KFGoreManager"
LightPoolClassPath="KFGame.KFLightPool"
TimerHelperClassPath="KFGame.KFRealtimeTimerHelper"
TWDeferredWorkManagerClassPath="Engine.TWDeferredWorkManager"
//TurbEffectPoolClassPath="KFGame.TurbEffectPool"
bUsePxVisibilityCollision=true
UseCheckbackMatchmaking=FALSE
`endif
}