KF2-StartWave/StartWave/Classes/StartWave.uc
2023-06-03 17:12:57 +03:00

529 lines
14 KiB
Ucode

class StartWave extends Info
config(StartWave);
const OptionsParser = class'OptionsParser';
var private KFGameInfo KFGI;
var private KFGameInfo_Survival KFGIS;
var private KFGameInfo_Endless KFGIE;
var private KFGI_Access KFGIA;
var private KFGameReplicationInfo KFGRI;
/*********************************************************************************************************
* Config properties
*********************************************************************************************************/
/** The wave that the match should start on. It is clamped between wave 1 and the boss wave. */
var config int StartWave;
/** The duration of the 'initial' trader (before the first wave). */
var config int InitialTraderTime;
/** The duration of standard trader (between waves). */
var config int TraderTime;
/** The starting dosh of players. */
var config int Dosh;
/** Whether an 'initial' trader time should occur before the first wave. */
var config bool bStartWithTrader;
/** Log level. */
var config E_LogLevel LogLevel;
/**
*** The boss override index. For the default boss list, 0-Hans, 1-Patty, 2-King FP, 3-Abomination.
*** Negative values can be used to keep the boss spawn random.
***/
var config int Boss;
/*********************************************************************************************************
* Instance variables
*********************************************************************************************************/
/** Used to determine whether the initial trader is still open / hasn't been closed. */
var bool bInitialTrader;
//These are used to determine whether everything in OverrideTimer has been done.
/** Whether the difficulty settings have been overriden. */
var bool bOverridenDifficultySettings;
/** Whether the trader duration has been overriden. */
var bool bOverridenTraderDuration;
public simulated function bool SafeDestroy()
{
`Log_Trace();
return (bPendingDelete || bDeleteMe || Destroy());
}
public event PreBeginPlay()
{
`Log_Trace();
if (WorldInfo.NetMode == NM_Client)
{
`Log_Fatal("Wrong NetMode:" @ WorldInfo.NetMode);
SafeDestroy();
return;
}
Super.PreBeginPlay();
PreInit();
}
public event PostBeginPlay()
{
`Log_Trace();
if (bPendingDelete || bDeleteMe) return;
Super.PostBeginPlay();
PostInit();
}
private function PreInit()
{
local String URL;
local String Options;
`Log_Trace();
URL = WorldInfo.GetLocalURL();
Options = Mid(URL, InStr(URL, "?"));
//Parse options entered via the launch command.
//We further restrict StartWave later when we know the maximum wave number for the selected game length.
StartWave = OptionsParser.static.GetIntOption (Options, "StartWave", StartWave);
InitialTraderTime = OptionsParser.static.GetIntOption (Options, "InitialTraderTime", InitialTraderTime);
TraderTime = OptionsParser.static.GetIntOption (Options, "TraderTime", TraderTime);
Dosh = OptionsParser.static.GetIntOption (Options, "Dosh", Dosh);
Boss = OptionsParser.static.GetIntOption (Options, "Boss", Boss);
bStartWithTrader = OptionsParser.static.GetBoolOption (Options, "bStartWithTrader", bStartWithTrader);
LogLevel = OptionsParser.static.GetLogLevelOption(Options, "LogLevel", LogLevel);
// Adjust values if needed
StartWave = Max(StartWave, 1);
InitialTraderTime = Max(InitialTraderTime, 1);
TraderTime = Max(TraderTime, 1);
Dosh = Max(Dosh, 0);
//DEBUG
`Log_Info("LogLevel:" @ LogLevel);
`Log_Info("StartWave:" @ StartWave);
`Log_Info("InitialTraderTime:" @ InitialTraderTime);
`Log_Info("TraderTime:" @ TraderTime);
`Log_Info("Dosh:" @ Dosh);
`Log_Info("Boss:" @ Boss);
`Log_Info("bStartWithTrader:" @ bStartWithTrader);
bOverridenDifficultySettings = false;
bOverridenTraderDuration = false;
}
private function PostInit()
{
`Log_Trace();
if (WorldInfo.Game == None || WorldInfo.GRI == None)
{
SetTimer(0.2, false, nameof(PostInit));
return;
}
KFGI = KFGameInfo(WorldInfo.Game);
if (KFGI == None)
{
`Log_Fatal("Incompatible gamemode:" @ WorldInfo.Game $ ". Destroy...");
SafeDestroy();
return;
}
KFGIA = new(KFGI) class'KFGI_Access';
if (KFGIA == None)
{
`Log_Fatal("Can't create KFGI_Access object");
SafeDestroy();
return;
}
KFGIS = KFGameInfo_Survival(KFGI);
if (KFGIS == None)
{
`Log_Warn("The game mode does not extend KFGameInfo_Survival. Most features of this mutator are not compatible with non-wave-based game modes.");
}
KFGIE = KFGameInfo_Endless(KFGIS);
KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
if (KFGRI == None)
{
`Log_Fatal("Incompatible game replication info:" @ WorldInfo.GRI $ ". Destroy...");
SafeDestroy();
return;
}
SetTimer(0.1, false, nameof(OverrideTimer));
//Override the boss with the boss corresponding to the specified boss index. -1 signifies random.
KFGIA.OverrideBossIndex(Boss);
CheckForceInitialTrader();
//We only care if this is the 'initial' trader time if we start with the trader active.
bInitialTrader = bStartWithTrader;
//If we want to start with the trader active or alter the starting wave number.
if (bStartWithTrader || StartWave > 1)
{
`Log_Debug("Calling StartWaveTimer() to alter the start wave or activate the trader initially.");
SetTimer(0.2, false, nameof(StartWaveTimer));
}
//If we will need to alter TimeBetweenWaves for later activations of the trader.
if (bStartWithTrader && InitialTraderTime != TraderTime)
{
`Log_Debug("Calling UpdateTraderDurationTimer() to alter the trader duration later.");
SetTimer(1, true, nameof(UpdateTraderDurationTimer));
}
`Log_Info("Initialized.");
}
/** Allows for handling player input in the console by the mutator. */
public function Mutate(string MutateString, PlayerController Sender)
{
local array<string> CommandBreakdown;
`Log_Trace();
if (MutateString == "")
{
return;
}
//Split the string on the space character.
ParseStringIntoArray(MutateString, CommandBreakdown, " ", true);
//The CheatManager check is equivalent to checking if cheats are enabled for that player.
if (CommandBreakdown.Length > 1&&
CommandBreakdown[0] == "setwave" &&
Sender.CheatManager != None &&
KFGI.GetLivingPlayerCount() > 0)
{
//The setwave command should be: mutate setwave WaveNum bSkipTraderTime
//where WaveNum is an integer (or byte) and bSkipTraderTime is a bool.
if (CommandBreakdown.Length == 2)
{
SetWave(int(CommandBreakdown[1]), Sender);
}
else
{
SetWave(int(CommandBreakdown[1]), Sender, bool(CommandBreakdown[2]));
}
}
}
/** Jumps to the specified wave, NewWaveNum, with trader time iff bSkipTraderTime is false. */
private function SetWave(int NewWaveNum, PlayerController PC, optional bool bSkipTraderTime)
{
`Log_Trace();
if (NewWaveNum < 1)
{
`Log_Error("SetWave: new wave num must be > 0.");
return;
}
if (KFGIE != None)
{
//Jump straight to the final wave if the specified wave number is higher than wave max.
if (NewWaveNum > 254)
{
NewWaveNum = 254;
}
}
else
{
//Jump straight to the boss wave if the specified wave number is higher than wave max.
if (NewWaveNum > KFGIS.WaveMax)
{
NewWaveNum = KFGIS.WaveMax+1;
}
}
if (KFGIS != None)
{
KFGIS.WaveNum = NewWaveNum - 1;
}
//Kill all zeds currently alive.
KillZeds();
//Clear any current objectives.
KFGRI.DeactivateObjective();
if (bSkipTraderTime)
{
//Go to some unused state so that PlayingWave.BeginState is called when we go to PlayingWave.
KFGI.GotoState('TravelTheWorld');
UpdateEndlessDifficulty();
//Go to PlayingWave to start the new wave.
KFGI.GotoState('PlayingWave');
}
else
{
//Go to trader time before starting the new wave.
KFGI.GotoState('TraderOpen');
UpdateEndlessDifficulty();
}
KFGI.ResetAllPickups();
}
/**
*** Since the difficulty in Endless scales with the wave number, we need to update the difficulty when
*** jumping between wave numbers to match the expected difficulty.
***/
private function UpdateEndlessDifficulty()
{
local int i;
`Log_Trace();
if (KFGIE == None)
{
return;
}
// KFGIE.ResetDifficulty() does not reset ModifiedDifficulty, so do it manually
KFGRI.SetModifiedGameDifficulty(0);
KFGI.GameDifficultyModifier = 0;
//Reflects the difficulty update in KFGameInfo_Endless.SetWave.
KFGIE.bIsInHoePlus = false;
KFGIE.ResetDifficulty();
KFGIE.SpawnManager.GetWaveSettings(KFGIE.SpawnManager.WaveSettings);
KFGIE.UpdateGameSettings();
//Don't bother iterating for i=0-4, no difficulty increment can occur.
for (i = 5; i <= KFGIE.WaveNum; ++i)
{
//Simulate the death of a boss. The difficulty is incremented after each boss round.
if (i % 5 == 0)
{
KFGIE.IncrementDifficulty();
}
//This should happen at the end of each wave (if we're in HoE+). The check is handled internally.
//We do this after the simulation of a boss death so that bIsInHoePlus can be set first.
KFGIE.HellOnEarthPlusRoundIncrement();
}
`Log_Debug("Updated difficulty (Game + Modifier):" @ String(KFGRI.GameDifficulty) @ "+" @ String(KFGRI.GameDifficultyModifier));
}
/** Checks whether we should force the initial trader, regardless of the config/command value. */
private function CheckForceInitialTrader()
{
`Log_Trace();
//Force the initial trader for compatibility with holdout maps. Otherwise, zeds spawn in the wrong room.
if (!bStartWithTrader && StartWave > 1)
{
bStartWithTrader = true;
InitialTraderTime = 1.0;
}
}
/** Overrides difficulty settings and trader duration when possible. */
private function OverrideTimer()
{
local KFGameDifficulty_Endless KFGDE;
local int i;
`Log_Trace();
//If we've overriden what we need to, don't call this timer again.
if (bOverridenDifficultySettings && bOverridenTraderDuration)
{
`Log_Debug("All settings have been overriden.");
return;
}
if (!bOverridenDifficultySettings && KFGI.DifficultyInfo != None)
{
`Log_Debug("Overriding difficulty settings...");
bOverridenDifficultySettings = true;
//Override starting dosh.
KFGI.DifficultyInfo.Normal.StartingDosh = Dosh;
KFGI.DifficultyInfo.Hard.StartingDosh = Dosh;
KFGI.DifficultyInfo.Suicidal.StartingDosh = Dosh;
KFGI.DifficultyInfo.HellOnEarth.StartingDosh = Dosh;
if (KFGIE != None)
{
KFGDE = KFGameDifficulty_Endless(KFGIE.DifficultyInfo);
if (KFGDE != None)
{
for (i = 0; i < KFGDE.CurrentDifficultyScaling.Difficulties.length; ++i)
{
KFGDE.CurrentDifficultyScaling.Difficulties[i].StartingDosh = Dosh;
}
}
}
`Log_Debug("Starting dosh has been set to:" @ Dosh @ "dosh.");
//We need to set the difficulty settings again - normally done in KFGameInfo.InitGame - to apply
//these changes, since this happens after InitGame is executed.
KFGI.DifficultyInfo.SetDifficultySettings(KFGI.GameDifficulty);
}
//Set the starting wave number.
if (!bOverridenTraderDuration)
{
if (KFGIS != None)
{
//We require the SpawnManager to be set, because this signifies that InitSpawnManager has been
//executed, which sets WaveMax.
if (KFGI.SpawnManager != None)
{
`Log_Debug("Overriding trader duration...");
bOverridenTraderDuration = true;
//Since InitSpawnManager has been executed, then PreBeginPlay must have been executed. This
//means that PostBeginPlay will have been executed as well since it happens straight after.
//Now we can override TimeBetweenWaves.
KFGIS.TimeBetweenWaves = bInitialTrader ? InitialTraderTime : TraderTime;
`Log_Debug("Trader duration has been set to:" @ KFGIS.TimeBetweenWaves @ "seconds.");
}
else
{
`Log_Debug("KFGI.SpawnManager hasn't been set yet. Calling StartWaveTimer again.");
//We don't know WaveMax yet, so we need to wait longer.
SetTimer(0.1, false, nameof(StartWaveTimer));
return;
}
}
}
//If the difficulty info isn't set yet, wait.
SetTimer(0.1, false, nameof(OverrideTimer));
}
private function StartWaveTimer()
{
local PlayerController PC;
`Log_Trace();
//We need to wait for the wave to be active, as this will signify that StartMatch has been executed.
if (!KFGI.IsWaveActive())
{
//If the wave isn't active yet (probably still in lobby), wait.
SetTimer(0.1, false, nameof(StartWaveTimer));
return;
}
if (KFGIS == None)
{
return;
}
`Log_Debug("Clearing the current wave.");
//Clear the current wave.
foreach WorldInfo.AllControllers(class'PlayerController', PC)
{
if (KFDemoRecSpectator(PC) == none)
{
KillZeds();
break;
}
}
//Set the starting wave number.
//Keep the assignments separated so that we can used the restricted StartWave later if we want.
StartWave = Min(StartWave, KFGIS.WaveMax);
//We need to subtract 1 because when the state is eventually reset to PlayingWave, this will be
//incremented by 1.
KFGIS.WaveNum = StartWave - 1;
UpdateEndlessDifficulty();
`Log_Info("WaveNum set to:" @ KFGIS.WaveNum);
if (bStartWithTrader)
{
`Log_Debug("Switching to state: TraderOpen.");
//We need to update GRI's WaveNum and update the HUD element that shows the last wave.
KFGRI.WaveNum = KFGIS.WaveNum;
KFGRI.UpdateHUDWaveCount();
//Start with the trader active.
KFGI.GotoState('TraderOpen', 'Begin');
}
else
{
`Log_Debug("Switching to state: PlayingWave.");
//Start with a wave as usual - but our StartWave number will be used.
KFGI.GotoState('PlayingWave');
}
//Since we've updated the wave number, we need to update the game settings (which includes the
//current wave number).
KFGI.UpdateGameSettings();
bInitialTrader = false;
}
/** Updates the trader duration. Waits until the initial trader has closed. */
private function UpdateTraderDurationTimer()
{
`Log_Trace();
//If the initial trader has already been opened, and the wave is now active.
if (!bInitialTrader && KFGI.IsWaveActive())
{
if (KFGIS != None)
{
`Log_Debug("Updating trader duration to" @ TraderTime @ "seconds.");
//We can update TimeBetweenWaves to be the TraderTime we specified in the launch command.
KFGIS.TimeBetweenWaves = TraderTime;
}
//We don't need to call this timer again.
ClearTimer(nameof(UpdateTraderDurationTimer));
}
}
private function KillZeds()
{
local KFPawn_Monster KFPM;
foreach WorldInfo.AllPawns(class'KFPawn_Monster', KFPM)
{
if (!KFPM.IsAliveAndWell()) continue;
if (KFPM.Health > 0 && PlayerController(KFPM.Controller) == None)
{
KFPM.Died(None, None, KFPM.Location);
}
}
}
defaultproperties
{
}