public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var spell = trigger.Text.NextEnum(SpellId.None);
var reason = trigger.Text.NextEnum(SpellFailedReason.Interrupted);
//SpellHandler.SendCastFailed(trigger.Args.Target, trigger.Args.Character.Client, spell, reason);
trigger.Reply("Done.");
}
public override void Process(CmdTrigger<ToolCmdArgs> trigger)
{
var mod = trigger.Text.NextModifiers();
if (mod == "e")
{
WCellEnumWriter.WriteAllEnums();
}
else if (!mod.Contains("f") && VersionUpdater.WoWFile.Version <= WCellInfo.RequiredVersion)
{
trigger.Reply("WCell does already have the same or higher version as the given client: " +
WCellInfo.RequiredVersion);
trigger.Reply("Use the -f switch (force) to update again.");
}
else
{
var dumpDBCs = trigger.Text.NextBool() || !Directory.Exists(VersionUpdater.DBCFolder);
if (dumpDBCs)
{
trigger.Reply("Dumping DBC files...");
VersionUpdater.DumpDBCs();
}
trigger.Reply("Updating changes for client: {0} ...", VersionUpdater.WoWFile);
VersionUpdater.DoUpdate();
trigger.Reply("Done.");
}
}
/// <summary>
/// Returns the realm, specified by the next word or number, if the Realm could be found, else sends a reply.
/// </summary>
/// <param name="trigger"></param>
/// <returns></returns>
public static RealmEntry GetRealm(CmdTrigger<AuthServerCmdArgs> trigger)
{
var arg = trigger.Text.Remainder;
uint no;
var count = AuthenticationServer.RealmCount;
if (count > 0)
{
if (uint.TryParse(arg, out no))
{
if (count < no)
{
trigger.Reply("Invalid Realm Number - Must be between 1 and {0}", count);
}
else
{
return AuthenticationServer.GetRealmByNumber((int)no);
}
}
else
{
return AuthenticationServer.GetRealmByName(arg);
}
}
else
{
trigger.Reply("There are no registered Realms.");
}
return null;
}
public static InstancedRegion GetInstance(CmdTrigger<RealmServerCmdArgs> trigger)
{
if (!trigger.Text.HasNext)
{
trigger.Reply("No MapId specified.");
}
var mapId = trigger.Text.NextEnum(MapId.End);
if (mapId == MapId.End)
{
trigger.Reply("Invalid MapId.");
return null;
}
if (!trigger.Text.HasNext)
{
trigger.Reply("No Instance-Id specified.");
}
var id = trigger.Text.NextUInt();
var instance = World.GetInstance(mapId, id);
if (instance == null)
{
trigger.Reply("Instance does not exist: {0} (#{1})", mapId, id);
}
return instance;
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
string accName = trigger.Text.NextWord();
if (accName != null)
{
RealmAccount acc = ServerApp<RealmServer>.Instance.GetOrRequestAccount(accName);
if (acc != null)
{
if (acc.IsActive)
{
trigger.Reply("Account '" + acc.Name + "' is not banned.");
}
else
{
trigger.Reply(acc.StatusUntil.Value.ToLongDateString());
}
}
else
{
trigger.Reply("Account '" + accName + "' does not exist.");
}
}
else
{
trigger.Reply("Please include the account name.");
}
}
public override void Process(CmdTrigger<AuthServerCmdArgs> trigger)
{
trigger.Reply("Recreating Database Schema...");
DatabaseUtil.CreateSchema();
AccountMgr.Instance.ResetCache();
trigger.Reply("Done.");
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
if (trigger.Text.NextModifiers() == "f")
{
var bgId = trigger.Text.NextEnum(BattlegroundId.End);
if (bgId == BattlegroundId.End)
{
trigger.Reply("Invalid BattlegroundId.");
return;
}
List(trigger, BattlegroundMgr.GetInstances(bgId).Values);
}
else
{
var total = 0;
for (var i = 0; i < BattlegroundMgr.Instances.Length; i++)
{
var bgs = BattlegroundMgr.Instances[i];
if (bgs != null)
{
total += List(trigger, bgs.Values);
}
}
if (total == 0)
{
trigger.Reply("There are no active Battleground instances");
}
}
}
public override void Process(CmdTrigger<ToolCmdArgs> trigger)
{
var mod = trigger.Text.NextModifiers();
string dir;
if (mod == "a")
{
dir = DBCTool.FindWowDir(null);
}
else
{
dir = Path.GetFullPath(trigger.Text.Remainder);
if (trigger.Text.Remainder.EndsWith(".exe"))
{
dir = Path.GetDirectoryName(dir);
}
}
if (!Directory.Exists(dir))
{
trigger.Reply("Directory does not exist: " + dir);
}
else
{
ToolConfig.WoWDir = dir;
ToolConfig.Instance.Save();
VersionUpdater.SetWowDir(ToolConfig.WoWFileLocation);
trigger.Reply("Selected client: {0}", VersionUpdater.WoWFile);
}
}
public override void Process(CmdTrigger<AuthServerCmdArgs> trigger)
{
foreach (var line in AuthStats.Instance.GetFullStats())
{
trigger.Reply(line);
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var id = trigger.Text.NextEnum(SkillId.None);
var skillLine = SkillHandler.Get(id);
if (skillLine != null)
{
var chr = ((Character)trigger.Args.Target);
var amount = trigger.Text.NextInt(1);
//var max = Math.Max(trigger.Text.NextInt(1), amount);
var tier = skillLine.GetTierForLevel(amount);
var skill = chr.Skills.GetOrCreate(id, true);
skill.CurrentValue = (ushort)amount;
//skill.MaxValue = (ushort)skillLine.Tiers.GetMaxValue(tier);
var spell = skillLine.GetSpellForTier(tier);
if (spell != null)
{
chr.Spells.AddSpell(spell);
}
trigger.Reply(RealmLangKey.CmdSkillSetResponse, skillLine, amount, tier);
}
else
{
trigger.Reply(RealmLangKey.CmdSkillSetError, id);
}
}
public override void Process(CmdTrigger<AuthServerCmdArgs> trigger)
{
var open = trigger.Text.NextBool() | !IPCServiceHost.IsOpen;
if (open)
{
if (IPCServiceHost.IsOpen)
{
trigger.Reply("IPC Service already running - You need to close it before being able to re-open it.");
}
else
{
IPCServiceHost.StartService();
trigger.Reply("Done.");
}
}
else
{
if (!IPCServiceHost.IsOpen)
{
trigger.Reply("IPC Service is already closed.");
}
else
{
IPCServiceHost.StopService();
trigger.Reply("Done.");
}
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
bool newState;
var target = trigger.Args.Target;
if (target == trigger.Args.Character)
{
target = trigger.Args.Character.Target;
}
if (!(target is NPC))
{
trigger.Reply("Must target NPC.");
return;
}
var brain = target.Brain;
if (brain == null)
{
trigger.Reply(target.Name + " doesn't have a brain.");
return;
}
if (trigger.Text.HasNext)
{
newState = trigger.Text.NextBool();
}
else
{
newState = !brain.IsRunning;
}
brain.IsRunning = newState;
trigger.Reply(target.Name + "'s Brain is now: " + (newState ? "Activated" : "Deactivated"));
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var mod = trigger.Text.NextModifiers();
TimeSpan? duration = null;
if (mod == "t")
{
duration = trigger.Text.NextTimeSpan();
if (duration == null)
{
trigger.Reply("Invalid Duration specified {0}", EnglishParamInfo);
return;
}
}
var id = trigger.Text.NextUInt();
var worldEvent = WorldEventMgr.GetEvent(id);
if (worldEvent == null)
{
trigger.Reply("Invalid World Event {0} specified", id);
if (id == 0)
{
trigger.Reply("Usage:" + EnglishParamInfo);
}
return;
}
worldEvent.TimeUntilNextStart = TimeSpan.Zero;
worldEvent.TimeUntilEnd = duration ?? worldEvent.Duration;
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var chr = ((Character)trigger.Args.Target);
var xp = trigger.Text.NextInt(1);
chr.GainXp(xp);
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
foreach (var doSpell in SpellHandler.DOSpells.Values)
{
trigger.Reply("{0} (Id: {1})", doSpell.Name, doSpell.Id);
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var target = trigger.Args.Character;
var position = target.Position;
WorldMap.DumpMapTileChunk(target.RegionId, position);
trigger.Reply(String.Format("Region: {0}", target.Region));
var zone = target.Zone;
string zoneStr;
if (zone != null)
{
zoneStr = zone.Id.ToString();
while ((zone = zone.ParentZone) != null)
{
zoneStr += " in " + zone;
}
}
else
{
zoneStr = "<null>";
}
trigger.Reply(String.Format("Zone: {0}", zoneStr));
trigger.Reply(String.Format("Position X: {0}, Y: {1}, Z: {2}, O: {3}", target.Position.X, target.Position.Y,
target.Position.Z, target.Orientation));
trigger.Reply("Chunk Dumped.");
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var name = trigger.Text.NextWord();
var chr = trigger.Args.GetCharArgumentOrTarget(trigger, name);
var handler = trigger.Args.TicketHandler;
if (chr != null && chr.IsInWorld)
{
var ticket = chr.Ticket;
var oldHandler = ticket.Handler;
if (oldHandler != null && oldHandler.Role > handler.Role)
{
trigger.Reply("Ticket is already being handled by: " + oldHandler.Name);
}
else
{
if (oldHandler != null)
{
trigger.Reply("Taking over Ticket from: " + oldHandler.Name);
oldHandler.SendMessage("The Ticket you were handling by " + ticket.Owner + " is now handled by: " + handler);
}
ticket.Handler = handler;
}
}
else
{
trigger.Reply("Selected player is offline or does not exist: " + name);
}
}
public void RemoveSelectedFiles(CmdTrigger<ToolCmdArgs> trigger, IEnumerable<string> parts)
{
List<int> indices = null;
int index;
foreach (var part in parts)
{
if (int.TryParse(part, out index))
{
if (indices == null)
{
indices = new List<int>();
}
indices.Add(index);
}
else
{
if (!PATool.RemoveSelectedFile(part.Trim()))
{
trigger.Reply(" File was not selected: " + part.Trim());
}
}
}
if (indices != null)
{
if (!PATool.RemoveSelectedFiles(indices.ToArray()))
{
trigger.Reply(" One or more indices were invalid: " + indices.ToString(", "));
}
}
trigger.Reply("Done - Selected files:");
DisplaySelectedFiles(trigger, " ");
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var email = trigger.Text.NextWord();
if (!Utility.IsValidEMailAddress(email))
{
trigger.Reply("Invalid Mail address.");
}
else
{
trigger.Reply("Setting mail address to " + email + "...");
RealmServer.Instance.AddMessage(new Message(() =>
{
var chr = ((Character)trigger.Args.Target);
if (chr.Account.SetEmail(email))
{
trigger.Reply("Done.");
}
else
{
trigger.Reply("Could not change email-address.");
}
}));
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var curChar = trigger.Args.Character;
var target = trigger.Args.SelectedUnitOrGO;
float? dist;
if (target != null)
{
dist = curChar.Region.Terrain.QueryWMOCollision(curChar.Position, target.Position);
}
else
{
var targetPos = new Vector3(curChar.Position.X + 10.0f, curChar.Position.Y + 10.0f, curChar.Position.Z);
dist = curChar.Region.Terrain.QueryWMOCollision(curChar.Position, targetPos);
}
if (dist == null)
{
trigger.Reply("Has LOS.");
}
else
{
trigger.Reply("No LOS");
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var mods = trigger.Text.NextModifiers();
var entry = trigger.Text.NextEnum(ItemId.None);
var templ = ItemMgr.GetTemplate(entry);
if (templ == null)
{
trigger.Reply("Invalid ItemId.");
return;
}
if (templ.IsCharter)
{
trigger.Reply("Charters cannot be added by command.");
return;
}
var amount = trigger.Text.NextInt(1);
var stacks = trigger.Text.NextUInt(1);
var ensure = mods.Contains("e");
var autoEquip = mods.Contains("a");
for (var i = 0; i < stacks; i++)
{
if (!AddItem((Character)trigger.Args.Target, templ, amount, autoEquip, ensure))
{
break;
}
}
//trigger.Reply("{0}/{1} stacks of {2} created{3}", x, stacks, templ, err == InventoryError.OK ? "." : ": " + err);
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
foreach (var dynObj in SpellHandler.StaticDOs.Values)
{
dynObj.Delete();
}
SpellHandler.StaticDOs.Clear();
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var target = trigger.Args.Target;
if (target != null)
{
target.Resurrect();
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
World.ExecuteWhilePaused(() =>
{
RealmLocalizer.Instance.Resync();
});
trigger.Reply(RealmLangKey.Done);
}
Guild CreateGuild(CmdTrigger<RealmServerCmdArgs> trigger, string name, CharacterRecord record)
{
var guild = new Guild(record, name);
trigger.Reply("Guild created");
return guild;
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
Map map;
if (trigger.Text.HasNext)
{
var mod = trigger.Text.NextModifiers();
if (mod == "a")
{
// spawn all
SpawnAllMaps(trigger);
trigger.Reply(RealmLangKey.CmdMapSpawnResponse1);
return;
}
else
{
var mapId = trigger.Text.NextEnum(MapId.End);
map = World.GetNonInstancedMap(mapId);
if (map == null)
{
trigger.Reply(RealmLangKey.CmdMapSpawnError1);
return;
}
}
}
else
{
if (trigger.Args.Target == null)
{
trigger.Reply(RealmLangKey.CmdMapSpawnError2);
return;
}
map = trigger.Args.Target.Map;
}
if (map.IsSpawned)
{
trigger.Reply(RealmLangKey.CmdMapSpawnError3);
}
else
{
trigger.Reply(RealmLangKey.CmdMapSpawnResponse2, map.Name);
if (!GOMgr.Loaded)
{
trigger.Reply(RealmLangKey.CmdMapSpawnError4);
}
if (!NPCMgr.Loaded)
{
trigger.Reply(RealmLangKey.CmdMapSpawnError5);
}
map.AddMessage(() =>
{
map.SpawnMap();
trigger.Reply(RealmLangKey.CmdMapSpawnResponse3, map);
});
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
Region region;
if (trigger.Text.HasNext)
{
var mod = trigger.Text.NextModifiers();
if (mod == "a")
{
// spawn all
SpawnAllRegions(trigger);
trigger.Reply("All regions spawned.");
return;
}
else
{
var regionId = trigger.Text.NextEnum(MapId.End);
region = World.GetRegion(regionId);
if (region == null)
{
trigger.Reply("Invalid Region.");
return;
}
}
}
else
{
if (trigger.Args.Target == null)
{
trigger.Reply("You did not specify the Region to be spawned.");
return;
}
region = trigger.Args.Target.Region;
}
if (region.IsSpawned)
{
trigger.Reply("Region " + region + " is already spawned.");
}
else
{
trigger.Reply("Spawning {0}...", region.Name);
if (!GOMgr.Loaded)
{
trigger.Reply("No GOs will be spawned (Use 'Load GOs' before spawning)");
}
if (!NPCMgr.Loaded)
{
trigger.Reply("No NPCs will be spawned (Use 'Load NPCs' before spawning)");
}
region.AddMessage(() =>
{
region.SpawnRegion();
trigger.Reply("Spawned region " + region);
});
}
}
public override void Process(CmdTrigger<RealmServerCmdArgs> trigger)
{
var chr = trigger.Args.Character;
if (chr == null)
{
trigger.Reply("Cannot read Mails if no Character is given (yet).");
}
chr.Mail.SendMailList();
}
public void Dump(CmdTrigger<ToolCmdArgs> trigger)
{
DumpSpellsCommand.Dump(trigger);
DumpNPCsCommand.Dump(trigger);
DumpGOsCommand.Dump(trigger);
DumpItemsCommand.Dump(trigger);
DumpQuestsCommand.Dump(trigger);
DumpATsCommand.Dump(trigger);
}
public override void Process(CmdTrigger<AuthServerCmdArgs> trigger)
{
var realm = GetRealm(trigger);
if (realm != null)
{
realm.Disconnect(true);
trigger.Reply("Deleted Realm {0}", realm);
}
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
((Character)trigger.Args.Target).OpenBank((WorldObject)trigger.Args.Character);
}
/// <summary>
/// Sets the Character of this trigger, according to the -a or -c switch, followed by the account- or character-name
/// </summary>
/// <param name="mod"></param>
/// <returns></returns>
public static Character GetCharacter(this CmdTrigger <RealmServerCmdArgs> trigger, string mod)
{
RealmServerCmdArgs args = trigger.Args;
Character character = (Character)null;
RoleGroup role = args.Role;
bool flag1 = mod.Contains("a");
bool flag2 = mod.Contains("c");
if (flag1 || flag2)
{
if (flag1 && flag2)
{
trigger.Reply("Invalid command-switch, cannot use -a and -c switch at the same time.");
}
else
{
if ((object)role != null && !role.CanUseCommandsOnOthers)
{
trigger.Reply("You may not use the -c or -a command-switch!");
}
string name = trigger.Text.NextWord();
if (flag1)
{
RealmAccount loggedInAccount =
ServerApp <WCell.RealmServer.RealmServer> .Instance.GetLoggedInAccount(name);
if (loggedInAccount == null || (character = loggedInAccount.ActiveCharacter) == null)
{
trigger.Reply("Account {0} is not online.", (object)name);
}
}
else
{
character = World.GetCharacter(name, false);
if (character == null)
{
trigger.Reply("Character {0} is not online.", (object)name);
}
}
if (character != null)
{
if ((object)role == null || !(character.Account.Role > role))
{
return(character);
}
if (flag1)
{
trigger.Reply("Account {0} is not online.", (object)name);
}
else if (character.Stealthed == 0)
{
trigger.Reply("Cannot use this Command on {0}.", (object)character.Name);
}
else
{
trigger.Reply("Character {0} is not online.", (object)name);
}
}
}
}
else
{
trigger.Reply("Invalid Command-Switch: " + mod);
}
return((Character)null);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
SetCommand.Set(trigger, trigger.EvalNextOrTargetOrUser());
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping AreaTriggers...");
ATOutput.DumpToFile();
trigger.Reply("Dumped AreaTriggers to: " + ATOutput.DumpFile);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
this.ProcessNth(trigger);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
trigger.Args.Target.Yell(trigger.Text.Remainder.Trim());
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping NPCs...");
NPCOutput.WriteNPCs();
trigger.Reply("Dumped NPCs to: " + NPCOutput.DumpFile);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
((Character)trigger.Args.Target).ResetOwnWorld();
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
World.Broadcast("Saving world...");
World.Save(false);
World.Broadcast("World saved.");
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
trigger.Reply("Not yet implemented - Use \"Map Spawn\" instead");
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
if (WCell.RealmServer.Global.World.CharacterCount == 0)
{
trigger.Reply("There are no characters online.");
}
else
{
string str1 = trigger.Text.NextModifiers();
List <Character> characterList;
if (str1.Contains("r"))
{
Map nonInstancedMap =
WCell.RealmServer.Global.World.GetNonInstancedMap(trigger.Text.NextEnum <MapId>(MapId.End));
if (nonInstancedMap != null)
{
characterList = new List <Character>(nonInstancedMap.CharacterCount);
characterList.AddRange((IEnumerable <Character>)nonInstancedMap.Characters);
}
else
{
trigger.Reply("Invalid map id.");
return;
}
}
else
{
characterList = WCell.RealmServer.Global.World.GetAllCharacters();
}
if (str1.Contains("f"))
{
FactionId factionId = trigger.Text.NextEnum <FactionId>(FactionId.End);
switch (factionId)
{
case FactionId.None:
case FactionId.End:
trigger.Reply("Invalid FactionID.");
return;
default:
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (character.FactionId != factionId)
{
characterList.Remove(character);
}
}
break;
}
}
if (str1.Contains("c"))
{
ClassId classId = trigger.Text.NextEnum <ClassId>(ClassId.End);
if (classId == ClassId.End)
{
trigger.Reply("Invalid class.");
return;
}
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (character.Class != classId)
{
characterList.Remove(character);
}
}
}
if (str1.Contains("n"))
{
string str2 = trigger.Text.NextWord();
if (str2.Length > 1)
{
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (!character.Name.Contains(str2))
{
characterList.Remove(character);
}
}
}
else
{
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (!character.Name.StartsWith(str2))
{
characterList.Remove(character);
}
}
}
}
if (str1.Contains("a"))
{
string str2 = trigger.Text.NextWord();
if (str2.Length > 1)
{
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (!character.Account.Name.Contains(str2))
{
characterList.Remove(character);
}
}
}
else
{
for (int index = characterList.Count - 1; index >= 0; --index)
{
Character character = characterList[index];
if (!character.Name.StartsWith(str2))
{
characterList.Remove(character);
}
}
}
}
if (characterList.Count == WCell.RealmServer.Global.World.CharacterCount)
{
trigger.Reply("All Online Players:");
}
else if (characterList.Count == 0)
{
trigger.Reply("No players match the given conditions.");
}
else
{
trigger.Reply("Matching Players:");
}
foreach (Character character in characterList)
{
trigger.Reply(character.ToString());
}
}
}
/// <summary>
/// Returns one of the possible values: EvalNext if next argument is in parentheses, else target ?? user
/// </summary>
public static object EvalNextOrTargetOrUser(this CmdTrigger <RealmServerCmdArgs> trigger)
{
return(trigger.EvalNext <object>((object)trigger.Args.Target ?? (object)trigger.Args.User));
}
public override void Process(CmdTrigger <ToolCmdArgs> trigger)
{
Dump(trigger);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
string str = trigger.Text.NextModifiers();
string name = "";
if (str.Contains("n"))
{
name = trigger.Text.NextWord();
}
Unit target = trigger.Args.Target;
if (target == null)
{
trigger.Reply("No target found.");
}
else
{
Map rgn = target.Map;
if (rgn == null)
{
trigger.Reply("Instances are currently not supported.");
}
else
{
NPC npc = (NPC)null;
rgn.ExecuteInContext((Action)(() =>
{
foreach (WorldObject worldObject in rgn)
{
if (worldObject is NPC && (name == "" || worldObject.Name.ContainsIgnoreCase(name)))
{
npc = (NPC)worldObject;
break;
}
}
}));
if (npc == null)
{
trigger.Reply("Could not find a matching NPC.");
}
else
{
Character character = trigger.Args.Character;
if (trigger.Args.HasCharacter)
{
if (name == "" && character.Target != null)
{
if (character.Target is NPC)
{
npc = character.Target as NPC;
}
else
{
character.Target = (Unit)npc;
}
}
else
{
character.Target = (Unit)npc;
}
}
else
{
trigger.Args.Target = (Unit)npc;
trigger.Args.Context = (IContextHandler)npc;
}
trigger.Reply("Selected: {0}", (object)npc);
NPCFlags npcFlags = npc.NPCFlags;
trigger.Reply("NPCFlags {0}:{1}", (object)npcFlags, (object)npcFlags);
UnitDynamicFlags dynamicFlags = npc.DynamicFlags;
trigger.Reply("DynamicFlags {0}:{1}", (object)dynamicFlags, (object)dynamicFlags);
UnitExtraFlags extraFlags = npc.ExtraFlags;
trigger.Reply("ExtraFlags {0}:{1}", (object)extraFlags, (object)extraFlags);
StateFlag stateFlags = npc.StateFlags;
trigger.Reply("StateFlags {0}:{1}", (object)stateFlags, (object)stateFlags);
UnitFlags unitFlags = npc.UnitFlags;
trigger.Reply("UnitFlags {0}:{1}", (object)unitFlags, (object)(int)unitFlags);
UnitFlags2 unitFlags2 = npc.UnitFlags2;
trigger.Reply("UnitFlags2 {0}:{1}", (object)unitFlags2, (object)unitFlags2);
}
}
}
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping GOs...");
GOOutput.WriteGOs();
trigger.Reply("Dumped GOs to: " + GOOutput.DumpFile);
}
public static NPCSpawnEntry GetNPCSpawnEntry(CmdTrigger <RealmServerCmdArgs> trigger, bool closest, out Map map)
{
Unit target = trigger.Args.Target;
map = (Map)null;
NPCSpawnEntry npcSpawnEntry;
if (closest)
{
if (target == null)
{
trigger.Reply("Cannot use the -c switch without active Target.");
return((NPCSpawnEntry)null);
}
npcSpawnEntry = NPCMgr.GetClosestSpawnEntry((IWorldLocation)target);
if (npcSpawnEntry == null)
{
trigger.Reply("No Spawnpoint found.");
return((NPCSpawnEntry)null);
}
}
else
{
string str = trigger.Text.NextWord();
NPCId result1;
if (!EnumUtil.TryParse <NPCId>(str, out result1))
{
uint result2;
uint.TryParse(str, out result2);
npcSpawnEntry = NPCMgr.GetSpawnEntry(result2);
if (npcSpawnEntry == null)
{
trigger.Reply("Invalid SpawnId: " + (object)result2);
return((NPCSpawnEntry)null);
}
}
else
{
NPCEntry entry = NPCMgr.GetEntry(result1);
if (entry == null)
{
trigger.Reply("Entry not found: " + (object)result1);
return((NPCSpawnEntry)null);
}
if (entry.SpawnEntries.Count == 0)
{
trigger.Reply("Entry has no SpawnEntries: " + (object)entry);
return((NPCSpawnEntry)null);
}
npcSpawnEntry = target != null
? entry.SpawnEntries.GetClosestSpawnEntry((IWorldLocation)target)
: entry.SpawnEntries.First <NPCSpawnEntry>();
}
}
map = npcSpawnEntry.Map;
if (map == null)
{
if (target != null && npcSpawnEntry.MapId == target.MapId)
{
map = target.Map;
}
else if (WCell.RealmServer.Global.World.IsInstance(npcSpawnEntry.MapId))
{
map = (Map)InstanceMgr.CreateInstance(target as Character, npcSpawnEntry.MapId);
if (map == null)
{
trigger.Reply("Failed to create instance: " + (object)npcSpawnEntry.MapId);
return((NPCSpawnEntry)null);
}
}
else
{
trigger.Reply("Cannot spawn NPC for map: " + (object)npcSpawnEntry.MapId);
return((NPCSpawnEntry)null);
}
}
return(npcSpawnEntry);
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping Spells...");
SpellOutput.WriteSpellsAndEffects();
trigger.Reply("Dumped Spells to: " + SpellOutput.DumpFile);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
string str1 = trigger.Text.NextModifiers();
string name = "";
if (str1.Contains("n"))
{
name = trigger.Text.NextWord();
}
Map rgn;
if (str1.Contains("d"))
{
string str2 = trigger.Text.NextWord();
INamedWorldZoneLocation worldZoneLocation = WorldLocationMgr.Get(str2);
if (worldZoneLocation == null)
{
MapId result;
rgn = !EnumUtil.TryParse <MapId>(str2, out result)
? (Map)null
: WCell.RealmServer.Global.World.GetNonInstancedMap(result);
if (rgn == null)
{
trigger.Reply("Invalid Destination: " + str2);
return;
}
}
else
{
rgn = worldZoneLocation.Map;
}
}
else
{
Unit target = trigger.Args.Target;
if (target == null)
{
trigger.Reply("Must have target or specify destination (using the -d switch).");
return;
}
rgn = target.Map;
int phase = (int)target.Phase;
}
if (rgn == null)
{
trigger.Reply("Instance-destinations are currently not supported.");
}
else
{
NPC npc = (NPC)null;
rgn.ExecuteInContext((Action)(() =>
{
foreach (WorldObject worldObject in rgn)
{
if (worldObject is NPC && (name == "" || worldObject.Name.ContainsIgnoreCase(name)))
{
npc = (NPC)worldObject;
break;
}
}
if (npc == null)
{
trigger.Reply("Could not find a matching NPC.");
}
else
{
Character character = trigger.Args.Character;
if (trigger.Args.HasCharacter)
{
if (name == "" && character.Target != null)
{
if (character.Target is NPC)
{
npc = character.Target as NPC;
}
else
{
character.Target = (Unit)npc;
}
}
else
{
character.Target = (Unit)npc;
}
}
else
{
trigger.Args.Target = (Unit)npc;
trigger.Args.Context = (IContextHandler)npc;
}
trigger.Reply("Selected: {0}", (object)npc);
}
}));
}
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping Quests...");
QuestOutput.WriteAllQuests();
trigger.Reply("Dumped Quests to: " + QuestOutput.DumpFile);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
string str1 = trigger.Text.NextModifiers();
string name = (string)null;
if (str1.Contains("d"))
{
name = trigger.Text.NextWord();
}
if (str1.Contains("r"))
{
NPC target = trigger.Args.Target as NPC;
if (target == null)
{
trigger.Reply("Wrong target.");
}
else
{
EntityId entityId = target.EntityId;
NPCSpawnEntry spawnEntry = target.SpawnEntry;
spawnEntry.CommitDeleteAndFlush();
trigger.Reply("Monstr {0} deleted from spawn.", (object)spawnEntry);
}
}
else
{
NPCId id = trigger.Text.NextEnum <NPCId>(NPCId.End);
if (id == NPCId.End)
{
trigger.Reply("Invalid NPC.");
}
else
{
uint num1 = trigger.Text.NextUInt(1U);
if (num1 < 1U)
{
trigger.Reply("Invalid amount: " + (object)num1);
}
else
{
string str2 = (string)null;
NPCEntry entry = NPCMgr.GetEntry(id);
if (entry == null)
{
trigger.Reply("Invalid NPCId: " + (object)id);
}
else
{
IWorldLocation target;
if (!string.IsNullOrEmpty(name))
{
target = (IWorldLocation)WorldLocationMgr.Get(name);
if (target == null)
{
trigger.Reply("Invalid destination: " + name);
return;
}
}
else
{
if (trigger.Args.Target == null)
{
trigger.Reply("No destination given.");
return;
}
target = (IWorldLocation)trigger.Args.Target;
}
int num2 = 1;
int x1 = -num2;
int y1 = -num2;
int num3 = 8;
long num4 = (long)num1 + (long)num3;
int num5 = 0;
while (true)
{
while (y1 > num2 || (long)num5++ >= num4)
{
int y2 = num2;
int x2 = x1 + 1;
if ((long)num5 < num4)
{
for (; x2 <= num2 && (long)num5++ < num4; ++x2)
{
if (num3 < num5)
{
this.SpawnMob(x2, y2, entry, target);
}
}
int x3 = num2;
int y3 = y2 - 1;
if ((long)num5 < num4)
{
for (; y3 >= -num2 && (long)num5++ < num4; --y3)
{
if (num3 < num5)
{
this.SpawnMob(x3, y3, entry, target);
}
}
y1 = -num2;
x1 = x3 - 1;
if ((long)num5 < num4)
{
for (; x1 >= -num2; --x1)
{
if (x1 == -num2)
{
++num2;
x1 = -num2;
y1 = -num2;
break;
}
if ((long)num5++ < num4)
{
if (num3 < num5)
{
this.SpawnMob(x1, y1, entry, target);
}
}
else
{
break;
}
}
if ((long)num5 < num4)
{
continue;
}
}
}
}
trigger.Reply("Created {0}.", (object)str2);
return;
}
if (num3 < num5)
{
this.SpawnMob(x1, y1, entry, target);
}
++y1;
}
}
}
}
}
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
trigger.Args.Target.Auras.ClearVisibleAuras();
trigger.Reply("All visible Auras removed.");
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
trigger.Args.Character.SetClass((int)trigger.Args.Character.RealProffLevel,
(int)trigger.Args.Character.Archetype.ClassId);
trigger.Reply("Repaired.");
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
BattlegroundJoinError err = trigger.Text.NextEnum <BattlegroundJoinError>(BattlegroundJoinError.None);
BattlegroundHandler.SendBattlegroundError((IPacketReceiver)trigger.Args.Character, err);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
Asda2LootMgr.EnableLuckyDropEvent();
trigger.Reply("done");
}
public static void Dump(CmdTrigger <ToolCmdArgs> trigger)
{
trigger.Reply("Dumping Items...");
ItemOutput.WriteAllItemInfo();
trigger.Reply("Dumped Items to: " + ItemOutput.DefaultDumpFile);
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
trigger.Reply("Sorry, someone forgot to add IP banning via RealmServer to WCell. Will be implemented soon :P");
//TODO: Finish this when someone implements it
}
public override object Eval(CmdTrigger <RealmServerCmdArgs> trigger)
{
return(Eval(trigger, false));
}
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
((Character)trigger.Args.Target).Reputations.LoveAll();
trigger.Reply("Everyone loves {0} now.", (object)trigger.Args.Target);
}
public static void ReplyFormat(this CmdTrigger <RealmServerCmdArgs> trigger, RealmLangKey key,
params object[] args)
{
trigger.ReplyFormat(RealmLocalizer.Instance.Translate(trigger.GetLocale(), key, args));
}
