Engine.LevelInfo

//=============================================================================
// LevelInfo contains information about the current level. There should 
// be one per level and it should be actor 0. UnrealEd creates each level's 
// LevelInfo automatically so you should never have to place one
// manually.
//
// The ZoneInfo properties in the LevelInfo are used to define
// the properties of all zones which don't themselves have ZoneInfo.
//=============================================================================
class LevelInfo extends ZoneInfo
	native
	nativereplication;

// Textures.
#exec Texture Import File=Textures\WhiteSquareTexture.pcx
#exec Texture Import File=Textures\S_Vertex.tga Name=LargeVertex
//NEW
#exec Texture Import File=Textures\WireframeTexture64.tga NAME=WireframeTexture //reduce memory consumption from 350k to 22k
//OLD #exec Texture Import File=Textures\WireframeTexture.tga

//NEW (mdf) moved here from UnPath.h IF THESE SIZES CHANGE, UPDATE PATHSIZES ALSO
const MINCOMMONRADIUS			= 20.0;			// min typical radius for non-human intelligent creatures
const HUMANRADIUS				= 28.0;			// normal player pawn radius
const COMMONRADIUS				= 34.0;			// max typical radius of intelligent creatures
const MAXCOMMONRADIUS			= 100.0;		// max radius to consider in building paths
const MINCOMMONHEIGHT			= 20.0;			// min typical height for non-human intelligent creatures 
const HUMANHEIGHT				= 54.0;			// normal playerpawn height
const COMMONHEIGHT				= 70.0;			// max typical radius of intelligent creatures
const MAXCOMMONHEIGHT			= 100.0;		// max height to consider in building paths
const CROUCHEDHUMANHEIGHT		= 32.0;			// crouched playerpawn height
const TESTJUMPZ					= 470.0;		// jumpz for defining paths (based on player jumpz for your game)
const TESTMAXFALLSPEED			= 2500.0;		// maximum landing speed without taking damage, for the pawntype that can survive the highest landing speed
const TESTSTANDARDFALLSPEED		= 1200.0;
const PATHPRUNING				= 1.2;			// maximum relative length of indirect path to allow pruning of direct reachspec between two pathnodes
const MAXJUMPHEIGHT				= 94.0;			// max height of ledge pawn can jump up onto
const MINMOVETHRESHOLD			= 4.1;			// minimum distance to consider an AI predicted move valid
const HUMANCROUCHHEIGHT			= 32.0;
//OLD

//NEW (mdf) expose max pathing distances (tbd - make these level properties?)
const PathsMaxDist				= 1200.0; 
const PathsMaxDistSquared		= 1440000.0;
//OLD

//NEW (arl) Level-Objectives support.
enum ELevelObjectiveStatus
{
	OBJECTIVE_Disabled,
	OBJECTIVE_Incomplete,
	OBJECTIVE_Completed,
	OBJECTIVE_Failed,
};
var localized string LevelObjectiveStatusText[4];
struct native TLevelObjective
{
	var() name Tag;
	var() string Text;
	var() ELevelObjectiveStatus Status;
};
var() localized array<TLevelObjective> LevelObjectives;
var() localized string EmptyObjectivesText;
//OLD

//-----------------------------------------------------------------------------
// Level time.

// Time passage.
var() float TimeDilation;          // Normally 1 - scales real time passage.

// Current time.
var           float	TimeSeconds;   // Time in seconds since level began play.
var transient int   Year;          // Year.
var transient int   Month;         // Month.
var transient int   Day;           // Day of month.
var transient int   DayOfWeek;     // Day of week.
var transient int   Hour;          // Hour.
var transient int   Minute;        // Minute.
var transient int   Second;        // Second.
var transient int   Millisecond;   // Millisecond.
var			  float	PauseDelay;		// time at which to start pause

//-----------------------------------------------------------------------------
// Text info about level.

var() localized string Title;
var() string Author;					// Who built it.
var() int IdealPlayerCount;				// Ideal number of players for this level. 
var() localized string LevelEnterText;  // Message to tell players when they enter.
var() string LocalizedPkg;				// Package to look in for localizations.
var PlayerReplicationInfo Pauser;       // If paused, name of person pausing the game.
var	LevelSummary Summary;
var	LevelDesc Description;				//NEW: Remove LevelSummary, etc?
var string VisibleGroups;				// List of the group names which were checked when the level was last saved
var	bool bDisableAmbientSound;			//NEW: controls whether ambient sound plays

