コード例 #1
0
 public DuelTarget(Duel duel)
     : base(100, false, TargetFlags.None)
 {
     m_Duel = duel;
 }
コード例 #2
0
        public static void EndDuel(Duel duel, Mobile loser)
        {
            duel.State = DuelState.End;

            Mobile winner;

            if (loser == duel.Defender)
            {
                winner = duel.Attacker;
            }
            else
            {
                winner = duel.Defender;
            }

            DuelInfo wInfo = GetInfo(winner);
            DuelInfo lInfo = GetInfo(loser);

            wInfo.AddLogEntry(String.Format("Won in a{0}duel against {1}.", (duel.Ranked ? " ranked " : "n unranked "), loser.Name));
            lInfo.AddLogEntry(String.Format("Lost in a{0}duel against {1}.", (duel.Ranked ? " ranked " : "n unranked "), winner.Name));

            if (duel.Ranked)
            {
                ++wInfo.Wins;
                ++lInfo.Losses;
            }

            if (!loser.Alive)
            {
                loser.Resurrect();

                if (loser.Corpse != null && loser.Corpse is Corpse)
                {
                    Corpse c = (Corpse)loser.Corpse;

                    for (int i = 0; i < c.Items.Count; ++i)
                    {
                        c.SetRestoreInfo(c.Items[i], c.Items[i].Location);
                    }

                    c.Open(loser, true);
                    c.Delete();
                }
            }

            Mobile[] mobs = new Mobile[] { winner, loser };

            winner.Delta(MobileDelta.Noto); /*	  Update	*/
            loser.Delta(MobileDelta.Noto);  /*   Notoriety	*/

            foreach (Mobile m in mobs)
            {
                m.CurePoison(m);
                m.StatMods.Clear();
                m.Combatant = null;

                m.Hits = m.HitsMax;
                m.Mana = m.ManaMax;
                m.Stam = m.StamMax;

                m.Location = duel.Arena.Home;

                m.Warmode  = false;
                m.Criminal = false;

                m.Aggressed.Clear();
                m.Aggressors.Clear();

                m.Delta(MobileDelta.Noto);
                m.InvalidateProperties();
            }

            winner.Say(String.Format("{0} has won the duel.", winner.Name));
            loser.Say(String.Format("{0} has lost the duel.", loser.Name));

            CancelDuel(duel);

            duel.Arena.Duel = null;
            duel.Arena      = null;
        }
コード例 #3
0
        public static void PrepareFighter(Mobile from, Duel duel)
        {
            if (!from.Alive)
            {
                from.Resurrect();
            }

            Container pack    = from.Backpack;
            BankBox   bank    = from.BankBox;
            Item      holding = from.Holding;

            if (holding != null && pack != null)
            {
                pack.DropItem(holding);
            }

            from.CurePoison(from);
            from.StatMods.Clear();

            from.Hits = from.HitsMax;
            from.Mana = from.ManaMax;
            from.Stam = from.StamMax;

            Targeting.Target.Cancel(from);
            from.MagicDamageAbsorb = 0;
            from.MeleeDamageAbsorb = 0;
            Spells.Second.ProtectionSpell.Registry.Remove(from);
            DefensiveSpell.Nullify(from);
            from.Combatant = null;

            from.Delta(MobileDelta.Noto);             //Update notoriety

            List <Item> items = new List <Item>();

            if (pack != null)
            {
                if (!duel.MagicWeapons)
                {
                    for (int i = 0; i < EquipmentLayers.Length; ++i)
                    {
                        Item item = from.FindItemOnLayer(EquipmentLayers[i]);

                        if (item != null && item is BaseWeapon)
                        {
                            BaseWeapon weapon = (BaseWeapon)item;

                            if (weapon.AccuracyLevel > 0 ||
                                weapon.DamageLevel > 0 ||
                                weapon.DurabilityLevel > 0)
                            {
                                items.Add(item);
                            }
                        }
                    }
                }

                if (!duel.MagicArmor)
                {
                    for (int i = 0; i < EquipmentLayers.Length; ++i)
                    {
                        Item item = from.FindItemOnLayer(EquipmentLayers[i]);

                        if (item != null && item is BaseArmor)
                        {
                            BaseArmor armor = (BaseArmor)item;

                            if (armor.Durability > 0 ||
                                armor.ProtectionLevel > 0)
                            {
                                items.Add(item);
                            }
                        }
                    }
                }

                for (int i = 0; i < pack.Items.Count; ++i)
                {
                    Item item = pack.Items[i];

                    if (item != null)
                    {
                        if (!duel.MagicWeapons && item is BaseWeapon)
                        {
                            BaseWeapon weapon = (BaseWeapon)item;

                            if (weapon.AccuracyLevel > 0 ||
                                weapon.DamageLevel > 0 ||
                                weapon.DurabilityLevel > 0)
                            {
                                items.Add(item);
                            }
                        }

                        else if (!duel.MagicArmor && item is BaseArmor)
                        {
                            BaseArmor armor = (BaseArmor)item;

                            if (armor.Durability > 0 ||
                                armor.ProtectionLevel > 0)
                            {
                                items.Add(item);
                            }
                        }
                        //else if ( !duel.Potions && item is BasePotion )
                        //items.Add( item );
                        else if (!duel.Bandages && item is Bandage)
                        {
                            items.Add(item);
                        }
                    }
                }
            }

            if (!duel.Mounts)
            {
                if (from.Mount != null)
                {
                    IMount mount = from.Mount;
                    mount.Rider = null;

                    if (mount is BaseCreature)
                    {
                        ((BaseCreature)mount).ControlOrder = OrderType.Stay;
                    }
                }
            }

            if (items.Count > 0)
            {
                foreach (Item item in items)
                {
                    bank.DropItem(item);
                }

                from.SendMessage("Some equipment has been moved to your bankbox due to restrictions on this duel.");
            }
        }
