예제 #1
0
        private void ProvideReward(GameSession session)
        {
            TrophyGradeMetadata grade = TrophyMetadataStorage.GetGrade(Id, NextGrade);
            RewardType          type  = (RewardType)grade.RewardType;

            switch (type)
            {
            case RewardType.Unknown:
            case RewardType.itemcoloring:
            case RewardType.shop_ride:
            case RewardType.title:
            case RewardType.beauty_hair:
            case RewardType.skillPoint:
            case RewardType.beauty_makeup:
            case RewardType.shop_build:
            case RewardType.item:
            case RewardType.shop_weapon:
            case RewardType.dynamicaction:
            case RewardType.etc:
            case RewardType.beauty_skin:
                break;

            case RewardType.statPoint:
                session.Player.StatPointDistribution.AddTotalStatPoints(grade.RewardValue, OtherStatsIndex.Trophy);
                session.Send(StatPointPacket.WriteTotalStatPoints(session.Player));
                break;

            default:
                break;
            }
        }
예제 #2
0
    private static void ProvideReward(TrophyGradeMetadata grade, GameSession session)
    {
        switch (grade.RewardType)
        {
        // this cases don't require any handling.
        case RewardType.None:
        case RewardType.itemcoloring:
        case RewardType.beauty_hair:
        case RewardType.skillPoint:
        case RewardType.beauty_makeup:
        case RewardType.shop_build:
        case RewardType.shop_weapon:
        case RewardType.dynamicaction:
        case RewardType.etc:
        case RewardType.beauty_skin:
        case RewardType.statPoint:
        case RewardType.shop_ride:
        default:
            break;

        case RewardType.item:
            session.Player.Inventory.AddItem(session, new(grade.RewardCode, grade.RewardValue), true);
            break;

        case RewardType.title:
            session.Player.Titles.Add(grade.RewardCode);
            session.Send(UserEnvPacket.AddTitle(grade.RewardCode));
            break;
        }
    }
        public Trophy(long characterId, long accountId, int trophyId)
        {
            TrophyMetadata trophyMetadata = TrophyMetadataStorage.GetMetadata(trophyId);

            Id         = trophyId;
            LastReward = 1;
            NextGrade  = 1;
            Timestamps = new List <long>();
            MaxGrade   = trophyMetadata.Grades.Count;
            TrophyGradeMetadata trophyGradeMetadata = trophyMetadata.Grades.FirstOrDefault(x => x.Grade == NextGrade);

            Condition        = trophyGradeMetadata.Condition;
            ConditionType    = trophyGradeMetadata.ConditionType;
            ConditionCodes   = trophyGradeMetadata.ConditionCodes;
            ConditionTargets = trophyGradeMetadata.ConditionTargets;
            Type             = trophyMetadata.Categories[0];
            if (trophyMetadata.AccountWide)
            {
                AccountId = accountId;
            }
            else
            {
                CharacterId = characterId;
            }
            Uid = DatabaseManager.Trophies.Insert(this);
        }