//-----------------------------------------------------------------------------
// Flags affecting the level.

var() bool           bLonePlayer;     // No multiplayer coordination, i.e. for entranceways.
var bool             bBegunPlay;      // Whether gameplay has begun.
var bool             bPlayersOnly;    // Only update players.
var bool             bHighDetailMode; // Client high-detail mode.
var bool			 bDropDetail;	  // frame rate is below DesiredFrameRate, so drop high detail actors
var bool			 bAggressiveLOD;  // frame rate is well below DesiredFrameRate, so make LOD more aggressive
var bool             bStartup;        // Starting gameplay.
//NEW (mdf)
var(Paths) const editconst int PathsRebuiltStamp;			// set to RequiredPathsRebuiltStamp when paths rebuilt
var(Paths) const editconst int RequiredPathsRebuiltStamp;	// minimum stamp needed for paths to be considered valid (incremented when build changed in a way that requires paths to be rebuilt
/*OLD
var	bool			 bPathsRebuilt;	  // True if path network is valid
*/
var transient const bool		 bPhysicsVolumesInitialized;	// true if physicsvolume list initialized

//-----------------------------------------------------------------------------
//NEW (mdf) Legend - used for saving the viewport camera positions
var() vector  CameraLocationDynamic;
var() vector  CameraLocationTop;
var() vector  CameraLocationFront;
var() vector  CameraLocationSide;
var() rotator CameraRotationDynamic;
//OLD

//-----------------------------------------------------------------------------
// Audio properties.

var(Audio) string	Song;			// Filename of the streaming song.
var(Audio) float	PlayerDoppler;	// Player doppler shift, 0=none, 1=full.
var(Audio) float	AudioMaxRadiusMultiplier; //NEW (mwp) formerly GAudioMaxRadiusMultiplier in Core.h

//NEW
//-----------------------------------------------------------------------------
var(DirectMusic) string DMSong,DMScript;
//OLD

//-----------------------------------------------------------------------------
// Miscellaneous information.

var() float Brightness;
var() texture Screenshot;
var texture DefaultTexture;
var texture WireframeTexture;
var texture WhiteSquareTexture;
var texture LargeVertex;
var int HubStackLevel;
var transient enum ELevelAction
{
	LEVACT_None,
	LEVACT_Loading,
	LEVACT_Saving,
	LEVACT_Connecting,
	LEVACT_Precaching,
	LEVACT_GameOver,
	LEVACT_MissionFailed,
	LEVACT_Initializing,
} LevelAction;

struct native UIComponentInfo
{
	var() string Component;
	var() string Parent;
};

var() array<UIComponentInfo> UIComponents;

//-----------------------------------------------------------------------------
// Renderer Management.
var() bool bNeverPrecache;
var() bool bCoronaPawnTrace;	//NEW (mwp)
var() float NearClippingPlane;	//NEW (mwp) set NEAR_CLIPPING_PLANE with this value when the level is loaded
var() float FarClippingPlane;	//NEW (mwp) set FAR_CLIPPING_PLANE with this value when the level is loaded

//-----------------------------------------------------------------------------
// Networking.

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.

//-----------------------------------------------------------------------------
// Gameplay rules

var() string DefaultGameType;
var GameInfo Game;
//NEW (mwp) Support for level-specific inventory configuration (for single-player) implemented w/in the game-specific GameInfo
var() array< class<Inventory> > DefaultInventory;
//OLD

//-----------------------------------------------------------------------------
// Navigation point and Pawn lists (chained using nextNavigationPoint and nextPawn).

var const NavigationPoint NavigationPointList;
var const Controller ControllerList;
var const PlayerController PlayerControllerList; //NEW (mdf)
var const Pawn PawnList; //NEW (mdf)
var private array<Actor> CoverActorList; //NEW (mdf) cover support
var private array<Actor> SpecialColliderList; //NEW (mdf) XMP support

var() array< class<Actor> > PrecacheList;	//NEW (mdf)
var globalconfig bool bPrecacheActors;		//NEW (mdf)

var private array<Mesh> MeshList; //NEW (mdf) fix for Golem serialization issues

//NEW MJL: generic lists
var() array<ActorList> ActorLists;
//OLD

//NEW: particles
var array<Object> ExternalForces;		// list of forces which affect bExternallyAffected ParticleTemplates.
var array<Object> AffectedTemplates;	// list of the aforementioned templates.
//OLD

//-----------------------------------------------------------------------------
// Server related.

