move to new mod format

4 files changed, 781 insertions, 0 deletions

diff --git a/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut
new file mode 100644
index 00000000..fd877f8c
--- /dev/null
+++ b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut
@@ -0,0 +1,37 @@
+untyped
+global function Lobby_Init
+global function Lobby_OnClientConnectionStarted
+global function Lobby_OnClientConnectionCompleted
+
+void function Lobby_Init()
+{
+	// need to prevent a crash
+	Music_Init()
+	
+	if ( IsPrivateMatch() || GetCurrentPlaylistName() == "private_match" ) // IsPrivateMatch() doesn't seem to be reliable on local server start
+		PrivateLobby_Init()
+	else
+	{
+		// non-private lobby clientcommands
+		AddClientCommandCallback( "StartPrivateMatchSearch", ClientCommandCallback_StartPrivateMatchSearch )
+	}
+}
+
+void function Lobby_OnClientConnectionStarted( entity player )
+{
+	
+}
+
+void function Lobby_OnClientConnectionCompleted( entity player )
+{
+	FinishClientScriptInitialization( player )
+}
+
+bool function ClientCommandCallback_StartPrivateMatchSearch( entity player, array<string> args )
+{
+	// open lobby in private match mode
+	SetCurrentPlaylist( "private_match" ) // required for private match lobby to start properly
+	ServerCommand( "changelevel mp_lobby" )
+	
+	return true
+}
\ No newline at end of file
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/lobby/_private_lobby.gnut b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_private_lobby.gnut
new file mode 100644
index 00000000..60daa452
--- /dev/null
+++ b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_private_lobby.gnut
@@ -0,0 +1,194 @@
+// TODO: could probably add some checks for whether player setting stuff is player 0 to check for host, might fail in dedicated tho
+
+global function PrivateLobby_Init
+
+struct {
+	int startState
+	string map = "mp_forwardbase_kodai"
+	string mode = "aitdm"
+} file 
+
+void function PrivateLobby_Init()
+{
+	print( "PrivateLobby_Init()" )
+	//ClearPlaylistVarOverrides()
+	
+	AddClientCommandCallback( "PrivateMatchLaunch", ClientCommandCallback_PrivateMatchLaunch )
+	AddClientCommandCallback( "PrivateMatchSetMode", ClientCommandCallback_PrivateMatchSetMode )
+	AddClientCommandCallback( "SetCustomMap", ClientCommandCallback_SetCustomMap )
+	AddClientCommandCallback( "PrivateMatchSwitchTeams", ClientCommandCallback_PrivateMatchSwitchTeams )
+	
+	AddClientCommandCallback( "PrivateMatchSetPlaylistVarOverride", ClientCommandCallback_PrivateMatchSetPlaylistVarOverride )
+	AddClientCommandCallback( "ResetMatchSettingsToDefault", ClientCommandCallback_ResetMatchSettingsToDefault )
+}
+
+bool function ClientCommandCallback_PrivateMatchLaunch( entity player, array<string> args )
+{
+	if ( file.startState == ePrivateMatchStartState.STARTING ) 
+	{
+		// cancel start if we're already mid-countdown
+		file.startState = ePrivateMatchStartState.READY
+		SetUIVar( level, "privatematch_starting", ePrivateMatchStartState.READY )
+		SetUIVar( level, "gameStartTime", null )
+	}
+	else
+	{
+		// start match
+		file.startState = ePrivateMatchStartState.STARTING
+		thread StartMatch()
+	}
+	
+	return true
+}
+
+bool function ClientCommandCallback_PrivateMatchSetMode( entity player, array<string> args )
+{
+	if ( file.startState == ePrivateMatchStartState.STARTING )
+		return true
+
+	if ( args.len() != 1 )
+		return true
+	
+	// todo: need to verify this value
+	file.mode = args[0]
+	//GameRules_SetGameMode( args[0] ) // can't do this here due to out of sync errors with new clients
+	
+	RefreshPlayerTeams()
+
+	SetUIVar( level, "privatematch_mode", GetPrivateMatchModeIndex( args[0] ) ) 
+	return true
+}
+
+bool function ClientCommandCallback_SetCustomMap( entity player, array<string> args )
+{
+	if ( file.startState == ePrivateMatchStartState.STARTING )
+		return true
+		
+	if ( args.len() != 1 )
+		return true
+	
+	// todo: need to verify this value
+	file.map = args[0]
+	
+	// todo: this should NOT be necessary, private matches should use an api to register maps in the future rather than hardcoded ids
+	// should be removed whenever possible really
+	SetUIVar( level, "privatematch_map", GetPrivateMatchMapIndex( args[0] ) )
+	return true
+}
+
+bool function ClientCommandCallback_PrivateMatchSwitchTeams( entity player, array<string> args )
+{
+	if ( file.startState == ePrivateMatchStartState.STARTING )
+		return true
+		
+	// currently only support 2 teams in private matches
+	SetTeam( player, player.GetTeam() == 2 ? 3 : 2 )
+	return true
+}
+
+void function StartMatch()
+{	
+	// set starting uivar
+	SetUIVar( level, "privatematch_starting", ePrivateMatchStartState.STARTING )
+	
+	// start countdown
+	SetUIVar( level, "gameStartTime", Time() + 15 ) 
+	float countdownEndTime = Time() + 15.0
+	
+	// can't use start here because we need to check stuff
+	while ( Time() < countdownEndTime )
+	{
+		// stop if the countdown's been cancelled
+		if ( file.startState != ePrivateMatchStartState.STARTING)
+			return
+	
+		WaitFrame()
+	}
+	
+	if ( file.mode in GAMETYPE_TEXT )
+		GameRules_SetGameMode( file.mode )
+	else
+		GameRules_SetGameMode( GetPlaylistGamemodeByIndex( file.mode, 0 ) )
+		
+	try
+	{
+		// todo: not every gamemode uses the same playlist as their name! need some code to resolve these manually
+		// would be nice if the gamemode api got some tweaks to allow for registering private match gamemodes maybe
+		SetCurrentPlaylist( file.mode )
+	}
+	catch ( exception ) 
+	{
+		// temp
+		if ( file.mode == "speedball" )
+			SetCurrentPlaylist( "lf" )
+	
+		print( "couldn't find playlist for gamemode " + file.mode )
+	}
+	
+	RefreshPlayerTeams()
+	
+	SetConVarBool( "ns_should_return_to_lobby", true ) // potentially temp?
+	
+	// TEMP for now: start game
+	ServerCommand( "changelevel " + file.map )
+}
+
+void function RefreshPlayerTeams()
+{
+	int maxTeams = GetGamemodeVarOrUseValue( file.mode, "max_teams", "2" ).tointeger()
+	int maxPlayers = GetGamemodeVarOrUseValue( file.mode, "max_players", "12" ).tointeger()
+
+	// special case for situations where we wrongly assume ffa teams because there's 2 teams/2 players
+	if ( maxPlayers == maxTeams && maxTeams > 2 )
+	{
+		array<entity> players = GetPlayerArray()
+		for ( int i = 0; i < players.len(); i++ )
+			SetTeam( players[ i ], i + 7 ) // 7 is the lowest ffa team
+	}
+	else
+	{
+		bool lastSetMilitia = false
+		foreach ( entity player in GetPlayerArray() )
+		{
+			if ( player.GetTeam() == TEAM_MILITIA || player.GetTeam() == TEAM_IMC )
+				continue
+				
+			if ( lastSetMilitia ) // ensure roughly evenish distribution
+				SetTeam( player, TEAM_IMC )
+			else
+				SetTeam( player, TEAM_MILITIA )
+				
+			lastSetMilitia = !lastSetMilitia
+		}
+	}
+}
+
+bool function ClientCommandCallback_PrivateMatchSetPlaylistVarOverride( entity player, array<string> args )
+{
+	if ( args.len() < 2 )
+		return true
+	
+	bool found = false
+	foreach ( string category in GetPrivateMatchSettingCategories() )
+	{
+		foreach ( CustomMatchSettingContainer setting in GetPrivateMatchCustomSettingsForCategory( category ) )
+		{
+			if ( args[ 0 ] == setting.playlistVar )
+			{
+				found = true
+				break
+			}
+		}
+	}
+		
+	if ( found )
+		SetPlaylistVarOverride( args[0], args[1] )
+	
+	return true
+}
+
+bool function ClientCommandCallback_ResetMatchSettingsToDefault( entity player, array<string> args )
+{
+	ClearPlaylistVarOverrides()
+	return true
+}
\ No newline at end of file
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_lobby.gnut b/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_lobby.gnut
new file mode 100644
index 00000000..2c02ebdc
--- /dev/null
+++ b/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_lobby.gnut
@@ -0,0 +1,495 @@
+globalize_all_functions
+
+const string PRIVATE_MATCH_PLAYLIST = "private_match"
+
+global struct CustomMatchSettingContainer
+{
+	string playlistVar
+	string defaultValue
+	string localizedName
+	bool isEnumSetting
+	
+	// enum setting
+	array< string > enumNames
+	array< string > enumValues
+	//table< string, string > enumValuePairs
+}
+
+struct {
+	array<string> modes = [ // default modes in vanilla
+		"aitdm",
+		"tdm",
+		"cp",
+		"at",
+		"ctf",
+		"lts",
+		"ps",
+		"speedball",
+		"mfd",
+		"ttdm",
+		"fd_easy",
+		"fd_normal",
+		"fd_hard",
+		"fd_master",
+		"fd_insane"
+	]
+	
+	array<string> maps = [ // default maps in vanilla
+		"mp_forwardbase_kodai",
+		"mp_grave",
+		"mp_homestead",
+		"mp_thaw",
+		"mp_black_water_canal",
+		"mp_eden",
+		"mp_drydock",
+		"mp_crashsite3",
+		"mp_complex3",
+		"mp_angel_city",
+		"mp_colony02",
+		"mp_glitch",
+		"mp_relic02",
+		"mp_wargames",
+		"mp_rise",
+		"mp_lf_stacks",
+		"mp_lf_deck",
+		"mp_lf_meadow",
+		"mp_lf_traffic",
+		"mp_lf_township",
+		"mp_lf_uma"
+	]
+	
+	table< string, array< CustomMatchSettingContainer > > customMatchSettingsByCategory // we set these up in sh_private_lobby_modes_init
+} file 
+
+
+void function AddPrivateMatchMode( string mode )
+{
+	if ( !file.modes.contains( mode ) )
+		file.modes.append( mode )
+	
+	#if CLIENT
+		// call this on ui too so the client and ui states are the same
+		RunUIScript( "AddPrivateMatchMode", mode ) 
+	#endif
+}
+
+void function AddPrivateMatchMap( string map )
+{
+	if ( !file.maps.contains( map ) )
+		file.maps.append( map )
+	
+	#if CLIENT 
+		// call this on ui too so the client and ui states are the same
+		RunUIScript( "AddPrivateMatchMap", map )
+	#endif
+}
+
+
+void function AddPrivateMatchModeSettingArbitrary( string category, string playlistVar, string defaultValue, string localizedName = "" )
+{
+	if ( localizedName == "" )
+		localizedName = "#" + playlistVar
+
+	if ( !( category in file.customMatchSettingsByCategory ) )
+		file.customMatchSettingsByCategory[ category ] <- []
+	
+	bool found = false
+	foreach ( CustomMatchSettingContainer setting in file.customMatchSettingsByCategory[ category ] )
+	{
+		if ( setting.playlistVar == playlistVar )
+		{
+			found = true
+			break
+		}
+	}
+	
+	if ( !found )
+	{
+		CustomMatchSettingContainer setting
+		setting.playlistVar = playlistVar
+		setting.defaultValue = defaultValue
+		setting.localizedName = localizedName
+		setting.isEnumSetting = false
+		
+		file.customMatchSettingsByCategory[ category ].append( setting )
+	}
+	
+	#if CLIENT
+		// call this on ui too so the client and ui states are the same
+		RunUIScript( "AddPrivateMatchModeSettingArbitrary", category, playlistVar, defaultValue, localizedName )
+	#endif
+}
+
+void function AddPrivateMatchModeSettingEnum( string category, string playlistVar, array< string > enums, string defaultValue, string localizedName = "" )
+{
+	table< string, string > pairs
+	for ( int i = 0; i < enums.len(); i++ )
+		pairs[ enums[ i ] ] <- i.tostring()
+		
+	AddPrivateMatchModeSettingEnumEx( category, playlistVar, pairs, defaultValue, localizedName )
+}
+
+void function AddPrivateMatchModeSettingEnumUIHack( string category, string playlistVar, string serializedEnumPairs, string defaultValue, string localizedName )
+{
+	// this fucking sucks, but RunUIScript won't take tables, so we serialize to a string
+	// we use \n as a delimeter and basically serialize to an array
+	array< string > serializedArray = split( serializedEnumPairs, "\n" )
+	table< string, string > enumPairs
+
+	for ( int i = 0; i < serializedArray.len(); i += 2 )
+		enumPairs[ serializedArray[ i ] ] <- serializedArray[ i + 1 ]
+		
+	AddPrivateMatchModeSettingEnumEx( category, playlistVar, enumPairs, defaultValue, localizedName )
+}
+
+void function AddPrivateMatchModeSettingEnumEx( string category, string playlistVar, table< string, string > enumPairs, string defaultValue, string localizedName = "" )
+{
+	if ( localizedName == "" )
+		localizedName = "#" + playlistVar
+
+	if ( !( category in file.customMatchSettingsByCategory ) )
+		file.customMatchSettingsByCategory[ category ] <- []
+		
+	bool found = false
+	foreach ( CustomMatchSettingContainer setting in file.customMatchSettingsByCategory[ category ] )
+	{
+		if ( setting.playlistVar == playlistVar )
+		{
+			found = true
+			break
+		}
+	}
+	
+	if ( !found )
+	{
+		CustomMatchSettingContainer setting
+		setting.playlistVar = playlistVar
+		setting.defaultValue = defaultValue
+		setting.localizedName = localizedName
+		setting.isEnumSetting = true
+		//setting.enumValuePairs = enumPairs
+		
+		foreach ( string name, string value in enumPairs )
+		{
+			setting.enumNames.append( name )
+			setting.enumValues.append( value )
+		}
+		
+		file.customMatchSettingsByCategory[ category ].append( setting )
+	}
+
+	#if CLIENT
+		// call this on ui too so the client and ui states are the same
+		// note: RunUIScript can't take tables, so manually serialize ( sucks, but just how it is ), using \n as a delimeter since i dont believe its ever used in vars
+		string serializedString
+		foreach ( string k, string v in enumPairs )
+			serializedString += k + "\n" + v + "\n"
+		
+		RunUIScript( "AddPrivateMatchModeSettingEnumUIHack", category, playlistVar, serializedString, defaultValue, localizedName )
+	#endif
+}
+
+array< string > function GetPrivateMatchSettingCategories()
+{
+	array< string > categories
+	foreach ( string k, v in file.customMatchSettingsByCategory )
+		categories.append( k )
+	
+	return categories
+}
+
+array< CustomMatchSettingContainer > function GetPrivateMatchCustomSettingsForCategory( string category )
+{
+	return file.customMatchSettingsByCategory[ category ]
+}
+
+
+array<string> function GetPrivateMatchModes()
+{
+	//array<string> modesArray
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	modesArray.append( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) )
+	//}
+	
+	//return modesArray
+	
+	return file.modes
+}
+
+int function GetPrivateMatchModeIndex( string modeName )
+{
+	//int indexForName = 0
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	if ( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) != modeName )
+	//		continue
+	//
+	//	indexForName = modeIndex;
+	//	break
+	//}
+	//
+	//return indexForName
+	
+	return file.modes.find( modeName )
+}
+
+
+array<string> function GetPrivateMatchMapsForMode( string modeName )
+{
+	//array<string> mapsArray
+	//
+	//int modeIndex = GetPrivateMatchModeIndex( modeName )
+	//int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+	//for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+	//{
+	//	mapsArray.append( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex ) )
+	//}
+	//
+	//return mapsArray
+	
+	array<string> maps
+	
+	// use the private match playlist for this if the gamemode is in it already
+	int privatePlaylistModeIndex = GetPrivateMatchModeIndex( modeName )
+	if ( privatePlaylistModeIndex < GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST ) )
+	{
+		for ( int i = 0; i < GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, privatePlaylistModeIndex ); i++ )
+			maps.append( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, privatePlaylistModeIndex, i ) )
+	}
+	else
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( modeName, 0 )
+		for ( int i = 0; i < numMaps; i++ )
+			maps.append( GetPlaylistGamemodeByIndexMapByIndex( modeName, 0, i ) )
+	}
+		
+	return maps
+}
+
+// never called
+/*array<string> function GetPrivateMatchModesForMap( string mapName )
+{
+	array<string> modesArray
+
+	int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+		for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+		{
+			if ( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex ) != mapName )
+				continue
+
+			modesArray.append( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) )
+		}
+	}
+
+	return modesArray
+}*/
+
+
+string function GetPrivateMatchMapForIndex( int index )
+{
+	array<string> mapsArray = GetPrivateMatchMaps()
+
+	if ( index >= mapsArray.len() || index < 0 )
+		return ""
+
+	return mapsArray[index]
+}
+
+string function GetPrivateMatchModeForIndex( int index )
+{
+	array<string> modesArray = GetPrivateMatchModes()
+
+	if ( index >= modesArray.len() || index < 0 )
+		return ""
+
+	return modesArray[index]
+}
+
+int function GetPrivateMatchMapIndex( string mapName )
+{
+	array<string> mapsArray = GetPrivateMatchMaps()
+	for ( int index = 0; index < mapsArray.len(); index++ )
+	{
+		if ( mapsArray[index] == mapName )
+			return index
+	}
+
+	return 0
+}
+/*
+int function GetPrivateMatchModeIndex( string modeName )
+{
+	array<string> modesArray = GetPrivateMatchModes()
+	for ( int index = 0; index < modesArray.len(); index++ )
+	{
+		if ( modesArray[index] == modeName )
+			return index
+	}
+
+	return 0
+}
+*/
+
+array<string> function GetPrivateMatchMaps()
+{
+	//array<string> mapsArray
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+	//	for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+	//	{
+	//		string mapName = GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex )
+	//		if ( mapsArray.contains( mapName ) )
+	//			continue
+	//
+	//		mapsArray.append( mapName )
+	//	}
+	//}
+	//
+	//return mapsArray
+	
+	return file.maps
+}
+
+
+
+array<string> function GetPlaylistMaps( string playlistName )
+{
+	array<string> mapsArray
+
+	int numModes = GetPlaylistGamemodesCount( playlistName )
+	for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( playlistName, modeIndex )
+		for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+		{
+			string mapName = GetPlaylistGamemodeByIndexMapByIndex( playlistName, modeIndex, mapIndex )
+			if ( mapsArray.contains( mapName ) )
+				continue
+
+			mapsArray.append( mapName )
+		}
+	}
+
+	return mapsArray
+}
+
+
+bool function MapSettings_SupportsTitans( string mapName )
+{
+	if ( mapName.find( "mp_lf_") != null )
+		return false
+
+	if ( mapName.find( "coliseum" ) != null )
+		return false;
+
+	return true
+}
+
+bool function MapSettings_SupportsAI( string mapName )
+{
+	if ( mapName.find( "mp_lf_") != null )
+		return false
+
+	if ( mapName.find( "coliseum" ) != null )
+		return false;
+
+	return true
+}
+
+
+bool function ModeSettings_RequiresTitans( string modeName )
+{
+	switch ( modeName )
+	{
+		case "lts":
+			return true
+	}
+
+	return false
+}
+
+bool function ModeSettings_RequiresAI( string modeName )
+{
+	switch ( modeName )
+	{
+		case "aitdm":
+		case "at":
+			return true
+	}
+	
+	if ( modeName.find( "fd" ) == 0 ) // bob edit: unsure if this keeps vanilla compatibility, but just make sure fd modes are counted as requiring ai
+		return true
+
+	return false
+}
+
+#if !CLIENT
+string function PrivateMatch_GetSelectedMap()
+{
+	var mapIndex = level.ui.privatematch_map
+	string mapName = GetPrivateMatchMapForIndex( expect int(mapIndex) )
+
+	return mapName
+}
+
+
+string function PrivateMatch_GetSelectedMode()
+{
+	var modeIndex = level.ui.privatematch_mode
+	string modeName = GetPrivateMatchModeForIndex( expect int(modeIndex) )
+
+	return modeName
+}
+#endif
+
+bool function PrivateMatch_IsValidMapModeCombo( string mapName, string modeName )
+{
+	array<string> mapsForMode = GetPrivateMatchMapsForMode( modeName )
+
+	return mapsForMode.contains( mapName )
+}
+
+// end private match stuff
+
+int function Player_GetMaxMatchmakingDelay( entity player )
+{
+	//	return GetCurrentPlaylistVarInt( "matchmaking_delay", 0 )
+	return 300
+}
+
+int function Player_GetRemainingMatchmakingDelay( entity player )
+{
+	int lastLeaveTime = player.GetPersistentVarAsInt( PERSISTENCE_LAST_LEAVE_TIME )
+
+	return Player_GetMaxMatchmakingDelay( player ) - (GetCurrentTimeForPersistence() - lastLeaveTime)
+}
+
+int function Player_NextAvailableMatchmakingTime( entity player )
+{
+	#if MP
+	int lastLeaveTime = player.GetPersistentVarAsInt( PERSISTENCE_LAST_LEAVE_TIME )
+	if ( GetCurrentTimeForPersistence() - lastLeaveTime < Player_GetMaxMatchmakingDelay( player ) )
+	{
+		return Player_GetRemainingMatchmakingDelay(	player )
+	}
+	#endif
+
+	return 0
+}
+
+int function GetCurrentTimeForPersistence()
+{
+	// Returns the unix timestap offset to the timezone we want to use
+	return GetUnixTimestamp() + DAILY_RESET_TIME_ZONE_OFFSET * SECONDS_PER_HOUR
+}
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_private_lobby_modes_init.gnut b/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_private_lobby_modes_init.gnut
new file mode 100644
index 00000000..41806e16
--- /dev/null
+++ b/Northstar.CustomServers/mod/scripts/vscripts/lobby/sh_private_lobby_modes_init.gnut
@@ -0,0 +1,55 @@
+global function PrivateMatchModesInit
+
+void function PrivateMatchModesInit()
+{
+	// match settings
+	// super temp: do localisation strings later
+	AddPrivateMatchModeSettingArbitrary( "Match", "scorelimit", "5" ) //, "Score Limit" )
+	AddPrivateMatchModeSettingArbitrary( "Match", "roundscorelimit", "0" ) //, "Score Limit (round-based modes)" )
+	AddPrivateMatchModeSettingArbitrary( "Match", "timelimit", "12" ) //, "Time Limit" )
+	AddPrivateMatchModeSettingArbitrary( "Match", "roundtimelimit", "0" ) //, "Time Limit (round-based modes)" )
+	
+	AddPrivateMatchModeSettingArbitrary( "Pilot", "pilot_health_multiplier", "1.0" )
+	AddPrivateMatchModeSettingArbitrary( "Pilot", "respawn_delay", "0.0" )
+	AddPrivateMatchModeSettingEnum( "Pilot", "boosts_enabled", [ "Default", "Disabled" ], "1" )
+	AddPrivateMatchModeSettingEnum( "Pilot", "earn_meter_pilot_overdrive", [ "Disabled", "Enabled", "Only" ], "1" )
+	AddPrivateMatchModeSettingArbitrary( "Pilot", "earn_meter_pilot_multiplier", "1.0" )
+	
+	AddPrivateMatchModeSettingArbitrary( "Titan", "earn_meter_titan_multiplier", "1.0" )
+	AddPrivateMatchModeSettingEnum( "Titan", "aegis_upgrades", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Titan", "infinite_doomed_state", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Titan", "titan_shield_regen", [ "Disabled", "Enabled" ], "0" )
+	
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "riff_floorislava", [ "Default", "Enabled", "Disabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_all_holopilot", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_all_grapple", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_all_phase", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_all_ticks", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_tactikill", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_amped_tacticals", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_rocket_arena", [ "Disabled", "Enabled" ], "0" )
+	AddPrivateMatchModeSettingEnum( "Riff Settings", "featured_mode_shotguns_snipers", [ "Disabled", "Enabled" ], "0" )
+	
+	// gamemode settings
+	AddPrivateMatchModeSettingEnum( "#GAMEMODE_cp", "amped_capture_points", [ "Disabled", "Enabled" ], "0" )
+	
+	AddPrivateMatchModeSettingEnum( "#GAMEMODE_coliseum", "coliseum_loadouts_enabled", [ "Disabled", "Enabled" ], "1" )
+
+
+	// modes
+	AddPrivateMatchMode( "ffa" )
+	AddPrivateMatchMode( "fra" )
+	AddPrivateMatchMode( "coliseum" )
+	
+	// playlists
+	AddPrivateMatchMode( "attdm" )
+	AddPrivateMatchMode( "turbo_ttdm" )
+	AddPrivateMatchMode( "alts" )
+	AddPrivateMatchMode( "turbo_lts" )
+	AddPrivateMatchMode( "rocket_lf" )
+	AddPrivateMatchMode( "holopilot_lf" )
+	
+	// maps
+	AddPrivateMatchMap( "mp_coliseum" )
+	AddPrivateMatchMap( "mp_coliseum_column" )
+}
\ No newline at end of file