648 lines
20 KiB
C#
648 lines
20 KiB
C#
using System;
|
|
using Server;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Server.Mobiles;
|
|
using Server.Items;
|
|
using Server.Engines.CityLoyalty;
|
|
using Server.Misc;
|
|
|
|
namespace Server.Engines.Blackthorn
|
|
{
|
|
public enum InvasionType
|
|
{
|
|
Dragons,
|
|
Undead,
|
|
Elemental,
|
|
Daemon,
|
|
Orc,
|
|
Wildlings,
|
|
Frost,
|
|
Arachnid,
|
|
Fey,
|
|
Nature
|
|
}
|
|
|
|
public class InvasionController : Item
|
|
{
|
|
public static bool Enabled = true;
|
|
public static int WaveCountMin = 8;
|
|
public static int WaveCountMax = 10;
|
|
public static int MaxWaves = 2;
|
|
|
|
[CommandProperty(AccessLevel.Administrator)]
|
|
public static InvasionController TramInstance { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.Administrator)]
|
|
public static InvasionController FelInstance { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.Administrator)]
|
|
public bool ForceRespawn
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if (!value)
|
|
return;
|
|
|
|
RemoveSpawn();
|
|
OnEndInvasion();
|
|
Cleanup();
|
|
BeginInvasion();
|
|
}
|
|
}
|
|
|
|
public static Dictionary<City, InvasionDefinition> Defs;
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public City CurrentInvasion { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public InvasionType InvasionType { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public InvasionBeacon Beacon { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public int SpawnCount
|
|
{
|
|
get
|
|
{
|
|
if (Spawn == null || Spawn.Count == 0)
|
|
return 0;
|
|
|
|
int count = 0;
|
|
|
|
foreach (KeyValuePair<BaseCreature, List<BaseCreature>> kvp in Spawn)
|
|
{
|
|
if (kvp.Key.Alive)
|
|
count++;
|
|
|
|
count += kvp.Value.Where(bc => bc.Alive).Count();
|
|
}
|
|
|
|
return count;
|
|
}
|
|
}
|
|
|
|
public Dictionary<BaseCreature, List<BaseCreature>> Spawn { get; set; }
|
|
|
|
public List<Rectangle2D> SpawnZones { get; set; }
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public int CurrentWave { get; private set; }
|
|
|
|
public bool BeaconVulnerable { get { return Beacon != null && (Spawn == null || Spawn.Count == 0); } }
|
|
|
|
public InvasionController(Map map) : base(3796)
|
|
{
|
|
Movable = false;
|
|
Visible = false;
|
|
|
|
Spawn = new Dictionary<BaseCreature, List<BaseCreature>>();
|
|
SpawnZones = new List<Rectangle2D>();
|
|
|
|
if (Enabled)
|
|
Timer.DelayCall(TimeSpan.FromSeconds(10), BeginInvasion);
|
|
}
|
|
|
|
public override void OnDoubleClick(Mobile from)
|
|
{
|
|
if (from.AccessLevel > AccessLevel.GameMaster)
|
|
{
|
|
from.SendGump(new Server.Gumps.PropertiesGump(from, this));
|
|
}
|
|
}
|
|
|
|
private Type[][] _SpawnTable =
|
|
{
|
|
new Type[] { typeof(Dragon), typeof(Drake), typeof(GiantSerpent), typeof(Reptalon), typeof(Hydra) },
|
|
new Type[] { typeof(Lich), typeof(Wraith), typeof(Mummy), typeof(Zombie), typeof(SkeletalKnight), typeof(BoneKnight) },
|
|
new Type[] { typeof(MudElemental), typeof(MoltenEarthElemental), typeof(DiseasedBloodElemental), typeof(GreaterAirElemental),
|
|
typeof(GreaterBloodElemental), typeof(GreaterEarthElemental), typeof(GreaterWaterElemental), typeof(ShameGreaterPoisonElemental),
|
|
typeof(StoneElemental) },
|
|
new Type[] { typeof(Daemon), typeof(Succubus), typeof(Imp), typeof(ChaosDaemon), typeof(BoneDemon) },
|
|
new Type[] { typeof(Orc), typeof(OrcBomber), typeof(OrcishMage), typeof(OrcishLord) },
|
|
new Type[] { typeof(SwampTentacle), typeof(PlagueBeast), typeof(Bogling), typeof(FeralTreefellow) },
|
|
new Type[] { typeof(IceElemental), typeof(SnowElemental), typeof(IceFiend), typeof(FrostTroll), typeof(IceSerpent) },
|
|
new Type[] { typeof(DreadSpider), typeof(GiantBlackWidow), typeof(Scorpion), typeof(TerathanWarrior), typeof(WolfSpider) },
|
|
new Type[] { typeof(Satyr), typeof(Centaur), typeof(CuSidhe), typeof(Wisp), typeof(MLDryad) },
|
|
new Type[] { typeof(DireWolf), typeof(GiantRat), typeof(Troglodyte), typeof(RagingGrizzlyBear), typeof(GreaterMongbat) },
|
|
};
|
|
|
|
public void BeginInvasion()
|
|
{
|
|
if (!Enabled)
|
|
return;
|
|
|
|
RemoveSpawn();
|
|
|
|
CurrentWave = 1;
|
|
InvasionType newType;
|
|
City newCity;
|
|
|
|
do
|
|
{
|
|
newType = (InvasionType)Utility.Random(10);
|
|
}
|
|
while(newType == this.InvasionType);
|
|
|
|
do
|
|
{
|
|
newCity = (City)Utility.Random(9);
|
|
}
|
|
while (newCity == this.CurrentInvasion);
|
|
|
|
this.CurrentInvasion = newCity;
|
|
this.InvasionType = newType;
|
|
SpawnZones = Defs[CurrentInvasion].SpawnRecs.ToList();
|
|
|
|
Beacon = new InvasionBeacon(this);
|
|
Beacon.MoveToWorld(Defs[CurrentInvasion].BeaconLoc, this.Map);
|
|
|
|
// Shuffle zones
|
|
for(int i = 0; i < 8; i++)
|
|
{
|
|
var rec = SpawnZones[Utility.Random(SpawnZones.Count)];
|
|
SpawnZones.Remove(rec);
|
|
SpawnZones.Insert(0, rec);
|
|
}
|
|
|
|
SpawnWave();
|
|
}
|
|
|
|
public void SpawnWave()
|
|
{
|
|
List<Rectangle2D> zones = new List<Rectangle2D>(SpawnZones);
|
|
|
|
for(int j = 0; j < 2; j++)
|
|
{
|
|
Rectangle2D spawnrec = zones[Utility.Random(zones.Count)];
|
|
zones.Remove(spawnrec);
|
|
|
|
int count = Utility.RandomMinMax(WaveCountMin, WaveCountMax);
|
|
List<BaseCreature> list = new List<BaseCreature>();
|
|
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
BaseCreature bc = Activator.CreateInstance(_SpawnTable[(int)this.InvasionType][Utility.Random(_SpawnTable[(int)this.InvasionType].Length)]) as BaseCreature;
|
|
|
|
Server.Engines.XmlSpawner2.XmlAttach.AttachTo(bc, new Server.Engines.XmlSpawner2.XmlData("Notoriety", "red"));
|
|
|
|
if (SpawnMobile(bc, spawnrec))
|
|
{
|
|
list.Add(bc);
|
|
}
|
|
else
|
|
{
|
|
bc.Delete();
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
Invader invader = new Invader(this.InvasionType);
|
|
|
|
if (SpawnMobile(invader, spawnrec))
|
|
{
|
|
list.Add(invader);
|
|
}
|
|
else
|
|
invader.Delete();
|
|
}
|
|
|
|
InvaderCaptain capt = new InvaderCaptain(this.InvasionType);
|
|
capt.Blessed = true;
|
|
|
|
if (SpawnMobile(capt, spawnrec) || SpawnMobile(capt, new Rectangle2D(Defs[CurrentInvasion].BeaconLoc.X - 10, Defs[CurrentInvasion].BeaconLoc.Y - 10, 20, 20)))
|
|
{
|
|
Spawn[capt] = list;
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool SpawnMobile(BaseCreature bc, Rectangle2D spawnrec)
|
|
{
|
|
if (Map == null)
|
|
return false;
|
|
|
|
if (bc != null)
|
|
{
|
|
for (int i = 0; i < 25; i++)
|
|
{
|
|
Point3D p = this.Map.GetRandomSpawnPoint(spawnrec);
|
|
bool exempt = false;
|
|
|
|
if (spawnrec.X == 6444 && spawnrec.Y == 2446)
|
|
{
|
|
exempt = true;
|
|
p.Z = -2;
|
|
}
|
|
|
|
if (exempt || this.Map.CanFit(p.X, p.Y, p.Z, 16, false, false, true))
|
|
{
|
|
bc.MoveToWorld(p, this.Map);
|
|
bc.Home = Defs[CurrentInvasion].BeaconLoc;
|
|
bc.SeeksHome = true;
|
|
bc.RangeHome = Utility.RandomMinMax(5, 10);
|
|
bc.CanSwim = false;
|
|
bc.Tamable = false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void OnDeath(BaseCreature bc)
|
|
{
|
|
if (bc == null || bc.Controlled || bc.Summoned)
|
|
return;
|
|
|
|
if (Spawn.ContainsKey(bc))
|
|
{
|
|
Spawn.Remove(bc);
|
|
|
|
bool wavecomplete = true;
|
|
foreach (KeyValuePair<BaseCreature, List<BaseCreature>> kvp in Spawn)
|
|
{
|
|
if (kvp.Key != null && kvp.Key.Alive)
|
|
{
|
|
wavecomplete = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (wavecomplete)
|
|
CompleteWave();
|
|
}
|
|
else
|
|
{
|
|
foreach (KeyValuePair<BaseCreature, List<BaseCreature>> kvp in Spawn)
|
|
{
|
|
if (kvp.Value.Contains(bc))
|
|
kvp.Value.Remove(bc);
|
|
|
|
int count = kvp.Value.Where(b => b != null && b.Alive).Count();
|
|
|
|
if (count == 0 && kvp.Key.Alive)
|
|
{
|
|
kvp.Key.Blessed = false;
|
|
kvp.Key.Delta(MobileDelta.Noto);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void CleanupSpawn()
|
|
{
|
|
if (Spawn == null)
|
|
return;
|
|
|
|
List<BaseCreature> list = null;
|
|
|
|
foreach (KeyValuePair<BaseCreature, List<BaseCreature>> kvp in Spawn)
|
|
{
|
|
if (kvp.Value != null)
|
|
{
|
|
list = new List<BaseCreature>(kvp.Value);
|
|
|
|
foreach (BaseCreature b in list.Where(bc => bc == null || !bc.Alive || bc.Deleted))
|
|
kvp.Value.Remove(b);
|
|
}
|
|
|
|
if (list != null && list.Count > 0)
|
|
{
|
|
list.Clear();
|
|
list.TrimExcess();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CompleteWave()
|
|
{
|
|
if(CurrentWave == MaxWaves)
|
|
{
|
|
DoMessage();
|
|
}
|
|
else
|
|
{
|
|
DoMessage();
|
|
CurrentWave++;
|
|
}
|
|
}
|
|
|
|
private void DoMessage()
|
|
{
|
|
if (this.Map == null)
|
|
return;
|
|
|
|
IPooledEnumerable eable = this.Map.GetMobilesInRange(Beacon.Location, 20);
|
|
|
|
foreach (Mobile m in eable)
|
|
{
|
|
if (m != null && m.NetState != null)
|
|
m.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, 1154550, m.NetState); // *A sound roars in the distance...Minax's Beacon is vulnerable to attack!!*
|
|
}
|
|
|
|
eable.Free();
|
|
}
|
|
|
|
public void OnBeaconDestroyed()
|
|
{
|
|
OnEndInvasion();
|
|
|
|
Timer.DelayCall(TimeSpan.FromMinutes(2), () =>
|
|
{
|
|
Cleanup();
|
|
BeginInvasion();
|
|
});
|
|
}
|
|
|
|
public void OnEndInvasion()
|
|
{
|
|
if (Beacon != null)
|
|
{
|
|
List<Mobile> rights = Beacon.GetLootingRights();
|
|
|
|
if (rights != null)
|
|
{
|
|
foreach (Mobile damager in rights.Where(mob => mob.InRange(Beacon.Location, 12)))
|
|
{
|
|
if (0.15 < Utility.RandomDouble())
|
|
continue;
|
|
|
|
Item i = CreateItem(damager);
|
|
|
|
if (i != null)
|
|
{
|
|
damager.PlaySound(0x5B4);
|
|
damager.SendLocalizedMessage(1154554); // You recover an artifact bearing the crest of Minax from the rubble.
|
|
|
|
if (!damager.PlaceInBackpack(i))
|
|
{
|
|
if (damager.BankBox != null && damager.BankBox.TryDropItem(damager, i, false))
|
|
damager.SendLocalizedMessage(1079730); // The item has been placed into your bank box.
|
|
else
|
|
{
|
|
damager.SendLocalizedMessage(1072523); // You find an artifact, but your backpack and bank are too full to hold it.
|
|
i.MoveToWorld(damager.Location, damager.Map);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Item CreateItem(Mobile damager)
|
|
{
|
|
Item i = Loot.RandomArmorOrShieldOrWeaponOrJewelry(LootPackEntry.IsInTokuno(damager), LootPackEntry.IsMondain(damager), LootPackEntry.IsStygian(damager));
|
|
|
|
if (i != null)
|
|
{
|
|
RunicReforging.GenerateRandomItem(i, damager, Utility.RandomMinMax(700, 800), damager is PlayerMobile ? ((PlayerMobile)damager).RealLuck : 0, ReforgedPrefix.None, ReforgedSuffix.Minax);
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
public void Cleanup()
|
|
{
|
|
if (Beacon != null)
|
|
Beacon.Delete();
|
|
}
|
|
|
|
public void RemoveSpawn()
|
|
{
|
|
if (Spawn == null)
|
|
return;
|
|
|
|
Dictionary<BaseCreature, List<BaseCreature>> copy = Spawn;
|
|
Spawn = new Dictionary<BaseCreature, List<BaseCreature>>();
|
|
|
|
foreach (KeyValuePair<BaseCreature, List<BaseCreature>> kvp in copy)
|
|
{
|
|
foreach (BaseCreature bc in kvp.Value.Where(b => b.Alive))
|
|
bc.Kill();
|
|
|
|
if (kvp.Key.Alive)
|
|
{
|
|
kvp.Key.Blessed = false;
|
|
kvp.Key.Kill();
|
|
}
|
|
}
|
|
|
|
copy.Clear();
|
|
}
|
|
|
|
public InvasionController(Serial serial) : base(serial)
|
|
{
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write(0);
|
|
|
|
writer.Write((int)CurrentInvasion);
|
|
writer.Write((int)InvasionType);
|
|
writer.Write(Beacon);
|
|
writer.Write(CurrentWave);
|
|
|
|
writer.Write(SpawnZones == null ? 0 : SpawnZones.Count);
|
|
SpawnZones.ForEach(rec => writer.Write(rec));
|
|
|
|
writer.Write(Spawn == null ? 0 : Spawn.Count);
|
|
foreach(KeyValuePair<BaseCreature, List<BaseCreature>> kvp in Spawn)
|
|
{
|
|
writer.Write(kvp.Key);
|
|
writer.Write(kvp.Value.Count);
|
|
kvp.Value.ForEach(bc => writer.Write(bc));
|
|
}
|
|
|
|
Timer.DelayCall(TimeSpan.FromSeconds(30), CleanupSpawn);
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
|
|
Spawn = new Dictionary<BaseCreature, List<BaseCreature>>();
|
|
SpawnZones = new List<Rectangle2D>();
|
|
|
|
if(Map == Map.Trammel)
|
|
TramInstance = this;
|
|
|
|
if(Map == Map.Felucca)
|
|
FelInstance = this;
|
|
|
|
CurrentInvasion = (City)reader.ReadInt();
|
|
InvasionType = (InvasionType)reader.ReadInt();
|
|
Beacon = reader.ReadItem() as InvasionBeacon;
|
|
CurrentWave = reader.ReadInt();
|
|
|
|
if (Beacon != null)
|
|
Beacon.Controller = this;
|
|
|
|
int count = reader.ReadInt();
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
SpawnZones.Add(reader.ReadRect2D());
|
|
}
|
|
|
|
count = reader.ReadInt();
|
|
for(int i = 0; i < count; i++)
|
|
{
|
|
BaseCreature captain = reader.ReadMobile() as BaseCreature;
|
|
int c = reader.ReadInt();
|
|
|
|
List<BaseCreature> list = new List<BaseCreature>();
|
|
|
|
for(int j = 0; j < c; j++)
|
|
{
|
|
BaseCreature spawn = reader.ReadMobile() as BaseCreature;
|
|
|
|
if(spawn != null)
|
|
{
|
|
list.Add(spawn);
|
|
}
|
|
}
|
|
|
|
if(captain != null)
|
|
Spawn[captain] = list;
|
|
else
|
|
{
|
|
list.Clear();
|
|
}
|
|
}
|
|
|
|
Timer.DelayCall(TimeSpan.FromSeconds(10), () =>
|
|
{
|
|
if (Beacon == null || Beacon.Destroyed)
|
|
{
|
|
Timer.DelayCall(TimeSpan.FromMinutes(2), () =>
|
|
{
|
|
Cleanup();
|
|
BeginInvasion();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
if (TramInstance == null)
|
|
{
|
|
TramInstance = new InvasionController(Map.Trammel);
|
|
TramInstance.MoveToWorld(new Point3D(6359, 2570, 0), Map.Trammel);
|
|
}
|
|
|
|
if (FelInstance == null)
|
|
{
|
|
TramInstance = new InvasionController(Map.Felucca);
|
|
TramInstance.MoveToWorld(new Point3D(6359, 2570, 0), Map.Felucca);
|
|
}
|
|
|
|
Defs = new Dictionary<City, InvasionDefinition>();
|
|
|
|
Defs[City.Moonglow] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6314, 2571, 10, 5),
|
|
new Rectangle2D(6288, 2535, 8, 15),
|
|
new Rectangle2D(6322, 2527, 8, 8),
|
|
new Rectangle2D(6302, 2524, 10, 5),
|
|
},
|
|
new Point3D(6317, 2555, 0));
|
|
|
|
Defs[City.Britain] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6296, 2464, 7, 7),
|
|
new Rectangle2D(6332, 2473, 8, 10),
|
|
new Rectangle2D(6320, 2508, 3, 8),
|
|
new Rectangle2D(6287, 2494, 8, 8),
|
|
},
|
|
new Point3D(6316, 2477, 11));
|
|
|
|
Defs[City.Jhelom] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6450, 2465, 10, 8),
|
|
new Rectangle2D(6418, 2497, 15, 5),
|
|
new Rectangle2D(6417, 2469, 5, 10),
|
|
new Rectangle2D(6432, 2507, 10, 5),
|
|
},
|
|
new Point3D(6448, 2492, 5));
|
|
|
|
Defs[City.Yew] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6314, 2397, 12, 5),
|
|
new Rectangle2D(6317, 2440, 10, 10),
|
|
new Rectangle2D(6286, 2432, 8, 8),
|
|
new Rectangle2D(6289, 2405, 5, 5),
|
|
},
|
|
new Point3D(6305, 2423, 0));
|
|
|
|
Defs[City.Minoc] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6309, 2339, 10, 5),
|
|
new Rectangle2D(6290, 2367, 5, 10),
|
|
new Rectangle2D(6304, 2378, 10, 5),
|
|
new Rectangle2D(6323, 2344, 5, 10)
|
|
},
|
|
new Point3D(6307, 2362, 15));
|
|
|
|
Defs[City.Trinsic] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6356, 2371, 10, 10),
|
|
new Rectangle2D(6354, 2344, 5, 10),
|
|
new Rectangle2D(6366, 2344, 5, 7),
|
|
new Rectangle2D(6386, 2355, 8, 8),
|
|
},
|
|
new Point3D(6402, 2368, 25));
|
|
|
|
Defs[City.SkaraBrae] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6434, 2330, 10, 5),
|
|
new Rectangle2D(6456, 2342, 5, 10),
|
|
new Rectangle2D(6458, 2368, 15, 6),
|
|
new Rectangle2D(6440, 2384, 10, 3),
|
|
new Rectangle2D(6412, 2360, 12, 12),
|
|
},
|
|
new Point3D(6442, 2351, 0));
|
|
|
|
Defs[City.NewMagincia] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6426, 2397, 10, 5),
|
|
new Rectangle2D(6444, 2446, 10, 5),
|
|
new Rectangle2D(6436, 2395, 5, 8),
|
|
new Rectangle2D(6419, 2446, 10, 5),
|
|
},
|
|
new Point3D(6440, 2419, 26));
|
|
|
|
Defs[City.Vesper] = new InvasionDefinition(
|
|
new Rectangle2D[]
|
|
{
|
|
new Rectangle2D(6428, 2534, 10, 5),
|
|
new Rectangle2D(6458, 2534, 5, 10),
|
|
new Rectangle2D(6460, 2551, 5, 10),
|
|
new Rectangle2D(6433, 2561, 6, 6),
|
|
},
|
|
new Point3D(6444, 2553, 0));
|
|
}
|
|
}
|
|
}
|