var string NextURL;
var bool bNextItems;
var float NextSwitchCountdown;

//-----------------------------------------------------------------------------
// Global object recycling pool.

var ObjectPool	ObjectPool;

struct native ObjectPoolPrecacheItem
{
	var() config class ObjectClass;
	var() config int NumObjects;
};

var() globalconfig array<ObjectPoolPrecacheItem> ObjectPoolPrecacheList;
var() bool bDisableObjectPoolPrecache;

//NEW: MP3
//-----------------------------------------------------------------------------
// MP3 playback
var() string MP3Filename;
//OLD

var() string MapName;						//NEW (mdf) mapname (e.g. to get around autoplay issue) -- should be a valid filename
var() bool bVerboseWarnings;				//NEW (mdf) controls which errors/warnings are shown when building level
var const array<ReachSpec> ReachSpecs;		//NEW (mdf) list of all reachspecs in level

var(Paths) array<TCollision> PathSizes;		//NEW (mdf) DO NOT MODIFY THIS UNLESS YOU KNOW WHAT YOU ARE DOING - list of path sizes to use when building paths (smallest to largest)
var(Paths) bool	bPathsFilterFly;			//NEW (mdf)
var(Paths) bool	bPathsFilterSwim;			//NEW (mdf)
var(Paths) float PathsMaxJumpDownDistance;	//NEW (mdf)
var(Paths) float PathsMaxJumpUpDistance;	//NEW (mdf)
var(Paths) float PathsMaxJumpDistance;		//NEW (mdf)
var(Paths) float PathsGroundSpeed;			//NEW (mdf) groundspeed for defining paths (based on player groundspeed for your game)
var(Paths) bool  bPlayerOnlyPickups;		//NEW (mdf) if true, pickups not used for paths

//-----------------------------------------------------------------------------
// Functions.

//NEW (mdf) tbd:
/* Attempts to insert a path node into the level's path network at the given 
location. First sees whether a PathNode can be placed at the given location and
moves the PathNode down so that it is resting on the level geometry below it.
If all is well, attempts to join the new path node to neighbouring pathnodes
which are within PathsMaxDist units. Does a simple reachability test using the
default player sizes (doesn't try all the sizes that are used during "paths
define"). 

If the reachability test succeeds, inserts that path into the level's path node
network:
	
	+adds the new reachspec to the end of the path node's PathList list
	+inserts the navigation point into the level's NavigationPoint list (if its
	 not there already)

Also checks paths in the opposite direction.

Use bForce=true to force the exact given location to be used (won't attempt to
drop the PathNode to the ground).

Returns true/false for success/failure. 

native static final function bool AddPathNode( vector Location, optional bool bForce );
*/
//OLD

//NEW MJL: generic lists
/*
Usage:
Level.ActorLists[Level.GetListNum('SomeName')].ActorTypes ....
local array<actor> List;
List = Level.GetList('Pawn');
for( i=0; i<List.Length; i++ )
	log(List[i].Location); //log the location of the various pawn's locations
*/

native simulated final function AddList( name ListName, array<ActorType> ActorTypes ); // add list by name with given ActorTypes
native simulated final function RemoveList( name ListName);				// remove list by name
native simulated function int GetListNum( name ListName );				// get the number for a given list name
native simulated function array<Actor> GetList( name ListName );	// get the actor list for a given list name
//OLD

//NEW (mjl) Lists
native(1080) final function RegisterExternalForce( Object Force );
native(1081) final function UnRegisterExternalForce( Object Force );
native(1082) final function RegisterAffectedTemplate( Object ParticleTemplate );
native(1083) final function UnRegisterAffectedTemplate( Object ParticleTemplate );
//OLD

//NEW
//
// Returns our LevelDesc object (creating it if necessary).
//
native simulated function LevelDesc GetLevelDesc();
//OLD

//
// Return the URL of this level on the local machine.
//
native simulated function string GetLocalURL();

//NEW URL option support
native simulated function bool HasURLOption( string Option );
native simulated function bool GetURLOption( string Option, out string Value );
native simulated function AddURLOption( string Option, string Value );
native simulated function RemoveURLOption( string Option );
//OLD

//
// Return the URL of this level, which may possibly
// exist on a remote machine.
//
native simulated function string GetAddressURL();

//
// Jump the server to a new level.
//
event ServerTravel( string URL, bool bItems )
{
	if( NextURL=="" )
	{
		bNextItems          = bItems;
		NextURL             = URL;
		if( Game!=None )
			Game.ProcessServerTravel( URL, bItems );
		else
			NextSwitchCountdown = 0;
	}
}

