diff --git a/src/Dapr/GameServer.Host/ConfigurationChangeController.cs b/src/Dapr/GameServer.Host/ConfigurationChangeController.cs
index 03cc71691..253367bf9 100644
--- a/src/Dapr/GameServer.Host/ConfigurationChangeController.cs
+++ b/src/Dapr/GameServer.Host/ConfigurationChangeController.cs
@@ -9,6 +9,7 @@ namespace MUnique.OpenMU.GameServer.Host;
 using MUnique.OpenMU.Dapr.Common;
 using MUnique.OpenMU.Interfaces;
 using MUnique.OpenMU.Persistence.EntityFramework;
+using MUnique.OpenMU.PlugIns;
 
 /// <summary>
 /// The API controller which handles the calls of the <see cref="ConfigurationChangePublisher"/>
@@ -21,14 +22,17 @@ namespace MUnique.OpenMU.GameServer.Host;
 public class ConfigurationChangeController : ControllerBase
 {
     private readonly IConfigurationChangeListener _changeListener;
+    private readonly PlugInManager _plugInManager;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigurationChangeController" /> class.
     /// </summary>
     /// <param name="changeListener">The change listener.</param>
-    public ConfigurationChangeController(IConfigurationChangeListener changeListener)
+    /// <param name="plugInManager">The plugin manager.</param>
+    public ConfigurationChangeController(IConfigurationChangeListener changeListener, PlugInManager plugInManager)
     {
         this._changeListener = changeListener;
+        this._plugInManager = plugInManager;
     }
 
     /// <summary>
@@ -50,6 +54,7 @@ public ValueTask ConfigurationAddedAsync([FromBody] ConfigurationChangeArguments
     [Topic("pubsub", nameof(IConfigurationChangePublisher.ConfigurationChangedAsync))]
     public ValueTask ConfigurationChangedAsync([FromBody] ConfigurationChangeArguments arguments)
     {
+        this._plugInManager.ApplyChangedConfiguration(arguments.Type, arguments.Id, arguments.Configuration);
         return this._changeListener.ConfigurationChangedAsync(arguments.Type, arguments.Id, arguments.Configuration!, null);
     }
 
@@ -61,6 +66,7 @@ public ValueTask ConfigurationChangedAsync([FromBody] ConfigurationChangeArgumen
     [Topic("pubsub", nameof(IConfigurationChangePublisher.ConfigurationRemovedAsync))]
     public ValueTask ConfigurationRemovedAsync([FromBody] ConfigurationChangeArguments arguments)
     {
+        this._plugInManager.ApplyRemovedConfiguration(arguments.Type, arguments.Id);
         return this._changeListener.ConfigurationRemovedAsync(arguments.Type, arguments.Id, null, null);
     }
-}
\ No newline at end of file
+}
diff --git a/src/GameLogic/GameMapTerrain.cs b/src/GameLogic/GameMapTerrain.cs
index 44d559f38..b0bb2e248 100644
--- a/src/GameLogic/GameMapTerrain.cs
+++ b/src/GameLogic/GameMapTerrain.cs
@@ -1,4 +1,4 @@
-// <copyright file="GameMapTerrain.cs" company="MUnique">
+// <copyright file="GameMapTerrain.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -12,11 +12,22 @@ namespace MUnique.OpenMU.GameLogic;
 /// </summary>
 public class GameMapTerrain
 {
+    /// <summary>
+    /// The size of the map in each dimension (byte range: 0–255).
+    /// </summary>
+    private const int MapSize = 256;
+
     /// <summary>
     /// The default terrain where all coordinates are walkable and not a safezone.
     /// </summary>
     private static readonly byte[] DefaultTerrain = Enumerable.Repeat<byte>(0, short.MaxValue).ToArray();
 
+    /// <summary>
+    /// Pre-computed array of walkable, non-safezone points.
+    /// Built once during construction for O(1) random spawn lookups.
+    /// </summary>
+    private readonly Point[] _spawnPoints;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="GameMapTerrain"/> class.
     /// </summary>
@@ -40,22 +51,42 @@ public GameMapTerrain(byte[]? terrainData)
         {
             this.ReadTerrainData(DefaultTerrain);
         }
+
+        this._spawnPoints = this.BuildSpawnPoints();
     }
 
     /// <summary>
     /// Gets a grid of all safezone coordinates.
     /// </summary>
-    public bool[,] SafezoneMap { get; } = new bool[256, 256];
+    public bool[,] SafezoneMap { get; } = new bool[MapSize, MapSize];
 
     /// <summary>
     /// Gets a grid of all walkable coordinates.
     /// </summary>
-    public bool[,] WalkMap { get; } = new bool[256, 256];
+    public bool[,] WalkMap { get; } = new bool[MapSize, MapSize];
 
     /// <summary>
     /// Gets a grid of the walkable coordinates of monsters.
     /// </summary>
-    public byte[,] AIgrid { get; } = new byte[256, 256];
+    public byte[,] AIgrid { get; } = new byte[MapSize, MapSize];
+
+    /// <summary>
+    /// Gets a random walkable, non-safezone point anywhere on the map.
+    /// Samples from a pre-computed array in O(1) per call.
+    /// </summary>
+    public Point? RandomWalkableCoordinate
+    {
+        get
+        {
+            var points = this._spawnPoints;
+            if (points.Length == 0)
+            {
+                return null;
+            }
+
+            return points[Random.Shared.Next(points.Length)];
+        }
+    }
 
     /// <summary>
     /// Gets a random drop coordinate at the specified point in the specified radius.
@@ -110,4 +141,27 @@ private void ReadTerrainData(ReadOnlySpan<byte> data)
             this.UpdateAiGridValue(x, y);
         }
     }
+
+    /// <summary>
+    /// Builds the array of valid spawn points.
+    /// A valid spawn point is walkable and not in a safezone.
+    /// </summary>
+    /// <returns>Array of valid spawn points.</returns>
+    private Point[] BuildSpawnPoints()
+    {
+        var result = new List<Point>(MapSize * MapSize);
+
+        for (var x = 0; x < MapSize; x++)
+        {
+            for (var y = 0; y < MapSize; y++)
+            {
+                if (this.WalkMap[x, y] && !this.SafezoneMap[x, y])
+                {
+                    result.Add(new Point((byte)x, (byte)y));
+                }
+            }
+        }
+
+        return result.ToArray();
+    }
 }
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/BaseInvasionPlugIn.cs b/src/GameLogic/PlugIns/InvasionEvents/BaseInvasionPlugIn.cs
index 99c2e03e9..773413619 100644
--- a/src/GameLogic/PlugIns/InvasionEvents/BaseInvasionPlugIn.cs
+++ b/src/GameLogic/PlugIns/InvasionEvents/BaseInvasionPlugIn.cs
@@ -1,71 +1,47 @@
-// <copyright file="BaseInvasionPlugIn.cs" company="MUnique">
+// <copyright file="BaseInvasionPlugIn.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
 namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
 
+using System.Collections.Concurrent;
 using MUnique.OpenMU.GameLogic.NPC;
 using MUnique.OpenMU.GameLogic.PlugIns.PeriodicTasks;
 using MUnique.OpenMU.GameLogic.Views;
 using MUnique.OpenMU.Interfaces;
+using MUnique.OpenMU.Pathfinding;
 using MUnique.OpenMU.PlugIns;
 
 /// <summary>
 /// Base class for invasion plugins.
 /// </summary>
