initial commit after moving to new repo

6 files changed, 949 insertions, 0 deletions

diff --git a/Northstar.CustomServers/scripts/vscripts/class/CHardPointEntity.nut b/Northstar.CustomServers/scripts/vscripts/class/CHardPointEntity.nut
new file mode 100644
index 000000000..4eb979558
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/CHardPointEntity.nut
@@ -0,0 +1,15 @@
+untyped
+
+global function CodeCallback_RegisterClass_C_HardPointEntity
+
+function CodeCallback_RegisterClass_C_HardPointEntity()
+{
+	/*C_HardPointEntity.ClassName <- "C_HardPointEntity"
+
+
+	function C_HardPointEntity::Enabled()
+	{
+		return this.GetHardpointID() >= 0
+	}
+	#document( "C_HardPointEntity::Enabled", "Returns true if this hardpoint is enabled" )*/
+}
diff --git a/Northstar.CustomServers/scripts/vscripts/class/cai_basenpc.nut b/Northstar.CustomServers/scripts/vscripts/class/cai_basenpc.nut
new file mode 100644
index 000000000..631e01fc0
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/cai_basenpc.nut
@@ -0,0 +1,272 @@
+untyped
+
+global function IsCrawling
+global function CodeCallback_RegisterClass_CAI_BaseNPC
+global function SetSpawnOption_AISettings
+global function SetSpawnOption_Alert
+global function SetSpawnOption_NotAlert
+global function SetSpawnOption_Ordnance
+global function SetSpawnOption_OwnerPlayer
+global function SetSpawnOption_Sidearm
+global function SetSpawnOption_SquadName
+global function SetSpawnOption_Special
+global function SetSpawnOption_Melee
+global function SetSpawnOption_CoreAbility
+global function SetSpawnOption_Antirodeo
+global function SetSpawnOption_Titanfall
+global function SetSpawnOption_TitanSoulPassive1
+global function SetSpawnOption_TitanSoulPassive2
+global function SetSpawnOption_TitanSoulPassive3
+global function SetSpawnOption_TitanSoulPassive4
+global function SetSpawnOption_TitanSoulPassive5
+global function SetSpawnOption_TitanSoulPassive6
+global function SetSpawnOption_Warpfall
+global function SetSpawnOption_Weapon
+global function SetSpawnOption_NPCTitan
+global function SetSpawnOption_TitanLoadout
+
+function CodeCallback_RegisterClass_CAI_BaseNPC()
+{
+	#document( "SetSpawnOption_AISettings", "Specify AI Setting" )
+	#document( "SetSpawnOption_Alert", "Enable spawn alerted" )
+	#document( "SetSpawnOption_NotAlert", "Enable spawn alerted" )
+	#document( "SetSpawnOption_Ordnance", "Specify spawn ordnance" )
+	#document( "SetSpawnOption_OwnerPlayer", "This titan will be the auto titan of this player" )
+	#document( "SetSpawnOption_SquadName", "Specify spawn squadname" )
+	#document( "SetSpawnOption_Special", "Specify spawn tactical ability" )
+	#document( "SetSpawnOption_Titanfall", "npc titan will spawn via titanfall" )
+	#document( "SetSpawnOption_TitanSoulPassive1", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_TitanSoulPassive2", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_TitanSoulPassive3", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_TitanSoulPassive4", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_TitanSoulPassive5", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_TitanSoulPassive6", "Set this passive on the titan soul" )
+	#document( "SetSpawnOption_Warpfall", "Titan or super spectre will spawn via warpsfall" )
+	#document( "SetSpawnOption_Weapon", "Specify spawn weapon and mods" )
+	#document( "SetSpawnOption_NPCTitan", "Spawn titan of type" )
+
+
+	//printl( "Class Script: CAI_BaseNPC" )
+
+	CAI_BaseNPC.ClassName <- "CAI_BaseNPC"
+	CAI_BaseNPC.supportsXRay <- null
+
+	CAI_BaseNPC.mySpawnOptions_aiSettings <- null
+	CAI_BaseNPC.mySpawnOptions_alert <- null
+	CAI_BaseNPC.mySpawnOptions_sidearm <- null
+	CAI_BaseNPC.mySpawnOptions_titanfallSpawn <- null
+	CAI_BaseNPC.mySpawnOptions_warpfallSpawn <- null
+	CAI_BaseNPC.mySpawnOptions_routeTD <- null
+	CAI_BaseNPC.mySpawnOptions_ownerPlayer <- null
+	CAI_BaseNPC.executedSpawnOptions <- null
+
+	function CAI_BaseNPC::HasXRaySupport()
+	{
+		return ( this.supportsXRay != null )
+	}
+
+	function CAI_BaseNPC::ForceCombat()
+	{
+		this.FireNow( "UpdateEnemyMemory", "!player" )
+	}
+	#document( CAI_BaseNPC, "ForceCombat", "Force into combat state by updating NPC's memory of the player." )
+
+	function CAI_BaseNPC::InCombat()
+	{
+		entity enemy = expect entity( this ).GetEnemy()
+		if ( !IsValid( enemy ) )
+			return false
+
+		return this.CanSee( enemy )
+	}
+	#document( CAI_BaseNPC, "InCombat", "Returns true if NPC is in combat" )
+}
+
+
+
+function SetSpawnOption_AISettings( entity npc, setting )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.mySpawnOptions_aiSettings = setting
+}
+
+function SetSpawnOption_Alert( entity npc )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.mySpawnOptions_alert = true
+}
+
+function SetSpawnOption_NotAlert( entity npc )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.mySpawnOptions_alert = false
+}
+
+void function SetSpawnOption_Weapon( entity npc, string weapon, array<string> mods = [] )
+{
+	Assert( weapon != "", "Tried to assign no weapon as a spawn weapon" )
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+
+	if ( npc.IsTitan() )
+	{
+		npc.ai.titanSpawnLoadout.primary = weapon
+		npc.ai.titanSpawnLoadout.primaryMods = mods
+	}
+	else
+	{
+		NPCDefaultWeapon spawnoptionsweapon
+		spawnoptionsweapon.wep = weapon
+		spawnoptionsweapon.mods = mods
+
+		npc.ai.mySpawnOptions_weapon = spawnoptionsweapon
+	}
+}
+
+void function SetSpawnOption_Sidearm( entity npc, string weapon, array<string> mods = [])
+{
+	Assert( weapon != "", "Tried to assign no weapon as a spawn weapon" )
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+
+	if ( !npc.IsTitan() )
+		npc.mySpawnOptions_sidearm = { wep = weapon, mods = mods }
+}
+
+void function SetSpawnOption_Ordnance( entity npc, string ordnance, array<string> mods = [] )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.ordnance = ordnance
+	npc.ai.titanSpawnLoadout.ordnanceMods = mods
+}
+
+void function SetSpawnOption_Special( entity npc, string special, array<string> mods = [] )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.special = special
+	npc.ai.titanSpawnLoadout.specialMods = mods
+}
+
+void function SetSpawnOption_Antirodeo( entity npc, string antirodeo, array<string> mods = [] )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.antirodeo = antirodeo
+	npc.ai.titanSpawnLoadout.antirodeoMods = mods
+}
+
+void function SetSpawnOption_Melee( entity npc, string melee )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.melee = melee
+}
+
+void function SetSpawnOption_CoreAbility( entity npc, string core )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.coreAbility = core
+}
+
+function SetSpawnOption_SquadName( entity npc, squadName )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.kv.squadname = squadName
+}
+
+function SetSpawnOption_Titanfall( entity npc )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	Assert( npc.IsTitan(), "npc is for titans only" )
+	npc.mySpawnOptions_titanfallSpawn = true
+}
+
+function SetSpawnOption_Warpfall( entity npc )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	Assert( npc.IsTitan() || npc.GetClassName() == "npc_super_spectre", "npc is for titans and superspectres only" )
+	npc.mySpawnOptions_warpfallSpawn = true
+}
+
+function SetSpawnOption_OwnerPlayer( entity npc, entity player )
+{
+	Assert( IsValid( player ) )
+	Assert( player.IsPlayer() )
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.mySpawnOptions_ownerPlayer = player
+}
+
+function SetSpawnOption_TitanSoulPassive1( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive1 = passive
+}
+
+function SetSpawnOption_TitanSoulPassive2( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive2 = passive
+}
+
+function SetSpawnOption_TitanSoulPassive3( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive3 = passive
+}
+
+function SetSpawnOption_TitanSoulPassive4( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive4 = passive
+}
+
+function SetSpawnOption_TitanSoulPassive5( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive5 = passive
+}
+
+function SetSpawnOption_TitanSoulPassive6( entity npc, string passive )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout.passive6 = passive
+}
+
+function SetSpawnOption_NPCTitan( entity npc, int type )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( npc.IsTitan(), npc + " is not a Titan!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.bossTitanType = type
+}
+
+
+function SetSpawnOption_TitanLoadout( entity npc, TitanLoadoutDef loadout )
+{
+	Assert( IsValid( npc ) && npc.IsNPC(), npc + " is not an npc!" )
+	Assert( npc.IsTitan(), npc + " is not a Titan!" )
+	Assert( !npc.executedSpawnOptions, npc + " tried to set spawn options after npc was dispatchspawned." )
+	npc.ai.titanSpawnLoadout = loadout
+}
+
+bool function IsCrawling( entity npc )
+{
+	return npc.ai.crawling
+}
+
diff --git a/Northstar.CustomServers/scripts/vscripts/class/cbasecombatcharacter.nut b/Northstar.CustomServers/scripts/vscripts/class/cbasecombatcharacter.nut
new file mode 100644
index 000000000..11018ceab
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/cbasecombatcharacter.nut
@@ -0,0 +1,28 @@
+untyped
+
+global function CodeCallback_RegisterClass_CBaseCombatCharacter
+
+function CodeCallback_RegisterClass_CBaseCombatCharacter()
+{
+	CBaseCombatCharacter.ClassName <- "CBaseCombatCharacter"
+
+	RegisterSignal( "ContextAction_SetBusy" ) // signalled from ContextAction_SetBusy() in code
+
+
+	/*
+	CBaseCombatCharacter.__SetActiveWeaponByName <- CBaseCombatCharacter.SetActiveWeaponByName
+	function CBaseCombatCharacter::SetActiveWeaponByName( weapon )
+	{
+		printt( "set active weapon " + weapon + " for " + this )
+		return this.__SetActiveWeaponByName( weapon )
+	}
+
+	CBaseCombatCharacter.__TakeWeapon <- CBaseCombatCharacter.TakeWeapon
+	function CBaseCombatCharacter::TakeWeapon( weapon )
+	{
+	//	printt( "Take weapon " + weapon + " from " + this )
+		return this.__TakeWeapon( weapon )
+	}
+
+	*/
+}
diff --git a/Northstar.CustomServers/scripts/vscripts/class/cbaseentity.nut b/Northstar.CustomServers/scripts/vscripts/class/cbaseentity.nut
new file mode 100644
index 000000000..08d2b2e17
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/cbaseentity.nut
@@ -0,0 +1,229 @@
+untyped
+
+global function CodeCallback_RegisterClass_CBaseEntity
+
+//=========================================================
+// CBaseEntity
+// Properties and methods added here can be accessed on all script entities
+//=========================================================
+
+#if DEV
+table __scriptVarDelegate = {}
+#endif
+
+function CodeCallback_RegisterClass_CBaseEntity()
+{
+	//printl( "Class Script: CBaseEntity" )
+
+	CBaseEntity.ClassName <- "CBaseEntity"
+
+	// Script variables; initializing these to something other than "null" will cause them to be treated as a
+	// static variable on the class instead of a unique variable on each instance.
+	CBaseEntity.s <- null
+
+	CBaseEntity.funcsByString <- null
+
+	CBaseEntity.useFunction <- null // should match on server/client
+
+	CBaseEntity._entityVars <- null
+
+	CBaseEntity.invulnerable <- 0
+
+	// this replacement could just be made in the scripts where this call happens,
+	// but there's too many for me to replace right now
+	CBaseEntity.__KeyValueFromString <- CBaseEntity.SetValueForKey
+	CBaseEntity.__KeyValueFromInt <- CBaseEntity.SetValueForKey
+
+	function CBaseEntity::constructor()
+	{
+		#if DEV
+			this.s = delegate __scriptVarDelegate : {}
+		#else
+			this.s = {}
+		#endif
+
+		this.useFunction = UseReturnTrue // default use function
+
+		this.funcsByString = {}
+	}
+
+	#if DEV
+		function __scriptVarDelegate::_typeof()
+		{
+			return "ScriptVariableTable"
+		}
+
+		disableoverwrite( __scriptVarDelegate )
+	#endif
+
+	/*
+	Do not delete, thanks.
+
+	CBaseEntity.__SetOrigin <- CBaseEntity.SetOrigin
+	function CBaseEntity::SetOrigin( origin )
+	{
+		if ( this.GetTargetName() == "xauto_1" )
+		{
+			printl( "\n\n" )
+			DumpStack()
+		}
+		this.__SetOrigin( origin )
+	}
+	*/
+
+	function CBaseEntity::_typeof()
+	{
+		return format( "[%d] %s: %s", this.entindex(), this.GetClassName(), this.GetTargetName() )
+	}
+
+	function CBaseEntity::Get( val )
+	{
+		return this.GetValueForKey( val )
+	}
+
+	function CBaseEntity::Set( key, val )
+	{
+		return this.SetValueForKey( key, val )
+	}
+
+	// This exists in code too and is only here for untyped entity variables
+	function CBaseEntity::WaitSignal( signalID )
+	{
+		return WaitSignal( this, signalID )
+	}
+
+	// This exists in code too and is only here for untyped entity variables
+	function CBaseEntity::EndSignal( signalID )
+	{
+		EndSignal( this, signalID )
+	}
+
+	// This exists in code too and is only here for untyped entity variables
+	function CBaseEntity::Signal( signalID, results = null )
+	{
+		Signal( this, signalID, results )
+	}
+
+	function CBaseEntity::DisableDraw()
+	{
+		this.FireNow( "DisableDraw" )
+	}
+	#document( "CBaseEntity::DisableDraw", "consider this the mega hide" )
+
+	function CBaseEntity::EnableDraw()
+	{
+		this.FireNow( "EnableDraw" )
+	}
+	#document( "CBaseEntity::EnableDraw", "its back!" )
+
+
+	// --------------------------------------------------------
+	function CBaseEntity::Kill_Deprecated_UseDestroyInstead( time = 0 )
+	{
+		EntFireByHandle( this, "kill", "", time, null, null )
+	}
+	#document( "CBaseEntity::Kill_Deprecated_UseDestroyInstead", "Kill this entity: this function is deprecated because it has a one-frame delay; instead, call ent.Destroy()" )
+
+	// --------------------------------------------------------
+	function CBaseEntity::Fire( output, param = "", delay = 0, activator = null, caller = null )
+	{
+		Assert( type( output ) == "string", "output type " + type( output ) + " is not a string" )
+		EntFireByHandle( this, output, string( param ), delay, activator, caller )
+	}
+	#document( "CBaseEntity::Fire", "Fire an output on this entity, with optional parm and delay" )
+
+	function CBaseEntity::FireNow( output, param = "", activator = null, caller = null )
+	{
+		Assert( type( output ) == "string" )
+		EntFireByHandleNow( this, output, string( param ), activator, caller )
+	}
+	#document( "CBaseEntity::FireNow", "Fire an output on this entity, with optional parm and delay (synchronous)" )
+
+	// --------------------------------------------------------
+	function CBaseEntity::AddOutput( outputName, target, inputName, parameter = "", delay = 0, maxFires = 0 )
+	{
+		local targetName = target
+
+		if ( type( target ) != "string" )
+		{
+			Assert( type( target ) == "instance" )
+			targetName = target.GetTargetName()
+			Assert( targetName.len(), "AddOutput: targetted entity must have a name!" )
+		}
+		Assert( targetName.len(), "Attemped to AddOutput on an unnamed target" )
+
+		local addOutputString = outputName + " " + targetName + ":" + inputName + ":" + parameter + ":" + delay + ":" + maxFires
+		//printl(" Added output string: " + addOutputString )
+
+		EntFireByHandle( this, "AddOutput", addOutputString, 0, null, null )
+	}
+	#document( "CBaseEntity::AddOutput", "Connects an output on this entity to an input on another entity via code.  The \"target\" can be a name or a named entity." )
+
+	/*
+	function MoveTo()
+	*/
+
+	function CBaseEntity::MoveTo( dest, time, easeIn = 0, easeOut = 0 )
+	{
+		if ( this.GetClassName() == "script_mover" )
+		{
+			this.NonPhysicsMoveTo( dest, time, easeIn, easeOut )
+		}
+		else
+		{
+			this.SetOrigin( dest )
+			CodeWarning( "Used moveto on non script_mover: " + this.GetClassName() + ", " + this )
+		}
+	}
+	#document( "CBaseEntity::MoveTo", "Move to the specified origin over time with ease in and ease out." )
+
+	/*
+	function RotateTo()
+	*/
+
+	function CBaseEntity::RotateTo( dest, time, easeIn = 0, easeOut = 0 )
+	{
+		if ( this.GetClassName() == "script_mover" )
+		{
+			this.NonPhysicsRotateTo( dest, time, easeIn, easeOut )
+		}
+		else
+		{
+			this.SetAngles( dest )
+			CodeWarning( "Used rotateto on non script_mover: " + this.GetClassName() + ", " + this )
+		}
+	}
+	#document( "CBaseEntity::RotateTo", "Rotate to the specified angles over time with ease in and ease out." )
+
+	function CBaseEntity::AddVar( varname, value )
+	{
+		Assert( !( varname in this.s ), "Tried to add variable to " + this + " that already existed: " + varname )
+
+		this.s[ varname ] <- value
+	}
+
+	function CBaseEntity::CreateStringForFunction( func )
+	{
+		// this is a general purpose function that returns a string which, when executed,
+		// runs the given function on this entity.
+		// the function must be called (or the entity deleted) at some point to avoid leaking the new slot we make in this Table.
+
+		Assert( type( func ) == "function" )
+
+		string newGuid = UniqueString()
+		this.funcsByString[newGuid] <- func
+
+		return "_RunFunctionByString( \"" + newGuid + "\" )"
+	}
+
+	function _RunFunctionByString( guid )
+	{
+		local activator = this.activator
+		Assert( activator.funcsByString[guid] )
+
+		local func = activator.funcsByString[guid].bindenv( activator.scope() )
+		delete activator.funcsByString[guid]
+
+		func()
+	}
+}
diff --git a/Northstar.CustomServers/scripts/vscripts/class/cplayer.nut b/Northstar.CustomServers/scripts/vscripts/class/cplayer.nut
new file mode 100644
index 000000000..b9f8f7eb8
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/cplayer.nut
@@ -0,0 +1,355 @@
+untyped
+
+
+global function CodeCallback_RegisterClass_CPlayer
+global function PlayerDropsScriptedItems
+global function IsDemigod
+global function EnableDemigod
+global function DisableDemigod
+
+int __nextInputHandle = 0
+
+
+global struct PlayerSlowDownEffect
+{
+	float slowEndTime
+	float speedCap // max speed multiplier if this slow effect is active
+}
+
+function CodeCallback_RegisterClass_CPlayer()
+{
+	//printl( "Class Script: CPlayer" )
+
+	CPlayer.ClassName <- "CPlayer"
+	CPlayer.hasSpawned <- null
+	CPlayer.hasConnected <- null
+	CPlayer.isSpawning <- null
+	CPlayer.isSpawningHotDroppingAsTitan <- false
+	CPlayer.disableWeaponSlots <- false
+	CPlayer.supportsXRay <- null
+
+	CPlayer.lastTitanTime <- 0
+
+	CPlayer.globalHint <- null
+	CPlayer.playerClassData <- null
+	CPlayer.escalation <- null
+	CPlayer.pilotAbility <- null
+	CPlayer.titansBuilt <- 0
+	CPlayer.spawnTime <- 0
+	CPlayer.serverFlags <- 0
+	CPlayer.watchingKillreplayEndTime <- 0.0
+	CPlayer.cloakedForever <- false
+	CPlayer.stimmedForever <- false
+
+	RegisterSignal( "OnRespawnPlayer" )
+	RegisterSignal( "NewViewAnimEntity" )
+	RegisterSignal( "PlayerDisconnected" )
+
+	function CPlayer::constructor()
+	{
+		CBaseEntity.constructor()
+	}
+
+	function CPlayer::RespawnPlayer( ent )
+	{
+		this.Signal( "OnRespawnPlayer", { ent = ent } )
+
+		// hack. Players should clear all these on spawn.
+		this.ViewOffsetEntity_Clear()
+		ClearPlayerAnimViewEntity( expect entity( this ) )
+		this.spawnTime = Time()
+
+		this.ClearReplayDelay()
+		this.ClearViewEntity()
+
+		// titan melee can set these vars, and they need to clear on respawn:
+		this.SetOwner( null )
+		this.kv.VisibilityFlags = ENTITY_VISIBLE_TO_EVERYONE
+
+
+		Assert( !this.GetParent(), this + " should not have a parent yet! - Parent: " + this.GetParent() )
+		Assert( this.s.respawnCount <= 1 || IsMultiplayer(), "Tried to respawn in single player, see callstack" )
+		this.Code_RespawnPlayer( ent )
+	}
+
+	/*
+	CPlayer.__SetTrackEntity <- CPlayer.SetTrackEntity
+	function CPlayer::SetTrackEntity( ent )
+	{
+		printl( "\nTime " + Time() + " Ent " + ent )
+
+		DumpStack()
+		this.__SetTrackEntity( ent )
+	}
+	*/
+
+	function CPlayer::GetDropEntForPoint( origin )
+	{
+		return null
+	}
+
+
+	function CPlayer::GetPlayerClassData( myClass )
+	{
+		Assert( myClass in this.playerClassData, myClass + " not in playerClassData" )
+		return this.playerClassData[ myClass ]
+	}
+
+
+	function CPlayer::InitMPClasses()
+	{
+		this.playerClassData = {}
+
+		Titan_AddPlayer( this )
+		Wallrun_AddPlayer( this )
+	}
+
+
+	function CPlayer::InitSPClasses()
+	{
+		this.playerClassData = {}
+		SetTargetName( expect entity( this ), expect string( this.GetTargetName() + this.entindex() ) )
+
+		Titan_AddPlayer( this )
+	}
+
+
+	// function SpawnAsClass()
+	function CPlayer::SpawnAsClass( className = null )
+	{
+		if ( !className )
+		{
+			className = this.GetPlayerClass()
+		}
+
+		switch ( className )
+		{
+			case level.pilotClass:
+				Wallrun_OnPlayerSpawn( this )
+				break
+
+			default:
+				Assert( 0, "Tried to spawn as unsupported " + className )
+		}
+	}
+
+
+	function CPlayer::GiveScriptWeapon( weaponName, equipSlot = null )
+	{
+		this.scope().GiveScriptWeapon( weaponName, equipSlot )
+	}
+
+	function CPlayer::OnDeathAsClass( damageInfo )
+	{
+		switch ( this.GetPlayerClass() )
+		{
+			case "titan":
+				Titan_OnPlayerDeath( expect entity( this ), damageInfo )
+				break
+
+			case level.pilotClass:
+				Wallrun_OnPlayerDeath( expect entity( this ), damageInfo )
+				break
+		}
+	}
+
+	function CPlayer::Disconnected()
+	{
+		this.Signal( "_disconnectedInternal" )
+		svGlobal.levelEnt.Signal( "PlayerDisconnected" )
+
+		if ( HasSoul( expect entity( this ) ) )
+		{
+			thread SoulDies( expect entity( this ).GetTitanSoul(), null )
+		}
+
+		entity titan = GetPlayerTitanInMap( expect entity( this ) )
+		if ( IsAlive( titan ) && titan.IsNPC() )
+		{
+			local soul = titan.GetTitanSoul()
+			if ( IsValid( soul ) && soul.followOnly )
+				FreeAutoTitan( titan )
+			else
+				titan.Die( null, null, { damageSourceId = eDamageSourceId.damagedef_suicide } )
+			//				titan.Die()
+		}
+
+		PROTO_CleanupTrackedProjectiles( expect entity( this ) )
+
+		if ( this.globalHint != null )
+		{
+			this.globalHint.Kill_Deprecated_UseDestroyInstead()
+			this.globalHint = null
+		}
+	}
+
+
+	function CPlayer::GetClassDataEnts()
+	{
+		local ents = []
+		local added
+
+		if ( this.playerClassData == null )
+			return ents;
+
+		foreach ( ent in this.playerClassData )
+		{
+			added = false
+
+			foreach ( newent in ents )
+			{
+				if ( newent == ent )
+				{
+					added = true
+					break
+				}
+			}
+
+			if ( !added )
+				ents.append( ent )
+		}
+
+		return ents
+	}
+
+
+	function CPlayer::CleanupMPClasses()
+	{
+	}
+
+	function CPlayer::HasXRaySupport()
+	{
+		return ( this.supportsXRay != null )
+	}
+
+	function CPlayer::GiveExtraWeaponMod( mod )
+	{
+		if ( this.HasExtraWeaponMod( mod ) )
+			return
+
+		local mods = this.GetExtraWeaponMods()
+		mods.append( mod )
+
+		this.SetExtraWeaponMods( mods )
+	}
+
+
+	function CPlayer::HasExtraWeaponMod( mod )
+	{
+		local mods = this.GetExtraWeaponMods()
+		foreach( _mod in mods )
+		{
+			if ( _mod == mod )
+				return true
+		}
+		return false
+	}
+
+
+	function CPlayer::TakeExtraWeaponMod( mod )
+	{
+		if ( !this.HasExtraWeaponMod( mod ) )
+			return
+
+		local mods = this.GetExtraWeaponMods()
+		mods.fastremovebyvalue( mod )
+
+		this.SetExtraWeaponMods( mods )
+	}
+
+	function CPlayer::ClearExtraWeaponMods()
+	{
+		this.SetExtraWeaponMods( [] )
+	}
+
+
+	function CPlayer::SetPlayerPilotSettings( settingsName )
+	{
+		this.SetPlayerRequestedSettings( settingsName )
+	}
+
+	function CPlayer::RecordLastMatchContribution( contribution )
+	{
+		// replace with code function
+	}
+
+	function CPlayer::RecordLastMatchPerformance( matchPerformance )
+	{
+		// replace with code function
+	}
+
+	function CPlayer::RecordSkill( skill )
+	{
+		// replace with code function
+		this.SetPersistentVar( "ranked.recordedSkill", skill )
+	}
+
+	function CPlayer::SetPlayerSettings( settings )
+	{
+		local oldPlayerClass = CPlayer.GetPlayerClass()
+
+		CPlayer.SetPlayerSettingsWithMods( settings, [] )
+
+		this.RunSettingsChangedFuncs( settings, oldPlayerClass )
+	}
+
+	function CPlayer::SetPlayerSettingsFromDataTable( pilotDataTable )
+	{
+		local oldPlayerClass = CPlayer.GetPlayerClass()
+
+		local settings = pilotDataTable.playerSetFile
+
+		local mods = pilotDataTable.playerSetFileMods
+
+		this.SetPlayerSettingsWithMods( settings, mods )
+
+		this.RunSettingsChangedFuncs( settings, oldPlayerClass )
+	}
+
+	function CPlayer::RunSettingsChangedFuncs( settings, oldPlayerClass )
+	{
+		if ( IsAlive( expect entity( this ) ) && !this.IsTitan() && GetCurrentPlaylistVarFloat( "pilot_health_multiplier", 0.0 ) != 0.0 )
+		{
+			float pilotHealthMultiplier = GetCurrentPlaylistVarFloat( "pilot_health_multiplier", 1.0 )
+			int pilotMaxHealth = int( this.GetMaxHealth() * pilotHealthMultiplier )
+			this.SetMaxHealth( pilotMaxHealth )
+			this.SetHealth( pilotMaxHealth )
+		}
+
+		if ( this.IsTitan() )
+		{
+			entity soul = expect entity ( this.GetTitanSoul() )
+			local index = PlayerSettingsNameToIndex( settings )
+			soul.SetPlayerSettingsNum( index )
+
+			foreach ( func in svGlobal.soulSettingsChangeFuncs )
+			{
+				func( soul )
+			}
+		}
+	}
+}
+
+void function PlayerDropsScriptedItems( entity player )
+{
+	foreach ( callbackFunc in svGlobal.onPlayerDropsScriptedItemsCallbacks )
+		callbackFunc( player )
+}
+
+bool function IsDemigod( entity player )
+{
+	return player.p.demigod
+}
+
+void function EnableDemigod( entity player )
+{
+	Assert( player.IsPlayer() )
+	player.p.demigod = true
+}
+
+void function DisableDemigod( entity player )
+{
+	Assert( player.IsPlayer() )
+	player.p.demigod = false
+}
+
diff --git a/Northstar.CustomServers/scripts/vscripts/class/ctitansoul.nut b/Northstar.CustomServers/scripts/vscripts/class/ctitansoul.nut
new file mode 100644
index 000000000..6f5ddb3e2
--- /dev/null
+++ b/Northstar.CustomServers/scripts/vscripts/class/ctitansoul.nut
@@ -0,0 +1,50 @@
+untyped
+
+global function CodeCallback_RegisterClass_CTitanSoul
+
+function CodeCallback_RegisterClass_CTitanSoul()
+{
+	CTitanSoul.ClassName <- "CTitanSoul"
+
+	// all soul-specific vars should be created here
+	CTitanSoul.lastAttackInfo <- null
+	CTitanSoul.hijackProgress <- null
+	CTitanSoul.lastHijackTime <- null
+	CTitanSoul.capturable <- null
+	CTitanSoul.followOnly <- null
+	CTitanSoul.passives <- null
+	CTitanSoul.createTime <- null
+	CTitanSoul.rodeoRiderTracker <- null
+	CTitanSoul.doomedTime <- null
+	CTitanSoul.nextRegenTime <- 0.0
+	CTitanSoul.nextHealthRegenTime <- 0.0
+	CTitanSoul.rodeoReservedSlots <- null
+
+	// the functions below should not change
+
+	function CTitanSoul::constructor()
+	{
+		CBaseEntity.constructor()
+
+		this.lastAttackInfo = { time = 0 }
+		this.passives = arrayofsize( GetNumPassives(), false )
+		this.createTime = Time()
+		this.doomedTime = null
+		this.rodeoRiderTracker = {} // all players that rode this titan, so they cant get multiple score events
+		this.capturable = false
+		this.followOnly = false
+		this.rodeoReservedSlots = arrayofsize( PROTOTYPE_DEFAULT_TITAN_RODEO_SLOTS, null )  //hardcoded 3 slots for now!
+	}
+
+
+	// function SoulDeath()
+	function CTitanSoul::SoulDestroy()
+	{
+		// transfer the soul away from the last owner
+		entity titan = expect entity( this.GetTitan() )
+		foreach ( func in svGlobal.soulTransferFuncs )
+		{
+			func( expect entity( this ), null, titan )
+		}
+	}
+}