//
// ensure the DefaultPhysicsVolume class is loaded.
//
function ThisIsNeverExecuted()
{
	local DefaultPhysicsVolume P;
	P = None;
}


/* Reset() 
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
{
	reliable if( bNetDirty && Role==ROLE_Authority )
		Pauser, TimeDilation;
}
*/

//
//	PreBeginPlay
//

simulated event PreBeginPlay()
{
	// Don't precache for entry.
	if(string(Outer)=="Entry")
		return;

	// Create the object pool.
	ObjectPool = new(Self) class'ObjectPool';
	PrecacheObjects();
}

simulated function PrecacheObjects()
{
	local int i,j;
	local ShadowBitmapMaterial M;
	local array<Object> Objects;

	if(bDisableObjectPoolPrecache)
		return;

	// Precache objects.
	for(i=0; i<ObjectPoolPrecacheList.Length; i++)
	{
		Objects.Length = ObjectPoolPrecacheList[i].NumObjects;
		for(j=0; j<Objects.Length; j++)
			Objects[j] = ObjectPool.AllocateObject(ObjectPoolPrecacheList[i].ObjectClass,Self);
		for(j=0; j<Objects.Length; j++)
			ObjectPool.FreeObject(Objects[j]);
	}

	// Hack for precaching ShadowBitmapMaterials.
	for(i=0; i<ObjectPool.Objects.Length; i++)
	{
		M = ShadowBitmapMaterial(ObjectPool.Objects[i]);
		if(M?) M.SetRes(GetClient().ShadowResolution);
	}
}

event Replication()
{
	Super.Replication();
	DOREP('Pauser');
	DOREP('TimeDilation');
}

//NEW (mdf)
function AddToCoverActorList( Actor A )
{
	//local int ii;
	
	CoverActorList[ CoverActorList.Length ] = A;
	//DMTNS( "AddToCoverActorList added: " $ A $ " to list with " $ CoverActorList.Length-1 $ " entries:" );
	//for( ii=0; ii<CoverActorList.Length; ii++ )
	//	DMTNS( "  " $ ii $ ": " $ CoverActorList[ ii ] );
}

function RemoveFromCoverActorList( Actor A )
{
	local bool bFound;
	local int ii;
	
	for( ii=0; ii<CoverActorList.Length; ii++ )
	{
		if( CoverActorList[ ii ] == A )
		{
			CoverActorList.Remove( ii, 1 );
			bFound = true;
			break;
		}
	}	
	
	//DMTNS( "RemoveFromCoverActorList removed: " $ A $ " from list with " $ CoverActorList.Length+1 $ " entries:" );
	//DMAssert( bFound, GetContext(0) @ " Actor not found in list: " $ A );
	//for( ii=0; ii<CoverActorList.Length; ii++ )
	//	DMTNS( "  " $ ii $ ": " $ CoverActorList[ ii ] );
}

function AddToSpecialColliderList( Actor A )
{
	//local int ii;
	
	SpecialColliderList[ SpecialColliderList.Length ] = A;
	//DMTNS( "AddToSpecialColliderList added: " $ A $ " to list with " $ CoverActorList.Length-1 $ " entries:" );
	//for( ii=0; ii<SpecialColliderList.Length; ii++ )
	//	DMTNS( "  " $ ii $ ": " $ SpecialColliderList[ ii ] );
}

function RemoveFromSpecialColliderList( Actor A )
{
	local bool bFound;
	local int ii;
	
	for( ii=0; ii<SpecialColliderList.Length; ii++ )
	{
		if( SpecialColliderList[ ii ] == A )
		{
			SpecialColliderList.Remove( ii, 1 );
			bFound = true;
			break;
		}
	}	
	
	//DMTNS( "RemoveFromSpecialColliderList removed: " $ A $ " from list with " $ SpecialColliderList.Length+1 $ " entries:" );
	//DMAssert( bFound, GetContext(0) @ " Actor not found in list: " $ A );
	//for( ii=0; ii<SpecialColliderList.Length; ii++ )
	//	DMTNS( "  " $ ii $ ": " $ SpecialColliderList[ ii ] );
	
}

function bool HasSpecialColliders()
{
	return ( SpecialColliderList.Length > 0 );
}
//OLD