-/// <typeparam name="TConfiguration">Configuration.</typeparam>
+/// <typeparam name="TConfiguration">The concrete configuration type.</typeparam>
 public abstract class BaseInvasionPlugIn<TConfiguration> : PeriodicTaskBasePlugIn<TConfiguration, InvasionGameServerState>, IPeriodicTaskPlugIn, IObjectAddedToMapPlugIn, ISupportCustomConfiguration<TConfiguration>
     where TConfiguration : PeriodicInvasionConfiguration
 {
-    /// <summary>
-    /// Lorencia.
-    /// </summary>
-    protected const ushort LorenciaId = 0;
-
-    /// <summary>
-    /// Devias.
-    /// </summary>
-    protected const ushort DeviasId = 2;
-
-    /// <summary>
-    /// Noria.
-    /// </summary>
-    protected const ushort NoriaId = 3;
-
-    /// <summary>
-    /// Gets mobs which spawn on event starting only on the selected map (MapId is null).
-    /// </summary>
-    private readonly InvasionMobSpawn[] _mobsOnSelectedMap;
-
-    /// <summary>
-    /// Gets mobs which spawn on event starting on specific maps (MapId is not null).
-    /// </summary>
-    private readonly InvasionMobSpawn[] _mobs;
-
     private readonly MapEventType? _mapEventType;
+    private readonly ConcurrentDictionary<MonsterCleanupHandler, byte> _cleanupHandlers = new();
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="BaseInvasionPlugIn{TConfiguration}" /> class.
+    /// Initializes a new instance of the <see cref="BaseInvasionPlugIn{TConfiguration}"/> class.
     /// </summary>
-    /// <param name="mapEventType">Type of the map event.</param>
-    /// <param name="mobs">The mobs which spawn on specific maps (MapId is not null).</param>
-    /// <param name="mobsOnSelectedMap">The mobs which always spawn on event starting on the selected map (MapId is null).</param>
-    protected BaseInvasionPlugIn(MapEventType? mapEventType, InvasionMobSpawn[]? mobs, InvasionMobSpawn[]? mobsOnSelectedMap)
+    /// <param name="mapEventType">
+    /// The map-event type used for UI state broadcasts.
+    /// Pass <c>null</c> to disable map-event state updates.
+    /// </param>
+    protected BaseInvasionPlugIn(MapEventType? mapEventType = null)
     {
         this._mapEventType = mapEventType;
-        this._mobs = mobs ?? [];
-        this._mobsOnSelectedMap = mobsOnSelectedMap ?? [];
     }
 
     /// <summary>
-    /// Occurs when the event has finished.
-    /// </summary>
-    public event EventHandler? Finished;
-
-    /// <summary>
-    /// Gets possible maps for the event.
+    /// Gets the list of map IDs from which the event display map is randomly selected.
+    /// When non-empty, <see cref="InvasionGameServerState.MapId"/> is chosen from this
+    /// list and map-event UI is shown only on that single map.
+    /// When <c>null</c>, <see cref="InvasionGameServerState.MapId"/> falls back to the
+    /// minimum of <see cref="InvasionGameServerState.MapIds"/>.
     /// </summary>
-    protected virtual ushort[] PossibleMaps { get; } = { LorenciaId, NoriaId, DeviasId };
+    protected virtual IReadOnlyList<ushort>? EventDisplayMapIds => null;
 
     /// <inheritdoc />
     public virtual async ValueTask ObjectAddedToMapAsync(GameMap map, ILocateable addedObject)
@@ -79,227 +55,334 @@ public virtual async ValueTask ObjectAddedToMapAsync(GameMap map, ILocateable ad
         {
             var state = this.GetStateByGameContext(player.GameContext);
             var isEnabled = state.State != PeriodicTaskState.NotStarted;
-            await this.TrySendMapEventStateUpdateAsync(player, isEnabled).ConfigureAwait(false);
+            await this.TrySendMapEventStateUpdateAsync(player, isEnabled, state).ConfigureAwait(false);
         }
     }
 
     /// <summary>
-    /// Create a new monster.
+    /// Spawns <paramref name="quantity"/> instances of <paramref name="monsterDefinition"/> on
+    /// <paramref name="gameMap"/>, each placed at a random walkable coordinate (or a fixed
+    /// coordinate when <paramref name="x"/> and <paramref name="y"/> are provided).
     /// </summary>
     /// <param name="gameContext">The game context.</param>
+    /// <param name="logger">The logger.</param>
     /// <param name="gameMap">The game map.</param>
     /// <param name="monsterDefinition">The monster definition.</param>
-    /// <param name="x1">The x1.</param>
-    /// <param name="x2">The x2.</param>
-    /// <param name="y1">The y1.</param>
-    /// <param name="y2">The y2.</param>
     /// <param name="quantity">The quantity.</param>
-    protected async ValueTask CreateMonstersAsync(IGameContext gameContext, GameMap gameMap, MonsterDefinition monsterDefinition, byte x1, byte x2, byte y1, byte y2, ushort quantity)
+    /// <param name="x">The optional fixed X coordinate.</param>
+    /// <param name="y">The optional fixed Y coordinate.</param>
+    protected async ValueTask CreateMonstersAsync(IGameContext gameContext, ILogger logger, GameMap gameMap, MonsterDefinition monsterDefinition, ushort quantity, byte? x = null, byte? y = null)
     {
-        var area = new MonsterSpawnArea
+        for (var i = 0; i < quantity; i++)
         {
-            GameMap = gameMap.Definition,
-            MonsterDefinition = monsterDefinition,
-            SpawnTrigger = SpawnTrigger.OnceAtEventStart,
-            Quantity = 1,
-            X1 = x1,
-            X2 = x2,
-            Y1 = y1,
-            Y2 = y2,
-        };
-
-        while (quantity-- > 0)
-        {
-            var intelligence = new BasicMonsterIntelligence();
+            Point? spawnPoint = (x.HasValue && y.HasValue)
+                ? new Point(x.Value, y.Value)
+                : gameMap.Terrain.RandomWalkableCoordinate;
 
-            var monster = new Monster(area, monsterDefinition, gameMap, gameContext.DropGenerator, intelligence, gameContext.PlugInManager, gameContext.PathFinderPool);
+            if (spawnPoint is null)
+            {
+                logger.LogDebug("Skipping one {Monster} on {Map}: no walkable cell found.", monsterDefinition.Designation, gameMap.Definition.Name);
+                continue;
+            }
+
+            var area = new MonsterSpawnArea
+            {
+                GameMap = gameMap.Definition,
+                MonsterDefinition = monsterDefinition,
+                SpawnTrigger = SpawnTrigger.OnceAtEventStart,
+                Quantity = 1,
+                X1 = spawnPoint.Value.X,
+                X2 = spawnPoint.Value.X,
+                Y1 = spawnPoint.Value.Y,
+                Y2 = spawnPoint.Value.Y,
+            };
+
+            var intelligence = new BasicMonsterIntelligence();
+            var monster = new Monster(
+                area,
+                monsterDefinition,
+                gameMap,
+                gameContext.DropGenerator,
+                intelligence,
+                gameContext.PlugInManager,
+                gameContext.PathFinderPool);
 
             monster.Initialize();
             await gameMap.AddAsync(monster).ConfigureAwait(false);
             monster.OnSpawn();
 
-            this.Finished += CleanUpOnFinish;
-            monster.Died += (_, _) => this.Finished -= CleanUpOnFinish;
-
-#pragma warning disable VSTHRD100
-            async void CleanUpOnFinish(object? sender, EventArgs e)
-#pragma warning restore VSTHRD100
-            {
-                try
-                {
-                    this.Finished -= CleanUpOnFinish;
-                    if (monster is not null && !monster.IsDisposed)
-                    {
-                        await monster.CurrentMap.RemoveAsync(monster).ConfigureAwait(false);
-                        monster.Dispose();
-                    }
-                }
-                catch
-                {
-                    // must be catched in async void method
-                }
-            }
+            var handler = new MonsterCleanupHandler(this, monster);
+            this._cleanupHandlers.TryAdd(handler, 0);
+            monster.Died += (_, _) => this._cleanupHandlers.TryRemove(handler, out _);
         }
     }
 
     /// <summary>
-    /// Spawn mobs on the map.
+    /// Spawns all configured mobs for the given <paramref name="mapId"/>.
     /// </summary>
     /// <param name="gameContext">The game context.</param>
     /// <param name="mapId">The map id.</param>
-    /// <param name="mobs">The mobs.</param>
-    protected async ValueTask SpawnMobsAsync(IGameContext gameContext, ushort mapId, IEnumerable<InvasionMobSpawn> mobs)
+    /// <param name="spawns">The spawn configurations.</param>
+    protected async ValueTask SpawnMobsAsync(IGameContext gameContext, ushort mapId, IEnumerable<InvasionSpawnConfiguration> spawns)
     {
         var gameMap = await gameContext.GetMapAsync(mapId).ConfigureAwait(false);
-
         if (gameMap is null)
         {
             return;
         }
 
         var logger = gameContext.LoggerFactory.CreateLogger(this.GetType());
-        foreach (var mob in mobs)
+
+        foreach (var spawn in spawns)
         {
-            if (gameContext.Configuration.Monsters.FirstOrDefault(m => m.Number == mob.MonsterId) is { } monsterDefinition)
+            if (gameContext.Configuration.Monsters.FirstOrDefault(m => m.Number == spawn.MonsterId) is { } monsterDefinition)
             {
-                // Use custom coordinates if provided, otherwise use default (10, 240, 10, 240)
-                var spawnX1 = mob.X1 ?? 10;
-                var spawnX2 = mob.X2 ?? 240;
-                var spawnY1 = mob.Y1 ?? 10;
-                var spawnY2 = mob.Y2 ?? 240;
-
-                await this.CreateMonstersAsync(gameContext, gameMap, monsterDefinition, spawnX1, spawnX2, spawnY1, spawnY2, mob.Count).ConfigureAwait(false);
+                await this.CreateMonstersAsync(gameContext, logger, gameMap, monsterDefinition, spawn.Count, spawn.X, spawn.Y).ConfigureAwait(false);
             }
             else
             {
-                logger.LogDebug("Skipping spawning of monster with number {mobId}, because monster definition wasn't found.", mob.MonsterId);
+                logger.LogDebug("Skipping monster {MobId}: definition not found.", spawn.MonsterId);
             }
         }
     }
 
     /// <inheritdoc />
-    protected async override ValueTask OnPrepareEventAsync(InvasionGameServerState state)
+    protected override async ValueTask OnPrepareEventAsync(InvasionGameServerState state)
     {
-        state.MapId = this.PossibleMaps[Rand.NextInt(0, this.PossibleMaps.Length)];
+        state.Reset();
+
+        var config = this.Configuration;
+        if (config?.Mobs is not { Count: > 0 } mobs)
+        {
+            return;
+        }
+
+        this.SelectSpawnMaps(mobs, state);
+        this.SelectDisplayMap(state);
     }
 
     /// <inheritdoc />
     protected override InvasionGameServerState CreateState(IGameContext gameContext)
-    {
-        return new InvasionGameServerState(gameContext);
-    }
+        => new(gameContext);
 
     /// <summary>
-    /// Returns true if the player stays on the map.
+    /// Sends the invasion start message to a single player.
     /// </summary>
     /// <param name="player">The player.</param>
-    /// <param name="checkForCurrentMap">True, if need to check current event map.</param>
-    protected bool IsPlayerOnMap(Player player, bool checkForCurrentMap = false)
+    /// <param name="state">The server state.</param>
+    protected async Task TrySendStartMessageAsync(Player player, InvasionGameServerState state)
     {
-        var state = this.GetStateByGameContext(player.GameContext);
+        var configuration = this.Configuration;
+        if (configuration is null || state.MapIds.Count == 0)
+        {
+            return;
+        }
+
+        var mapName = state.Context.Configuration.Maps
+                          .FirstOrDefault(m => m.Number == state.MapId)
+                          ?.Name.GetTranslation(player.Culture)
+                      ?? string.Empty;
+
+        var message = (configuration.StartMessage.GetTranslation(player.Culture)
+                       ?? PlugInResources.BaseInvasionPlugIn_DefaultStartMessage)
+            .Replace("{mapName}", mapName, StringComparison.InvariantCulture);
 
-        return player.CurrentMap is { } map
-            && !player.PlayerState.CurrentState.IsDisconnectedOrFinished()
-            && (!checkForCurrentMap || map.MapId == state.MapId);
+        try
+        {
+            await player.InvokeViewPlugInAsync<IShowMessagePlugIn>(p => p.ShowMessageAsync(message, MessageType.GoldenCenter)).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            player.Logger.LogDebug(ex, "Unexpected error sending invasion start message.");
+        }
     }
 
     /// <summary>
-    /// Send a golden message to player's client.
+    /// Sends the invasion end message to a single player.
     /// </summary>
     /// <param name="player">The player.</param>
-    /// <param name="mapName">The map name.</param>
-    protected async Task TrySendStartMessageAsync(Player player, LocalizedString mapName)
+    /// <param name="state">The server state.</param>
+    protected async Task TrySendEndMessageAsync(Player player, InvasionGameServerState state)
     {
         var configuration = this.Configuration;
-
-        if (configuration is null)
+        if (configuration is null || state.MapIds.Count == 0 || string.IsNullOrWhiteSpace(configuration.EndMessage))
         {
             return;
         }
 
-        var message = (configuration.Message.GetTranslation(player.Culture) ?? PlugInResources.BaseInvasionPlugIn_DefaultStartMessage).Replace("{mapName}", mapName.GetTranslation(player.Culture), StringComparison.InvariantCulture);
+        var mapName = state.Context.Configuration.Maps
+                          .FirstOrDefault(m => m.Number == state.MapId)
+                          ?.Name.GetTranslation(player.Culture)
+                      ?? string.Empty;
 
-        if (this.IsPlayerOnMap(player))
+        var message = (configuration.EndMessage.GetTranslation(player.Culture) ?? string.Empty)
+            .Replace("{mapName}", mapName, StringComparison.InvariantCulture);
+
+        if (string.IsNullOrWhiteSpace(message))
         {
-            try
-            {
-                await player.InvokeViewPlugInAsync<IShowMessagePlugIn>(p => p.ShowMessageAsync(message, Interfaces.MessageType.GoldenCenter)).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                player.Logger.LogDebug(ex, "Unexpected error sending start message.");
-            }
+            return;
+        }
+
+        try
+        {
+            await player.InvokeViewPlugInAsync<IShowMessagePlugIn>(p => p.ShowMessageAsync(message, MessageType.GoldenCenter)).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            player.Logger.LogDebug(ex, "Unexpected error sending invasion end message.");
         }
     }
 
-    /// <summary>
-    /// Calls after the state changed to Prepared.
-    /// </summary>
-    /// <param name="state">The state.</param>
+    /// <inheritdoc />
     protected override async ValueTask OnPreparedAsync(InvasionGameServerState state)
     {
-        await state.Context.ForEachPlayerAsync(p => this.TrySendStartMessageAsync(p, state.MapName)).ConfigureAwait(false);
+        await state.Context.ForEachPlayerAsync(p => this.TrySendStartMessageAsync(p, state)).ConfigureAwait(false);
 
         if (this._mapEventType is not null)
         {
-            await state.Context.ForEachPlayerAsync(p => this.TrySendMapEventStateUpdateAsync(p, true)).ConfigureAwait(false);
+            await state.Context.ForEachPlayerAsync(p => this.TrySendMapEventStateUpdateAsync(p, true, state)).ConfigureAwait(false);
         }
     }
 
-    /// <summary>
-    /// Calls after the state changed to Started.
-    /// </summary>
-    /// <param name="state">State.</param>
+    /// <inheritdoc />
     protected override async ValueTask OnStartedAsync(InvasionGameServerState state)
     {
-        await this.SpawnMobsOnSelectedMapAsync(state).ConfigureAwait(false);
         await this.SpawnMobsOnMapsAsync(state).ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// Calls after the state changed to Finished.
-    /// </summary>
-    /// <param name="state">State.</param>
+    /// <inheritdoc />
     protected override async ValueTask OnFinishedAsync(InvasionGameServerState state)
     {
+        await state.Context.ForEachPlayerAsync(p => this.TrySendEndMessageAsync(p, state)).ConfigureAwait(false);
+
         if (this._mapEventType is not null)
         {
-            await state.Context.ForEachPlayerAsync(p => this.TrySendMapEventStateUpdateAsync(p, false)).ConfigureAwait(false);
+            await state.Context.ForEachPlayerAsync(p => this.TrySendMapEventStateUpdateAsync(p, false, state)).ConfigureAwait(false);
         }
 
-        this.Finished?.Invoke(this, EventArgs.Empty);
+        if (this._cleanupHandlers.Count > 0)
+        {
+            var handlers = this._cleanupHandlers.Keys.ToArray();
+            if (handlers.Length > 0)
+            {
+                await Task.WhenAll(handlers.Select(h => h.CleanUpAsync())).ConfigureAwait(false);
+            }
+        }
     }
 
     /// <summary>
-    /// Spawn mobs on the selected map.
+    /// Spawns mobs on the maps that were selected during <see cref="OnPrepareEventAsync"/>.
     /// </summary>
     /// <param name="state">The state.</param>
-    protected virtual async ValueTask SpawnMobsOnSelectedMapAsync(InvasionGameServerState state)
+    protected virtual async ValueTask SpawnMobsOnMapsAsync(InvasionGameServerState state)
     {
+        var config = this.Configuration;
+        if (config?.Mobs is not { Count: > 0 } spawns)
+        {
+            return;
+        }
+
         var gameContext = state.Context;
-        await this.SpawnMobsAsync(gameContext, state.MapId, this._mobsOnSelectedMap).ConfigureAwait(false);
+
+        foreach (var spawn in spawns)
+        {
+            if (spawn.IsSpawnOnAllMaps)
+            {
+                foreach (var mapId in spawn.MapIds)
+                {
+                    await this.SpawnMobsAsync(gameContext, mapId, [spawn]).ConfigureAwait(false);
+                }
+            }
+            else if (state.SelectedMaps.TryGetValue(spawn.MonsterId, out var selectedMapId))
+            {
+                await this.SpawnMobsAsync(gameContext, selectedMapId, [spawn]).ConfigureAwait(false);
+            }
+            else
+            {
+                // This indicates an unexpected state or configuration mismatch.
+            }
+        }
     }
 
     /// <summary>
-    /// Spawn mobs on the map.
+    /// Iterates the mob configurations and registers the selected spawn maps into the state.
+    /// For mobs configured with <see cref="SpawnMapStrategy.AllMaps"/>, all map IDs are registered.
+    /// For mobs configured with <see cref="SpawnMapStrategy.RandomMap"/>, a single map is picked at random.
     /// </summary>
-    /// <param name="state">The state.</param>
-    protected virtual async ValueTask SpawnMobsOnMapsAsync(InvasionGameServerState state)
+    /// <param name="mobs">The mob spawn configurations.</param>
+    /// <param name="state">The current invasion state.</param>
+    private void SelectSpawnMaps(IList<InvasionSpawnConfiguration> mobs, InvasionGameServerState state)
     {
-        var gameContext = state.Context;
+        foreach (var mob in mobs)
+        {
+            if (mob.MapIds.Count == 0)
+            {
+                continue;
+            }
+
+            if (mob.IsSpawnOnAllMaps)
+            {
+                foreach (var mapId in mob.MapIds)
+                {
+                    state.RegisterMap(mapId);
+                }
+            }
+            else
+            {
+                var randomMapId = mob.MapIds.Count == 1
+                    ? mob.MapIds[0]
+                    : mob.MapIds[Rand.NextInt(0, mob.MapIds.Count)];
+
+                state.RegisterMap(randomMapId, mob.MonsterId);
+            }
+        }
+    }
 
-        foreach (var group in this._mobs.GroupBy(mob => mob.MapId!.Value))
+    /// <summary>
+    /// Selects the single map used for UI event display and message broadcast from
+    /// the maps that were actually selected for spawning during <see cref="SelectSpawnMaps"/>.
+    /// When <see cref="EventDisplayMapIds"/> is configured, the display map is restricted
+    /// to the intersection of <see cref="EventDisplayMapIds"/> and the selected spawn maps,
+    /// ensuring the announced map always has active monsters.
+    /// Falls back to the minimum map ID if no intersection exists or no display maps are configured.
+    /// </summary>
+    /// <param name="state">The current invasion state.</param>
+    private void SelectDisplayMap(InvasionGameServerState state)
+    {
+        if (state.MapIds.Count == 0)
         {
-            var mapId = group.Key;
-            var mobs = group;
+            return;
+        }
 
-            await this.SpawnMobsAsync(gameContext, mapId, mobs).ConfigureAwait(false);
+        if (this.EventDisplayMapIds is { Count: > 0 } displayMaps)
+        {
+            var eligible = state.MapIds
+                .Where(displayMaps.Contains)
+                .ToList();
+
+            state.MapId = eligible.Count switch
+            {
+                0 => state.MapIds.Min(),
+                1 => eligible[0],
+                _ => eligible[Rand.NextInt(0, eligible.Count)],
+            };
+        }
+        else
+        {
+            state.MapId = state.MapIds.Min();
         }
     }
 
-    private async Task TrySendMapEventStateUpdateAsync(Player player, bool enabled)
+    private bool IsPlayerOnRelevantMap(Player player, InvasionGameServerState state)
+        => state.MapId.HasValue
+           && player.CurrentMap is { } map
+           && !player.PlayerState.CurrentState.IsDisconnectedOrFinished()
+           && map.MapId == state.MapId.Value
+           && (this.EventDisplayMapIds is null || this.EventDisplayMapIds.Contains(state.MapId.Value));
+
+    private async Task TrySendMapEventStateUpdateAsync(Player player, bool enabled, InvasionGameServerState state)
     {
-        if (this._mapEventType is null || !this.IsPlayerOnMap(player, true))
+        if (this._mapEventType is null || !this.IsPlayerOnRelevantMap(player, state))
         {
             return;
         }
@@ -310,7 +393,46 @@ private async Task TrySendMapEventStateUpdateAsync(Player player, bool enabled)
         }
         catch (Exception ex)
         {
-            player.Logger.LogDebug(ex, $"Unexpected error sending map event state update, event type {this._mapEventType}.");
+            player.Logger.LogDebug(
+                ex,
+                "Unexpected error sending map event state update, event type: {MapEventType}",
+                this._mapEventType);
+        }
+    }
+
+    /// <summary>
+    /// Handles cleanup of a single spawned monster when the invasion event finishes.
+    /// Encapsulates the self-referencing delegate pattern needed to unsubscribe from
+    /// the cleanup handler list without relying on captured uninitialized variables.
+    /// </summary>
+    private sealed class MonsterCleanupHandler
+    {
+        private readonly BaseInvasionPlugIn<TConfiguration> _plugin;
+        private readonly Monster _monster;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MonsterCleanupHandler"/> class.
+        /// </summary>
+        /// <param name="plugin">The owning plugin instance.</param>
+        /// <param name="monster">The monster to clean up.</param>
+        public MonsterCleanupHandler(BaseInvasionPlugIn<TConfiguration> plugin, Monster monster)
+        {
+            this._plugin = plugin;
+            this._monster = monster;
+        }
+
+        /// <summary>
+        /// Removes the monster from the map and disposes it.
+        /// Unsubscribes itself from the plugin's cleanup handler list so it is not called again.
+        /// </summary>
+        public async Task CleanUpAsync()
+        {
+            this._plugin._cleanupHandlers.TryRemove(this, out _);
+            if (!this._monster.IsDisposed)
+            {
+                await this._monster.CurrentMap.RemoveAsync(this._monster).ConfigureAwait(false);
+                this._monster.Dispose();
+            }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/GameLogic/PlugIns/InvasionEvents/GoldenInvasionPlugIn.cs b/src/GameLogic/PlugIns/InvasionEvents/GoldenInvasionPlugIn.cs
index 84bd64e32..be99bb858 100644
--- a/src/GameLogic/PlugIns/InvasionEvents/GoldenInvasionPlugIn.cs
+++ b/src/GameLogic/PlugIns/InvasionEvents/GoldenInvasionPlugIn.cs
@@ -1,4 +1,4 @@
-// <copyright file="GoldenInvasionPlugIn.cs" company="MUnique">
+// <copyright file="GoldenInvasionPlugIn.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -8,46 +8,25 @@ namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
 using MUnique.OpenMU.PlugIns;
 
 /// <summary>
-/// This plugin enables Golden Invasion feature.
+/// Enables the Golden Invasion feature.
 /// </summary>
 [PlugIn]
 [Display(Name = nameof(PlugInResources.GoldenInvasionPlugIn_Name), Description = nameof(PlugInResources.GoldenInvasionPlugIn_Description), ResourceType = typeof(PlugInResources))]
 [Guid("06D18A9E-2919-4C17-9DBC-6E4F7756495C")]
-public class GoldenInvasionPlugIn : BaseInvasionPlugIn<PeriodicInvasionConfiguration>, ISupportDefaultCustomConfiguration
+public sealed class GoldenInvasionPlugIn : SimpleInvasionPlugIn
 {
-    private const ushort AtlansId = 7;
-    private const ushort TarkanId = 8;
-
-    private const ushort GoldenBudgeDragonId = 43;
-    private const ushort GoldenGoblinId = 78;
-    private const ushort GoldenSoldierId = 54;
-    private const ushort GoldenTitanId = 53;
-    private const ushort GoldenDragonId = 79;
-    private const ushort GoldenVeparId = 81;
-    private const ushort GoldenLizardKingId = 80;
-    private const ushort GoldenWheelId = 83;
-    private const ushort GoldenTantallosId = 82;
+    private static readonly IReadOnlyList<ushort> DisplayMaps =
+    [
+        InvasionMaps.Lorencia,
+        InvasionMaps.Noria,
+        InvasionMaps.Devias,
+    ];
 
     /// <summary>
     /// Initializes a new instance of the <see cref="GoldenInvasionPlugIn"/> class.
     /// </summary>
     public GoldenInvasionPlugIn()
-        : base(
-            MapEventType.GoldenDragonInvasion,
-            [
-                new(GoldenBudgeDragonId, 20, MapId: LorenciaId),
-                new(GoldenGoblinId, 20, MapId: NoriaId),
-                new(GoldenSoldierId, 20, MapId: DeviasId),
-                new(GoldenTitanId, 10, MapId: DeviasId),
-                new(GoldenVeparId, 20, MapId: AtlansId),
-                new(GoldenLizardKingId, 10, MapId: AtlansId),
-                new(GoldenWheelId, 20, MapId: TarkanId),
-                new(GoldenTantallosId, 10, MapId: TarkanId),
-            ],
-            [new(GoldenDragonId, 10)])
+        : base(MapEventType.GoldenDragonInvasion, DisplayMaps, () => InvasionConfigurationDefaults.Golden)
     {
     }
-
-    /// <inheritdoc />
-    public object CreateDefaultConfig() => PeriodicInvasionConfiguration.DefaultGoldenInvasion;
 }
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionConfigurationDefaults.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionConfigurationDefaults.cs
new file mode 100644
index 000000000..f071126df
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/InvasionConfigurationDefaults.cs
@@ -0,0 +1,53 @@
+// <copyright file="InvasionConfigurationDefaults.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+using MUnique.OpenMU.GameLogic.PlugIns.PeriodicTasks;
+
+/// <summary>
+/// Provides ready-to-use default configurations for the built-in invasion types.
+/// </summary>
+internal static class InvasionConfigurationDefaults
+{
+    /// <summary>
+    /// Gets the default configuration for the Golden Invasion event.
+    /// </summary>
+    public static PeriodicInvasionConfiguration Golden => new()
+    {
+        TaskDuration = TimeSpan.FromMinutes(30),
+        PreStartMessageDelay = TimeSpan.FromSeconds(3),
+        StartMessage = "[{mapName}] Golden invasion!",
+        EndMessage = "[{mapName}] Golden invasion has ended.",
+        Timetable = PeriodicTaskConfiguration.GenerateTimeSequence(TimeSpan.FromHours(4)).ToList(),
+        Mobs =
+        [
+            new(InvasionMonsters.GoldenBudgeDragon, 20, [InvasionMaps.Lorencia], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenGoblin, 20, [InvasionMaps.Noria], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenSoldier, 20, [InvasionMaps.Devias], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenTitan, 10, [InvasionMaps.Devias], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenVepar, 20, [InvasionMaps.Atlans], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenLizardKing, 10, [InvasionMaps.Atlans], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenWheel, 20, [InvasionMaps.Tarkan], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenTantallos, 10, [InvasionMaps.Tarkan], SpawnMapStrategy.RandomMap),
+            new(InvasionMonsters.GoldenDragon, 10, [InvasionMaps.Lorencia, InvasionMaps.Noria, InvasionMaps.Devias, InvasionMaps.Atlans, InvasionMaps.Tarkan], SpawnMapStrategy.RandomMap),
+        ],
+    };
+
+    /// <summary>
+    /// Gets the default configuration for the Red Dragon Invasion event.
+    /// </summary>
+    public static PeriodicInvasionConfiguration RedDragon => new()
+    {
+        TaskDuration = TimeSpan.FromMinutes(30),
+        PreStartMessageDelay = TimeSpan.FromSeconds(3),
+        StartMessage = "[{mapName}] Red Dragon invasion!",
+        EndMessage = "[{mapName}] Red Dragon invasion has ended.",
+        Timetable = PeriodicTaskConfiguration.GenerateTimeSequence(TimeSpan.FromHours(6), new TimeOnly(2, 0)).ToList(),
+        Mobs =
+        [
+            new(InvasionMonsters.RedDragon, 5, [InvasionMaps.Lorencia, InvasionMaps.Noria, InvasionMaps.Devias], SpawnMapStrategy.RandomMap),
+        ],
+    };
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionGameServerState.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionGameServerState.cs
index 750774c72..6d738c5e7 100644
--- a/src/GameLogic/PlugIns/InvasionEvents/InvasionGameServerState.cs
+++ b/src/GameLogic/PlugIns/InvasionEvents/InvasionGameServerState.cs
@@ -1,4 +1,4 @@
-// <copyright file="InvasionGameServerState.cs" company="MUnique">
+// <copyright file="InvasionGameServerState.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -8,37 +8,65 @@ namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
 using MUnique.OpenMU.Interfaces;
 
 /// <summary>
-/// Game server state per event.
+/// Invasion state that is created for every periodic invasion run.
 /// </summary>
 public class InvasionGameServerState : PeriodicTaskGameServerState
 {
+    private readonly HashSet<ushort> _mapIds = [];
+    private readonly Dictionary<ushort, ushort> _selectedMaps = [];
+
     /// <summary>
     /// Initializes a new instance of the <see cref="InvasionGameServerState"/> class.
     /// </summary>
-    /// <param name="context">The context.</param>
+    /// <param name="context">The game context.</param>
     public InvasionGameServerState(IGameContext context)
         : base(context)
     {
     }
 
+
     /// <summary>
-    /// Gets or sets the map identifier.
+    /// Gets or sets the map identifier used for UI display / map-event state broadcasts.
+    /// <c>null</c> means no event is active or the display map has not been selected yet.
     /// </summary>
-    public ushort MapId { get; set; }
+    public ushort? MapId { get; set; }
 
     /// <summary>
-    /// Gets the map.
+    /// Gets the set of map identifiers on which monsters will spawn this run.
     /// </summary>
-    public GameMapDefinition Map => this.Context.Configuration.Maps.First(m => m.Number == this.MapId);
+    public IReadOnlySet<ushort> MapIds => this._mapIds;
 
     /// <summary>
-    /// Gets the name of the map.
+    /// Gets the read-only mapping of monster ID to selected map identifier.
+    /// Populated for spawns whose <see cref="SpawnMapStrategy"/> is <see cref="SpawnMapStrategy.RandomMap"/>.
     /// </summary>
-    public LocalizedString MapName => this.Map.Name;
+    public IReadOnlyDictionary<ushort, ushort> SelectedMaps => this._selectedMaps;
 
-    /// <inheritdoc />
-    public override string? ToString()
+    /// <summary>
+    /// Registers a map as active for this run and optionally records which map was
+    /// randomly chosen for a particular monster type.
+    /// </summary>
+    /// <param name="mapId">The map identifier to register.</param>
+    /// <param name="monsterId">
+    /// When provided, records the <paramref name="mapId"/> as the chosen map for this monster.
+    /// Pass <c>null</c> for "spawn-on-all-maps" entries.
+    /// </param>
+    internal void RegisterMap(ushort mapId, ushort? monsterId = null)
+    {
+        this._mapIds.Add(mapId);
+        if (monsterId.HasValue)
+        {
+            this._selectedMaps[monsterId.Value] = mapId;
+        }
+    }
+
+    /// <summary>
+    /// Clears all state accumulated from a previous run so the object can be reused.
+    /// </summary>
+    internal void Reset()
     {
-        return this.MapName.ToString();
+        this.MapId = null;
+        this._mapIds.Clear();
+        this._selectedMaps.Clear();
     }
 }
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionMaps.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionMaps.cs
new file mode 100644
index 000000000..6fdaf23ac
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/InvasionMaps.cs
@@ -0,0 +1,36 @@
+// <copyright file="InvasionMaps.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+/// <summary>
+/// Well-known map identifiers used across invasion plugins.
+/// </summary>
+internal static class InvasionMaps
+{
+    /// <summary>
+    /// The Lorencia map.
+    /// </summary>
+    public const ushort Lorencia = 0;
+
+    /// <summary>
+    /// The Devias map.
+    /// </summary>
+    public const ushort Devias = 2;
+
+    /// <summary>
+    /// The Noria map.
+    /// </summary>
+    public const ushort Noria = 3;
+
+    /// <summary>
+    /// The Atlans map.
+    /// </summary>
+    public const ushort Atlans = 7;
+
+    /// <summary>
+    /// The Tarkan map.
+    /// </summary>
+    public const ushort Tarkan = 8;
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionMobSpawn.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionMobSpawn.cs
deleted file mode 100644
index 99ba33df4..000000000
--- a/src/GameLogic/PlugIns/InvasionEvents/InvasionMobSpawn.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// <copyright file="InvasionMobSpawn.cs" company="MUnique">
-// Licensed under the MIT License. See LICENSE file in the project root for full license information.
-// </copyright>
-
-namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
-
-/// <summary>
-/// Represents a mob spawn configuration for invasions.
-/// </summary>
-/// <param name="MonsterId">The monster ID to spawn.</param>
-/// <param name="Count">The number of monsters to spawn.</param>
-/// <param name="MapId">The map ID. If null, spawns on the selected map.</param>
-/// <param name="X1">The minimum X coordinate. If null, uses default (10).</param>
-/// <param name="X2">The maximum X coordinate. If null, uses default (240).</param>
-/// <param name="Y1">The minimum Y coordinate. If null, uses default (10).</param>
-/// <param name="Y2">The maximum Y coordinate. If null, uses default (240).</param>
-public record InvasionMobSpawn(
-    ushort MonsterId,
-    ushort Count,
-    ushort? MapId = null,
-    byte? X1 = null,
-    byte? Y1 = null,
-    byte? X2 = null,
-    byte? Y2 = null);
-
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionMonsters.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionMonsters.cs
new file mode 100644
index 000000000..69da4dbb3
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/InvasionMonsters.cs
@@ -0,0 +1,61 @@
+// <copyright file="InvasionMonsters.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+/// <summary>
+/// Monster identifiers used across invasion plugins.
+/// </summary>
+internal static class InvasionMonsters
+{
+    /// <summary>
+    /// The Golden Budge Dragon monster.
+    /// </summary>
+    public const ushort GoldenBudgeDragon = 43;
+
+    /// <summary>
+    /// The Golden Soldier monster.
+    /// </summary>
+    public const ushort GoldenSoldier = 54;
+
+    /// <summary>
+    /// The Golden Titan monster.
+    /// </summary>
+    public const ushort GoldenTitan = 53;
+
+    /// <summary>
+    /// The Golden Goblin monster.
+    /// </summary>
+    public const ushort GoldenGoblin = 78;
+
+    /// <summary>
+    /// The Golden Dragon monster.
+    /// </summary>
+    public const ushort GoldenDragon = 79;
+
+    /// <summary>
+    /// The Golden Lizard King monster.
+    /// </summary>
+    public const ushort GoldenLizardKing = 80;
+
+    /// <summary>
+    /// The Golden Vepar monster.
+    /// </summary>
+    public const ushort GoldenVepar = 81;
+
+    /// <summary>
+    /// The Golden Tantallos monster.
+    /// </summary>
+    public const ushort GoldenTantallos = 82;
+
+    /// <summary>
+    /// The Golden Wheel monster.
+    /// </summary>
+    public const ushort GoldenWheel = 83;
+
+    /// <summary>
+    /// The Red Dragon monster.
+    /// </summary>
+    public const ushort RedDragon = 44;
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/InvasionSpawnConfiguration.cs b/src/GameLogic/PlugIns/InvasionEvents/InvasionSpawnConfiguration.cs
new file mode 100644
index 000000000..d306cfcde
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/InvasionSpawnConfiguration.cs
@@ -0,0 +1,119 @@
+// <copyright file="InvasionSpawnConfiguration.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+using System.ComponentModel.DataAnnotations;
+
+/// <summary>
+/// Represents a spawn configuration for an invasion event monster.
+/// </summary>
+public class InvasionSpawnConfiguration
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="InvasionSpawnConfiguration"/> class.
+    /// Required for serialization and UI binding.
+    /// </summary>
+    public InvasionSpawnConfiguration()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="InvasionSpawnConfiguration"/> class.
+    /// </summary>
+    /// <param name="monsterId">The monster ID to spawn.</param>
+    /// <param name="count">The number of monsters to spawn (1-254).</param>
+    /// <param name="mapIds">The list of map IDs where the monster can spawn.</param>
+    /// <param name="mapStrategy">Controls whether to spawn on a random map or all maps.</param>
+    /// <param name="x">The optional fixed X coordinate.</param>
+    /// <param name="y">The optional fixed Y coordinate.</param>
+    public InvasionSpawnConfiguration(
+        ushort monsterId,
+        ushort count,
+        IList<ushort> mapIds,
+        SpawnMapStrategy mapStrategy,
+        byte? x = null,
+        byte? y = null)
+    {
+        this.MonsterId = monsterId;
+        this.Count = count;
+        this.MapIds = mapIds;
+        this.MapStrategy = mapStrategy;
+        this.X = x;
+        this.Y = y;
+    }
+
+    /// <summary>
+    /// Gets or sets the monster ID to spawn.
+    /// </summary>
+    [Required]
+    public ushort MonsterId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of monsters to spawn (1-254).
+    /// </summary>
+    [Range(1, 254)]
+    public ushort Count { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of map IDs where the monster can spawn.
+    /// </summary>
+    [Required]
+    [MinLength(1)]
+    public IList<ushort> MapIds { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the strategy used to select a map when spawning.
+    /// </summary>
+    public SpawnMapStrategy MapStrategy { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the monster spawns on all maps in <see cref="MapIds"/>.
+    /// When set to <c>true</c>, <see cref="MapStrategy"/> is changed to <see cref="SpawnMapStrategy.AllMaps"/>.
+    /// When set to <c>false</c>, <see cref="MapStrategy"/> is changed to <see cref="SpawnMapStrategy.RandomMap"/>.
+    /// This property exists for UI binding and serialization compatibility.
+    /// </summary>
+    public bool IsSpawnOnAllMaps
+    {
+        get => this.MapStrategy == SpawnMapStrategy.AllMaps;
+        set => this.MapStrategy = value ? SpawnMapStrategy.AllMaps : SpawnMapStrategy.RandomMap;
+    }
+
+    /// <summary>
+    /// Gets or sets the fixed X coordinate.
+    /// If <c>null</c>, a random walkable coordinate is used.
+    /// </summary>
+    [Range(0, 255)]
+    public byte? X { get; set; }
+
+    /// <summary>
+    /// Gets or sets the fixed Y coordinate.
+    /// If <c>null</c>, a random walkable coordinate is used.
+    /// </summary>
+    [Range(0, 255)]
+    public byte? Y { get; set; }
+
+    /// <inheritdoc />
+    /// <remarks>
+    /// Equality is based solely on <see cref="MonsterId"/>, as each monster type
+    /// may only have one spawn configuration per invasion event.
+    /// </remarks>
+    public override bool Equals(object? obj)
+    {
+        if (obj is not InvasionSpawnConfiguration other)
+        {
+            return false;
+        }
+
+        return this.MonsterId == other.MonsterId;
+    }
+
+    /// <inheritdoc />
+    /// <remarks>
+    /// The hash code is based solely on <see cref="MonsterId"/>, consistent with <see cref="Equals"/>.
+    /// This means the object can be safely mutated (maps, count, strategy, coordinates)
+    /// while held in a hash-based collection without becoming unreachable.
+    /// </remarks>
+    public override int GetHashCode() => this.MonsterId.GetHashCode();
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/PeriodicInvasionConfiguration.cs b/src/GameLogic/PlugIns/InvasionEvents/PeriodicInvasionConfiguration.cs
index f50444f0c..95a23f6b4 100644
--- a/src/GameLogic/PlugIns/InvasionEvents/PeriodicInvasionConfiguration.cs
+++ b/src/GameLogic/PlugIns/InvasionEvents/PeriodicInvasionConfiguration.cs
@@ -1,13 +1,16 @@
-// <copyright file="PeriodicInvasionConfiguration.cs" company="MUnique">
+// <copyright file="PeriodicInvasionConfiguration.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
 namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
 
+using System.ComponentModel.DataAnnotations;
 using MUnique.OpenMU.GameLogic.PlugIns.PeriodicTasks;
 
 /// <summary>
-/// Abstract configuration for periodic invasions.
+/// Configuration data for a periodic invasion event.
+/// Responsible only for describing the shape of the configuration (SRP).
+/// Default values live in <see cref="InvasionConfigurationDefaults"/>.
 /// </summary>
 public class PeriodicInvasionConfiguration : PeriodicTaskConfiguration
 {
@@ -16,28 +19,13 @@ public class PeriodicInvasionConfiguration : PeriodicTaskConfiguration
     /// </summary>
     public PeriodicInvasionConfiguration()
     {
-        this.Message = "Invasion's been started!";
+        this.StartMessage = "Invasion has started!";
+        this.EndMessage = "Invasion has ended!";
     }
 
     /// <summary>
-    /// Gets the default configuration.
+    /// Gets or sets the monster spawns for this invasion.
     /// </summary>
-    public static PeriodicInvasionConfiguration DefaultGoldenInvasion => new()
-    {
-        TaskDuration = TimeSpan.FromMinutes(5),
-        PreStartMessageDelay = TimeSpan.FromSeconds(3),
-        Message = "[{mapName}] Golden Invasion!",
-        Timetable = GenerateTimeSequence(TimeSpan.FromHours(4)).ToList(), // Every 4 hours
-    };
-
-    /// <summary>
-    /// Gets the default configuration for the red dragon invasion.
-    /// </summary>
-    public static PeriodicInvasionConfiguration DefaultRedDragonInvasion => new()
-    {
-        TaskDuration = TimeSpan.FromMinutes(10),
-        PreStartMessageDelay = TimeSpan.FromSeconds(3),
-        Message = "[{mapName}] Red Dragon Invasion!",
-        Timetable = GenerateTimeSequence(TimeSpan.FromHours(6), new TimeOnly(2, 0)).ToList(), // Every 6 hours, starting from 02:00
-    };
+    [Display(Name = "Monster Spawns", Order = 6)]
+    public IList<InvasionSpawnConfiguration> Mobs { get; set; } = [];
 }
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/RedDragonInvasionPlugIn.cs b/src/GameLogic/PlugIns/InvasionEvents/RedDragonInvasionPlugIn.cs
index 2c089c6e3..d703a5ec3 100644
--- a/src/GameLogic/PlugIns/InvasionEvents/RedDragonInvasionPlugIn.cs
+++ b/src/GameLogic/PlugIns/InvasionEvents/RedDragonInvasionPlugIn.cs
@@ -1,4 +1,4 @@
-// <copyright file="RedDragonInvasionPlugIn.cs" company="MUnique">
+// <copyright file="RedDragonInvasionPlugIn.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -8,23 +8,25 @@ namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
 using MUnique.OpenMU.PlugIns;
 
 /// <summary>
-/// This plugin enables Red Dragon Invasion feature.
+/// Enables the Red Dragon Invasion feature.
 /// </summary>
 [PlugIn]
 [Display(Name = nameof(PlugInResources.RedDragonInvasionPlugIn_Name), Description = nameof(PlugInResources.RedDragonInvasionPlugIn_Description), ResourceType = typeof(PlugInResources))]
 [Guid("548A76CC-242C-441C-BC9D-6C22745A2D72")]
-public class RedDragonInvasionPlugIn : BaseInvasionPlugIn<PeriodicInvasionConfiguration>, ISupportDefaultCustomConfiguration
+public sealed class RedDragonInvasionPlugIn : SimpleInvasionPlugIn
 {
-    private const ushort RedDragonId = 44;
+    private static readonly IReadOnlyList<ushort> DisplayMaps =
+    [
+        InvasionMaps.Lorencia,
+        InvasionMaps.Noria,
+        InvasionMaps.Devias,
+    ];
 
     /// <summary>
     /// Initializes a new instance of the <see cref="RedDragonInvasionPlugIn"/> class.
     /// </summary>
     public RedDragonInvasionPlugIn()
-        : base(MapEventType.RedDragonInvasion, null, [new(RedDragonId, 5)])
+        : base(MapEventType.RedDragonInvasion, DisplayMaps, () => InvasionConfigurationDefaults.RedDragon)
     {
     }
-
-    /// <inheritdoc />
-    public object CreateDefaultConfig() => PeriodicInvasionConfiguration.DefaultRedDragonInvasion;
 }
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/SimpleInvasionPlugIn.cs b/src/GameLogic/PlugIns/InvasionEvents/SimpleInvasionPlugIn.cs
new file mode 100644
index 000000000..c0306d1a2
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/SimpleInvasionPlugIn.cs
@@ -0,0 +1,37 @@
+// <copyright file="SimpleInvasionPlugIn.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+using MUnique.OpenMU.PlugIns;
+
+/// <summary>
+/// Convenience base for invasion plugins that need no logic beyond choosing a display
+/// map and returning a default configuration.
+/// </summary>
+public abstract class SimpleInvasionPlugIn
+    : BaseInvasionPlugIn<PeriodicInvasionConfiguration>, ISupportDefaultCustomConfiguration
+{
+    private readonly IReadOnlyList<ushort> _displayMaps;
+    private readonly Func<PeriodicInvasionConfiguration> _defaultConfigFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SimpleInvasionPlugIn"/> class.
+    /// </summary>
+    /// <param name="mapEventType">The map-event type for UI broadcasting.</param>
+    /// <param name="displayMaps">Maps eligible to be shown in the event UI.</param>
+    /// <param name="defaultConfigFactory">Factory that returns the default configuration.</param>
+    protected SimpleInvasionPlugIn(MapEventType mapEventType, IReadOnlyList<ushort> displayMaps, Func<PeriodicInvasionConfiguration> defaultConfigFactory)
+        : base(mapEventType)
+    {
+        this._displayMaps = displayMaps;
+        this._defaultConfigFactory = defaultConfigFactory;
+    }
+
+    /// <inheritdoc />
+    protected override IReadOnlyList<ushort> EventDisplayMapIds => this._displayMaps;
+
+    /// <inheritdoc />
+    public object CreateDefaultConfig() => this._defaultConfigFactory();
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/InvasionEvents/SpawnMapStrategy.cs b/src/GameLogic/PlugIns/InvasionEvents/SpawnMapStrategy.cs
new file mode 100644
index 000000000..b1ef20dcd
--- /dev/null
+++ b/src/GameLogic/PlugIns/InvasionEvents/SpawnMapStrategy.cs
@@ -0,0 +1,21 @@
+// <copyright file="SpawnMapStrategy.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+
+/// <summary>
+/// Defines how the spawn map is selected when multiple map IDs are configured.
+/// </summary>
+public enum SpawnMapStrategy
+{
+    /// <summary>
+    /// A single map is picked at random from the configured list.
+    /// </summary>
+    RandomMap,
+
+    /// <summary>
+    /// The monster spawns on every map in the configured list.
+    /// </summary>
+    AllMaps,
+}
\ No newline at end of file
diff --git a/src/GameLogic/PlugIns/PeriodicTasks/HappyHourConfiguration.cs b/src/GameLogic/PlugIns/PeriodicTasks/HappyHourConfiguration.cs
index c31695d90..8593c4853 100644
--- a/src/GameLogic/PlugIns/PeriodicTasks/HappyHourConfiguration.cs
+++ b/src/GameLogic/PlugIns/PeriodicTasks/HappyHourConfiguration.cs
@@ -1,4 +1,4 @@
-// <copyright file="HappyHourConfiguration.cs" company="MUnique">
+// <copyright file="HappyHourConfiguration.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -18,7 +18,8 @@ public class HappyHourConfiguration : PeriodicTaskConfiguration
     {
         TaskDuration = TimeSpan.FromHours(1),
         PreStartMessageDelay = TimeSpan.FromSeconds(0),
-        Message = "Happy Hour event has been started!",
+        StartMessage = "Happy Hour event has been started!",
+        EndMessage = "Happy Hour event has ended!",
         Timetable = GenerateTimeSequence(TimeSpan.FromHours(6), new TimeOnly(0, 5)).ToList(), // Every 6 hours,
         ExperienceMultiplier = 1.5f,
     };
diff --git a/src/GameLogic/PlugIns/PeriodicTasks/HappyHourPlugIn.cs b/src/GameLogic/PlugIns/PeriodicTasks/HappyHourPlugIn.cs
index 18197f2e3..aa6706e6e 100644
--- a/src/GameLogic/PlugIns/PeriodicTasks/HappyHourPlugIn.cs
+++ b/src/GameLogic/PlugIns/PeriodicTasks/HappyHourPlugIn.cs
@@ -1,4 +1,4 @@
-// <copyright file="HappyHourPlugIn.cs" company="MUnique">
+// <copyright file="HappyHourPlugIn.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -124,7 +124,7 @@ protected async Task TrySendStartMessageAsync(Player player)
 
         try
         {
-            var message = configuration.Message.GetTranslation(player.Culture) is { Length: > 0 } translation ? translation : player.GetLocalizedMessage(nameof(PlayerMessage.HappyHourEventHasBeenStarted));
+            var message = configuration.StartMessage.GetTranslation(player.Culture) is { Length: > 0 } translation ? translation : player.GetLocalizedMessage(nameof(PlayerMessage.HappyHourEventHasBeenStarted));
             await player.InvokeViewPlugInAsync<IShowMessagePlugIn>(p => p.ShowMessageAsync(message, Interfaces.MessageType.GoldenCenter)).ConfigureAwait(false);
         }
         catch (Exception ex)
diff --git a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskBasePlugIn.cs b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskBasePlugIn.cs
index 9dd7cc2e4..a29eaaeba 100644
--- a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskBasePlugIn.cs
+++ b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskBasePlugIn.cs
@@ -1,4 +1,4 @@
-// <copyright file="PeriodicTaskBasePlugIn.cs" company="MUnique">
+// <copyright file="PeriodicTaskBasePlugIn.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -71,6 +71,12 @@ public async ValueTask ExecuteTaskAsync(GameContext gameContext)
                         return;
                     }
 
+                    if (this.IsPreviousEventStillRunning(state))
+                    {
+                        this._isStartForced = false;
+                        return;
+                    }
+
                     this._isStartForced = false;
                     state.NextRunUtc = DateTime.UtcNow.Add(configuration.PreStartMessageDelay);
                     await this.OnPrepareEventAsync(state).ConfigureAwait(false);
@@ -89,6 +95,7 @@ public async ValueTask ExecuteTaskAsync(GameContext gameContext)
                 {
                     state.NextRunUtc = DateTime.UtcNow.Add(configuration.TaskDuration);
                     state.State = PeriodicTaskState.Started;
+                    state.LastRunUtc = DateTime.UtcNow;
 
                     await this.OnStartedAsync(state).ConfigureAwait(false);
 
@@ -131,6 +138,15 @@ protected virtual bool IsItTimeToStart(IGameContext gameContext)
         return this._isStartForced || (this.Configuration?.IsItTimeToStart() ?? false);
     }
 
+    /// <summary>
+    /// Determines whether the previous event run is still within its configured task duration.
+    /// Prevents a new event from starting before the previous one has fully elapsed.
+    /// </summary>
+    /// <param name="state">The current task state.</param>
+    /// <returns><c>true</c> if the previous event duration has not elapsed yet; otherwise <c>false</c>.</returns>
+    protected virtual bool IsPreviousEventStillRunning(TState state)
+        => state.LastRunUtc != DateTime.MinValue && state.LastRunUtc.Add(this.Configuration?.TaskDuration ?? TimeSpan.Zero) > DateTime.UtcNow;
+
     /// <summary>
     /// Called when the task should be prepared before starting it.
     /// </summary>
diff --git a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskConfiguration.cs b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskConfiguration.cs
index 39454581d..dd64c860c 100644
--- a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskConfiguration.cs
+++ b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskConfiguration.cs
@@ -1,4 +1,4 @@
-// <copyright file="PeriodicTaskConfiguration.cs" company="MUnique">
+// <copyright file="PeriodicTaskConfiguration.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -11,29 +11,35 @@ namespace MUnique.OpenMU.GameLogic.PlugIns.PeriodicTasks;
 /// </summary>
 public class PeriodicTaskConfiguration
 {
-    /// <summary>
-    /// Gets or sets a timetable for the event.
-    /// </summary>
-    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_Timetable_Name))]
-    public IList<TimeOnly> Timetable { get; set; } = new List<TimeOnly>();
-
     /// <summary>
     /// Gets or sets a time delay.
     /// </summary>
-    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_PreStartMessageDelay_Name))]
+    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_PreStartMessageDelay_Name), Order = 1)]
     public TimeSpan PreStartMessageDelay { get; set; } = TimeSpan.FromSeconds(3);
 
     /// <summary>
     /// Gets or sets the minimum time of the task duration.
     /// </summary>
-    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_TaskDuration_Name))]
+    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_TaskDuration_Name), Order = 2)]
     public TimeSpan TaskDuration { get; set; } = TimeSpan.FromMinutes(5);
 
     /// <summary>
