protected virtual void OnConfirmCreateBattle(GumpButton button)
{
if (Selected == null)
{
Close();
return;
}
PvPBattle battle = AutoPvP.CreateBattle(Selected);
if (UseConfirmDialog)
{
Send(
new ConfirmDialogGump(
User,
Refresh(true),
title: "View New Battle?",
html: "Your new battle has been created.\nDo you want to view it now?",
onAccept: b => Send(new PvPBattleOverviewGump(User, Hide(true), battle))));
}
else
{
Send(new PvPBattleOverviewGump(User, Hide(true), battle));
}
}
public static void InvokeBattleWorldBroadcast(PvPBattle battle, string message)
{
if (OnBattleWorldBroadcast != null)
{
OnBattleWorldBroadcast(battle, message);
}
}
public void Subscribe(PvPBattle battle)
{
if (battle != null && !battle.Deleted && battle.State != PvPBattleState.Internal)
{
Subscriptions.AddOrReplace(battle);
}
}
private static Tuple <PvPSerial, PvPBattle> DeserializeBattle(GenericReader reader)
{
PvPSerial key = null;
PvPBattle val = null;
int version = reader.GetVersion();
switch (version)
{
case 0:
{
reader.ReadBlock(() => key = reader.ReadTypeCreate <PvPSerial>(reader));
reader.ReadBlock(() => val = reader.ReadTypeCreate <PvPBattle>(reader));
}
break;
}
if (key == null)
{
if (val != null && val.Serial != null)
{
key = val.Serial;
}
else
{
return(null);
}
}
return(new Tuple <PvPSerial, PvPBattle>(key, val));
}
private static bool SerializeBattle(GenericWriter writer, PvPSerial key, PvPBattle val)
{
int version = writer.SetVersion(0);
switch (version)
{
case 0:
{
writer.WriteBlock(
() => writer.WriteType(
key,
t =>
{
if (t != null)
{
key.Serialize(writer);
}
}));
writer.WriteBlock(
() => writer.WriteType(
val,
t =>
{
if (t != null)
{
val.Serialize(writer);
}
}));
}
break;
}
return(true);
}
public static void InvokeExitBattle(PvPBattle battle, PvPRegion region, Mobile m)
{
if (OnExitBattle != null)
{
OnExitBattle(battle, region, m);
}
}
public void Subscribe(PvPBattle battle)
{
if (battle != null && !battle.Deleted && !battle.IsInternal)
{
Subscriptions.Update(battle);
}
}
public static void InvokeQueueUpdate(PvPBattle battle, PvPTeam team, PlayerMobile m)
{
if (OnQueueUpdate != null)
{
OnQueueUpdate(battle, team, m);
}
}
private static void CMDisabled()
{
InternalizeAllBattles();
PvPBattle.Unbind();
BattleNotoriety.Disable();
}
public void Unsubscribe(PvPBattle battle)
{
if (battle != null && !battle.Deleted)
{
Subscriptions.Remove(battle);
}
}
public static void InvokeBattleStateChanged(PvPBattle battle)
{
if (OnBattleStateChanged != null)
{
OnBattleStateChanged(battle);
}
}
public static bool AllowHarmful(Mobile a, Mobile b)
{
if (_HarmfulParent == null)
{
return(NotorietyHandlers.Mobile_AllowHarmful(a, b));
}
if (a == null || a.Deleted || b == null || b.Deleted || a == b)
{
return(_HarmfulParent(a, b));
}
if (a is PlayerMobile && b is PlayerMobile)
{
PlayerMobile x = (PlayerMobile)a, y = (PlayerMobile)b;
PvPBattle battleA = AutoPvP.FindBattle(x), battleB = AutoPvP.FindBattle(y);
if (battleA == null || battleA.Deleted || battleB == null || battleB.Deleted || battleA != battleB || x == y)
{
return(_HarmfulParent(x, y));
}
var battle = battleA;
if (_HarmfulHandlers.ContainsKey(battle) && _HarmfulHandlers[battle] != null)
{
return(_HarmfulHandlers[battle](x, y));
}
}
return(_HarmfulParent(a, b));
}
public PvPBattleCommandState(PvPBattle battle, PlayerMobile from, string command, string[] args)
{
Battle = battle;
Mobile = from;
Command = command;
Args = args;
Speech = String.Join(" ", args);
}
public double ComputeScorePotential(PvPBattle b, PlayerMobile p)
{
double min = 0, max = 0, total = 0;
ComputeScore(b, p, ref min, ref max, ref total);
return(total);
}
public PvPBattleCommandState(PvPBattle battle, PlayerMobile from, string command, string[] args)
{
Battle = battle;
Mobile = from;
Command = command;
Args = args;
Speech = String.Join(" ", args);
}
public PvPTeamListGump(Mobile user, PvPBattle battle, Gump parent = null, bool useConfirm = true)
: base(user, parent, emptyText: "There are no battles to display.", title: "PvP Teams")
{
Battle = battle;
UseConfirmDialog = useConfirm;
ForceRecompile = true;
}
private static void CMInvoke()
{
PvPBattle.Bind();
BattleNotoriety.Enable();
var scenarios = new List <PvPScenario>();
foreach (var type in BattleTypes.Where(t => t != null))
{
VitaNexCore.TryCatch(
() =>
{
var battle = type.CreateInstanceSafe <PvPBattle>();
if (battle == null)
{
throw new Exception("PvPBattle Type could not be constructed, requires a constructor with 0 arguments.");
}
PvPScenario scenario = battle;
scenarios.Add(scenario);
battle.Delete();
CMOptions.ToConsole("Created scenario ({0}) '{1}'", scenario.TypeOf.Name, scenario.Name);
},
CMOptions.ToConsole);
}
Scenarios = scenarios.ToArray();
scenarios.Clear();
foreach (var battle in Battles.Values.Where(b => b != null && !b.Deleted).ToArray())
{
VitaNexCore.TryCatch(
battle.Init,
ex =>
{
VitaNexCore.TryCatch(battle.Delete);
CMOptions.ToConsole("Failed to initialize battle #{0} '{1}'", battle.Serial, battle.Name);
CMOptions.ToConsole(ex);
});
}
foreach (var profile in Profiles.Values.Where(p => p != null && !p.Deleted).ToArray())
{
VitaNexCore.TryCatch(
profile.Init,
ex =>
{
VitaNexCore.TryCatch(profile.Delete);
CMOptions.ToConsole("Failed to initialize profile #{0} '{1}'", profile.Owner.Serial.Value, profile.Owner.RawName);
CMOptions.ToConsole(ex);
});
}
}
public virtual bool Completed(PvPBattle battle, PlayerMobile player)
{
if (!Enabled || Player.IsEmpty)
{
return(false);
}
return(Player.Completed(battle, player));
}
public virtual double ComputeScore(PvPBattle battle, PlayerMobile player)
{
if (!Enabled || Player.IsEmpty)
{
return(0);
}
return(Player.ComputeScore(battle, player));
}
public virtual string GetStatus(PvPBattle battle, PlayerMobile player)
{
if (!Enabled || Player.IsEmpty)
{
return(String.Empty);
}
return(Player.GetStatus(battle, player));
}
public void Unsubscribe(PvPBattle battle)
{
if (battle == null || battle.Deleted || !IsSubscribed(battle))
{
return;
}
Subscriptions.Remove(battle);
}
public PvPRegion(PvPBattle battle, string name, params Rectangle3D[] bounds)
: base(
name,
battle.Options.Locations.Map,
battle.Options.Locations.BattlePriority,
(bounds ?? new Rectangle3D[0]).ZFix().ToArray())
{
Battle = battle;
}
public void Subscribe(PvPBattle battle)
{
if (battle == null || battle.Deleted || battle.State == PvPBattleState.Internal || IsSubscribed(battle))
{
return;
}
Subscriptions.Add(battle);
}
public PvPRegion(PvPBattle battle, string name, params Rectangle3D[] bounds)
: base(
name,
battle.Options.Locations.Map,
battle.Options.Locations.BattlePriority,
(bounds ?? new Rectangle3D[0]).ZFix().ToArray())
{
Battle = battle;
}
public PvPTeam(PvPBattle battle, GenericReader reader)
: this(true)
{
Battle = battle;
Deserializing = true;
Deserialize(reader);
Deserializing = false;
}
public PvPSpectatorGate(PvPBattle battle)
{
Battle = battle;
Name = "PvP Battle Gate";
ItemID = 19343;
Hue = 51;
Visible = true;
Movable = false;
}
public static void RegisterNotorietyHandler(PvPBattle battle, BattleNotorietyHandler <int> handler)
{
if (!_NameHandlers.ContainsKey(battle))
{
_NameHandlers.Add(battle, handler);
}
else
{
_NameHandlers[battle] = handler;
}
}
public static void RegisterNotorietyHandler(PvPBattle battle, BattleNotorietyHandler<int> handler)
{
if (!_NameHandlers.ContainsKey(battle))
{
_NameHandlers.Add(battle, handler);
}
else
{
_NameHandlers[battle] = handler;
}
}
public static void RegisterAllowBeneficialHandler(PvPBattle battle, BattleNotorietyHandler<bool> handler)
{
if (!_BeneficialHandlers.ContainsKey(battle))
{
_BeneficialHandlers.Add(battle, handler);
}
else
{
_BeneficialHandlers[battle] = handler;
}
}
public static void RegisterAllowHarmfulHandler(PvPBattle battle, BattleNotorietyHandler <bool> handler)
{
if (!_HarmfulHandlers.ContainsKey(battle))
{
_HarmfulHandlers.Add(battle, handler);
}
else
{
_HarmfulHandlers[battle] = handler;
}
}
public static PvPBattle CreateBattle(PvPScenario scenario)
{
if (scenario == null)
{
return(null);
}
PvPBattle battle = scenario.CreateBattle();
Battles.Add(battle.Serial, battle);
battle.Init();
return(battle);
}
public PvPBattle CreateBattle()
{
PvPBattle battle = Activator.CreateInstance(_TypeOf) as PvPBattle;
foreach (PvPProfile profile in AutoPvP.Profiles.Values)
{
if (!profile.IsSubscribed(battle))
{
profile.Subscribe(battle);
}
}
return(battle);
}
private static bool SerializeBattle(GenericWriter writer, PvPSerial key, PvPBattle val)
{
var version = writer.SetVersion(0);
switch (version)
{
case 0:
{
writer.WriteBlock(w => w.WriteType(key, t => key.Serialize(w)));
writer.WriteBlock(w => w.WriteType(val, t => val.Serialize(w)));
}
break;
}
return(true);
}
public virtual bool Completed(PvPBattle b, PlayerMobile p)
{
double min = 0, max = 0, total = 0;
var score = ComputeScore(b, p, ref min, ref max, ref total);
if (score <= 0 || total <= 0)
{
return(false);
}
if (AllRequired)
{
return(score >= total);
}
return(max >= 1.0);
}
public PvPSpectateBoundsGump(PlayerMobile user, PvPBattle battle, Gump parent = null)
: base(
user,
parent,
list: battle.Options.Locations.SpectateBounds,
emptyText: "There are no bounds in the list.",
title: "Spectate Region Bounds")
{
Battle = battle;
InputMap = Battle.Map;
Preview = true;
PreviewHue = HighlightHue;
PreviewEffect = 3259;
PreviewName = String.Format("Spectate Region Preview: {0} ({1})", Battle.Name, Battle.Serial);
ForceRecompile = true;
}
public PvPScenario(PvPBattle battle)
{
_TypeOf = battle.GetType();
_Name = battle.Name;
_Info = battle.ToHtmlString(preview: true).Replace("(Internal)", String.Empty);
}
private static bool SerializeBattle(GenericWriter writer, PvPSerial key, PvPBattle val)
{
int version = writer.SetVersion(0);
switch (version)
{
case 0:
{
writer.WriteBlock(w => w.WriteType(key, t => key.Serialize(w)));
writer.WriteBlock(w => w.WriteType(val, t => val.Serialize(w)));
}
break;
}
return true;
}
public PvPRegion(PvPBattle battle, string name, GenericReader reader)
: this(battle, name)
{
Deserialize(reader);
}
public PvPSpectateRegion(PvPBattle battle)
: base(battle, battle.SpectateRegionName, battle.Options.Locations.SpectateBounds.ToArray())
{ }
public PvPInviteGump(PlayerMobile user, PvPBattle battle, Gump parent = null)
: base(user, parent, title: "Call To Arms")
{
Battle = battle;
}
public PvPSpectateRegion(PvPBattle battle, GenericReader reader)
: base(battle, battle.SpectateRegionName, reader)
{ }