//NEW (mdf) fix for Golem serialization issues
// NOTE (mdf): destroy is causing problems with golem. If you save/load
// a level when there are no more references to Mesh X, then Mesh X is
// "cleaned up" and subsequent NPCs which are spawned in and use that 
// Mesh won't have a mesh (and will be drawn as a collision cylinder).
// This code makes sure that there is always at least one reference
// to any Mesh that has been used in the level.
function AddMeshListEntry( Actor A )
{
	local int ii;

	if( A.Mesh == None || A.DrawType != DT_Mesh )
		return; // not applicable
		
	for( ii=0; ii<MeshList.Length; ii++ )
	{
		if( MeshList[ ii ] == A.Mesh )
			return; // already in list
	}

	MeshList[ MeshList.Length ] = A.Mesh;
}
//OLD

//NEW (arl) Level-Objectives support.
function array<string> UpdateObjective( name Tag, ELevelObjectiveStatus Status )
{
	local array<string> Text;
	local int i,j;
	for(i=0;i<LevelObjectives.length;i++)
		if(LevelObjectives[i].Tag==Tag)
		{
			if(LevelObjectives[i].Status==OBJECTIVE_Disabled)
				Text[j++]=LevelObjectives[i].Text;
			LevelObjectives[i].Status=Status;
		}
	return Text;
}

function array<string> GetObjectives()
{
	local array<string> Objectives;
	local int i,j;
	for(i=0;i<LevelObjectives.length;i++)
		if(LevelObjectives[i].Status!=OBJECTIVE_Disabled)
			Objectives[j++] = " * " $ LevelObjectiveStatusText[LevelObjectives[i].Status] $ " " $ LevelObjectives[i].Text;
	if(Objectives.length==0)
		Objectives[0]=EmptyObjectivesText;
	return Objectives;
}
//OLD

defaultproperties
{
	LevelObjectiveStatusText(0)="[Disabled]"
	LevelObjectiveStatusText(1)="[Incomplete]"
	LevelObjectiveStatusText(2)="[Completed]"
	LevelObjectiveStatusText(3)="[Failed]"
	EmptyObjectivesText="No current objectives."
	TimeDilation=1.000000
	Title="Untitled"
	VisibleGroups="None"
	bHighDetailMode=true
	PathsRebuiltStamp=1
	RequiredPathsRebuiltStamp=4
	CameraLocationDynamic=(X=-500.000000,Y=-300.000000,Z=300.000000)
	CameraLocationTop=(X=-500.000000,Y=-300.000000,Z=40000.000000)
	CameraLocationFront=(X=-500.000000,Y=300.000000,Z=40000.000000)
	CameraLocationSide=(X=-300.000000,Y=300.000000,Z=40000.000000)
	AudioMaxRadiusMultiplier=100.000000
	Brightness=1.000000
	DefaultTexture=Texture'Engine.DefaultTexture'
	WireframeTexture=Texture'Engine.WireframeTexture'
	WhiteSquareTexture=Texture'Engine.WhiteSquareTexture'
	LargeVertex=Texture'Engine.LargeVertex'
	NearClippingPlane=10.000000
	FarClippingPlane=65536.000000
	bPrecacheActors=true
     ObjectPoolPrecacheList(0)=(ObjectClass=Class'Engine.ShadowBitmapMaterial',NumObjects=16)
     PathSizes(0)=(Height=20.000000,Radius=20.000000)
     PathSizes(1)=(Height=32.000000,Radius=28.000000)
     PathSizes(2)=(Height=54.000000,Radius=28.000000)
     PathSizes(3)=(Height=70.000000,Radius=34.000000)
     PathSizes(4)=(Height=70.000000,Radius=40.000000)
     PathSizes(5)=(Height=70.000000,Radius=60.000000)
     PathSizes(6)=(Height=96.000000,Radius=60.000000)
     PathSizes(7)=(Height=100.000000,Radius=80.000000)
     PathSizes(8)=(Height=100.000000,Radius=100.000000)
     PathSizes(9)=(Height=100.000000,Radius=120.000000)
	PathsMaxJumpDownDistance=340282346638528860000000000000000000000.000000
	PathsMaxJumpUpDistance=340282346638528860000000000000000000000.000000
	PathsMaxJumpDistance=340282346638528860000000000000000000000.000000
	PathsGroundSpeed=263.000000
	bPlayerOnlyPickups=true
	bWorldGeometry=true
	bAlwaysRelevant=true
	NetUpdateFrequency=0.250000
	bHiddenEd=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}