-    /// Gets or sets the text which prints as a golden message in the game.
+    /// Gets or sets the text which prints as a golden message in the game when task starts.
     /// </summary>
-    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_Message_Name))]
-    public LocalizedString Message { get; set; }
+    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_StartMessage_Name), Order = 3)]
+    public LocalizedString StartMessage { get; set; }
+
+    /// <summary>
+    /// Gets or sets the text which prints as a golden message in the game when task ends.
+    /// </summary>
+    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_EndMessage_Name), Order = 4)]
+    public LocalizedString EndMessage { get; set; }
+
+    /// <summary>
+    /// Gets or sets a timetable for the event.
+    /// </summary>
+    [Display(ResourceType = typeof(PlugInResources), Name = nameof(PlugInResources.PeriodicTaskConfiguration_Timetable_Name), Order = 5)]
+    public IList<TimeOnly> Timetable { get; set; } = new List<TimeOnly>();
 
     /// <summary>
     /// Generate a sequence of time points like [00:00, 00:01, ...].
diff --git a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskGameServerState.cs b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskGameServerState.cs
index 56b08fd8a..8e145ea54 100644
--- a/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskGameServerState.cs
+++ b/src/GameLogic/PlugIns/PeriodicTasks/PeriodicTaskGameServerState.cs
@@ -1,4 +1,4 @@
-// <copyright file="PeriodicTaskGameServerState.cs" company="MUnique">
+// <copyright file="PeriodicTaskGameServerState.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -28,6 +28,12 @@ public PeriodicTaskGameServerState(IGameContext context)
     /// </summary>
     public DateTime NextRunUtc { get; set; } = DateTime.UtcNow;
 
