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 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 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) { }