예제 #4
0
        protected override List <TrophyMetadata> Parse()
        {
            List <TrophyMetadata> trophyList = new List <TrophyMetadata>();

            foreach (PackFileEntry entry in Resources.XmlReader.Files)
            {
                if (!entry.Name.StartsWith("achieve/"))
                {
                    continue;
                }

                XmlDocument document = Resources.XmlReader.GetXmlDocument(entry);
                XmlNode     trophy   = document.SelectSingleNode("/ms2/achieves");

                TrophyMetadata newTrophy = new TrophyMetadata();
                newTrophy.Id          = int.Parse(trophy.Attributes["id"].Value);
                newTrophy.Categories  = trophy.Attributes["categoryTag"]?.Value.Split(",");
                newTrophy.AccountWide = trophy.Attributes["account"].Value == "1";

                XmlNodeList grades = trophy.SelectNodes("grade");

                foreach (XmlNode grade in grades)
                {
                    TrophyGradeMetadata newGrade = new TrophyGradeMetadata();
                    newGrade.Grade = int.Parse(grade.Attributes["value"].Value);

                    XmlNode condition = grade.SelectSingleNode("condition");
                    newGrade.Condition        = long.Parse(condition.Attributes["value"].Value);
                    newGrade.ConditionType    = condition.Attributes["type"].Value;
                    newGrade.ConditionCodes   = condition.Attributes["code"].Value.Split(",");
                    newGrade.ConditionTargets = condition.Attributes["target"].Value.Split(",");

                    XmlNode reward = grade.SelectSingleNode("reward");
                    Enum.TryParse(reward.Attributes["type"].Value, true, out RewardType type);
                    newGrade.RewardType  = type;
                    newGrade.RewardCode  = int.Parse(reward.Attributes["code"].Value);
                    newGrade.RewardValue = int.Parse(reward.Attributes["value"].Value);

                    newTrophy.Grades.Add(newGrade);
                }
                trophyList.Add(newTrophy);
            }

            return(trophyList);
        }
        public Trophy(long uid, int trophyId, int nextGrade, long counter, bool isDone, byte lastReward, List <long> timestamps, long characterId, long accountId)
        {
            TrophyMetadata trophyMetadata = TrophyMetadataStorage.GetMetadata(trophyId);

            Uid       = uid;
            Id        = trophyId;
            NextGrade = nextGrade;
            MaxGrade  = trophyMetadata.Grades.Count;
            TrophyGradeMetadata trophyGradeMetadata = trophyMetadata.Grades.FirstOrDefault(x => x.Grade == NextGrade);

            Condition        = trophyGradeMetadata.Condition;
            ConditionType    = trophyGradeMetadata.ConditionType;
            ConditionCodes   = trophyGradeMetadata.ConditionCodes;
            ConditionTargets = trophyGradeMetadata.ConditionTargets;
            Type             = trophyMetadata.Categories[0];
            Counter          = counter;
            IsDone           = isDone;
            LastReward       = lastReward;
            Timestamps       = timestamps;
            CharacterId      = characterId;
            AccountId        = accountId;
        }
        public void AddCounter(GameSession session, long amount)
        {
            Counter += amount;
            if (IsDone)
            {
                return;
            }

            if (Counter < Condition)
            {
                return;
            }

            TrophyGradeMetadata grade = TrophyMetadataStorage.GetMetadata(Id).Grades.FirstOrDefault(x => x.Grade == NextGrade);

            if (!RewardTypeRequiresClaim(grade.RewardType) && LastReward == NextGrade)
            {
                // Add stat points and skill points
                switch (grade.RewardType)
                {
                case RewardType.statPoint:
                    session.Player.AddStatPoint(grade.RewardValue, OtherStatsIndex.Trophy);
                    break;

                case RewardType.skillPoint:
                    // TODO: Add skill points
                    break;
                }
                LastReward++;
            }
            NextGrade++;
            Timestamps.Add(DateTimeOffset.UtcNow.ToUnixTimeSeconds());

            // level up but not completed
            if (NextGrade <= MaxGrade)
            {
                // Update condition
                TrophyGradeMetadata trophyGradeMetadata = TrophyMetadataStorage.GetMetadata(Id).Grades.FirstOrDefault(x => x.Grade == NextGrade);
                Condition      = trophyGradeMetadata.Condition;
                ConditionType  = trophyGradeMetadata.ConditionType;
                ConditionCodes = trophyGradeMetadata.ConditionCodes;
                return;
            }

            // level up and completed
            IsDone = true;
            NextGrade--;
            string[] categories = TrophyMetadataStorage.GetMetadata(Id).Categories;
            foreach (string category in categories)
            {
                switch (category)
                {
                case string s when s.Contains("combat"):
                    session.Player.TrophyCount[0] += 1;

                    break;

                case string s when s.Contains("adventure"):
                    session.Player.TrophyCount[1] += 1;

                    break;

                case string s when s.Contains("lifestyle"):
                    session.Player.TrophyCount[2] += 1;

                    break;
                }
            }
        }