+    /// <summary>
+    /// Gets or sets the UTC timestamp of when the last event run started.
+    /// Used to prevent a new event from starting before the previous task duration has elapsed.
+    /// </summary>
+    public DateTime LastRunUtc { get; set; } = DateTime.MinValue;
+
     /// <summary>
     /// Gets or sets the state.
     /// </summary>
diff --git a/src/GameLogic/Properties/PlugInResources.Designer.cs b/src/GameLogic/Properties/PlugInResources.Designer.cs
index 6e19694f5..2da89378c 100644
--- a/src/GameLogic/Properties/PlugInResources.Designer.cs
+++ b/src/GameLogic/Properties/PlugInResources.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
@@ -1645,20 +1645,38 @@ public static string PeriodicSaveProgressPlugInConfiguration_Interval_Name {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to The text which prints as a golden message in the game..
+        ///   Looks up a localized string similar to The text which prints as a golden message in the game when task starts..
         /// </summary>
-        public static string PeriodicTaskConfiguration_Message_Description {
+        public static string PeriodicTaskConfiguration_StartMessage_Description {
             get {
-                return ResourceManager.GetString("PeriodicTaskConfiguration_Message_Description", resourceCulture);
+                return ResourceManager.GetString("PeriodicTaskConfiguration_StartMessage_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Message.
+        ///   Looks up a localized string similar to Start message.
+        /// </summary>
+        public static string PeriodicTaskConfiguration_StartMessage_Name {
+            get {
+                return ResourceManager.GetString("PeriodicTaskConfiguration_StartMessage_Name", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to The text which prints as a golden message in the game when task ends..
+        /// </summary>
+        public static string PeriodicTaskConfiguration_EndMessage_Description {
+            get {
+                return ResourceManager.GetString("PeriodicTaskConfiguration_EndMessage_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to End message.
         /// </summary>
-        public static string PeriodicTaskConfiguration_Message_Name {
+        public static string PeriodicTaskConfiguration_EndMessage_Name {
             get {
-                return ResourceManager.GetString("PeriodicTaskConfiguration_Message_Name", resourceCulture);
+                return ResourceManager.GetString("PeriodicTaskConfiguration_EndMessage_Name", resourceCulture);
             }
         }
         
diff --git a/src/GameLogic/Properties/PlugInResources.resx b/src/GameLogic/Properties/PlugInResources.resx
index f31d436ba..6f488c63a 100644
--- a/src/GameLogic/Properties/PlugInResources.resx
+++ b/src/GameLogic/Properties/PlugInResources.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -1101,11 +1101,17 @@
   <data name="PeriodicTaskConfiguration_TaskDuration_Name" xml:space="preserve">
     <value>Task duration (minimum)</value>
   </data>
-  <data name="PeriodicTaskConfiguration_Message_Name" xml:space="preserve">
-    <value>Message</value>
+  <data name="PeriodicTaskConfiguration_StartMessage_Name" xml:space="preserve">
+    <value>Start message</value>
+  </data>
+  <data name="PeriodicTaskConfiguration_StartMessage_Description" xml:space="preserve">
+    <value>The text which prints as a golden message in the game when task starts.</value>
+  </data>
+  <data name="PeriodicTaskConfiguration_EndMessage_Name" xml:space="preserve">
+    <value>End message</value>
   </data>
-  <data name="PeriodicTaskConfiguration_Message_Description" xml:space="preserve">
-    <value>The text which prints as a golden message in the game.</value>
+  <data name="PeriodicTaskConfiguration_EndMessage_Description" xml:space="preserve">
+    <value>The text which prints as a golden message in the game when task ends.</value>
   </data>
   <data name="ResetConfiguration_ResetLimit_Name" xml:space="preserve">
     <value>Reset limit</value>
diff --git a/src/Persistence/InMemory/InMemoryPersistenceContextProvider.cs b/src/Persistence/InMemory/InMemoryPersistenceContextProvider.cs
index d711c29f2..84e5b2e11 100644
--- a/src/Persistence/InMemory/InMemoryPersistenceContextProvider.cs
+++ b/src/Persistence/InMemory/InMemoryPersistenceContextProvider.cs
@@ -9,6 +9,7 @@ namespace MUnique.OpenMU.Persistence.InMemory;
 using System.Threading;
 using MUnique.OpenMU.DataModel.Configuration;
 using MUnique.OpenMU.Interfaces;
+using MUnique.OpenMU.PlugIns;
 
 /// <summary>
 /// A context provider which uses in-memory repositories to hold its data, e.g. for testing or demo purposes.
@@ -16,7 +17,6 @@ namespace MUnique.OpenMU.Persistence.InMemory;
 /// </summary>
 public class InMemoryPersistenceContextProvider : IMigratableDatabaseContextProvider
 {
-    private readonly IConfigurationChangePublisher? _changePublisher;
     private InMemoryRepositoryProvider _repositoryProvider = new ();
 
     /// <summary>
@@ -25,22 +25,31 @@ public class InMemoryPersistenceContextProvider : IMigratableDatabaseContextProv
     /// <param name="changePublisher">The change publisher.</param>
     public InMemoryPersistenceContextProvider(IConfigurationChangePublisher? changePublisher = null)
     {
-        this._changePublisher = changePublisher;
+        this.ChangePublisher = changePublisher;
     }
 
     /// <inheritdoc />
     public IRepositoryProvider RepositoryProvider => this._repositoryProvider;
 
+    /// <summary>
+    /// Gets or sets the publisher for configuration changes.
+    /// </summary>
+    public IConfigurationChangePublisher? ChangePublisher { get; set; }
+
     /// <inheritdoc/>
     public IContext CreateNewContext()
     {
-        return new InMemoryContext(this._repositoryProvider);
+        var context = new InMemoryContext(this._repositoryProvider);
+        this.AttachChangePublisher(context, typeof(PlugInConfiguration));
+        return context;
     }
 
     /// <inheritdoc/>
     public IContext CreateNewContext(GameConfiguration gameConfiguration)
     {
-        return new InMemoryContext(this._repositoryProvider);
+        var context = new InMemoryContext(this._repositoryProvider);
+        this.AttachChangePublisher(context, typeof(PlugInConfiguration));
+        return context;
     }
 
     /// <inheritdoc/>
@@ -77,28 +86,7 @@ public IGuildServerContext CreateNewGuildContext()
     public IContext CreateNewTypedContext(Type editType, bool useCache, GameConfiguration? gameConfiguration = null)
     {
         var context = new InMemoryContext(this._repositoryProvider);
-        if (this._changePublisher is { })
-        {
-#pragma warning disable VSTHRD100
-            async void OnContextOnSavedChanges(object? o, EventArgs e)
-#pragma warning restore VSTHRD100
-            {
-                try
-                {
-                    foreach (var obj in await context.GetAsync(editType, default).ConfigureAwait(false))
-                    {
-                        await this._changePublisher.ConfigurationChangedAsync(editType, obj.GetId(), obj).ConfigureAwait(false);
-                    }
-                }
-                catch
-                {
-                    // ignore all errors.
-                }
-            }
-
-            context.SavedChanges += OnContextOnSavedChanges;
-        }
-
+        this.AttachChangePublisher(context, editType);
         return context;
     }
 
@@ -151,4 +139,34 @@ public void ResetCache()
     {
         // do nothing here
     }
-}
\ No newline at end of file
+
+    private void AttachChangePublisher(InMemoryContext context, Type editType)
+    {
+        if (this.ChangePublisher is { } changePublisher)
+        {
+#pragma warning disable VSTHRD100
+            async void OnContextOnSavedChanges(object? o, EventArgs e)
+#pragma warning restore VSTHRD100
+            {
+                await this.PublishConfigurationChangesAsync(context, changePublisher, editType).ConfigureAwait(false);
+            }
+
+            context.SavedChanges += OnContextOnSavedChanges;
+        }
+    }
+
+    private async ValueTask PublishConfigurationChangesAsync(InMemoryContext context, IConfigurationChangePublisher changePublisher, Type editType)
+    {
+        try
+        {
+            foreach (var obj in await context.GetAsync(editType, default).ConfigureAwait(false))
+            {
+                await changePublisher.ConfigurationChangedAsync(editType, obj.GetId(), obj).ConfigureAwait(false);
+            }
+        }
+        catch
+        {
+            // ignore all errors.
+        }
+    }
+}
diff --git a/src/PlugIns/PlugInConfigurationChangeApplier.cs b/src/PlugIns/PlugInConfigurationChangeApplier.cs
new file mode 100644
index 000000000..8108dd63d
--- /dev/null
+++ b/src/PlugIns/PlugInConfigurationChangeApplier.cs
@@ -0,0 +1,92 @@
+// <copyright file="PlugInConfigurationChangeApplier.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.PlugIns;
+
+using System.Text.Json;
+
+/// <summary>
+/// Applies configuration changes to a local <see cref="PlugInManager" />.
+/// </summary>
+public static class PlugInConfigurationChangeApplier
+{
+    /// <summary>
+    /// Applies a changed configuration to the local <see cref="PlugInManager" />, if it is a plugin configuration.
+    /// </summary>
+    /// <param name="plugInManager">The plugin manager.</param>
+    /// <param name="type">The changed configuration type.</param>
+    /// <param name="id">The changed configuration identifier.</param>
+    /// <param name="configuration">The changed configuration.</param>
+    /// <returns><c>True</c>, if the change was applied; Otherwise, <c>false</c>.</returns>
+    public static bool ApplyChangedConfiguration(this PlugInManager plugInManager, Type type, Guid id, object? configuration)
+    {
+        if (!TryGetPlugInConfiguration(type, configuration, out var plugInConfiguration))
+        {
+            return false;
+        }
+
+        var plugInTypeId = plugInConfiguration.TypeId == Guid.Empty
+            ? id
+            : plugInConfiguration.TypeId;
+        plugInManager.ApplyChangedPlugInConfiguration(plugInTypeId, plugInConfiguration);
+        return true;
+    }
+
+    /// <summary>
+    /// Applies a removed configuration to the local <see cref="PlugInManager" />, if it is a plugin configuration.
+    /// </summary>
+    /// <param name="plugInManager">The plugin manager.</param>
+    /// <param name="type">The removed configuration type.</param>
+    /// <param name="id">The removed configuration identifier.</param>
+    /// <returns><c>True</c>, if the change was applied; Otherwise, <c>false</c>.</returns>
+    public static bool ApplyRemovedConfiguration(this PlugInManager plugInManager, Type type, Guid id)
+    {
+        if (!type.IsAssignableTo(typeof(PlugInConfiguration)))
+        {
+            return false;
+        }
+
+        plugInManager.DeactivatePlugIn(id);
+        return true;
+    }
+
+    private static void ApplyChangedPlugInConfiguration(this PlugInManager plugInManager, Guid id, PlugInConfiguration plugInConfiguration)
+    {
+        var currentlyActive = plugInManager.IsPlugInActive(id);
+        if (currentlyActive && !plugInConfiguration.IsActive)
+        {
+            plugInManager.DeactivatePlugIn(id);
+        }
+        else if (!currentlyActive && plugInConfiguration.IsActive)
+        {
+            plugInManager.ActivatePlugIn(id);
+        }
+        else
+        {
+            plugInManager.ConfigurePlugIn(id, plugInConfiguration);
+        }
+    }
+
+    private static bool TryGetPlugInConfiguration(Type type, object? configuration, out PlugInConfiguration plugInConfiguration)
+    {
+        if (configuration is PlugInConfiguration typedConfiguration)
+        {
+            plugInConfiguration = typedConfiguration;
+            return true;
+        }
+
+        if (type.IsAssignableTo(typeof(PlugInConfiguration)) && configuration is JsonElement jsonElement)
+        {
+            var deserialized = jsonElement.Deserialize<PlugInConfiguration>();
+            if (deserialized is not null)
+            {
+                plugInConfiguration = deserialized;
+                return true;
+            }
+        }
+
+        plugInConfiguration = null!;
+        return false;
+    }
+}
diff --git a/src/Startup/ConfigurationChangeHandler.cs b/src/Startup/ConfigurationChangeHandler.cs
index d38ea1412..27cfc2e0f 100644
--- a/src/Startup/ConfigurationChangeHandler.cs
+++ b/src/Startup/ConfigurationChangeHandler.cs
@@ -35,9 +35,9 @@ public ConfigurationChangeHandler(IServiceProvider serviceProvider, IConfigurati
     public async Task ConfigurationChangedAsync(Type type, Guid id, object configuration)
     {
         // TODO: subscribe these systems to the change mediator
-        if (configuration is PlugInConfiguration plugInConfiguration)
+        if (this._serviceProvider.GetService<PlugInManager>() is { } plugInManager)
         {
-            this.OnPlugInConfigurationChanged(id, plugInConfiguration);
+            plugInManager.ApplyChangedConfiguration(type, id, configuration);
         }
 
         if (configuration is ConnectServerDefinition connectServerDefinition)
@@ -67,9 +67,9 @@ public async Task ConfigurationAddedAsync(Type type, Guid id, object configurati
     /// <inheritdoc />
     public async Task ConfigurationRemovedAsync(Type type, Guid id)
     {
-        if (type.IsAssignableTo(typeof(PlugInConfiguration)) && this._serviceProvider.GetService<PlugInManager>() is { } plugInManager)
+        if (this._serviceProvider.GetService<PlugInManager>() is { } plugInManager)
         {
-            plugInManager.DeactivatePlugIn(id);
+            plugInManager.ApplyRemovedConfiguration(type, id);
         }
 
         await this._changeMediator.HandleConfigurationRemovedAsync(type, id).ConfigureAwait(false);
@@ -104,25 +104,4 @@ private async ValueTask OnConnectServerDefinitionChangedAsync(Guid id, ConnectSe
         }
     }
 
-    private void OnPlugInConfigurationChanged(Guid id, PlugInConfiguration plugInConfiguration)
-    {
-        if (this._serviceProvider.GetService<PlugInManager>() is not { } plugInManager)
-        {
-            return;
-        }
-
-        var currentlyActive = plugInManager.IsPlugInActive(id);
-        if (currentlyActive && !plugInConfiguration.IsActive)
-        {
-            plugInManager.DeactivatePlugIn(id);
-        }
-        else if (!currentlyActive && plugInConfiguration.IsActive)
-        {
-            plugInManager.ActivatePlugIn(id);
-        }
-        else
-        {
-            plugInManager.ConfigurePlugIn(id, plugInConfiguration);
-        }
-    }
-}
\ No newline at end of file
+}
diff --git a/src/Startup/Program.cs b/src/Startup/Program.cs
index 84a8b64e8..62745c2de 100644
--- a/src/Startup/Program.cs
+++ b/src/Startup/Program.cs
@@ -259,8 +259,9 @@ private async Task<IHost> CreateHostAsync(string[] args)
             .AddSingleton(s =>
                 this.DeterminePersistenceContextProviderAsync(
                     args,
-                    s.GetService<ILoggerFactory>() ?? throw new Exception($"{nameof(ILoggerFactory)} not registered."),
-                    s.GetService<IConfigurationChangeListener>() ?? throw new Exception($"{nameof(IConfigurationChangeListener)} not registered."))
+                    s.GetService<ILoggerFactory>() ?? throw new InvalidOperationException($"{nameof(ILoggerFactory)} not registered."),
+                    s.GetService<IConfigurationChangeListener>() ?? throw new InvalidOperationException($"{nameof(IConfigurationChangeListener)} not registered."),
+                    s.GetService<IConfigurationChangePublisher>() ?? throw new InvalidOperationException($"{nameof(IConfigurationChangePublisher)} not registered."))
                     .WaitAndUnwrapException())
             .AddSingleton<IPersistenceContextProvider>(s => s.GetService<IMigratableDatabaseContextProvider>()!)
             .AddSingleton<Lazy<IPersistenceContextProvider>>(s => new(() => s.GetService<IMigratableDatabaseContextProvider>()!))
@@ -447,15 +448,17 @@ private string GetVersionParameter(string[] args)
         return parameter.Substring(parameter.IndexOf(':') + 1);
     }
 
-    private async Task<IMigratableDatabaseContextProvider> DeterminePersistenceContextProviderAsync(string[] args, ILoggerFactory loggerFactory, IConfigurationChangeListener changeListener)
+    private async Task<IMigratableDatabaseContextProvider> DeterminePersistenceContextProviderAsync(string[] args, ILoggerFactory loggerFactory, IConfigurationChangeListener changeListener, IConfigurationChangePublisher changePublisher)
     {
         var version = this.GetVersionParameter(args);
 
         IMigratableDatabaseContextProvider contextProvider;
         if (args.Contains("-demo"))
         {
-            contextProvider = new InMemoryPersistenceContextProvider(null); // TODO pass change mediator or whatever
+            var inMemoryProvider = new InMemoryPersistenceContextProvider();
+            contextProvider = inMemoryProvider;
             await this.InitializeDataAsync(version, loggerFactory, contextProvider).ConfigureAwait(false);
+            inMemoryProvider.ChangePublisher = changePublisher;
         }
         else
         {
@@ -533,4 +536,4 @@ private async Task InitializeDataAsync(string version, ILoggerFactory loggerFact
         var initialization = plugInManager.GetStrategy<IDataInitializationPlugIn>(version) ?? throw new Exception("Data initialization plugin not found");
         await initialization.CreateInitialDataAsync(3, true).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Web/Shared/ComponentBuilders/InvasionSpawnTableFieldBuilder.cs b/src/Web/Shared/ComponentBuilders/InvasionSpawnTableFieldBuilder.cs
new file mode 100644
index 000000000..5ff150cfa
--- /dev/null
+++ b/src/Web/Shared/ComponentBuilders/InvasionSpawnTableFieldBuilder.cs
@@ -0,0 +1,25 @@
+// <copyright file="InvasionSpawnTableFieldBuilder.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.ComponentBuilders;
+
+using System.Reflection;
+using Microsoft.AspNetCore.Components.Rendering;
+using MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+using MUnique.OpenMU.Web.Shared.Components.Form;
+using MUnique.OpenMU.Web.Shared.Services;
+
+/// <summary>
+/// A <see cref="IComponentBuilder" /> for <see cref="IList{InvasionSpawnConfiguration}"/> fields.
+/// </summary>
+public class InvasionSpawnTableFieldBuilder : BaseComponentBuilder, IComponentBuilder
+{
+    /// <inheritdoc/>
+    public int BuildComponent(object model, PropertyInfo propertyInfo, RenderTreeBuilder builder, int currentIndex, IChangeNotificationService notificationService)
+        => this.BuildField<IList<InvasionSpawnConfiguration>>(model, typeof(InvasionSpawnTable), propertyInfo, builder, currentIndex, notificationService);
+
+    /// <inheritdoc/>
+    public bool CanBuildComponent(PropertyInfo propertyInfo)
+        => propertyInfo.PropertyType == typeof(IList<InvasionSpawnConfiguration>);
+}
diff --git a/src/Web/Shared/Components/Form/AutoFields.cs b/src/Web/Shared/Components/Form/AutoFields.cs
index 56c1497ed..0f7059ef9 100644
--- a/src/Web/Shared/Components/Form/AutoFields.cs
+++ b/src/Web/Shared/Components/Form/AutoFields.cs
@@ -1,4 +1,4 @@
-// <copyright file="AutoFields.cs" company="MUnique">
+// <copyright file="AutoFields.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -53,6 +53,7 @@ static AutoFields()
         Builders.Add(new IntCollectionFieldBuilder());
         Builders.Add(new ByteArrayFieldBuilder());
         Builders.Add(new ValueListFieldBuilder());
+        Builders.Add(new InvasionSpawnTableFieldBuilder());
     }
 
     /// <summary>
diff --git a/src/Web/Shared/Components/Form/InvasionSpawnTable.razor b/src/Web/Shared/Components/Form/InvasionSpawnTable.razor
new file mode 100644
index 000000000..af2e69c9b
--- /dev/null
+++ b/src/Web/Shared/Components/Form/InvasionSpawnTable.razor
@@ -0,0 +1,72 @@
+@using MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents
+@using MUnique.OpenMU.DataModel.Configuration
+@using MUnique.OpenMU.Web.Shared.Services
+@using MUnique.OpenMU.Web.Shared.Properties
+
+@inherits Microsoft.AspNetCore.Components.Forms.InputBase<IList<InvasionSpawnConfiguration>>
+
+<div class="card">
+    <h5 class="card-header">
+        <FieldLabel Text="@Label" ValueExpression="@this.ValueExpression" />
+    </h5>
+    <div class="card-body">
+        @foreach (var spawn in this._viewModels)
+        {
+            <div class="border-bottom py-3 d-flex flex-column w-100">
+                <div class="mb-3">
+                    <LookupField TObject="MonsterDefinition"
+                                 @bind-Value="spawn.Monster" />
+                </div>
+                <div class="mb-3">
+                    <MultiLookupField TObject="GameMapDefinition"
+                                      @bind-Value="spawn.Maps" />
+                </div>
+                <div class="d-flex align-items-center flex-wrap">
+                    <div class="d-flex align-items-center mr-4">
+                        <label class="mb-0 mr-2">@Resources.Quantity</label>
+                        <InputNumber @bind-Value="spawn.Count"
+                                     class="form-control form-control"
+                                     style="width: 70px;"
+                                     min="1" max="254" />
+                    </div>
+                    <div class="d-flex align-items-center mr-4">
+                        <label class="mb-0 mr-2">X</label>
+                        <InputNumber @bind-Value="spawn.X"
+                                     class="form-control form-control"
+                                     style="width: 70px;"
+                                     min="0" max="255" />
+                    </div>
+                    <div class="d-flex align-items-center mr-4">
+                        <label class="mb-0 mr-2">Y</label>
+                        <InputNumber @bind-Value="spawn.Y"
+                                     class="form-control form-control"
+                                     style="width: 70px;"
+                                     min="0" max="255" />
+                    </div>
+                    <div class="mb-0 d-flex align-items-center mr-4">
+                        <label class="mb-0" style="min-width: 250px;" for="@($"checkbox_{spawn.GetHashCode()}")" title="@Resources.SpawnOnAllSelectedMapsTooltip">
+                            @Resources.SpawnOnAllSelectedMaps
+                            <span class="oi oi-info" style="cursor: help;"></span>
+                        </label>
+                        <input type="checkbox"
+                               id="@($"checkbox_{spawn.GetHashCode()}")"
+                               class="mt-0"
+                               @bind="spawn.IsSpawnOnAllMaps" />
+                    </div>
+                </div>
+                <div class="mt-2">
+                    <button type="button"
+                            class="btn-danger"
+                            @onclick="@(() => this.OnRemoveClick(spawn))">
+                        @Resources.Remove
+                    </button>
+                </div>
+            </div>
+        }
+        <div class="mt-3">
+            <button type="button" class="btn btn-primary" @onclick="@this.OnAddClick">
+                <i class="oi oi-plus"></i> @Resources.AddValue
+            </button>
+        </div>
+    </div>
+</div>
diff --git a/src/Web/Shared/Components/Form/InvasionSpawnTable.razor.cs b/src/Web/Shared/Components/Form/InvasionSpawnTable.razor.cs
new file mode 100644
index 000000000..1c52027fa
--- /dev/null
+++ b/src/Web/Shared/Components/Form/InvasionSpawnTable.razor.cs
@@ -0,0 +1,320 @@
+// <copyright file="InvasionSpawnTable.razor.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Web.Shared.Components.Form;
+
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
+using MUnique.OpenMU.DataModel.Configuration;
+using MUnique.OpenMU.GameLogic.PlugIns.InvasionEvents;
+using MUnique.OpenMU.Persistence;
+
+/// <summary>
+/// A component which shows a collection of <see cref="InvasionSpawnConfiguration"/> in a table.
+/// </summary>
+public partial class InvasionSpawnTable : InputBase<IList<InvasionSpawnConfiguration>>
+{
+    private static readonly JsonSerializerOptions JsonOptions = new() { PropertyNameCaseInsensitive = true };
+
+    private List<SpawnViewModel> _viewModels = new();
+    private IEnumerable<MonsterDefinition>? _allMonsters;
+    private IEnumerable<GameMapDefinition>? _allMaps;
+    private bool _parsing;
+
+    /// <summary>
+    /// Gets or sets the label.
+    /// </summary>
+    [Parameter]
+    public string Label { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the persistence context.
+    /// </summary>
+    [CascadingParameter]
+    public IContext PersistenceContext { get; set; } = null!;
+
+    [Inject]
+    private IDataSource<GameConfiguration> GameConfigurationSource { get; set; } = null!;
+
+    /// <inheritdoc />
+    protected override async Task OnInitializedAsync()
+    {
+        await base.OnInitializedAsync().ConfigureAwait(false);
+        if (this.Value is null)
+        {
+            this.Value = new List<InvasionSpawnConfiguration>();
+        }
+
+        await this.GameConfigurationSource.GetOwnerAsync().ConfigureAwait(false);
+        this._allMonsters = this.GameConfigurationSource.GetAll<MonsterDefinition>();
+        this._allMaps = this.GameConfigurationSource.GetAll<GameMapDefinition>();
+
+        this._viewModels = this.Value.Select(v => new SpawnViewModel(v, this)).ToList();
+    }
+
+    /// <inheritdoc />
+    protected override bool TryParseValueFromString(string? value, [MaybeNullWhen(false)] out IList<InvasionSpawnConfiguration> result, [NotNullWhen(false)] out string? validationErrorMessage)
+    {
+        if (this._parsing)
+        {
+            result = this.Value ?? new List<InvasionSpawnConfiguration>();
+            validationErrorMessage = null;
+            return true;
+        }
+
+        this._parsing = true;
+        try
+        {
+            result = JsonSerializer.Deserialize<IList<InvasionSpawnConfiguration>>(value ?? "[]", JsonOptions) ?? new List<InvasionSpawnConfiguration>();
+            validationErrorMessage = null;
+            return true;
+        }
+        catch (Exception ex)
+        {
+            result = this.Value ?? new List<InvasionSpawnConfiguration>();
+            validationErrorMessage = ex.Message;
+            return true;
+        }
+        finally
+        {
+            this._parsing = false;
+        }
+    }
+
+    /// <inheritdoc />
+    protected override string FormatValueAsString(IList<InvasionSpawnConfiguration>? value)
+    {
+        return JsonSerializer.Serialize(value ?? new List<InvasionSpawnConfiguration>(), JsonOptions);
+    }
+
+    private void OnAddClick()
+    {
+        var newSpawn = new InvasionSpawnConfiguration();
+        this.Value?.Add(newSpawn);
+        this._viewModels.Add(new SpawnViewModel(newSpawn, this));
+    }
+
+    private void OnRemoveClick(SpawnViewModel viewModel)
+    {
+        this.Value?.Remove(viewModel.Model);
+        this._viewModels.Remove(viewModel);
+    }
+
+    private MonsterDefinition? GetMonster(ushort monsterId)
+    {
+        if (monsterId == 0)
+        {
+            return null;
+        }
+
+        return this._allMonsters?.FirstOrDefault(m => m.Number == monsterId);
+    }
+
+    private IList<GameMapDefinition> GetMaps(IList<ushort> mapIds)
+    {
+        if (mapIds.Count == 0 || this._allMaps is null)
+        {
+            return new List<GameMapDefinition>();
+        }
+
+        return mapIds.Select(id => this._allMaps.FirstOrDefault(m => m.Number == (short)id))
+            .Where(map => map is not null)
+            .Cast<GameMapDefinition>()
+            .ToList();
+    }
+
+    private void SetMaps(InvasionSpawnConfiguration spawn, IList<GameMapDefinition> maps)
+    {
+        spawn.MapIds = maps.Select(m => (ushort)m.Number).ToList();
+    }
+
+    /// <summary>
+    /// View model for a single invasion spawn configuration to facilitate better Blazor data binding.
+    /// </summary>
+    public class SpawnViewModel
+    {
+        private readonly InvasionSpawnConfiguration _model;
+        private readonly InvasionSpawnTable _parent;
+        private SyncedMapList _cachedMaps;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpawnViewModel"/> class.
+        /// </summary>
+        /// <param name="model">The model.</param>
+        /// <param name="parent">The parent component.</param>
+        public SpawnViewModel(InvasionSpawnConfiguration model, InvasionSpawnTable parent)
+        {
+            this._model = model;
+            this._parent = parent;
+            var initialMaps = parent.GetMaps(model.MapIds);
+            this._cachedMaps = new SyncedMapList(initialMaps, this);
+        }
+
+        /// <summary>
+        /// Gets the underlying model.
+        /// </summary>
+        public InvasionSpawnConfiguration Model => this._model;
+
+        /// <summary>
+        /// Gets or sets the maps where the monster can spawn.
+        /// </summary>
+        public IList<GameMapDefinition> Maps
+        {
+            get => this._cachedMaps;
+            set
+            {
+                this._cachedMaps = new SyncedMapList(value, this);
+                this.SyncMapIdsToModel();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the monster definition.
+        /// </summary>
+        public MonsterDefinition? Monster
+        {
+            get => this._parent.GetMonster(this._model.MonsterId);
+            set => this._model.MonsterId = (ushort)(value?.Number ?? 0);
+        }
+
+        /// <summary>
+        /// Gets or sets the quantity of monsters to spawn.
+        /// </summary>
+        public int Count
+        {
+            get => this._model.Count;
+            set => this._model.Count = (byte)value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to spawn on all maps or just a random one.
+        /// Delegates to <see cref="InvasionSpawnConfiguration.MapStrategy"/> via the
+        /// <see cref="InvasionSpawnConfiguration.IsSpawnOnAllMaps"/> bridge property.
+        /// </summary>
+        public bool IsSpawnOnAllMaps
+        {
+            get => this._model.IsSpawnOnAllMaps;
+            set => this._model.IsSpawnOnAllMaps = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the fixed X coordinate.
+        /// </summary>
+        public int? X
+        {
+            get => this._model.X;
+            set => this._model.X = (byte?)value;
+        }
+
+        /// <summary>
+        /// Gets or sets the fixed Y coordinate.
+        /// </summary>
+        public int? Y
+        {
+            get => this._model.Y;
+            set => this._model.Y = (byte?)value;
+        }
+
+        private void SyncMapIdsToModel()
+        {
+            this._model.MapIds = this._cachedMaps
+                .Select(m => (ushort)m.Number)
+                .ToList();
+        }
+
+        /// <summary>
+        /// A list wrapper that automatically syncs changes back to the model's MapIds.
+        /// </summary>
+        private class SyncedMapList : IList<GameMapDefinition>
+        {
+            private readonly List<GameMapDefinition> _inner;
+            private readonly SpawnViewModel _owner;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="SyncedMapList"/> class.
+            /// </summary>
+            /// <param name="items">The initial map items.</param>
+            /// <param name="owner">The owning view model to sync back to.</param>
+            public SyncedMapList(IEnumerable<GameMapDefinition> items, SpawnViewModel owner)
+            {
+                this._inner = new List<GameMapDefinition>(items);
+                this._owner = owner;
+            }
+
+            /// <inheritdoc />
+            public int Count => this._inner.Count;
+
+            /// <inheritdoc />
+            public bool IsReadOnly => false;
+
+            /// <inheritdoc />
+            public GameMapDefinition this[int index]
+            {
+                get => this._inner[index];
+                set
+                {
+                    this._inner[index] = value;
+                    this._owner.SyncMapIdsToModel();
+                }
+            }
+
+            /// <inheritdoc />
+            public void Add(GameMapDefinition item)
+            {
+                this._inner.Add(item);
+                this._owner.SyncMapIdsToModel();
+            }
+
+            /// <inheritdoc />
+            public bool Remove(GameMapDefinition item)
+            {
+                var result = this._inner.Remove(item);
+                if (result)
+                {
+                    this._owner.SyncMapIdsToModel();
+                }
+
+                return result;
+            }
+
+            /// <inheritdoc />
+            public void Clear()
+            {
+                this._inner.Clear();
+                this._owner.SyncMapIdsToModel();
+            }
+
+            /// <inheritdoc />
+            public void Insert(int index, GameMapDefinition item)
+            {
+                this._inner.Insert(index, item);
+                this._owner.SyncMapIdsToModel();
+            }
+
+            /// <inheritdoc />
+            public void RemoveAt(int index)
+            {
+                this._inner.RemoveAt(index);
+                this._owner.SyncMapIdsToModel();
+            }
+
+            /// <inheritdoc />
+            public bool Contains(GameMapDefinition item) => this._inner.Contains(item);
+
+            /// <inheritdoc />
+            public void CopyTo(GameMapDefinition[] array, int arrayIndex) => this._inner.CopyTo(array, arrayIndex);
+
+            /// <inheritdoc />
+            public int IndexOf(GameMapDefinition item) => this._inner.IndexOf(item);
+
+            /// <inheritdoc />
+            public IEnumerator<GameMapDefinition> GetEnumerator() => this._inner.GetEnumerator();
+
+            /// <inheritdoc />
+            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => this.GetEnumerator();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Web/Shared/Properties/Resources.Designer.cs b/src/Web/Shared/Properties/Resources.Designer.cs
index 3a93d96b6..5f54cf46b 100644
--- a/src/Web/Shared/Properties/Resources.Designer.cs
+++ b/src/Web/Shared/Properties/Resources.Designer.cs
@@ -1,7 +1,6 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -12,46 +11,32 @@ namespace MUnique.OpenMU.Web.Shared.Properties {
     using System;
     
     
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
+    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     public class Resources {
         
-        private static global::System.Resources.ResourceManager resourceMan;
+        private static System.Resources.ResourceManager resourceMan;
         
-        private static global::System.Globalization.CultureInfo resourceCulture;
+        private static System.Globalization.CultureInfo resourceCulture;
         
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        public Resources() {
+        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
         }
         
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static global::System.Resources.ResourceManager ResourceManager {
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static System.Resources.ResourceManager ResourceManager {
             get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MUnique.OpenMU.Web.Shared.Properties.Resources", typeof(Resources).Assembly);
+                if (object.Equals(null, resourceMan)) {
+                    System.Resources.ResourceManager temp = new System.Resources.ResourceManager("MUnique.OpenMU.Web.Shared.Properties.Resources", typeof(Resources).Assembly);
                     resourceMan = temp;
                 }
                 return resourceMan;
             }
         }
         
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static global::System.Globalization.CultureInfo Culture {
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static System.Globalization.CultureInfo Culture {
             get {
                 return resourceCulture;
             }
@@ -60,450 +45,284 @@ public Resources() {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to E-Mail.
-        /// </summary>
-        public static string AccountCreationParameters_EMail_Name {
+        public static string Loading {
             get {
-                return ResourceManager.GetString("AccountCreationParameters_EMail_Name", resourceCulture);
+                return ResourceManager.GetString("Loading", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Login Name.
-        /// </summary>
-        public static string AccountCreationParameters_LoginName_Name {
+        public static string All {
             get {
-                return ResourceManager.GetString("AccountCreationParameters_LoginName_Name", resourceCulture);
+                return ResourceManager.GetString("All", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Password.
-        /// </summary>
-        public static string AccountCreationParameters_Password_Name {
+        public static string TargetMap {
             get {
-                return ResourceManager.GetString("AccountCreationParameters_Password_Name", resourceCulture);
+                return ResourceManager.GetString("TargetMap", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Security Code.
-        /// </summary>
-        public static string AccountCreationParameters_SecurityCode_Name {
+        public static string Target {
             get {
-                return ResourceManager.GetString("AccountCreationParameters_SecurityCode_Name", resourceCulture);
+                return ResourceManager.GetString("Target", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Status.
-        /// </summary>
-        public static string AccountCreationParameters_State_Name {
+        public static string SelectedMap {
             get {
-                return ResourceManager.GetString("AccountCreationParameters_State_Name", resourceCulture);
+                return ResourceManager.GetString("SelectedMap", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to All.
-        /// </summary>
-        public static string All {
+        public static string Map {
             get {
-                return ResourceManager.GetString("All", resourceCulture);
+                return ResourceManager.GetString("Map", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Ancient Option Level.
-        /// </summary>
-        public static string AncientOptionLevel {
+        public static string Toolbar {
             get {
-                return ResourceManager.GetString("AncientOptionLevel", resourceCulture);
+                return ResourceManager.GetString("Toolbar", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Bonus.
-        /// </summary>
-        public static string Bonus {
+        public static string CreationGroup {
             get {
-                return ResourceManager.GetString("Bonus", resourceCulture);
+                return ResourceManager.GetString("CreationGroup", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Control Group.
-        /// </summary>
         public static string ControlGroup {
             get {
                 return ResourceManager.GetString("ControlGroup", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Creation Group.
-        /// </summary>
-        public static string CreationGroup {
+        public static string Remove {
             get {
-                return ResourceManager.GetString("CreationGroup", resourceCulture);
+                return ResourceManager.GetString("Remove", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Has Guardian Option (Level 380 PvP).
-        /// </summary>
-        public static string HasGuardianOption {
+        public static string TerrainOf {
             get {
-                return ResourceManager.GetString("HasGuardianOption", resourceCulture);
+                return ResourceManager.GetString("TerrainOf", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Loading ....
-        /// </summary>
-        public static string Loading {
+        public static string SelectedObject {
             get {
-                return ResourceManager.GetString("Loading", resourceCulture);
+                return ResourceManager.GetString("SelectedObject", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Map.
-        /// </summary>
-        public static string Map {
+        public static string AncientOptionLevel {
             get {
-                return ResourceManager.GetString("Map", resourceCulture);
+                return ResourceManager.GetString("AncientOptionLevel", resourceCulture);
+            }
+        }
+        
+        public static string Bonus {
+            get {
+                return ResourceManager.GetString("Bonus", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Option Level.
-        /// </summary>
         public static string OptionLevel {
             get {
                 return ResourceManager.GetString("OptionLevel", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to &lt;Please select a definition&gt;.
-        /// </summary>
-        public static string PleaseSelectItemDefinition {
+        public static string HasGuardianOption {
             get {
-                return ResourceManager.GetString("PleaseSelectItemDefinition", resourceCulture);
+                return ResourceManager.GetString("HasGuardianOption", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Duplicate.
-        /// </summary>
-        public static string Duplicate {
+        
+        public static string SocketNumber {
             get {
-                return ResourceManager.GetString("Duplicate", resourceCulture);
+                return ResourceManager.GetString("SocketNumber", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Filter.
-        /// </summary>
-        public static string Filter {
+        
+        public static string AccountCreationParameters_LoginName_Name {
             get {
-                return ResourceManager.GetString("Filter", resourceCulture);
+                return ResourceManager.GetString("AccountCreationParameters_LoginName_Name", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Search.
-        /// </summary>
-        public static string Search {
+        
+        public static string AccountCreationParameters_Password_Name {
             get {
-                return ResourceManager.GetString("Search", resourceCulture);
+                return ResourceManager.GetString("AccountCreationParameters_Password_Name", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Remove.
-        /// </summary>
-        public static string Remove {
+        
+        public static string AccountCreationParameters_SecurityCode_Name {
             get {
-                return ResourceManager.GetString("Remove", resourceCulture);
+                return ResourceManager.GetString("AccountCreationParameters_SecurityCode_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Selected Map.
-        /// </summary>
-        public static string SelectedMap {
+        public static string AccountCreationParameters_EMail_Name {
             get {
-                return ResourceManager.GetString("SelectedMap", resourceCulture);
+                return ResourceManager.GetString("AccountCreationParameters_EMail_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Selected Object.
-        /// </summary>
-        public static string SelectedObject {
+        public static string AccountCreationParameters_State_Name {
             get {
-                return ResourceManager.GetString("SelectedObject", resourceCulture);
+                return ResourceManager.GetString("AccountCreationParameters_State_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Socket {0}.
-        /// </summary>
-        public static string SocketNumber {
+        public static string UserCreationParameters_LoginName_Name {
             get {
-                return ResourceManager.GetString("SocketNumber", resourceCulture);
+                return ResourceManager.GetString("UserCreationParameters_LoginName_Name", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Target.
-        /// </summary>
-        public static string Target {
+        public static string UserCreationParameters_Password_Name {
             get {
-                return ResourceManager.GetString("Target", resourceCulture);
+                return ResourceManager.GetString("UserCreationParameters_Password_Name", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Target map.
-        /// </summary>
-        public static string TargetMap {
+        
+        public static string TheValueMustNotContain {
             get {
-                return ResourceManager.GetString("TargetMap", resourceCulture);
+                return ResourceManager.GetString("TheValueMustNotContain", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Terrain of {0}.
-        /// </summary>
-        public static string TerrainOf {
+        public static string PleaseSelectItemDefinition {
             get {
-                return ResourceManager.GetString("TerrainOf", resourceCulture);
+                return ResourceManager.GetString("PleaseSelectItemDefinition", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to {0}: The value must not contain &quot;{1}&quot;..
-        /// </summary>
-        public static string TheValueMustNotContain {
+        public static string Duplicate {
             get {
-                return ResourceManager.GetString("TheValueMustNotContain", resourceCulture);
+                return ResourceManager.GetString("Duplicate", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Toolbar.
-        /// </summary>
-        public static string Toolbar {
+        public static string Filter {
             get {
-                return ResourceManager.GetString("Toolbar", resourceCulture);
+                return ResourceManager.GetString("Filter", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Username.
-        /// </summary>
-        public static string UserCreationParameters_LoginName_Name {
+        public static string Search {
             get {
-                return ResourceManager.GetString("UserCreationParameters_LoginName_Name", resourceCulture);
+                return ResourceManager.GetString("Search", resourceCulture);
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Password.
-        /// </summary>
-        public static string UserCreationParameters_Password_Name {
+        public static string NoResultsFound {
             get {
-                return ResourceManager.GetString("UserCreationParameters_Password_Name", resourceCulture);
+                return ResourceManager.GetString("NoResultsFound", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Monster.
-        /// </summary>
-        public static string Monster
-        {
-            get
-            {
+        
+        public static string Monster {
+            get {
                 return ResourceManager.GetString("Monster", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Target Maps.
-        /// </summary>
-        public static string TargetMaps
-        {
-            get
-            {
+        
+        public static string TargetMaps {
+            get {
                 return ResourceManager.GetString("TargetMaps", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Quantity.
-        /// </summary>
-        public static string Quantity
-        {
-            get
-            {
+        
+        public static string Quantity {
+            get {
                 return ResourceManager.GetString("Quantity", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Spawn Rules.
-        /// </summary>
-        public static string SpawnRules
-        {
-            get
-            {
+        
+        public static string SpawnRules {
+            get {
                 return ResourceManager.GetString("SpawnRules", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Spawn on All Selected Maps.
-        /// </summary>
-        public static string SpawnOnAllSelectedMaps
-        {
-            get
-            {
+        
+        public static string SpawnOnAllSelectedMaps {
+            get {
                 return ResourceManager.GetString("SpawnOnAllSelectedMaps", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to If enabled spawn monster on all selected maps, if false, select a random map..
-        /// </summary>
-        public static string SpawnOnAllSelectedMapsTooltip
-        {
-            get
-            {
+        
+        public static string SpawnOnAllSelectedMapsTooltip {
+            get {
                 return ResourceManager.GetString("SpawnOnAllSelectedMapsTooltip", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Add Value.
-        /// </summary>
-        public static string AddValue
-        {
-            get
-            {
+        
+        public static string AddValue {
+            get {
                 return ResourceManager.GetString("AddValue", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Reset zoom (100%).
-        /// </summary>
-        public static string ResetZoom
-        {
-            get
-            {
+        
+        public static string ResetZoom {
+            get {
                 return ResourceManager.GetString("ResetZoom", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Toggle grid.
-        /// </summary>
-        public static string ToggleGrid
-        {
-            get
-            {
+        
+        public static string ToggleGrid {
+            get {
                 return ResourceManager.GetString("ToggleGrid", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to No selection.
-        /// </summary>
-        public static string NoSelection
-        {
-            get
-            {
+        
+        public static string NoSelection {
+            get {
                 return ResourceManager.GetString("NoSelection", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Undo.
-        /// </summary>
-        public static string Undo
-        {
-            get
-            {
+        
+        public static string Undo {
+            get {
                 return ResourceManager.GetString("Undo", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Save.
-        /// </summary>
-        public static string Save
-        {
-            get
-            {
+        
+        public static string Save {
+            get {
                 return ResourceManager.GetString("Save", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Type Filter.
-        /// </summary>
-        public static string TypeFilter
-        {
-            get
-            {
+        
+        public static string TypeFilter {
+            get {
                 return ResourceManager.GetString("TypeFilter", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Monsters.
-        /// </summary>
-        public static string Monsters
-        {
-            get
-            {
+        
+        public static string Monsters {
+            get {
                 return ResourceManager.GetString("Monsters", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to NPCs.
-        /// </summary>
-        public static string Npcs
-        {
-            get
-            {
+        
+        public static string Npcs {
+            get {
                 return ResourceManager.GetString("Npcs", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Gates.
-        /// </summary>
-        public static string Gates
-        {
-            get
-            {
+        
+        public static string Gates {
+            get {
                 return ResourceManager.GetString("Gates", resourceCulture);
             }
         }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Others.
-        /// </summary>
-        public static string Others
-        {
-            get
-            {
+        
+        public static string Others {
+            get {
                 return ResourceManager.GetString("Others", resourceCulture);
             }
         }
diff --git a/src/Web/Shared/Services/PlugInController.cs b/src/Web/Shared/Services/PlugInController.cs
index 070342f66..a95d527de 100644
--- a/src/Web/Shared/Services/PlugInController.cs
+++ b/src/Web/Shared/Services/PlugInController.cs
@@ -42,9 +42,6 @@ public PlugInController(IDataSource<GameConfiguration> dataSource, IModalService
     /// <summary>
     /// Gets or sets the name filter.
     /// </summary>
-    /// <value>
-    /// The name filter.
-    /// </value>
     public string NameFilter
     {
         get => this._nameFilter;
@@ -58,9 +55,6 @@ public string NameFilter
     /// <summary>
     /// Gets or sets the type filter.
     /// </summary>
-    /// <value>
-    /// The type filter.
-    /// </value>
     public string TypeFilter
     {
         get => this._typeFilter;
@@ -130,7 +124,7 @@ public async Task<List<PlugInConfigurationViewItem>> GetAsync(int offset, int co
 
         try
         {
-            var gameConfiguration = await this._dataSource.GetOwnerAsync(Guid.Empty);
+            var gameConfiguration = await this._dataSource.GetOwnerAsync(Guid.Empty).ConfigureAwait(true);
             var allPlugIns = GetPluginTypes().ToDictionary(t => t.GUID, t => t);
 
             var rest = count - result.Count;
@@ -180,7 +174,7 @@ public async Task ShowPlugInConfigAsync(PlugInConfigurationViewItem item)
                             ?? Activator.CreateInstance(item.ConfigurationType);
         var parameters = new ModalParameters();
         parameters.Add(nameof(ModalCreateNew<object>.Item), configuration!);
-        parameters.Add(nameof(ModalCreateNew<object>.PersistenceContext), await this._dataSource.GetContextAsync());
+        parameters.Add(nameof(ModalCreateNew<object>.PersistenceContext), await this._dataSource.GetContextAsync().ConfigureAwait(true));
         var options = new ModalOptions
         {
             DisableBackgroundCancel = true,
@@ -198,6 +192,7 @@ public async Task ShowPlugInConfigAsync(PlugInConfigurationViewItem item)
         {
             item.Configuration.SetConfiguration(configuration!, referenceResolver);
             await (await this._dataSource.GetContextAsync().ConfigureAwait(false)).SaveChangesAsync().ConfigureAwait(false);
+
             this.DataChanged?.Invoke(this, EventArgs.Empty);
         }
     }
@@ -318,4 +313,4 @@ private bool FilterByPoint(Type plugInType)
     {
         return this.PointFilter == Guid.Empty || this.PointFilter == GetPlugInExtensionPointType(plugInType)?.GUID;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Web/Shared/Styles/Site.scss b/src/Web/Shared/Styles/Site.scss
index 9cf6b912c..7e92cdb81 100644
--- a/src/Web/Shared/Styles/Site.scss
+++ b/src/Web/Shared/Styles/Site.scss
@@ -1,4 +1,9 @@
-@import "bootstrap-4.6.1/scss/bootstrap";
+// Disable form validation icons and extra padding
+$form-feedback-icon-valid: none;
+$form-feedback-icon-invalid: none;
+$enable-validation-icons: false;
+
+@import "bootstrap-4.6.1/scss/bootstrap";
 @import "open-iconic/font/css/open-iconic-bootstrap.min.css";
 
 @import "Navigation";
diff --git a/src/Web/Shared/wwwroot/css/shared.css b/src/Web/Shared/wwwroot/css/shared.css
index 46e66131b..4963b0712 100644
--- a/src/Web/Shared/wwwroot/css/shared.css
+++ b/src/Web/Shared/wwwroot/css/shared.css
@@ -2011,31 +2011,14 @@ textarea.form-control, textarea.valid.modified, .invalid textarea.valid {
 
 .was-validated .form-control:valid, .was-validated th input:valid, th .was-validated input:valid, .valid.modified .form-control:valid, .valid.modified th input:valid, th .valid.modified input:valid, .was-validated .invalid .valid:valid, .valid.modified .invalid .valid:valid, .invalid .was-validated .valid:valid, .invalid .valid.modified .valid:valid, .was-validated form input:valid, .valid.modified form input:valid, form .was-validated input:valid, form .valid.modified input:valid, .was-validated select:valid, .valid.modified select:valid, .form-control.is-valid, th input.is-valid, .valid.modified, .invalid .is-valid.valid, form input.is-valid, select.is-valid {
   border-color: #28a745;
-  padding-right: calc(1.5em + 0.75rem) !important;
-  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");
-  background-repeat: no-repeat;
-  background-position: right calc(0.375em + 0.1875rem) center;
-  background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
 }
 .was-validated .form-control:valid:focus, .was-validated th input:valid:focus, th .was-validated input:valid:focus, .valid.modified .form-control:valid:focus, .valid.modified th input:valid:focus, th .valid.modified input:valid:focus, .was-validated .invalid .valid:valid:focus, .valid.modified .invalid .valid:valid:focus, .invalid .was-validated .valid:valid:focus, .invalid .valid.modified .valid:valid:focus, .was-validated form input:valid:focus, .valid.modified form input:valid:focus, form .was-validated input:valid:focus, form .valid.modified input:valid:focus, .was-validated select:valid:focus, .valid.modified select:valid:focus, .form-control.is-valid:focus, th input.is-valid:focus, .valid.modified:focus, .invalid .is-valid.valid:focus, form input.is-valid:focus, select.is-valid:focus {
   border-color: #28a745;
   box-shadow: 0 0 0 0.2rem rgba(40, 167, 69, 0.25);
 }
 
-.was-validated select.form-control:valid, .was-validated select:valid, .valid.modified select:valid, select.form-control.is-valid, .invalid select.is-valid.valid, select.is-valid, select.valid.modified {
-  padding-right: 3rem !important;
-  background-position: right 1.5rem center;
-}
-
-.was-validated textarea.form-control:valid, .valid.modified textarea.form-control:valid, .was-validated .invalid textarea.valid:valid, .valid.modified .invalid textarea.valid:valid, .invalid .was-validated textarea.valid:valid, .invalid .valid.modified textarea.valid:valid, textarea.form-control.is-valid, textarea.valid.modified, .invalid textarea.is-valid.valid {
-  padding-right: calc(1.5em + 0.75rem);
-  background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem);
-}
-
 .was-validated .custom-select:valid, .valid.modified .custom-select:valid, .custom-select.is-valid, .custom-select.valid.modified {
   border-color: #28a745;
-  padding-right: calc(0.75em + 2.3125rem) !important;
-  background: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") right 0.75rem center/8px 10px no-repeat, #fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e") center right 1.75rem/calc(0.75em + 0.375rem) calc(0.75em + 0.375rem) no-repeat;
 }
 .was-validated .custom-select:valid:focus, .valid.modified .custom-select:valid:focus, .custom-select.is-valid:focus, .custom-select.valid.modified:focus {
   border-color: #28a745;
@@ -2117,31 +2100,14 @@ textarea.form-control, textarea.valid.modified, .invalid textarea.valid {
 
 .was-validated .form-control:invalid, .was-validated th input:invalid, th .was-validated input:invalid, .was-validated .valid.modified:invalid, .valid.modified .form-control:invalid, .valid.modified th input:invalid, th .valid.modified input:invalid, .valid.modified .valid.modified:invalid, .was-validated .invalid .valid:invalid, .valid.modified .invalid .valid:invalid, .invalid .was-validated .valid:invalid, .invalid .valid.modified .valid:invalid, .was-validated form input:invalid, .valid.modified form input:invalid, form .was-validated input:invalid, form .valid.modified input:invalid, .was-validated select:invalid, .valid.modified select:invalid, .form-control.is-invalid, th input.is-invalid, .is-invalid.valid.modified, .form-control.invalid.modified, th input.invalid.modified, .invalid.modified.valid, .invalid .is-invalid.valid, form input.is-invalid, form input.invalid.modified, select.is-invalid, select.invalid.modified {
   border-color: #dc3545;
-  padding-right: calc(1.5em + 0.75rem) !important;
-  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");
-  background-repeat: no-repeat;
-  background-position: right calc(0.375em + 0.1875rem) center;
-  background-size: calc(0.75em + 0.375rem) calc(0.75em + 0.375rem);
 }
 .was-validated .form-control:invalid:focus, .was-validated th input:invalid:focus, th .was-validated input:invalid:focus, .was-validated .valid.modified:invalid:focus, .valid.modified .form-control:invalid:focus, .valid.modified th input:invalid:focus, th .valid.modified input:invalid:focus, .valid.modified .valid.modified:invalid:focus, .was-validated .invalid .valid:invalid:focus, .valid.modified .invalid .valid:invalid:focus, .invalid .was-validated .valid:invalid:focus, .invalid .valid.modified .valid:invalid:focus, .was-validated form input:invalid:focus, .valid.modified form input:invalid:focus, form .was-validated input:invalid:focus, form .valid.modified input:invalid:focus, .was-validated select:invalid:focus, .valid.modified select:invalid:focus, .form-control.is-invalid:focus, th input.is-invalid:focus, .is-invalid.valid.modified:focus, .form-control.invalid.modified:focus, th input.invalid.modified:focus, .invalid.modified.valid:focus, .invalid .is-invalid.valid:focus, form input.is-invalid:focus, form input.invalid.modified:focus, select.is-invalid:focus, select.invalid.modified:focus {
   border-color: #dc3545;
   box-shadow: 0 0 0 0.2rem rgba(220, 53, 69, 0.25);
 }
 
-.was-validated select.form-control:invalid, .was-validated select:invalid, .valid.modified select:invalid, select.form-control.is-invalid, select.is-invalid.valid.modified, .invalid select.is-invalid.valid, select.is-invalid, select.invalid.modified {
-  padding-right: 3rem !important;
-  background-position: right 1.5rem center;
-}
-
-.was-validated textarea.form-control:invalid, .was-validated textarea.valid.modified:invalid, .valid.modified textarea.form-control:invalid, .valid.modified textarea.valid.modified:invalid, .was-validated .invalid textarea.valid:invalid, .valid.modified .invalid textarea.valid:invalid, .invalid .was-validated textarea.valid:invalid, .invalid .valid.modified textarea.valid:invalid, textarea.form-control.is-invalid, textarea.is-invalid.valid.modified, textarea.form-control.invalid.modified, textarea.invalid.modified.valid, .invalid textarea.is-invalid.valid {
-  padding-right: calc(1.5em + 0.75rem);
-  background-position: top calc(0.375em + 0.1875rem) right calc(0.375em + 0.1875rem);
-}
-
 .was-validated .custom-select:invalid, .valid.modified .custom-select:invalid, .custom-select.is-invalid, .custom-select.invalid.modified {
   border-color: #dc3545;
-  padding-right: calc(0.75em + 2.3125rem) !important;
-  background: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") right 0.75rem center/8px 10px no-repeat, #fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e") center right 1.75rem/calc(0.75em + 0.375rem) calc(0.75em + 0.375rem) no-repeat;
 }
 .was-validated .custom-select:invalid:focus, .valid.modified .custom-select:invalid:focus, .custom-select.is-invalid:focus, .custom-select.invalid.modified:focus {
   border-color: #dc3545;
diff --git a/tests/MUnique.OpenMU.Tests/Party/PartyManagerTest.cs b/tests/MUnique.OpenMU.Tests/Party/PartyManagerTest.cs
index c62cef766..ba22b59ca 100644
--- a/tests/MUnique.OpenMU.Tests/Party/PartyManagerTest.cs
+++ b/tests/MUnique.OpenMU.Tests/Party/PartyManagerTest.cs
@@ -75,7 +75,7 @@ public async ValueTask KickedMember_IsRemovedFromPartyList()
     {
         var (party, _, member2) = await this.CreatePartyWithTwoMembersAsync().ConfigureAwait(false);
 
-        await party.KickPlayerAsync((byte)((List<IPartyMember>)party.PartyList).IndexOf(member2)).ConfigureAwait(false);
+        await party.KickPlayerAsync(GetPartyMemberIndex(party, member2)).ConfigureAwait(false);
 
         Assert.That(party.PartyList, Is.Not.Contains(member2));
         Assert.That(member2.Party, Is.Null);
@@ -183,10 +183,23 @@ public async ValueTask ReplaceMember_ClearsOldMemberPartyReference()
         return (party, member1, member2);
     }
 
+    private static byte GetPartyMemberIndex(Party party, IPartyMember member)
+    {
+        for (byte index = 0; index < party.PartyList.Count; index++)
+        {
+            if (party.PartyList[index] == member)
+            {
+                return index;
+            }
+        }
+
+        throw new ArgumentException("The member is not part of the party.", nameof(member));
+    }
+
     private async ValueTask<Player> CreatePartyMemberAsync()
     {
         var result = await PlayerTestHelper.CreatePlayerAsync(GameContextTestHelper.CreateGameContext()).ConfigureAwait(false);
         await result.PlayerState.TryAdvanceToAsync(PlayerState.EnteredWorld).ConfigureAwait(false);
         return result;
     }
-}
\ No newline at end of file
+}
diff --git a/tests/MUnique.OpenMU.Tests/Party/PartyTest.cs b/tests/MUnique.OpenMU.Tests/Party/PartyTest.cs
index 49c6f9da4..786351347 100644
--- a/tests/MUnique.OpenMU.Tests/Party/PartyTest.cs
+++ b/tests/MUnique.OpenMU.Tests/Party/PartyTest.cs
@@ -44,7 +44,7 @@ public async ValueTask PartyMemberKickFailByNonMasterAsync()
         var partyMember2 = (Player)party.PartyList[1];
         var partyMember3 = party.PartyList[2];
 
-        await this._kickAction.KickPlayerAsync(partyMember2, (byte)((List<IPartyMember>)party.PartyList).IndexOf(partyMember3)).ConfigureAwait(false);
+        await this._kickAction.KickPlayerAsync(partyMember2, GetPartyMemberIndex(party, partyMember3)).ConfigureAwait(false);
         Assert.That(party.PartyList, Contains.Item(partyMember3));
     }
 
@@ -57,7 +57,7 @@ public async ValueTask PartyMemberKickHimselfAsync()
         var party = await this.CreatePartyWithMembersAsync(3).ConfigureAwait(false);
         var partyMember2 = party.PartyList[1];
 
-        await this._kickAction.KickPlayerAsync((Player)partyMember2, (byte)((List<IPartyMember>)party.PartyList).IndexOf(partyMember2)).ConfigureAwait(false);
+        await this._kickAction.KickPlayerAsync((Player)partyMember2, GetPartyMemberIndex(party, partyMember2)).ConfigureAwait(false);
         Assert.That(party.PartyList, Is.Not.Contains(partyMember2));
         Assert.That(party.PartyList, Has.Count.EqualTo(2));
     }
@@ -72,7 +72,7 @@ public async ValueTask PartyMemberKickByMasterAsync()
         var partyMaster = (Player)party.PartyList[0];
         var partyMember = (Player)party.PartyList[1];
 
-        await this._kickAction.KickPlayerAsync(partyMaster, (byte)((List<IPartyMember>)party.PartyList).IndexOf(partyMember)).ConfigureAwait(false);
+        await this._kickAction.KickPlayerAsync(partyMaster, GetPartyMemberIndex(party, partyMember)).ConfigureAwait(false);
         Assert.That(party.PartyList, Is.Not.Contains(partyMember));
         Assert.That(party.PartyList, Has.Count.EqualTo(2));
     }
@@ -87,7 +87,7 @@ public async ValueTask PartyMasterKicksHimselfAsync()
         var partyMaster = party.PartyList[0];
         var partyMember = party.PartyList[1];
 
-        await this._kickAction.KickPlayerAsync((Player)partyMaster, (byte)((List<IPartyMember>)party.PartyList).IndexOf(partyMaster)).ConfigureAwait(false);
+        await this._kickAction.KickPlayerAsync((Player)partyMaster, GetPartyMemberIndex(party, partyMaster)).ConfigureAwait(false);
 
         // Master leaves the party; the remaining 2 members stay.
         Assert.That(partyMaster.Party, Is.Null);
@@ -189,6 +189,19 @@ private async ValueTask<Player> CreatePartyMemberAsync()
         return result;
     }
 
+    private static byte GetPartyMemberIndex(Party party, IPartyMember member)
+    {
+        for (byte index = 0; index < party.PartyList.Count; index++)
+        {
+            if (party.PartyList[index] == member)
+            {
+                return index;
+            }
+        }
+
+        throw new ArgumentException("The member is not part of the party.", nameof(member));
+    }
+
     private async ValueTask<Party> CreatePartyWithMembersAsync(int numberOfMembers)
     {
         var party = new Party(new PartyManager(5, new NullLogger<Party>()), 5, new NullLogger<Party>());
@@ -200,4 +213,4 @@ private async ValueTask<Party> CreatePartyWithMembersAsync(int numberOfMembers)
 
         return party;
     }
-}
\ No newline at end of file
+}