add custom spawn manager

PublicationContent/description.txt

@@ -1,7 +0,0 @@
-[h1]ZedSpawner[/h1]
-
-[h1]Description[/h1]
-Work In Progress...
-
-[h1]Sources[/h1]
-[url=https://github.com/GenZmeY/KF2-ZedSpawner]https://github.com/GenZmeY/KF2-ZedSpawner[/url]

PublicationContent/tags.txt

@@ -1 +0,0 @@
-Mutators

PublicationContent/title.txt

@@ -1 +0,0 @@
-ZedSpawner

ZedSpawner/Classes/AISpawnManager.uc

@@ -0,0 +1,350 @@
+class AISpawnManager extends KFAISpawnManager
+	abstract;
+
+const class<Config_SpawnManager> Config;
+
+struct S_DifficultyWaveInfo
+{
+    var Array<AIWaveInfo> Waves;
+};
+
+var protected ZedSpawner ZS;
+
+var protected Array<S_DifficultyWaveInfo> V_DifficultyWaveSettings;
+var protected S_DifficultyWaveInfo        V_WaveSettings;
+var protected Array<AISpawnSquad>         V_AvailableSquads;
+
+var public E_LogLevel LogLevel;
+
+private function CopySpawnSquadArray(Array<KFAISpawnSquad> From, out Array<AISpawnSquad> To)
+{
+	local KFAISpawnSquad SS;
+	
+	`ZS_Trace(`Location);
+	
+	To.Length = 0;
+	foreach From(SS)
+		To.AddItem(class'AISpawnSquad'.static.CreateFrom(SS));
+}
+
+private function ZedSpawner GetZedSpawner()
+{
+	foreach WorldInfo.DynamicActors(class'ZedSpawner', ZS)
+		return ZS;
+	return None;
+}
+
+public function Initialize()
+{
+	ZS = GetZedSpawner();
+	if (ZS != None)
+	{
+		LogLevel = ZS.LogLevel;
+		`ZS_Trace(`Location);
+	}
+	else
+	{
+		`ZS_Log("FATAL: no ZedSpawner found! Destroy" @ Self.class);
+		`ZS_Log("FATAL:" @ `Location);
+		Destroy();
+		return;
+	}
+	
+	// TODO:
+	
+	Super.Initialize();
+}
+
+public function GetWaveSettings(out DifficultyWaveInfo WaveInfo)
+{
+	`ZS_Trace(`Location);
+	
+	if (DifficultyWaveSettings.Length > 0)
+		WaveInfo = DifficultyWaveSettings[Clamp(GameDifficulty, 0, DifficultyWaveSettings.Length - 1)];
+
+	V_GetWaveSettings(V_WaveSettings);
+}
+
+protected function V_GetWaveSettings(out S_DifficultyWaveInfo WaveInfo)
+{
+	`ZS_Trace(`Location);
+	
+	if (V_DifficultyWaveSettings.Length > 0)
+		WaveInfo = V_DifficultyWaveSettings[Clamp(GameDifficulty, 0, V_DifficultyWaveSettings.Length - 1)];
+}
+
+public function SetupNextWave(byte NextWaveIndex, int TimeToNextWaveBuffer = 0)
+{
+	local KFGameReplicationInfo KFGRI;
+
+	`ZS_Trace(`Location);
+
+	if (OutbreakEvent.ActiveEvent.bBossRushMode)
+	{
+		NextWaveIndex = MyKFGRI.WaveMax - 1;
+	}
+
+	if (NextWaveIndex < V_WaveSettings.Waves.Length)
+	{
+    	if (GameDifficulty < RecycleSpecialSquad.Length)
+    	{
+    	   bRecycleSpecialSquad = RecycleSpecialSquad[GameDifficulty];
+    	}
+    	else
+    	{
+    	   bRecycleSpecialSquad = RecycleSpecialSquad[RecycleSpecialSquad.Length - 1];
+    	}
+
+        LeftoverSpawnSquad.Length = 0;
+        NumSpawnListCycles = 1;
+        NumSpecialSquadRecycles = 0;
+
+		if (MyKFGRI.IsBossWave() || OutbreakEvent.ActiveEvent.bBossRushMode)
+		{
+			WaveTotalAI = 1;
+		}
+		else
+		{
+			if (V_WaveSettings.Waves[NextWaveIndex].bRecycleWave)
+			{
+				WaveTotalAI = V_WaveSettings.Waves[NextWaveIndex].MaxAI *
+					DifficultyInfo.GetPlayerNumMaxAIModifier(GetNumHumanTeamPlayers()) *
+					DifficultyInfo.GetDifficultyMaxAIModifier();
+			}
+			else
+			{
+				WaveTotalAI = V_WaveSettings.Waves[NextWaveIndex].MaxAI;
+			}
+			WaveTotalAI *= GetTotalWaveCountScale();
+			WaveTotalAI = Max(1, WaveTotalAI);
+		}
+
+        GetAvailableSquads(NextWaveIndex, true);
+
+		WaveStartTime = WorldInfo.TimeSeconds;
+		TimeUntilNextSpawn = 5.f + TimeToNextWaveBuffer;
+
+		if (NextWaveIndex == 0)
+		{
+            TotalWavesActiveTime = 0;
+        }
+
+    	KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
+    	if (KFGRI != None && (KFGRI.bDebugSpawnManager || KFGRI.bGameConductorGraphingEnabled))
+    	{
+    		KFGRI.CurrentSineMod = GetSineMod();
+    		KFGRI.CurrentNextSpawnTime = TimeUntilNextSpawn;
+    		KFGRI.CurrentSineWavFreq = GetSineWaveFreq();
+    		KFGRI.CurrentNextSpawnTimeMod = GetNextSpawnTimeMod();
+    		KFGRI.CurrentTotalWavesActiveTime = TotalWavesActiveTime;
+    		KFGRI.CurrentMaxMonsters = GetMaxMonsters();
+    		KFGRI.CurrentTimeTilNextSpawn = TimeUntilNextSpawn;
+    	}
+	}
+
+    LastAISpawnVolume = None;
+}
+
+public function GetAvailableSquads(byte MyWaveIndex, optional bool bNeedsSpecialSquad=false)
+{
+	local int i, j, TotalZedsInSquads;
+
+	`ZS_Trace(`Location);
+	
+    if (V_WaveSettings.Waves[MyWaveIndex] != None)
+	{
+		NumSpawnListCycles++;
+
+        V_WaveSettings.Waves[MyWaveIndex].GetNewSquadList(V_AvailableSquads);
+
+		if (bNeedsSpecialSquad)
+		{
+		 	V_WaveSettings.Waves[MyWaveIndex].GetSpecialSquad(V_AvailableSquads);
+
+            for (i = 0; i < V_AvailableSquads.Length; i++)
+        	{
+        		for (j = 0; j < V_AvailableSquads[i].MonsterList.Length; j++)
+        		{
+                    TotalZedsInSquads += V_AvailableSquads[i].MonsterList[j].Num;
+        		}
+        	}
+
+    	 	if (WaveTotalAI < TotalZedsInSquads)
+    	 	{
+                bForceRequiredSquad = true;
+            }
+		}
+	}
+}
+
+public function V_GetSpawnListFromSquad(byte SquadIdx, out Array<AISpawnSquad> SquadsList, out Array<class<KFPawn_Monster> > AISpawnList)
+{
+	local AISpawnSquad Squad;
+	local EAIType AIType;
+	local int i, j, RandNum;
+	local ESquadType LargestMonsterSquadType;
+    local Array<class<KFPawn_Monster> > TempSpawnList;
+	local int RandBossIndex;
+	
+	`ZS_Trace(`Location);
+	
+	Squad = SquadsList[SquadIdx];
+
+	LargestMonsterSquadType = EST_Crawler;
+
+	for (i = 0; i < Squad.MonsterList.Length; i++)
+	{
+		for (j = 0; j < Squad.MonsterList[i].Num; j++)
+		{
+			if (Squad.MonsterList[i].CustomClass != None)
+			{
+				TempSpawnList.AddItem(Squad.MonsterList[i].CustomClass);
+			}
+			else
+			{
+				AIType = Squad.MonsterList[i].Type;
+				if (AIType == AT_BossRandom)
+				{
+                    if (OutbreakEvent.ActiveEvent.bBossRushMode)
+					{
+						RandBossIndex = Rand(BossRushEnemies.length);
+						TempSpawnList.AddItem( default.AIBossClassList[BossRushEnemies[RandBossIndex]]);
+						BossRushEnemies.Remove(RandBossIndex, 1);
+					}
+					else
+					{
+						TempSpawnList.AddItem(GetBossAISpawnType());
+					}
+
+                    LargestMonsterSquadType = EST_Boss;
+				}
+				else
+				{
+					TempSpawnList.AddItem(GetAISpawnType(AIType));
+				}
+			}
+
+			if (TempSpawnList[TempSpawnList.Length - 1].default.MinSpawnSquadSizeType < LargestMonsterSquadType)
+            {
+                LargestMonsterSquadType = TempSpawnList[TempSpawnList.Length - 1].default.MinSpawnSquadSizeType;
+            }
+		}
+	}
+	if (TempSpawnList.Length > 0)
+	{
+        while (TempSpawnList.Length > 0)
+        {
+            RandNum = Rand( TempSpawnList.Length);
+            AISpawnList.AddItem( TempSpawnList[RandNum]);
+            TempSpawnList.Remove( RandNum, 1);
+        }
+
+		DesiredSquadType = Squad.MinVolumeType;
+
+		if (LargestMonsterSquadType < DesiredSquadType)
+        {
+            DesiredSquadType = LargestMonsterSquadType;
+        }
+	}
+}
+
+public function Array<class<KFPawn_Monster> > GetNextSpawnList()
+{
+	local Array<class<KFPawn_Monster> >  NewSquad, RequiredSquad;
+	local int RandNum, AINeeded;
+
+	`ZS_Trace(`Location);
+	
+	if (LeftoverSpawnSquad.Length > 0)
+    {
+        NewSquad = LeftoverSpawnSquad;
+        SetDesiredSquadTypeForZedList(NewSquad);
+    }
+    else
+    {
+		if (!IsAISquadAvailable())
+		{
+			if (!bSummoningBossMinions)
+			{
+	            if (bRecycleSpecialSquad && NumSpawnListCycles % 2 == 1 && (MaxSpecialSquadRecycles == -1 || NumSpecialSquadRecycles < MaxSpecialSquadRecycles))
+	            {
+	                GetAvailableSquads(MyKFGRI.WaveNum - 1, true);
+	                ++NumSpecialSquadRecycles;
+	            }
+	            else
+	            {
+	                GetAvailableSquads(MyKFGRI.WaveNum - 1);
+	            }
+	        }
+	        else
+	        {
+				CopySpawnSquadArray(BossMinionsSpawnSquads, V_AvailableSquads);
+	        }
+		}
+
+		RandNum = Rand(V_AvailableSquads.Length);
+
+		if (bForceRequiredSquad && RandNum == (V_AvailableSquads.Length - 1))
+		{
+		   bForceRequiredSquad=false;
+		}
+		
+		V_GetSpawnListFromSquad(RandNum, V_AvailableSquads, NewSquad);
+
+		if (bForceRequiredSquad)
+		{
+	    	V_GetSpawnListFromSquad((V_AvailableSquads.Length - 1), V_AvailableSquads, RequiredSquad);
+
+	        if ((NumAISpawnsQueued + NewSquad.Length + RequiredSquad.Length) > WaveTotalAI)
+	        {
+	            NewSquad = RequiredSquad;
+	            RandNum = (V_AvailableSquads.Length - 1);
+	            bForceRequiredSquad=false;
+	        }
+		}
+
+		V_AvailableSquads.Remove(RandNum, 1);
+	}
+
+	AINeeded = GetNumAINeeded();
+	if (AINeeded < NewSquad.Length)
+	{
+		LeftoverSpawnSquad = NewSquad;
+        LeftoverSpawnSquad.Remove(0, AINeeded);
+        NewSquad.Length = AINeeded;
+	}
+	else
+	{
+        LeftoverSpawnSquad.Length = 0;
+	}
+
+	return NewSquad;
+}
+
+public function bool IsAISquadAvailable()
+{
+	`ZS_Trace(`Location);
+	
+	return (V_AvailableSquads.Length > 0);
+}
+
+public function SummonBossMinions(Array<KFAISpawnSquad> NewMinionSquad, int NewMaxBossMinions, optional bool bUseLivingPlayerScale = true)
+{
+	`ZS_Trace(`Location);
+	
+	CopySpawnSquadArray(NewMinionSquad, V_AvailableSquads);
+	Super.SummonBossMinions(NewMinionSquad, NewMaxBossMinions, bUseLivingPlayerScale);
+}
+
+public function StopSummoningBossMinions()
+{
+	`ZS_Trace(`Location);
+	
+	V_AvailableSquads.Length = 0;
+	Super.StopSummoningBossMinions();
+}
+
+defaultproperties
+{
+	Config = class'Config_SpawnManager'
+}

ZedSpawner/Classes/AISpawnManager_Endless.uc

@@ -0,0 +1,118 @@
+class AISpawnManager_Endless extends AISpawnManager
+	within KFGameInfo_Endless;
+
+struct S_MacroDifficultyWaveInfo
+{
+	var Array<S_DifficultyWaveInfo> MacroDifficultyWaveSettings;
+};
+
+struct MacroDifficultyWaveInfo
+{
+	var Array<DifficultyWaveInfo> MacroDifficultyWaveSettings;
+};
+
+var protected Array<MacroDifficultyWaveInfo> DifficultyWaves;
+var protected Array<S_MacroDifficultyWaveInfo> V_DifficultyWaves;
+
+public function SetupNextWave(byte NextWaveIndex, int TimeToNextWaveBuffer = 0)
+{
+	`ZS_Trace(`Location);
+	
+	Super.SetupNextWave(NextWaveIndex % WaveSettings.Waves.length, TimeToNextWaveBuffer);
+}
+
+public function GetAvailableSquads(byte MyWaveIndex, optional bool bNeedsSpecialSquad = false)
+{
+	`ZS_Trace(`Location);
+	
+	Super.GetAvailableSquads(MyWaveIndex % WaveSettings.Waves.length, bNeedsSpecialSquad);
+}
+
+public function GetWaveSettings(out DifficultyWaveInfo WaveInfo)
+{
+	local int AdGD;   // AdjustedGameDifficulty
+	local int AvAdGD; // AvailableAdjustedGameDifficulty
+	local int AvGD;   // AvailableGameDifficulty
+	local int DWL;    // DifficultyWavesLength
+	local int MDWSL;  // MacroDifficultyWaveSettingsLength
+	
+	`ZS_Trace(`Location);
+	
+	DWL = DifficultyWaves.Length;
+	if (DWL > 0)
+	{
+		AvGD = Clamp(GameDifficulty, 0, DWL - 1);
+		MDWSL = DifficultyWaves[AvGD].MacroDifficultyWaveSettings.Length;
+		if (MDWSL > 0)
+		{
+			AdGD     = EndlessDifficulty.GetCurrentDifficultyIndex();
+			AvAdGD   = Clamp(AdGD, 0, MDWSL - 1);
+			WaveInfo = DifficultyWaves[AvGD].MacroDifficultyWaveSettings[AvAdGD];
+		}
+	}
+	
+	V_GetWaveSettings(V_WaveSettings);
+}
+
+protected function V_GetWaveSettings(out S_DifficultyWaveInfo WaveInfo)
+{
+	local int AdGD;   // AdjustedGameDifficulty
+	local int AvAdGD; // AvailableAdjustedGameDifficulty
+	local int AvGD;   // AvailableGameDifficulty
+	local int VDWL;   // V_DifficultyWavesLength
+	local int MDWSL;  // MacroDifficultyWaveSettingsLength
+	
+	`ZS_Trace(`Location);
+	
+	VDWL = V_DifficultyWaves.Length;
+	if (VDWL > 0)
+	{
+		AvGD = Clamp(GameDifficulty, 0, VDWL - 1);
+		MDWSL = V_DifficultyWaves[AvGD].MacroDifficultyWaveSettings.Length;
+		if (MDWSL > 0)
+		{
+			AdGD     = EndlessDifficulty.GetCurrentDifficultyIndex();
+			AvAdGD   = Clamp(AdGD, 0, MDWSL - 1);
+			WaveInfo = V_DifficultyWaves[AvGD].MacroDifficultyWaveSettings[AvAdGD];
+		}
+	}
+}
+
+public function OnDifficultyUpdated()
+{
+	`ZS_Trace(`Location);
+	
+	GetWaveSettings(WaveSettings);
+}
+
+public function OnBossDied()
+{
+	`ZS_Trace(`Location);
+	
+	BossMinionsSpawnSquads.length = 0;
+	AvailableSquads.length        = 0;
+	V_AvailableSquads.length      = 0;
+}
+
+public function float GetNextSpawnTimeMod()
+{
+	local float SpawnTimeMod, SpawnTimeModMin;
+	local int TempModIdx;
+
+	`ZS_Trace(`Location);
+
+	SpawnTimeMod = super.GetNextSpawnTimeMod();
+
+	if (MyKFGRI.IsSpecialWave(TempModIdx))
+	{
+		SpawnTimeModMin = EndlessDifficulty.GetSpecialWaveSpawnTimeModMin(SpecialWaveType);
+		SpawnTimeMod = Max(SpawnTimeMod, SpawnTimeModMin);
+	}
+
+	return SpawnTimeMod;
+}
+
+defaultproperties
+{
+	Config = class'Config_SpawnManager_Endless'
+}

ZedSpawner/Classes/AISpawnManager_Long.uc

@@ -0,0 +1,6 @@
+class AISpawnManager_Long extends AISpawnManager;
+
+DefaultProperties
+{
+	Config = class'Config_SpawnManager_Long'
+}

ZedSpawner/Classes/AISpawnManager_Normal.uc

@@ -0,0 +1,6 @@
+class AISpawnManager_Normal extends AISpawnManager;
+
+DefaultProperties
+{
+	Config = class'Config_SpawnManager_Normal'
+}

ZedSpawner/Classes/AISpawnManager_Short.uc

@@ -0,0 +1,6 @@
+class AISpawnManager_Short extends AISpawnManager;
+
+DefaultProperties
+{
+	Config = class'Config_SpawnManager_Short'
+}

ZedSpawner/Classes/AISpawnSquad.uc

@@ -0,0 +1,61 @@
+class AISpawnSquad extends Object
+	hidecategories(Object);
+
+struct S_AISquadElement
+{
+	var() EAIType Type;
+	var() byte    Num <ClampMin=1 | ClampMax=6>;
+
+	var class<KFPawn_Monster> CustomClass;
+
+	structdefaultproperties
+	{
+		Num = 1
+	}
+};
+
+var() ESquadType              MinVolumeType;
+var() array<S_AISquadElement> MonsterList;
+
+public function AISpawnSquad InitFrom(KFAISpawnSquad SpawnSquad)
+{
+	local AISquadElement SE;
+	local S_AISquadElement SSE;
+	
+	MinVolumeType = SpawnSquad.MinVolumeType;
+	
+	foreach SpawnSquad.MonsterList(SE)
+	{
+		SSE.Type        = SE.Type;
+		SSE.Num         = SE.Num;
+		SSE.CustomClass = SE.CustomClass;
+		MonsterList.AddItem(SSE);
+	}
+	
+	return Self;
+}
+
+public static function AISpawnSquad CreateFrom(KFAISpawnSquad SpawnSquad)
+{
+	local AISquadElement SE;
+	local S_AISquadElement SSE;
+	local AISpawnSquad NewSpawnSquad;
+	
+	NewSpawnSquad = new class'AISpawnSquad';
+	NewSpawnSquad.MinVolumeType = SpawnSquad.MinVolumeType;
+	
+	foreach SpawnSquad.MonsterList(SE)
+	{
+		SSE.Type        = SE.Type;
+		SSE.Num         = SE.Num;
+		SSE.CustomClass = SE.CustomClass;
+		NewSpawnSquad.MonsterList.AddItem(SSE);
+	}
+	
+	return NewSpawnSquad;
+}
+
+defaultproperties
+{
+	MinVolumeType = EST_Medium
+}

ZedSpawner/Classes/AIWaveInfo.uc

@@ -0,0 +1,71 @@
+class AIWaveInfo extends Object
+	dependson(AISpawnSquad)
+	hidecategories(Object);
+
+var() bool bRecycleWave;
+var() Array<AISpawnSquad> Squads;
+var() Array<AISpawnSquad> SpecialSquads;
+var() int MaxAI<ClampMin=1|ClampMax=200|DisplayName=TotalAIBase>;
+var() Array<AISpawnSquad> EventSquads;
+
+public function GetNewSquadList(out Array<AISpawnSquad> out_SquadList)
+{
+	local AISpawnSquad SS;
+
+	out_SquadList.Length = 0;
+	foreach Squads(SS)
+		if (SS != None)
+			out_SquadList.AddItem(SS);
+}
+
+public function GetSpecialSquad(out Array<AISpawnSquad> out_SquadList)
+{
+	if (SpecialSquads.Length > 0)
+		out_SquadList.AddItem(SpecialSquads[Rand(SpecialSquads.Length)]);
+}
+
+public function GetEventSquadList(out Array<AISpawnSquad> out_SquadList)
+{
+	local AISpawnSquad SS;
+
+	out_SquadList.Length = 0;
+	foreach EventSquads(SS)
+		if (SS != None)
+			out_SquadList.AddItem(SS);
+}
+
+public function InitFrom(KFAIWaveInfo WaveInfo)
+{
+	local KFAISpawnSquad KFSS;
+	
+	bRecycleWave = WaveInfo.bRecycleWave;
+	MaxAI        = WaveInfo.MaxAI;
+	
+	Squads.Length = 0;
+	foreach WaveInfo.Squads(KFSS)
+		Squads.AddItem(class'AISpawnSquad'.static.CreateFrom(KFSS));
+	
+	SpecialSquads.Length = 0;
+	foreach WaveInfo.SpecialSquads(KFSS)
+		SpecialSquads.AddItem(class'AISpawnSquad'.static.CreateFrom(KFSS));
+	
+	EventSquads.Length = 0;
+	foreach WaveInfo.EventSquads(KFSS)
+		EventSquads.AddItem(class'AISpawnSquad'.static.CreateFrom(KFSS));
+}
+
+public static function AIWaveInfo CreateFrom(KFAIWaveInfo WaveInfo)
+{
+	local AIWaveInfo AIWI;
+	
+	AIWI = new class'AIWaveInfo';
+	AIWI.InitFrom(WaveInfo);
+	
+	return AIWI;
+}
+
+defaultproperties
+{
+	bRecycleWave = true
+	MaxAI = 32
+}

ZedSpawner/Classes/Config_SpawnListBossWaves.uc

@@ -1,4 +1,4 @@
-class SpawnListBossWaves extends Object
+class Config_SpawnListBossWaves extends Object
 	dependson(ZedSpawner)
 	config(ZedSpawner);
 
@@ -13,45 +13,31 @@ struct S_SpawnEntryCfg
 	var bool    bSpawnAtPlayerStart;
 };
 
-var public  config bool bStopRegularSpawn;
-var private config Array<S_SpawnEntryCfg> Spawn;
+var config bool bStopRegularSpawn;
+var config Array<S_SpawnEntryCfg> Spawn;
 
-public static function InitConfig(int Version, int LatestVersion, KFGI_Access KFGIA)
-{
-	switch (Version)
-	{
-		case `NO_CONFIG:
-			ApplyDefault(KFGIA);
-			
-		default: break;
-	}
-	
-	if (LatestVersion != Version)
-	{
-		StaticSaveConfig();
-	}
-}
-
-private static function ApplyDefault(KFGI_Access KFGIA)
+public static function InitConfig()
 {
 	local S_SpawnEntryCfg SpawnEntry;
-	local Array<class<KFPawn_Monster> > KFPM_Bosses;
-	local class<KFPawn_Monster> KFPMC;
 	
-	default.bStopRegularSpawn      = true;
-	default.Spawn.Length           = 0;
+	default.bStopRegularSpawn = true;
+	
+	default.Spawn.Length = 0;
+	
+	SpawnEntry.BossClass           = "KFGameContent.KFPawn_ZedFleshpoundKing";
 	SpawnEntry.ZedClass            = "SomePackage.SomeClass";
 	SpawnEntry.SpawnCountBase      = 2;
 	SpawnEntry.SingleSpawnLimit    = 1;
-	SpawnEntry.Delay               = 30;
+	SpawnEntry.Delay               = 60;
 	SpawnEntry.Probability         = 100;
 	SpawnEntry.bSpawnAtPlayerStart = false;
-	KFPM_Bosses = KFGIA.GetAIBossClassList();
-	foreach KFPM_Bosses(KFPMC)
-	{
-		SpawnEntry.BossClass = "KFGameContent." $ String(KFPMC);
-		default.Spawn.AddItem(SpawnEntry);
-	}
+	default.Spawn.AddItem(SpawnEntry);
+	
+	// TODO:
+	//SpawnEntry.BossClass           = "KFGameContent.KFPawn_ZedFleshpoundKing";
+	//default.Spawn.AddItem(SpawnEntry);
+	
+	StaticSaveConfig();
 }
 
 public static function Array<S_SpawnEntry> Load(E_LogLevel LogLevel)

ZedSpawner/Classes/Config_SpawnListRegular.uc

@@ -1,4 +1,4 @@
-class SpawnListRegular extends Object
+class Config_SpawnListRegular extends Object
 	dependson(ZedSpawner)
 	config(ZedSpawner);
 
@@ -14,47 +14,35 @@ struct S_SpawnEntryCfg
 	var bool    bSpawnAtPlayerStart;
 };
 
-var public config Array<S_SpawnEntryCfg> Spawn;
+var config Array<S_SpawnEntryCfg> Spawn;
 
-public static function InitConfig(int Version, int LatestVersion, KFGI_Access KFGIA)
-{
-	switch (Version)
-	{
-		case `NO_CONFIG:
-			ApplyDefault(KFGIA);
-			
-		default: break;
-	}
-	
-	if (LatestVersion != Version)
-	{
-		StaticSaveConfig();
-	}
-}
-
-private static function ApplyDefault(KFGI_Access KFGIA)
+public static function InitConfig()
 {
 	local S_SpawnEntryCfg SpawnEntry;
-	local Array<class<KFPawn_Monster> > KFPM_Zeds;
-	local class<KFPawn_Monster> KFPMC;
 	
 	default.Spawn.Length = 0;
 	
-	SpawnEntry.Wave                = 0;
+	SpawnEntry.Wave                = 1;
+	SpawnEntry.ZedClass            = "SomePackage.SomeZedClass1";
 	SpawnEntry.SpawnCountBase      = 2;
 	SpawnEntry.SingleSpawnLimit    = 1;
-	SpawnEntry.RelativeStart       = 25;
+	SpawnEntry.RelativeStart       = 0;
 	SpawnEntry.Delay               = 60;
 	SpawnEntry.Probability         = 100;
 	SpawnEntry.bSpawnAtPlayerStart = false;
+	default.Spawn.AddItem(SpawnEntry);
 	
-	KFPM_Zeds = KFGIA.GetAIClassList();
-	foreach KFPM_Zeds(KFPMC)
-	{
-		++SpawnEntry.Wave;
-		SpawnEntry.ZedClass = "KFGameContent." $ String(KFPMC);
-		default.Spawn.AddItem(SpawnEntry);
-	}
+	SpawnEntry.Wave                = 2;
+	SpawnEntry.ZedClass            = "SomePackage.SomeZedClass2";
+	SpawnEntry.SpawnCountBase      = 2;
+	SpawnEntry.SingleSpawnLimit    = 1;
+	SpawnEntry.RelativeStart       = 25;
+	SpawnEntry.Delay               = 30;
+	SpawnEntry.Probability         = 50;
+	SpawnEntry.bSpawnAtPlayerStart = false;
+	default.Spawn.AddItem(SpawnEntry);
+	
+	StaticSaveConfig();
 }
 
 public static function Array<S_SpawnEntry> Load(E_LogLevel LogLevel)

ZedSpawner/Classes/Config_SpawnListSpecialWaves.uc

@@ -1,4 +1,4 @@
-class SpawnListSpecialWaves extends Object
+class Config_SpawnListSpecialWaves extends Object
 	dependson(ZedSpawner)
 	config(ZedSpawner);
 
@@ -14,32 +14,18 @@ struct S_SpawnEntryCfg
 	var bool    bSpawnAtPlayerStart;
 };
 
-var public  config bool bStopRegularSpawn;
-var private config Array<S_SpawnEntryCfg> Spawn;
+var config bool bStopRegularSpawn;
+var config Array<S_SpawnEntryCfg> Spawn;
 
-public static function InitConfig(int Version, int LatestVersion)
-{
-	switch (Version)
-	{
-		case `NO_CONFIG:
-			ApplyDefault();
-			
-		default: break;
-	}
-	
-	if (LatestVersion != Version)
-	{
-		StaticSaveConfig();
-	}
-}
-
-private static function ApplyDefault()
+public static function InitConfig()
 {
 	local S_SpawnEntryCfg SpawnEntry;
-	local EAIType AIType;
 	
 	default.bStopRegularSpawn = true;
+	
 	default.Spawn.Length = 0;
+	
+	SpawnEntry.Wave                = AT_Husk;
 	SpawnEntry.ZedClass            = "SomePackage.SomeClass";
 	SpawnEntry.SpawnCountBase      = 2;
 	SpawnEntry.SingleSpawnLimit    = 1;
@@ -47,11 +33,9 @@ private static function ApplyDefault()
 	SpawnEntry.Delay               = 60;
 	SpawnEntry.Probability         = 100;
 	SpawnEntry.bSpawnAtPlayerStart = false;
-	foreach class'KFGameInfo_Endless'.default.SpecialWaveTypes(AIType)
-	{
-		SpawnEntry.Wave = AIType;
-		default.Spawn.AddItem(SpawnEntry);
-	}
+	default.Spawn.AddItem(SpawnEntry);
+	
+	StaticSaveConfig();
 }
 
 public static function Array<S_SpawnEntry> Load(KFGameInfo_Endless KFGIE, E_LogLevel LogLevel)

ZedSpawner/Classes/Config_SpawnManager.uc

@@ -0,0 +1,37 @@
+class Config_SpawnManager extends Object
+	config(ZedSpawner);
+
+var const class<KFAISpawnManager> DefSpawnManager;
+
+public static function InitConfig()
+{
+	local DifficultyWaveInfo DWI;
+	local KFAIWaveInfo       KFAIWI;
+	local AIWaveInfo         AIWI;
+	local int                Diff, Wave;
+	
+	`ZS_Log("InitConfig:" @ default.DefSpawnManager);
+	foreach default.DefSpawnManager.default.DifficultyWaveSettings(DWI, Diff)
+	{
+		`ZS_Log(" Diff:" @ Diff);
+		foreach DWI.Waves(KFAIWI, Wave)
+		{
+			`ZS_Log("  Wave:" @ Wave);
+			AIWI = class'AIWaveInfo'.static.CreateFrom(KFAIWI);
+		}
+	}
+	
+	//StaticSaveConfig();
+}
+
+public static function bool Load(E_LogLevel LogLevel)
+{
+	local bool Errors;
+	Errors = false;
+	return !Errors;
+}
+
+defaultproperties
+{
+	DefSpawnManager = class'KFAISpawnManager'
+}

ZedSpawner/Classes/Config_SpawnManager_Endless.uc

@@ -0,0 +1,14 @@
+class Config_SpawnManager_Endless extends Config_SpawnManager
+	config(ZedSpawner);
+
+public static function bool Load(E_LogLevel LogLevel)
+{
+	local bool Errors;
+	Errors = false;
+	return !Errors;
+}
+
+defaultproperties
+{
+	DefSpawnManager = class'KFAISpawnManager_Endless'
+}

ZedSpawner/Classes/Config_SpawnManager_Long.uc

@@ -0,0 +1,14 @@
+class Config_SpawnManager_Long extends Config_SpawnManager
+	config(ZedSpawner);
+	
+public static function bool Load(E_LogLevel LogLevel)
+{
+	local bool Errors;
+	Errors = false;
+	return !Errors;
+}
+
+defaultproperties
+{
+	DefSpawnManager = class'KFAISpawnManager_Long'
+}

ZedSpawner/Classes/Config_SpawnManager_Normal.uc

@@ -0,0 +1,14 @@
+class Config_SpawnManager_Normal extends Config_SpawnManager
+	config(ZedSpawner);
+
+public static function bool Load(E_LogLevel LogLevel)
+{
+	local bool Errors;
+	Errors = false;
+	return !Errors;
+}
+
+defaultproperties
+{
+	DefSpawnManager = class'KFAISpawnManager_Normal'
+}

ZedSpawner/Classes/Config_SpawnManager_Short.uc

@@ -0,0 +1,14 @@
+class Config_SpawnManager_Short extends Config_SpawnManager
+	config(ZedSpawner);
+
+public static function bool Load(E_LogLevel LogLevel)
+{
+	local bool Errors;
+	Errors = false;
+	return !Errors;
+}
+
+defaultproperties
+{
+	DefSpawnManager = class'KFAISpawnManager_Short'
+}

ZedSpawner/Classes/Config_SpawnManager_WaveInfo.uc

@@ -0,0 +1,184 @@
+class Config_SpawnManager_WaveInfo extends Object
+	abstract
+	config(ZedSpawnManager);
+
+var const class<KFAISpawnManager> DefSpawnManager;
+var const byte   Difficulty;
+var const byte   Wave;
+
+struct Unit
+{
+	var int    Num;
+	var String ZedClass;
+};
+
+struct Squad
+{
+	var ESquadType  MinVolumeType;
+	var Array<Unit> Units;
+};
+
+var config bool         bRecycleWave;
+var config int          MaxAI;
+var config Array<Squad> Squads;
+var config Array<Squad> SquadsSpecial;
+var config Array<Squad> SquadsEvent;
+
+public static function InitConfig(KFGI_Access KFGIA)
+{
+	local KFAIWaveInfo   KFAIWI;
+	local KFAISpawnSquad KFAISS;
+	local AISquadElement AISE;
+	local Squad          S;
+	local Unit           U;
+	
+	KFAIWI = default.DefSpawnManager.default.DifficultyWaveSettings[default.Difficulty].Waves[default.Wave];
+	
+	default.bRecycleWave = KFAIWI.bRecycleWave;
+	default.MaxAI        = KFAIWI.MaxAI;
+	
+	default.Squads.Length = 0;
+	foreach KFAIWI.Squads(KFAISS)
+	{
+		S.MinVolumeType = KFAISS.MinVolumeType;
+		foreach KFAISS.MonsterList(AISE)
+		{
+			U.ZedClass = GetPawnClassString(KFGIA, AISE);
+			U.Num      = AISE.Num;
+			S.Units.AddItem(U);
+		}
+		default.Squads.AddItem(S);
+	}
+	
+	default.SquadsSpecial.Length = 0;
+	foreach KFAIWI.SpecialSquads(KFAISS)
+	{
+		S.MinVolumeType = KFAISS.MinVolumeType;
+		foreach KFAISS.MonsterList(AISE)
+		{
+			U.ZedClass = GetPawnClassString(KFGIA, AISE);
+			U.Num      = AISE.Num;
+			S.Units.AddItem(U);
+		}
+		default.SquadsSpecial.AddItem(S);
+	}
+	
+	default.SquadsEvent.Length = 0;
+	foreach KFAIWI.EventSquads(KFAISS)
+	{
+		S.MinVolumeType = KFAISS.MinVolumeType;
+		foreach KFAISS.MonsterList(AISE)
+		{
+			U.ZedClass = GetPawnClassString(KFGIA, AISE);
+			U.Num      = AISE.Num;
+			S.Units.AddItem(U);
+		}
+		default.SquadsEvent.AddItem(S);
+	}
+	
+	StaticSaveConfig();
+}
+
+private static function String GetPawnClassString(KFGI_Access KFGIA, AISquadElement AISE)
+{
+	local class<KFPawn_Monster> KFPMC;
+	
+	KFPMC = KFGIA.AITypePawn(AISE.Type);
+	if (KFPMC == None)
+		KFPMC = AISE.CustomClass;
+	
+	return "KFGameContent." $ String(KFPMC);
+}
+
+public static function AIWaveInfo Load(E_LogLevel LogLevel, KFGI_Access KFGIA)
+{
+	local class<KFPawn_Monster> KFPMC;
+	local AIWaveInfo       AIWI;
+	local AISpawnSquad     AISS;
+	local S_AISquadElement AISE;
+	local Squad            S;
+	local Unit             U;
+	
+	AIWI = new class'AIWaveInfo';
+	
+	AIWI.bRecycleWave = default.bRecycleWave;
+	AIWI.MaxAI        = default.MaxAI;
+	
+	foreach default.Squads(S)
+	{
+		AISS = new class'AISpawnSquad';
+		AISS.MinVolumeType = S.MinVolumeType;
+		foreach S.Units(U)
+		{
+			KFPMC = class<KFPawn_Monster>(DynamicLoadObject(U.ZedClass, class'Class'));
+			if (KFPMC == None)
+			{
+				`ZS_Warn("Can't load zed class:" @ U.ZedClass);
+				continue;
+			}
+			
+			if (!KFGIA.IsOriginalAI(KFPMC, AISE.Type))
+				AISE.CustomClass = KFPMC;
+			
+			AISE.Num = AISE.Num;
+			
+			AISS.MonsterList.AddItem(AISE);
+		}
+		AIWI.Squads.AddItem(AISS);
+	}
+	
+	foreach default.SquadsSpecial(S)
+	{
+		AISS = new class'AISpawnSquad';
+		AISS.MinVolumeType = S.MinVolumeType;
+		foreach S.Units(U)
+		{
+			KFPMC = class<KFPawn_Monster>(DynamicLoadObject(U.ZedClass, class'Class'));
+			if (KFPMC == None)
+			{
+				`ZS_Warn("Can't load zed class:" @ U.ZedClass);
+				continue;
+			}
+			
+			if (!KFGIA.IsOriginalAI(KFPMC, AISE.Type))
+				AISE.CustomClass = KFPMC;
+			
+			AISE.Num = AISE.Num;
+			
+			AISS.MonsterList.AddItem(AISE);
+		}
+		AIWI.SpecialSquads.AddItem(AISS);
+	}
+	
+	foreach default.SquadsEvent(S)
+	{
+		AISS = new class'AISpawnSquad';
+		AISS.MinVolumeType = S.MinVolumeType;
+		foreach S.Units(U)
+		{
+			KFPMC = class<KFPawn_Monster>(DynamicLoadObject(U.ZedClass, class'Class'));
+			if (KFPMC == None)
+			{
+				`ZS_Warn("Can't load zed class:" @ U.ZedClass);
+				continue;
+			}
+			
+			if (!KFGIA.IsOriginalAI(KFPMC, AISE.Type))
+				AISE.CustomClass = KFPMC;
+			
+			AISE.Num = AISE.Num;
+			
+			AISS.MonsterList.AddItem(AISE);
+		}
+		AIWI.EventSquads.AddItem(AISS);
+	}
+	
+	return AIWI;
+}
+
+defaultproperties
+{
+	DefSpawnManager    = class'KFAISpawnManager'
+	Difficulty         = 255
+	Wave               = 255
+}

ZedSpawner/Classes/Config_Spawner.uc

@@ -1,44 +1,32 @@
-class Spawn extends Object
+class Config_Spawner extends Object
 	dependson(ZedSpawner)
 	config(ZedSpawner);
 
-var public config bool  bCyclicalSpawn;
-var public config bool  bShadowSpawn;
-var public config float ZedTotalMultiplier;
-var public config float SpawnTotalPlayerMultiplier;
-var public config float SpawnTotalCycleMultiplier;
-var public config float SingleSpawnLimitMultiplier;
-var public config float SingleSpawnLimitPlayerMultiplier;
-var public config float SingleSpawnLimitCycleMultiplier;
-var public config int   AliveSpawnLimit;
+var config bool  bCyclicalSpawn;
+var config bool  bShadowSpawn;
 
-public static function InitConfig(int Version, int LatestVersion)
+var config float ZedTotalMultiplier;
+var config float SpawnTotalPlayerMultiplier;
+var config float SpawnTotalCycleMultiplier;
+
+var config float SingleSpawnLimitMultiplier;
+var config float SingleSpawnLimitPlayerMultiplier;
+var config float SingleSpawnLimitCycleMultiplier;
+
+var config int   AliveSpawnLimit;
+
+public static function InitConfig()
 {
-	switch (Version)
-	{
-		case `NO_CONFIG:
-			ApplyDefault();
-			
-		default: break;
-	}
-	
-	if (LatestVersion != Version)
-	{
-		StaticSaveConfig();
-	}
-}
-
-private static function ApplyDefault()
-{
-	default.bCyclicalSpawn                   = true;
-	default.bShadowSpawn                     = true;
-	default.ZedTotalMultiplier               = 1.0;
-	default.SpawnTotalPlayerMultiplier       = 0.75;
-	default.SpawnTotalCycleMultiplier        = 0.75;
-	default.SingleSpawnLimitMultiplier       = 1.0;
+	default.bCyclicalSpawn = true;
+	default.bShadowSpawn = true;
+	default.ZedTotalMultiplier = 1.0;
+	default.SpawnTotalPlayerMultiplier = 0.75;
+	default.SpawnTotalCycleMultiplier = 0.75;
 	default.SingleSpawnLimitPlayerMultiplier = 0.75;
-	default.SingleSpawnLimitCycleMultiplier  = 0.75;
-	default.AliveSpawnLimit                  = 0;
+	default.SingleSpawnLimitCycleMultiplier = 0.75;
+	default.AliveSpawnLimit = 0;
+
+	StaticSaveConfig();
 }
 
 public static function bool Load(E_LogLevel LogLevel)

ZedSpawner/Classes/KFGI_Access.uc

@@ -1,39 +1,6 @@
 class KFGI_Access extends Object
 	within KFGameInfo;
 
-public function Array<class<KFPawn_Monster> > GetAIClassList()
-{
-	local Array<class<KFPawn_Monster> > RV;
-	local class<KFPawn_Monster> KFPMC;
-	
-	foreach AIClassList(KFPMC)
-		RV.AddItem(KFPMC);
-		
-	return RV;
-}
-
-public function Array<class<KFPawn_Monster> > GetNonSpawnAIClassList()
-{
-	local Array<class<KFPawn_Monster> > RV;
-	local class<KFPawn_Monster> KFPMC;
-	
-	foreach NonSpawnAIClassList(KFPMC)
-		RV.AddItem(KFPMC);
-		
-	return RV;
-}
-
-public function Array<class<KFPawn_Monster> > GetAIBossClassList()
-{
-	local Array<class<KFPawn_Monster> > RV;
-	local class<KFPawn_Monster> KFPMC;
-	
-	foreach AIBossClassList(KFPMC)
-		RV.AddItem(KFPMC);
-		
-	return RV;
-}
-
 public function bool IsCustomZed(class<KFPawn_Monster> KFPM)
 {
 	if (AIClassList.Find(KFPM)         != INDEX_NONE) return false;
@@ -42,6 +9,7 @@ public function bool IsCustomZed(class<KFPawn_Monster> KFPM)
 	return true;
 }
 
+// WARN: <optional out> - can it work? need check
 public function bool IsOriginalAI(class<KFPawn_Monster> KFPM, optional out EAIType AIType)
 {
 	local int Type;

ZedSpawner/Classes/ZedSpawner.uc

@@ -1,32 +1,27 @@
 class ZedSpawner extends Info
 	config(ZedSpawner);
 
-const LatestVersion = 1;
-
 const dt = 1;
 
-const CfgSpawn        = class'Spawn';
-const CfgSpawnListRW  = class'SpawnListRegular';
-const CfgSpawnListBW  = class'SpawnListBossWaves';
-const CfgSpawnListSW  = class'SpawnListSpecialWaves';
+const CfgSpawn         = class'Config_Spawner';
+const CfgSpawnListR    = class'Config_SpawnListRegular';
+const CfgSpawnListBW   = class'Config_SpawnListBossWaves';
+const CfgSpawnListSW   = class'Config_SpawnListSpecialWaves';
+const CfgSpawnManagerE = class'Config_SpawnManager_Endless';
+const CfgSpawnManagerS = class'Config_SpawnManager_Short';
+const CfgSpawnManagerN = class'Config_SpawnManager_Normal';
+const CfgSpawnManagerL = class'Config_SpawnManager_Long';
 
-enum E_LogLevel
-{
-	LL_WrongLevel,
-	LL_Fatal,
-	LL_Error,
-	LL_Warning,
-	LL_Info,
-	LL_Debug,
-	LL_Trace,
-	LL_All
-};
+const SpawnManagerS    = class'AISpawnManager_Short';
+const SpawnManagerN    = class'AISpawnManager_Normal';
+const SpawnManagerL    = class'AISpawnManager_Long';
+const SpawnManagerE    = class'AISpawnManager_Endless';
 
 struct S_SpawnEntry
 {
 	var class<KFPawn_Monster> BossClass;
 	var class<KFPawn_Monster> ZedClass;
-	var byte  Wave;
+	var int   Wave;
 	var int   SpawnCountBase;
 	var int   SingleSpawnLimitDefault;
 	var int   SingleSpawnLimit;
@@ -40,40 +35,55 @@ struct S_SpawnEntry
 	var bool  SpawnAtPlayerStart;
 };
 
-var private config int        Version;
-var private config E_LogLevel LogLevel;
+var config bool       bConfigInitialized;
+var config E_LogLevel LogLevel;
 
-var private Array<S_SpawnEntry> SpawnListRW;
+var private Array<S_SpawnEntry> SpawnListR;
 var private Array<S_SpawnEntry> SpawnListBW;
 var private Array<S_SpawnEntry> SpawnListSW;
-var private Array<S_SpawnEntry> SpawnListCurrent;
-
-var private bool NoFreeSpawnSlots;
-var private bool UseRegularSpawnList;
-var private bool UseBossSpawnList;
-var private bool UseSpecialSpawnList;
 
 var private KFGameInfo_Survival KFGIS;
 var private KFGameInfo_Endless  KFGIE;
-var private KFGI_Access         KFGIA;
+
+var private KFGI_Access KFGIA;
 
 var private int CurrentWave;
-var private int SpecialWave;
 var private int CurrentCycle;
 var private int CycleWaveShift;
 var private int CycleWaveSize;
-var private int WaveTotalAI;
 
-var private class<KFPawn_Monster>         CurrentBossClass;
+var private int WaveTotalAI;
+var private class<KFPawn_Monster> CurrentBossClass;
+var private int SpecialWave;
+
+var private String SpawnTimerLastMessage;
+
 var private Array<class<KFPawn_Monster> > BossClassCache;
 var private Array<class<KFPawn_Monster> > CustomZeds;
 
-var private String SpawnTimerLastMessage;
-var private String SpawnListsComment;
-
 delegate bool WaveCondition(S_SpawnEntry SE);
 
-public event PreBeginPlay()
+event PreBeginPlay()
+{
+	`ZS_Trace(`Location);
+	
+	Super.PreBeginPlay();
+	
+	PreInit();
+}
+
+event PostBeginPlay()
+{
+	`ZS_Trace(`Location);
+	
+	if (bPendingDelete) return;
+	
+	Super.PostBeginPlay();
+	
+	PostInit();
+}
+
+private function PreInit()
 {
 	`ZS_Trace(`Location);
 	
@@ -84,66 +94,52 @@ public event PreBeginPlay()
 		return;
 	}
 	
-	Super.PreBeginPlay();
-}
-
-public event PostBeginPlay()
-{
-	`ZS_Trace(`Location);
-	
-	if (bPendingDelete) return;
-	
-	Super.PostBeginPlay();
-	
-	Init();
-}
-
-private function InitConfig()
-{
-	if (Version == `NO_CONFIG)
+	if (!bConfigInitialized)
 	{
+		bConfigInitialized = true;
 		LogLevel = LL_Info;
 		SaveConfig();
+		CfgSpawn.static.InitConfig();
+		CfgSpawnListR.static.InitConfig();
+		CfgSpawnListBW.static.InitConfig();
+		CfgSpawnListSW.static.InitConfig();
+		CfgSpawnManagerS.static.InitConfig();
+		CfgSpawnManagerN.static.InitConfig();
+		CfgSpawnManagerL.static.InitConfig();
+		CfgSpawnManagerE.static.InitConfig();
+		`ZS_Info("Config initialized.");
 	}
 	
-	CfgSpawn.static.InitConfig(Version, LatestVersion);
-	CfgSpawnListRW.static.InitConfig(Version, LatestVersion, KFGIA);
-	CfgSpawnListBW.static.InitConfig(Version, LatestVersion, KFGIA);
-	CfgSpawnListSW.static.InitConfig(Version, LatestVersion);
+	CfgSpawnManagerS.static.InitConfig();
+	CfgSpawnManagerN.static.InitConfig();
+	CfgSpawnManagerL.static.InitConfig();
+	CfgSpawnManagerE.static.InitConfig();
 
-	switch (Version)
+	if (LogLevel == LL_WrongLevel)
 	{
-		case `NO_CONFIG:
-			`ZS_Info("Config created");
-
-		case MaxInt:
-			`ZS_Info("Config updated to version"@LatestVersion);
-			break;
-			
-		case LatestVersion:
-			`ZS_Info("Config is up-to-date");
-			break;
-			
-		default:
-			`ZS_Warn("The config version is higher than the current version (are you using an old mutator?)");
-			`ZS_Warn("Config version is" @ Version @ "but current version is" @ LatestVersion);
-			`ZS_Warn("The config version will be changed to" @ LatestVersion);
-			break;
-	}
-
-	if (LatestVersion != Version)
-	{
-		Version = LatestVersion;
+		LogLevel = LL_Info;
+		`ZS_Warn("Wrong 'LogLevel', return to default value");
 		SaveConfig();
 	}
+	
+	`ZS_Log("LogLevel:" @ LogLevel);
+	
+	if (!CfgSpawn.static.Load(LogLevel))
+	{
+		`ZS_Fatal("Wrong settings, Destroy...");
+		Destroy();
+		return;
+	}
 }
 
-private function Init()
+private function PostInit()
 {
 	local S_SpawnEntry SE;
+	local bool NeedInitSM;
 	
 	`ZS_Trace(`Location);
 	
+	CurrentWave = INDEX_NONE;
 	KFGIS = KFGameInfo_Survival(WorldInfo.Game);
 	if (KFGIS == None)
 	{
@@ -155,71 +151,76 @@ private function Init()
 	KFGIA = new(KFGIS) class'KFGI_Access';
 	KFGIE = KFGameInfo_Endless(KFGIS);
 	
-	InitConfig();
-
-	if (LogLevel == LL_WrongLevel)
-	{
-		LogLevel = LL_Info;
-		`ZS_Warn("Wrong 'LogLevel', return to default value");
-		SaveConfig();
-	}
-	`ZS_Log("LogLevel:" @ LogLevel);
-	
-	if (!CfgSpawn.static.Load(LogLevel))
-	{
-		`ZS_Fatal("Wrong settings, Destroy...");
-		Destroy();
-		return;
-	}
-
-	SpawnListRW = CfgSpawnListRW.static.Load(LogLevel);
+	SpawnListR  = CfgSpawnListR.static.Load(LogLevel);
 	SpawnListBW = CfgSpawnListBW.static.Load(LogLevel);
 	SpawnListSW = CfgSpawnListSW.static.Load(KFGIE, LogLevel);
 	
-	CurrentWave = INDEX_NONE;
+	CfgSpawnManagerE.static.Load(LogLevel);
+	CfgSpawnManagerS.static.Load(LogLevel);
+	CfgSpawnManagerN.static.Load(LogLevel);
+	CfgSpawnManagerL.static.Load(LogLevel);
+	
 	SpecialWave = INDEX_NONE;
 	CurrentCycle = 1;
-	
-	if (CfgSpawn.default.bCyclicalSpawn)
+	CycleWaveSize = 0;
+	CycleWaveShift = MaxInt;
+	foreach SpawnListR(SE)
 	{
-		CycleWaveSize = 0;
-		CycleWaveShift = MaxInt;
-		foreach SpawnListRW(SE)
-		{
-			CycleWaveShift = Min(CycleWaveShift, SE.Wave);
-			CycleWaveSize  = Max(CycleWaveSize, SE.Wave);
-		}
-		CycleWaveSize = CycleWaveSize - CycleWaveShift + 1;
+		CycleWaveShift = Min(CycleWaveShift, SE.Wave);
+		CycleWaveSize  = Max(CycleWaveSize, SE.Wave);
 	}
-	
-	CreateBossCache();
-	PreloadContent();
-	
-	SetTimer(float(dt), true, nameof(SpawnTimer));
-}
-
-private function CreateBossCache()
-{
-	local S_SpawnEntry SE;
+	CycleWaveSize = CycleWaveSize - CycleWaveShift + 1;
 	
 	foreach SpawnListBW(SE)
 		if (BossClassCache.Find(SE.BossClass) == INDEX_NONE)
 			BossClassCache.AddItem(SE.BossClass);
+	
+	if (true)
+	{
+		NeedInitSM = (KFGIS.SpawnManager != None);
+		KFGIS.SpawnManagerClasses.Length = 0;
+		if (KFGIE != None)
+		{
+			KFGIE.SpawnManagerClasses.AddItem(SpawnManagerE);
+		}
+		else
+		{
+			KFGIS.SpawnManagerClasses.AddItem(SpawnManagerS);
+			KFGIS.SpawnManagerClasses.AddItem(SpawnManagerN);
+			KFGIS.SpawnManagerClasses.AddItem(SpawnManagerL);
+		}
+		
+		if (NeedInitSM)
+		{
+			KFGIS.InitSpawnManager();
+		}
+		
+		`ZS_Info("SpawnManager replaced");
+	}
+	
+	PreparePreloadContent();
+	
+	if (SpawnListSW.Length > 0 || SpawnListBW.Length > 0 || SpawnListR.Length > 0)
+	{
+		SetTimer(float(dt), true, nameof(SpawnTimer));
+	}
+	else
+	{
+		`ZS_Info("Spawn timer disabled (no spawn lists)", LogLevel);
+	}
 }
 
-private function PreloadContent()
+private function PreparePreloadContent()
 {
 	local class<KFPawn_Monster> PawnClass;
 	
-	ExtractCustomZedsFromSpawnList(SpawnListRW, CustomZeds);
+	ExtractCustomZedsFromSpawnList(SpawnListR,  CustomZeds);
 	ExtractCustomZedsFromSpawnList(SpawnListBW, CustomZeds);
 	ExtractCustomZedsFromSpawnList(SpawnListSW, CustomZeds);
+	ExtractCustomZedsFromSpawnManager(AISpawnManager(KFGIS.SpawnManager), CustomZeds);
 	
 	foreach CustomZeds(PawnClass)
-	{
-		`ZS_Info("Preload content:" @ PawnClass);
 		PawnClass.static.PreloadContent();
-	}
 }
 
 private function ExtractCustomZedsFromSpawnList(Array<S_SpawnEntry> SpawnList, out Array<class<KFPawn_Monster> > Out)
@@ -231,35 +232,67 @@ private function ExtractCustomZedsFromSpawnList(Array<S_SpawnEntry> SpawnList, o
 		if (Out.Find(SE.ZedClass) == INDEX_NONE
 		&&  KFGIA.IsCustomZed(SE.ZedClass))
 		{
+			`ZS_Debug("Add custom zed:" @ SE.ZedClass);
 			Out.AddItem(SE.ZedClass);
 		}
 	}
 }
 
+private function ExtractCustomZedsFromSpawnManager(AISpawnManager SpawnManager, out Array<class<KFPawn_Monster> > Out)
+{
+	// TODO
+}
+
+private function PreloadContent(Array<class<KFPawn_Monster> > Pawns)
+{
+	local class<KFPawn_Monster> KFPM;
+	foreach Pawns(KFPM) KFPM.static.PreloadContent();
+}
+
 public function bool WaveConditionRegular(S_SpawnEntry SE)
 {
+	`ZS_Trace(`Location);
+	
 	return (SE.Wave == KFGIS.WaveNum - CycleWaveSize * (CurrentCycle - 1));
 }
 
 public function bool WaveConditionBoss(S_SpawnEntry SE)
 {
+	local KFPawn_Monster KFPM;
+	local int Index;
+	
+	`ZS_Trace(`Location);
+	
 	if (CurrentBossClass == None)
+	{
+		foreach WorldInfo.AllPawns(class'KFPawn_Monster', KFPM)
+		{
+			Index = BossClassCache.Find(KFPM.class);
+			if (Index != INDEX_NONE)
+			{
+				CurrentBossClass = BossClassCache[Index];
+				break;
+			}
+		}
+	}
+	
+	if (CurrentBossClass == None)
+	{
 		return false;
-	else
-		return (SE.BossClass == CurrentBossClass);
+	}
+	
+	return (SE.BossClass == CurrentBossClass);
 }
 
 public function bool WaveConditionSpecial(S_SpawnEntry SE)
 {
+	`ZS_Trace(`Location);
+	
 	return (SE.Wave == SpecialWave);
 }
 
-
 private function SpawnTimer()
 {
-	local S_SpawnEntry SE;
-	local int Index;
-	
 	`ZS_Trace(`Location);
 	
 	if (KFGIS.WaveNum != 0 && CurrentWave < KFGIS.WaveNum)
@@ -279,76 +312,41 @@ private function SpawnTimer()
 		return;
 	}
 		
-	if (!KFGIS.MyKFGRI.IsBossWave() && CfgSpawn.default.bShadowSpawn)
+	if (!KFGIS.MyKFGRI.IsBossWave() && CfgSpawn.default.bShadowSpawn && KFGIS.MyKFGRI.AIRemaining <= KFGIS.AIAliveCount)
 	{
-		if (NoFreeSpawnSlots || KFGIS.MyKFGRI.AIRemaining <= KFGIS.AIAliveCount)
-		{
-			NoFreeSpawnSlots = true;
-			SpawnTimerLogger(true, "no free spawn slots");
-			return;
-		}
+		SpawnTimerLogger(true, "shadow spawn is active and no free spawn slots");
+		return;
 	}
 
-	SpawnTimerLogger(false, SpawnListsComment);
+	SpawnTimerLogger(false);
 
-	foreach SpawnListCurrent(SE, Index)
+	if ((SpecialWave == INDEX_NONE && !KFGIS.MyKFGRI.IsBossWave())
+	|| (SpecialWave  != INDEX_NONE && !CfgSpawnListSW.default.bStopRegularSpawn)
+	|| (KFGIS.MyKFGRI.IsBossWave() && !CfgSpawnListBW.default.bStopRegularSpawn))
 	{
-		if (!ReadyToStart(SE))
-		{
-			continue;
-		}
+		SpawnZeds(SpawnListR, WaveConditionRegular);
+	}
 	
-		if (SE.Delay > 0)
-		{
-			SpawnListCurrent[Index].Delay -= dt;
-			continue;
-		}
+	if (SpecialWave != INDEX_NONE)
+	{
+		SpawnZeds(SpawnListSW, WaveConditionSpecial);
+	}
 	
-		if (SE.SpawnsLeft > 0)
-		{
-			SpawnEntry(SpawnListCurrent, Index);
-		}
+	if (KFGIS.MyKFGRI.IsBossWave())
+	{
+		SpawnZeds(SpawnListBW, WaveConditionBoss);
 	}
 }
 
 private function SetupWave()
 {
-	local Array<String> SpawnListNames;
-	local int           WaveTotalAIDef;
-	local String        WaveTypeInfo;
+	local int WaveTotalAIDef;
 	
 	`ZS_Trace(`Location);
 	
-	if (CfgSpawn.default.bCyclicalSpawn && KFGIS.WaveNum > 1 && KFGIS.WaveNum == CycleWaveShift + CycleWaveSize * CurrentCycle)
-	{
-		CurrentCycle++;
-		`ZS_Info("Spawn cycle started:" @ CurrentCycle);
-	}
-	
 	CurrentWave = KFGIS.WaveNum;
 	
-	if (KFGIE != None)
-	{
-		SpecialWave = KFGameReplicationInfo_Endless(KFGIE.GameReplicationInfo).CurrentSpecialMode;
-		if (SpecialWave != INDEX_NONE)
-		{
-			WaveTypeInfo = "Special:" @ EAIType(SpecialWave);
-		}
-	}
-	
-	if (KFGIS.MyKFGRI.IsBossWave())
-	{
-		CurrentBossClass = KFGIA.BossAITypePawn(EBossAIType(KFGIS.MyKFGRI.BossIndex));
-		if (CurrentBossClass == None)
-		{
-			`ZS_Error("Can't determine boss class:" @ CurrentBossClass);
-		}
-		else
-		{
-			WaveTypeInfo = "Boss:" @ CurrentBossClass;
-		}
-	}
-	else
+	if (!KFGIS.MyKFGRI.IsBossWave())
 	{
 		WaveTotalAIDef = KFGIS.SpawnManager.WaveTotalAI;
 		KFGIS.SpawnManager.WaveTotalAI *= CfgSpawn.default.ZedTotalMultiplier;
@@ -360,56 +358,24 @@ private function SetupWave()
 		{
 			`ZS_Info("increase WaveTotalAI from" @ WaveTotalAIDef @ "to" @ WaveTotalAI @ "due to ZedTotalMultiplier" @ "(" $ CfgSpawn.default.ZedTotalMultiplier $ ")");
 		}
-		
-		CurrentBossClass = None;
 	}
 	
-	NoFreeSpawnSlots    = false;
-	UseBossSpawnList    = KFGIS.MyKFGRI.IsBossWave();
-	UseSpecialSpawnList = (SpecialWave != INDEX_NONE);
-	UseRegularSpawnList = ((!UseSpecialSpawnList && !UseBossSpawnList)
-	|| (UseSpecialSpawnList && !CfgSpawnListSW.default.bStopRegularSpawn)
-	|| (UseBossSpawnList && !CfgSpawnListBW.default.bStopRegularSpawn));
-
-	SpawnListCurrent.Length = 0;
-	if (UseRegularSpawnList)
+	if (CfgSpawn.default.bCyclicalSpawn && KFGIS.WaveNum > 1 && KFGIS.WaveNum == CycleWaveShift + CycleWaveSize * CurrentCycle)
 	{
-		SpawnListNames.AddItem("regular");
-		FillCurrentSpawnList(SpawnListRW, WaveConditionRegular);
+		CurrentCycle++;
+		`ZS_Info("Next spawn cycle started:" @ CurrentCycle);
 	}
 	
-	if (UseSpecialSpawnList)
+	ResetSpawnList(SpawnListR);
+	ResetSpawnList(SpawnListSW);
+	ResetSpawnList(SpawnListBW);
+	
+	CurrentBossClass = None;
+	
+	if (KFGIE != None)
 	{
-		SpawnListNames.AddItem("special");
-		FillCurrentSpawnList(SpawnListSW, WaveConditionSpecial);
+		SpecialWave = KFGameReplicationInfo_Endless(KFGIE.GameReplicationInfo).CurrentSpecialMode;
 	}
-	
-	if (UseBossSpawnList)
-	{
-		SpawnListNames.AddItem("boss");
-		FillCurrentSpawnList(SpawnListBW, WaveConditionBoss);
-	}
-	
-	JoinArray(SpawnListNames, SpawnListsComment, ", ");
-	ResetSpawnList(SpawnListCurrent);
-	
-	if (WaveTypeInfo != "")
-	{
-		WaveTypeInfo = "(" $ WaveTypeInfo $ ")";
-	}
-	
-	`ZS_Info("Wave" @ CurrentWave @ WaveTypeInfo);
-}
-
-private function FillCurrentSpawnList(Array<S_SpawnEntry> SpawnList, delegate<WaveCondition> Condition)
-{
-	local S_SpawnEntry SE;
-	
-	`ZS_Trace(`Location);
-	
-	foreach SpawnList(SE)
-		if (Condition(SE))
-			SpawnListCurrent.AddItem(SE);
 }
 
 private function ResetSpawnList(out Array<S_SpawnEntry> List)
@@ -443,7 +409,7 @@ private function ResetSpawnList(out Array<S_SpawnEntry> List)
 		else
 		{
 			List[Index].RelativeStart = SE.RelativeStartDefault;
-			if (List[Index].RelativeStart == 0.f)
+			if (SE.RelativeStart == 0.f)
 				List[Index].Delay = SE.DelayDefault;
 			else
 				List[Index].Delay = 0;
@@ -453,10 +419,12 @@ private function ResetSpawnList(out Array<S_SpawnEntry> List)
 		List[Index].SpawnsLeft  = List[Index].SpawnsTotal;
 		
 		List[Index].SingleSpawnLimit = Round(SE.SingleSpawnLimitDefault * (MLB + MLC * (Cycle - 1.0f) + MLP * (Players - 1.0f)));
+		
+		`ZS_Debug(SE.ZedClass @ "SpawnsTotal:" @ List[Index].SpawnsTotal @ "SingleSpawnLimit:" @ List[Index].SingleSpawnLimit);
 	}
 }
 
-private function SpawnTimerLogger(bool Stop, optional String Comment)
+private function SpawnTimerLogger(bool Stop, optional String Reason)
 {
 	local String Message;
 	
@@ -467,8 +435,8 @@ private function SpawnTimerLogger(bool Stop, optional String Comment)
 	else
 		Message = "Start spawn";
 	
-	if (Comment != "")
-		Message @= "(" $ Comment $ ")";
+	if (Reason != "")
+		Message @= "(" $ Reason $ ")";
 	
 	if (Message != SpawnTimerLastMessage)
 	{
@@ -477,6 +445,27 @@ private function SpawnTimerLogger(bool Stop, optional String Comment)
 	}
 }
 
+private function SpawnZeds(out Array<S_SpawnEntry> SpawnList, delegate<WaveCondition> Condition)
+{
+	local S_SpawnEntry SE;
+	local int Index;
+	
+	`ZS_Trace(`Location);
+
+	foreach SpawnList(SE, Index)
+	{
+		if (Condition(SE))
+		{
+			if (!ReadyToStart(SE)) continue;
+			
+			if (ReadyToSpawn(SE))
+				SpawnEntry(SpawnListR, Index);
+			else
+				SpawnListR[Index].Delay -= dt;
+		}
+	}
+}
+
 private function bool ReadyToStart(S_SpawnEntry SE)
 {
 	`ZS_Trace(`Location);
@@ -491,6 +480,13 @@ private function bool ReadyToStart(S_SpawnEntry SE)
 	}
 }
 
+private function bool ReadyToSpawn(S_SpawnEntry SE)
+{
+	`ZS_Trace(`Location);
+	
+	return SE.Delay <= 0 && SE.SpawnsLeft > 0;
+}
+
 private function SpawnEntry(out Array<S_SpawnEntry> SpawnList, int Index)
 {
 	local S_SpawnEntry SE;
@@ -512,13 +508,7 @@ private function SpawnEntry(out Array<S_SpawnEntry> SpawnList, int Index)
 		if (CfgSpawn.default.bShadowSpawn && !KFGIS.MyKFGRI.IsBossWave())
 		{
 			FreeSpawnSlots = KFGIS.MyKFGRI.AIRemaining - KFGIS.AIAliveCount;
-			if (FreeSpawnSlots == 0)
-			{
-				NoFreeSpawnSlots = true;
-				SpawnList[Index].SpawnsLeft = 0;
-				return;
-			}
-			else if (SpawnCount > FreeSpawnSlots)
+			if (SpawnCount > FreeSpawnSlots)
 			{
 				`ZS_Info("Not enough free slots to spawn, will spawn" @ FreeSpawnSlots @ "instead of" @ SpawnCount);
 				SpawnCount = FreeSpawnSlots;
@@ -587,7 +577,7 @@ private function int SpawnZed(class<KFPawn_Monster> ZedClass, int SpawnCount, bo
 	local Vector SpawnLocation;
 	local KFPawn_Monster KFPM;
 	local Controller C;
-	local int SpawnFailed, Spawned;
+	local int SpawnFailed;
 	local int Index;
 	
 	`ZS_Trace(`Location);
@@ -629,17 +619,14 @@ private function int SpawnZed(class<KFPawn_Monster> ZedClass, int SpawnCount, bo
 		C.Possess(KFPM, false);
 	}
 
-	Spawned = (SpawnCount - SpawnFailed);
-
 	if (CfgSpawn.default.bShadowSpawn && !KFGIS.MyKFGRI.IsBossWave())
 	{
-		KFGIS.NumAIFinishedSpawning += Spawned;
-		KFGIS.NumAISpawnsQueued += Spawned;
+		KFGIS.MyKFGRI.AIRemaining -= (SpawnCount - SpawnFailed);
 	}
 	
-	KFGIS.UpdateAIRemaining();
+	KFGIS.RefreshMonsterAliveCount();
 
-	return Spawned;
+	return SpawnCount - SpawnFailed;
 }
 
 public function NotifyLogin(Controller C)

ZedSpawner/Classes/_CommonTypes.uc

@@ -0,0 +1,18 @@
+class _CommonTypes extends Object;
+
+enum E_LogLevel
+{
+	LL_WrongLevel,
+	LL_Fatal,
+	LL_Error,
+	LL_Warning,
+	LL_Info,
+	LL_Debug,
+	LL_Trace,
+	LL_All
+};
+
+defaultproperties
+{
+	
+}

ZedSpawner/Globals.uci

@@ -8,5 +8,3 @@
 `define ZS_Info(msg)      `log("INFO:"  @ `msg, (LogLevel >= LL_Info),    `ZS_Tag)
 `define ZS_Debug(msg)     `log("DEBUG:" @ `msg, (LogLevel >= LL_Debug),   `ZS_Tag)
 `define ZS_Trace(msg)     `log("TRACE:" @ `msg, (LogLevel >= LL_Trace),   `ZS_Tag)
-
-`define NO_CONFIG 0