Beispiel #1
0
        protected override int GetProgress(ConquestState state, ConquestProgressContainer args)
        {
            if (state.User == null)
            {
                return(0);
            }

            int progress = base.GetProgress(state, args);

            if (progress <= 0)
            {
                return(progress);
            }

            int total = args.State.Progress + args.Offset;

            ConquestProfile p = Conquests.EnsureProfile(state.User);

            if (p != null)
            {
                total += p.Sum(s => s != state && Include(s) ? s.Progress : 0);
            }

            return(Math.Max(0, total - state.Progress));
        }
        protected override int GetProgress(ConquestState state, ConquestTierCompletedContainer args)
        {
            if (state.User == null)
            {
                return(0);
            }

            int progress = base.GetProgress(state, args);

            if (progress <= 0)
            {
                return(progress);
            }

            int count = args.Tier >= TierReq ? 1 : 0;

            ConquestProfile p = Conquests.EnsureProfile(state.User);

            if (p != null)
            {
                count += p.Count(s => s != state && Include(s));
            }

            return(Math.Max(0, count - state.Progress));
        }
Beispiel #3
0
        public ConquestStateListGump(
            PlayerMobile user,
            Gump parent             = null,
            ConquestProfile profile = null,
            string category         = "All")
            : base(user, parent, emptyText: "There are no conquests to display.", title: "Conquests")
        {
            Profile = profile ?? Conquests.EnsureProfile(User);

            Category = category.ToUpperWords() ?? "All";

            ForceRecompile = true;
            AutoRefresh    = true;

            Sorted = true;
        }
        public ConquestStatesGump(
            PlayerMobile user, Gump parent = null, ConquestProfile profile = null, ConquestCategory category = null)
            : base(user, parent)
        {
            Title        = "Conquests";
            RootCategory = String.Empty;

            Profile = profile ?? Conquests.EnsureProfile(user);

            Category = category ?? String.Empty;

            Categories = new List <ConquestCategory>();

            ForceRecompile = true;

            CanMove = true;

            Sorted = true;

            EntriesPerPage = 4;
        }
Beispiel #5
0
        public virtual void OnTierComplete(ConquestState s)
        {
            if (!Enabled || Deleted || s == null || s.Conquest != this || s.User == null)
            {
                return;
            }

            ConquestProfile p = Conquests.EnsureProfile(s.User);

            if (p != null)
            {
                p.Credit += Points;
            }

            if (s.TiersComplete || RewardTierComplete)
            {
                GiveRewards(s);
            }

            if (SoundOnComplete > 0)
            {
                s.User.PlaySound(SoundOnComplete);
            }

            if (!CentralGump.CentralGump.EnsureProfile(s.User).IgnoreConquests)
            {
                ConquestCompletedGump g = ConquestCompletedGump.Acquire(s);

                if (g != null)
                {
                    g.Send();
                }
            }

            if (Conquests.CMOptions.ModuleDebug)
            {
                Conquests.CMOptions.ToConsole("{0} tier complete: {1} ({2})", Name, s.User, s.Tier);
            }
        }
Beispiel #6
0
        public virtual void GiveRewards(ConquestState s)
        {
            if (!Enabled || Deleted || s == null || s.Conquest != this || s.User == null)
            {
                return;
            }

            if (AccountBound)
            {
                var account = s.User.Account as Account;

                if (account == null)
                {
                    return;
                }

                string tag = account.GetTag(TagKey);

                if (!String.IsNullOrWhiteSpace(tag))
                {
                    return;
                }

                // Look for all players in the account that aren't the owner of the current conquest state.
                for (int i = 0; i < account.Length; i++)
                {
                    var pm = account[i] as PlayerMobile;

                    if (pm == null || pm == s.User)
                    {
                        continue;
                    }

                    ConquestProfile prof = Conquests.EnsureProfile(pm);

                    ConquestState state;

                    if (!prof.TryGetState(this, out state) || state == null || state == s || !state.Completed)
                    {
                        continue;
                    }

                    account.SetTag(TagKey, state.CompletedDate.ToSimpleString("t@h:m@ d-m-y"));
                    return;                     // get outta here, no rewards!
                }

                account.SetTag(TagKey, s.CompletedDate.ToSimpleString("t@h:m@ d-m-y"));
            }
            else
            {
                var account = s.User.Account as Account;

                if (account != null)
                {
                    account.RemoveTag(TagKey);                     // Remove the tag, just in case it was bound previously but isn't now.
                }
            }

            InvalidateRewardInfo();

            if (Rewards.Count == 0)
            {
                return;
            }

            var rewards     = new List <IEntity>();
            var attachments = new List <IXmlAttachment>();

            Rewards.ForEach(
                type =>
            {
                if (type == null)
                {
                    return;
                }

                int count = ScaleRewards ? s.Tier : 1;

                while (--count >= 0)
                {
                    var reward = type.CreateInstanceSafe <object>();

                    if (reward is Item)
                    {
                        var rewardItem = (Item)reward;

                        if (!OnBeforeGiveReward(s, rewardItem))
                        {
                            rewardItem.Delete();
                            return;
                        }

                        OnGiveReward(s, rewardItem);

                        if (!rewardItem.Deleted)
                        {
                            rewards.Add(rewardItem);
                        }
                    }
                    else if (reward is BaseCreature)
                    {
                        var rewardCreature = (BaseCreature)reward;

                        if (!OnBeforeGiveReward(s, rewardCreature))
                        {
                            rewardCreature.Delete();
                            return;
                        }

                        OnGiveReward(s, rewardCreature);

                        if (!rewardCreature.Deleted)
                        {
                            rewards.Add(rewardCreature);
                        }
                    }
                    else if (reward is Mobile)
                    {
                        var rewardMobile = (Mobile)reward;

                        if (!OnBeforeGiveReward(s, rewardMobile))
                        {
                            rewardMobile.Delete();
                            return;
                        }

                        OnGiveReward(s, rewardMobile);

                        if (!rewardMobile.Deleted)
                        {
                            rewards.Add(rewardMobile);
                        }
                    }
                    else if (reward is XmlAttachment)
                    {
                        var a = (XmlAttachment)reward;

                        if (!OnBeforeGiveReward(s, a))
                        {
                            a.Delete();
                            return;
                        }

                        OnGiveReward(s, a);

                        if (!a.Deleted)
                        {
                            attachments.Add(a);
                        }
                    }
                }
            });

            OnRewarded(s, rewards, attachments, true);
        }