Beispiel #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="character"></param>
        /// <param name="message"></param>
        private void BoostStats(CharacterEntity character, string message)
        {
            var statId = 0;

            if (!int.TryParse(message.Substring(2), out statId))
            {
                character.SafeDispatch(WorldMessage.BASIC_NO_OPERATION());
                return;
            }

            if (!m_statById.ContainsKey(statId))
            {
                character.SafeDispatch(WorldMessage.BASIC_NO_OPERATION());
                return;
            }

            character.AddMessage(() =>
            {
                var effect        = m_statById[statId];
                var actualValue   = character.Statistics.GetEffect(effect).Base;
                var boostValue    = statId == 11 && character.Breed == CharacterBreedEnum.BREED_SACRIEUR ? 2 : 1;
                var requiredPoint = GenericStats.GetRequiredStatsPoint(character.Breed, statId, actualValue);

                if (character.CaractPoint < requiredPoint)
                {
                    character.Dispatch(WorldMessage.BASIC_NO_OPERATION());
                    return;
                }

                character.CaractPoint -= requiredPoint;

                switch (effect)
                {
                case EffectEnum.AddStrength:
                    character.DatabaseRecord.Strength += boostValue;
                    break;

                case EffectEnum.AddVitality:
                    character.DatabaseRecord.Vitality += boostValue;
                    break;

                case EffectEnum.AddWisdom:
                    character.DatabaseRecord.Wisdom += boostValue;
                    break;

                case EffectEnum.AddIntelligence:
                    character.DatabaseRecord.Intelligence += boostValue;
                    break;

                case EffectEnum.AddAgility:
                    character.DatabaseRecord.Agility += boostValue;
                    break;

                case EffectEnum.AddChance:
                    character.DatabaseRecord.Chance += boostValue;
                    break;
                }

                character.Statistics.AddBase(effect, boostValue);
                character.Dispatch(WorldMessage.ACCOUNT_STATS(character));
            });
        }
Beispiel #2
0
        public static void ProcessBoostStatsRequest(WorldClient Client, string Packet)
        {
            int StatsId = 0, capital = 1;

            if (!int.TryParse(Packet.Substring(2, 2), out StatsId))
            {
                Client.Send(new BasicNoOperationMessage());
                return;
            }

            var EffectType = EffectEnum.None;

            if (!CharacterHandler.BOOST_ID_TO_STATS.TryGetValue(StatsId, out EffectType))
            {
                Client.Send(new BasicNoOperationMessage());
                return;
            }

            var Character = Client.Character;

            var StatsValue = Character.GetStats().GetEffect(EffectType).Base;
            var BoostValue = StatsId == 11 && (ClassEnum)Character.Classe == ClassEnum.CLASS_SACRIEUR ? 2 : 1;

            if (Settings.AppSettings.GetBoolElement("Extra.ElbustCore"))
            {
                try
                {
                    capital = int.Parse(Packet.Split(';')[1]);
                    int quantite = 0;
                    if (capital > Client.Character.CaractPoint)
                    {
                        capital = Client.Character.CaractPoint;
                    }
                    while (capital >= quantite)
                    {
                        StatsValue = Character.GetStats().GetEffect(EffectType).Base;
                        quantite   = GenericStats.GetRequiredStatsPoint((ClassEnum)Character.Classe, StatsId, StatsValue);
                        if (capital >= quantite)
                        {
                            lock (Client.BoostStatsSync)
                            {
                                switch (EffectType)
                                {
                                case EffectEnum.AddForce:
                                    Character.Strength += BoostValue;
                                    break;

                                case EffectEnum.AddVitalite:
                                    Character.Vitality += BoostValue;
                                    Character.Life     += BoostValue; // on boost la life
                                    break;

                                case EffectEnum.AddSagesse:
                                    Character.Wisdom += BoostValue;
                                    break;

                                case EffectEnum.AddIntelligence:
                                    Character.Intell += BoostValue;
                                    break;

                                case EffectEnum.AddChance:
                                    Character.Chance += BoostValue;
                                    break;

                                case EffectEnum.AddAgilite:
                                    Character.Agility += BoostValue;
                                    break;
                                }
                                Character.GetStats().AddBase(EffectType, BoostValue);
                                Character.CaractPoint -= quantite;
                                capital -= quantite;
                            }
                        }
                    }
                    Client.Send(new AccountStatsMessage(Client.Character));
                    return;
                }
                catch (Exception e)
                {
                }
            }

            var RequiredStatsPoints = GenericStats.GetRequiredStatsPoint((ClassEnum)Character.Classe, StatsId, StatsValue);

            if (Character.CaractPoint < RequiredStatsPoints)
            {
                Client.Send(new BasicNoOperationMessage());
                return;
            }


            lock (Client.BoostStatsSync)
            {
                switch (EffectType)
                {
                case EffectEnum.AddForce:
                    Character.Strength += BoostValue;
                    break;

                case EffectEnum.AddVitalite:
                    Character.Vitality += BoostValue;
                    Character.Life     += BoostValue; // on boost la life
                    break;

                case EffectEnum.AddSagesse:
                    Character.Wisdom += BoostValue;
                    break;

                case EffectEnum.AddIntelligence:
                    Character.Intell += BoostValue;
                    break;

                case EffectEnum.AddChance:
                    Character.Chance += BoostValue;
                    break;

                case EffectEnum.AddAgilite:
                    Character.Agility += BoostValue;
                    break;
                }

                Character.GetStats().AddBase(EffectType, BoostValue);
                Character.CaractPoint -= RequiredStatsPoints;
            }

            Client.Send(new AccountStatsMessage(Client.Character));
        }