コード例 #4
0
        public static void InitializeDuel(Duel duel)
        {
            if (duel.Attacker == null || duel.Defender == null)
            {
                CancelDuel(duel);
                return;
            }

            List <DuelArena> open = new List <DuelArena>();

            for (int i = 0; i < m_Arenas.Count; ++i)
            {
                if (m_Arenas[i].Usable)
                {
                    open.Add(m_Arenas[i]);
                }
            }

            if (open.Count == 0)
            {
                duel.Attacker.SendMessage("There were no available arenas to duel in. Please try again later.");
                duel.Defender.SendMessage("There were no available arenas to duel in. Please try again later.");
                CancelDuel(duel);
                return;
            }

            DuelArena arena = open[Utility.Random(open.Count)];             //Random open arena

            arena.Duel = duel;
            duel.Arena = arena;

            PrepareFighter(duel.Attacker, duel);
            PrepareFighter(duel.Defender, duel);

            GetInfo(duel.Attacker).Last = duel.Attacker.Location;
            GetInfo(duel.Defender).Last = duel.Defender.Location;

            Moongate gate = new Moongate(duel.Arena.Home, duel.Arena.Map);

            gate.Dispellable = false;
            gate.Hue         = 1015;
            gate.Name        = "a spectator gate";
            gate.MoveToWorld(duel.Attacker.Location, Map.Felucca);

            Timer.DelayCall(TimeSpan.FromSeconds(15.0), new TimerStateCallback(delegate(object state)
            {
                if (gate != null && !gate.Deleted)
                {
                    gate.Delete();
                }
            }), null);

            duel.Attacker.MoveToWorld(arena.GetAttackerLocation(), arena.Map);
            duel.Defender.MoveToWorld(arena.GetDefenderLocation(), arena.Map);

            duel.Attacker.Blessed = true;
            duel.Defender.Blessed = true;

            duel.Attacker.Frozen = true;
            duel.Defender.Frozen = true;

            WallOfStoneEast wall = new WallOfStoneEast();

            wall.MoveToWorld(arena.GetCenter(), arena.Map);

            duel.Attacker.SendMessage("The duel will start in 10 seconds.");
            duel.Defender.SendMessage("The duel will start in 10 seconds.");

            duel.State = DuelState.Duel;

            Timer.DelayCall(TimeSpan.FromSeconds(10.0), new TimerStateCallback(FinalizeDuel), new object[] { wall, duel });
        }
コード例 #5
0
        public static void EventSink_Speech(SpeechEventArgs e)
        {
            Mobile from = e.Mobile;

            if (e.Speech.ToLower().IndexOf("showladder") != -1)
            {
                if (m_Enabled)
                {
                    if (from != null)
                    {
                        if (m_Infos.ContainsKey(from.Serial))
                        {
                            DuelInfo info = m_Infos[from.Serial];

                            from.NonlocalOverheadMessage(Server.Network.MessageType.Regular, 1161, true, String.Format("I have {0} win{1} and {2} loss{3}.", info.Wins, (info.Wins != 1 ? "s" : ""), info.Losses, (info.Losses != 1 ? "es" : "")));
                            from.LocalOverheadMessage(Server.Network.MessageType.Regular, 1161, true, String.Format("I have {0} win{1} and {2} loss{3}.", info.Wins, (info.Wins != 1 ? "s" : ""), info.Losses, (info.Losses != 1 ? "es" : "")));
                        }
                        else
                        {
                            from.NonlocalOverheadMessage(Server.Network.MessageType.Regular, 1161, true, String.Format("I have not participated in any duels yet."));
                            from.LocalOverheadMessage(Server.Network.MessageType.Regular, 1161, true, String.Format("You have not participated in any duels yet."));
                        }
                    }
                }
                else
                {
                    from.SendMessage("The dueling system has been disabled.");
                }
            }

            if (e.Speech.ToLower().IndexOf("bank") != -1)
            {
                if (FindDuel(from) != null)
                {
                    e.Handled = true;
                    return;
                }
            }

            if (e.Speech.ToLower().IndexOf("top 10") != -1)
            {
                if (m_Enabled)
                {
                    from.CloseGump(typeof(TopTenGump));
                    from.SendGump(new TopTenGump(from));
                }
                else
                {
                    from.SendMessage("The dueling system has been disabled");
                }
            }

            if (e.Speech.ToLower().IndexOf("i wish to duel") != -1)
            {
                if (m_Enabled)
                {
                    if (from == null)
                    {
                        return;
                    }

                    if (!CanDuel(from))
                    {
                        return;
                    }

                    Duel duel = new Duel(from, null);

                    m_Duels.Add(duel);

                    duel.State = DuelState.Setup;

                    from.CloseGump(typeof(PlayerDuelAcceptGump));
                    from.CloseGump(typeof(PlayerDuelGump));
                    from.SendGump(new PlayerDuelGump(duel));
                }
                else
                {
                    from.SendMessage("The dueling system has been disabled.");
                }
            }
        }