Ejemplo n.º 1
0
    public float GetTotalStatValue(StatAttribute attribute)
    {
        float statValue = 0;

        if (Constants.ContainsKey(attribute))
        {
            statValue += Constants[attribute].GetValue();
        }
        if (Statics.ContainsKey(attribute))
        {
            statValue += Statics[attribute].GetValue();
        }
        if (Randoms.ContainsKey(attribute))
        {
            statValue += Randoms[attribute].GetValue();
        }
        if (Enchants.ContainsKey(attribute))
        {
            statValue += Enchants[attribute].Flat;
            statValue += statValue * Enchants[attribute].Rate;
        }
        if (LimitBreakEnchants.ContainsKey(attribute))
        {
            statValue += LimitBreakEnchants[attribute].Flat;
            statValue += statValue * LimitBreakEnchants[attribute].Rate;
        }

        return(statValue);
    }
Ejemplo n.º 2
0
    private static ItemStat ReadStat(int statId, int value)
    {
        switch (statId)
        {
        // Basic Stat with percent value
        case >= 1000 and < 11000:
        {
            float         percent   = (float)(value + 5) / 10000;
            StatAttribute attribute = (StatAttribute)(statId - 1000);
            return(new BasicStat(attribute, percent, StatAttributeType.Rate));
        }

        // Special Stat with percent value
        case >= 11000:
        {
            float         percent   = (float)(value + 5) / 10000;
            StatAttribute attribute = (StatAttribute)(statId);
            return(new SpecialStat(attribute, percent, StatAttributeType.Rate));
        }

        default:
            // Basic Stat with flat value
            return(new BasicStat((StatAttribute)statId, value, StatAttributeType.Flat));
        }
    }
Ejemplo n.º 3
0
    private static void HandleStatIncrement(GameSession session, PacketReader packet)
    {
        StatAttribute statTypeIndex = (StatAttribute)packet.ReadByte();

        session.Player.StatPointDistribution.AddPoint(statTypeIndex);
        session.Player.FieldPlayer.ComputeStats();
        session.Send(StatPointPacket.WriteStatPointDistribution(session.Player));
        session.Send(StatPacket.SetStats(session.Player.FieldPlayer));
    }
Ejemplo n.º 4
0
    public void AddPoint(StatAttribute statType)
    {
        if (AllocatedStats.ContainsKey(statType))
        {
            AllocatedStats[statType] += 1;
            return;
        }

        AllocatedStats[statType] = 1;
    }
Ejemplo n.º 5
0
    private static List <ParserSpecialStat> ParseSpecialStat(StatAttribute attribute, XmlNode node, StatAttributeType type)
    {
        List <ParserSpecialStat> values = new();

        for (int i = 2; i <= 17; i++)
        {
            values.Add(new(attribute, float.Parse(node.Attributes[$"idx{i}"].Value), type));
        }

        return(values);
    }
Ejemplo n.º 6
0
    /// <summary>
    /// Update all stats.
    /// </summary>
    public static PacketWriter SetStats(IFieldActor actor)
    {
        PacketWriter pWriter = PacketWriter.Of(SendOp.Stat);

        pWriter.WriteInt(actor.ObjectId);
        pWriter.WriteByte(); // Unknown (0x00/0x01)
        pWriter.Write(StatsMode.SendAllStats);
        for (int i = 0; i < (int)StatsMode.SendAllStats; i++)
        {
            StatAttribute statAttribute = (StatAttribute)i;
            pWriter.WriteStat(statAttribute, actor.Stats.Data[statAttribute]);
        }

        return(pWriter);
    }
Ejemplo n.º 7
0
    public static void AddHiddenNormalStat(List <ItemStat> stats, StatAttribute attribute, int value, float calibrationFactor)
    {
        ItemStat normalStat = stats.FirstOrDefault(x => x.ItemAttribute == attribute);

        if (normalStat == null)
        {
            return;
        }
        int calibratedValue = (int)(value * calibrationFactor);

        int index        = stats.FindIndex(x => x.ItemAttribute == attribute);
        int biggerValue  = Math.Max(value, calibratedValue);
        int smallerValue = Math.Min(value, calibratedValue);
        int summedFlat   = (int)(normalStat.Flat + Random.Shared.Next(smallerValue, biggerValue));

        stats[index] = new SpecialStat(normalStat.ItemAttribute, summedFlat, StatAttributeType.Flat);
    }
Ejemplo n.º 8
0
    private static void WriteStat(this PacketWriter pWriter, StatAttribute statAttribute, Stat stat)
    {
        if (statAttribute is StatAttribute.Hp)
        {
            for (int i = 0; i < 3; i++)
            {
                pWriter.WriteLong(stat[i]);
            }

            return;
        }

        for (int i = 0; i < 3; i++)
        {
            pWriter.WriteInt(stat[i]);
        }
    }
Ejemplo n.º 9
0
        public void CombinedRelationshipChangedValue()
        {
            const int attributeAValue      = 1234;
            const int attributeBValue      = 4938;
            const int attributeBMultiplier = 2;
            var       statAttributeA       = new StatAttribute(this.attributeA, attributeAValue);

            this.statAttributes.Add(statAttributeA);
            this.statAttributes.Add(new StatAttribute(this.attributeB, attributeBValue));
            this.relationShips.Add(new AttributeRelationship(this.attributeAplusB, 1, this.attributeA));
            this.relationShips.Add(new AttributeRelationship(this.attributeAplusB, attributeBMultiplier, this.attributeB));
            var       system             = this.CreateAttributeSystem();
            const int attributeAnewValue = 1000;

            statAttributeA.Value = attributeAnewValue;
            var value = system[this.attributeAplusB];

            Assert.That(value, Is.EqualTo(attributeAnewValue + (attributeBValue * attributeBMultiplier)));
        }
Ejemplo n.º 10
0
        public int this[StatAttribute key]
        {
            get
            {
                if (stats.ContainsKey(key))
                {
                    return(stats[key]);
                }
                else
                {
                    return(0);
                }
            }

            set
            {
                stats[key] = value;
            }
        }
Ejemplo n.º 11
0
        public void CombinedRelationshipAddedElement()
        {
            const int attributeAValue      = 1234;
            const int attributeBValue      = 4938;
            const int attributeBMultiplier = 2;
            var       statAttributeA       = new StatAttribute(this.attributeA, attributeAValue);

            this.statAttributes.Add(statAttributeA);
            this.statAttributes.Add(new StatAttribute(this.attributeB, attributeBValue));
            this.relationShips.Add(new AttributeRelationship(this.attributeAplusB, 1, this.attributeA));
            this.relationShips.Add(new AttributeRelationship(this.attributeAplusB, attributeBMultiplier, this.attributeB));
            var       system = this.CreateAttributeSystem();
            const int addedAttributeValue = 10;

            system.AddElement(new ConstValueAttribute(addedAttributeValue, this.attributeAplusB), this.attributeAplusB);
            var value = system[this.attributeAplusB];

            Assert.That(value, Is.EqualTo(attributeAValue + (attributeBValue * attributeBMultiplier) + addedAttributeValue));
        }
Ejemplo n.º 12
0
    public static Dictionary <StatAttribute, ItemStat> GetEnchantStats(int enchantLevel, ItemType itemType, int itemLevel)
    {
        Dictionary <StatAttribute, ItemStat> enchantStats = new();
        Script   script = ScriptLoader.GetScript("Functions/calcEnchantValues");
        DynValue statValueScriptResult = script.RunFunction("calcEnchantBoostValues", enchantLevel, (int)itemType, itemLevel);

        for (int i = 0; i < statValueScriptResult.Tuple.Length; i += 2)
        {
            if (statValueScriptResult.Tuple[i].Number == 0)
            {
                continue;
            }

            StatAttribute attribute = (StatAttribute)statValueScriptResult.Tuple[i].Number;
            float         boostRate = (float)statValueScriptResult.Tuple[i + 1].Number;
            enchantStats[attribute] = new BasicStat(attribute, boostRate, StatAttributeType.Rate);
        }

        return(enchantStats);
    }
Ejemplo n.º 13
0
    private void AddStat(EffectStatusMetadata status, StatAttribute stat, long value)
    {
        if (value == 0)
        {
            return;
        }

        EffectStatMetadata currentValue;

        if (status.Stats.TryGetValue(stat, out currentValue))
        {
            currentValue.Flat = value;

            return;
        }

        status.Stats.Add(stat, new()
        {
            Flat          = value,
            AttributeType = StatAttributeType.Flat
        });
    }
Ejemplo n.º 14
0
        protected override void Start()
        {
            base.Start();
            team = StatAttribute.Create(1f, "Team");

            maxHealth = StatAttribute.Create(10f, "MaxHealth");
            health    = FloatVariable.Create(FloatConstant.Create(maxHealth.Value), FloatConstant.Create(0), maxHealth,
                                             AttributeType.Create("Health"));

            armor = StatAttribute.Create(10f, "Armor");

            speed           = StatAttribute.Create(3f, "Speed");
            sneakMultiplier = 0.7f;
            runMultiplier   = 2f;

            jumpPower = 450f;

            weight    = StatAttribute.Create(0, "Weight");
            maxWeight = StatAttribute.Create(0, "MaxWeight");

            slotCapacity = -1;
        }
Ejemplo n.º 15
0
 public Stats SetStat(StatAttribute attributes, int value)
 {
     stats[attributes] = value;
     return(this);
 }
Ejemplo n.º 16
0
 public StatModifierInstance(StatModifier modifier, StatAttribute attribute, IStatModifierSource source)
 {
     Modifier  = modifier;
     Attribute = attribute;
     Source    = source;
 }
Ejemplo n.º 17
0
 public static double FetchMultiplier(Stats stats, StatAttribute attribute)
 {
     return((double)stats[attribute].Total / 1000);
 }
Ejemplo n.º 18
0
    public static DamageHandler CalculateDamage(SkillCast skill, IFieldActor source, IFieldActor target, double luckCoefficient)
    {
        // TODO: get accuracyWeakness from enemy stats from enemy buff. new stat recommended
        const double AccuracyWeakness = 0;
        double       hitRate          = (source.Stats[StatAttribute.Accuracy].Total + AccuracyWeakness) / Math.Max(target.Stats[StatAttribute.Evasion].Total, 0.1);

        if (Random.Shared.NextDouble() > hitRate)
        {
            return(new(source, target, 0, HitType.Miss)); // we missed
        }

        bool isCrit = skill.IsGuaranteedCrit() || RollCrit(source, target, luckCoefficient);

        double finalCritDamage = 1;

        if (isCrit)
        {
            // TODO: get critResist from enemy stats from enemy buff. new stat recommended
            const double CritResist = 1;
            double       critDamage = 1000 + source.Stats[StatAttribute.CritDamage].Total;
            finalCritDamage = CritResist * ((critDamage / 1000) - 1) + 1;
        }

        double damageBonus = 1 + FetchMultiplier(source.Stats, StatAttribute.TotalDamage);

        damageBonus *= finalCritDamage;

        switch (skill.GetElement())
        {
        case Element.Fire:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.FireDamage);
            break;

        case Element.Ice:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.IceDamage);
            break;

        case Element.Electric:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.ElectricDamage);
            break;

        case Element.Holy:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.HolyDamage);
            break;

        case Element.Dark:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.DarkDamage);
            break;

        case Element.Poison:
            damageBonus += FetchMultiplier(source.Stats, StatAttribute.PoisonDamage);
            break;
        }

        SkillRangeType rangeType = skill.GetRangeType();

        if (rangeType != SkillRangeType.Special)
        {
            damageBonus += FetchMultiplier(source.Stats, rangeType == SkillRangeType.Melee ? StatAttribute.MeleeDamage : StatAttribute.RangedDamage);
        }

        bool isBoss = false;

        if (target is INpc npc)
        {
            isBoss = npc.Value.IsBoss();
        }

        damageBonus += isBoss ? FetchMultiplier(source.Stats, StatAttribute.BossDamage) : 0;

        // TODO: properly fetch enemy attack speed weakness from enemy buff. new stat recommended
        const double AttackSpeedWeakness = 0;

        damageBonus += AttackSpeedWeakness * FetchMultiplier(source.Stats, StatAttribute.AttackSpeed);

        double damageMultiplier = damageBonus * skill.GetDamageRate();

        // TODO: properly fetch enemy pierce resistance from enemy buff. new stat recommended
        const double EnemyPierceResistance = 1;

        double defensePierce = 1 - Math.Min(0.3, EnemyPierceResistance * FetchMultiplier(source.Stats, StatAttribute.Pierce));

        damageMultiplier *= 1 / (Math.Max(target.Stats[StatAttribute.Defense].Total, 1) * defensePierce);

        bool          isPhysical     = skill.GetSkillDamageType() == DamageType.Physical;
        StatAttribute resistanceStat = isPhysical ? StatAttribute.PhysicalRes : StatAttribute.MagicRes;
        StatAttribute attackStat     = isPhysical ? StatAttribute.PhysicalAtk : StatAttribute.MagicAtk;
        StatAttribute piercingStat   = isPhysical ? StatAttribute.PhysicalPiercing : StatAttribute.MagicPiercing;

        double targetRes  = target.Stats[resistanceStat].Total;
        double attackType = source.Stats[attackStat].Total;
        double resPierce  = FetchMultiplier(source.Stats, piercingStat);
        double resistance = (1500.0 - Math.Max(0, targetRes - 1500 * resPierce)) / 1500;

        // does this need to be divided by anything at all to account for raw physical attack?
        damageMultiplier *= attackType * resistance;

        // TODO: apply special standalone multipliers like Spicy Maple Noodles buff? it seems to have had it's own multiplier. new stat recommended
        const double FinalDamageMultiplier = 1;

        damageMultiplier *= FinalDamageMultiplier;

        double attackDamage = 300;

        if (source is IFieldActor <Player> player)
        {
            double bonusAttack = player.Stats[StatAttribute.BonusAtk].Total + 0.4 * player.Stats[StatAttribute.PetBonusAtk].Total;

            // TODO: properly fetch enemy bonus attack weakness from enemy buff. new stat recommended
            const double BonusAttackWeakness = 1;

            double minDamage = player.Stats[StatAttribute.MinWeaponAtk].Total + BonusAttackWeakness * bonusAttack;
            double maxDamage = player.Stats[StatAttribute.MaxWeaponAtk].Total + BonusAttackWeakness * bonusAttack;

            attackDamage = minDamage + (maxDamage - minDamage) * Random.Shared.NextDouble();
        }

        attackDamage *= damageMultiplier;

        return(new(source, target, Math.Max(1, attackDamage), isCrit ? HitType.Critical : HitType.Normal));
    }
Ejemplo n.º 19
0
        public async Task <bool> UpdateDatabasePVEProfileAsync(KeyValuePair <string, IQueryProfile> profile, IGuildUser guser, IUserMessage msg = null, bool nameTag = false, bool IsNameLocked = false, bool PVEDecimals = true)
        {
            if (_uow.Db <BlackListUser>().Where(p => p.Id == guser.Id.ToString()).Any())
            {
                return(false);
            }

            var svvrs = await profile.Value.GetSurvivors();

            var svvrsResource = await svvrs.CalcSurvivorFORTs();

            var resources = await profile.Value.CalcResearchFORTs();

            var AccountPowerLevel = await SurvivorStaticData.CalcEnergyByFORT(svvrsResource + resources);

            var mSchematics    = profile.Value.AmountOfMythicSchematics();
            var frostnite2019  = profile.Value.DoneEliteFrostnite2019();
            var mockPveProfile = new FortnitePVEProfile
            {
                EpicId              = profile.Value.profileChanges.First().profile.accountId,
                PlayerName          = profile.Key,
                AccountPowerLevel   = AccountPowerLevel,
                NumMythicSchematics = mSchematics,
                EliteFortnite2019   = frostnite2019
            };

            if (AccountPowerLevel < 16)
            {
                mockPveProfile.Map = MapRoles.Stonewood;
            }
            else if (AccountPowerLevel < 46)
            {
                mockPveProfile.Map = MapRoles.Plankerton;
            }
            else if (AccountPowerLevel < 70)
            {
                mockPveProfile.Map = MapRoles.CannyValley;
            }
            else
            {
                mockPveProfile.Map = MapRoles.TwinePeaks;
            }

            StatAttribute stats = profile.Value.profileChanges.First().profile.stats["attributes"];

            if (stats.rewards_claimed_post_max_level.HasValue)
            {
                if (stats != null)
                {
                    mockPveProfile.CommanderLevel = (stats.level + stats.rewards_claimed_post_max_level.Value);
                }
            }
            else
            {
                if (stats != null)
                {
                    mockPveProfile.CommanderLevel = stats.level;
                }
            }
            if (stats.collection_book != null)
            {
                mockPveProfile.CollectionBookLevel = stats.collection_book.maxBookXpLevelAchieved;
            }

            UpdateDatabaseUserProfile(mockPveProfile.EpicId, guser, msg, nameTag, GameUserMode.PVE);
            StoredProcedure.SP_TABLE_FortnitePVEProfile_Update(mockPveProfile);
            await UpdateDiscordPVEProfileAsync(mockPveProfile, nameTag, guser, msg, IsNameLocked, PVEDecimals);

            return(true);
        }
Ejemplo n.º 20
0
 public SpecialStat(StatAttribute attribute, float value, StatAttributeType type) : base(attribute, type, value)
 {
 }
Ejemplo n.º 21
0
 protected ItemStat(StatAttribute attribute, StatAttributeType type, float value)
 {
     ItemAttribute = attribute;
     AttributeType = type;
     SetValue(value);
 }
 public ParserSpecialStat(StatAttribute attribute, float value, StatAttributeType type)
 {
     Attribute     = attribute;
     Value         = value;
     AttributeType = type;
 }
Ejemplo n.º 23
0
    private static Item GetNextLevelItem(Item item)
    {
        Script   script            = ScriptLoader.GetScript("Functions/calcLimitBreakValues");
        DynValue scriptResultRates = script.RunFunction("calcLimitBreakStatRateValues", item.LimitBreakLevel);
        DynValue scriptResultFlats = script.RunFunction("calcLimitBreakStatFlatValues", item.LimitBreakLevel);

        Item nextLevelItem = new(item)
        {
            Uid = 0
        };

        if (nextLevelItem.LimitBreakLevel == 0)
        {
            nextLevelItem.EnchantLevel             = 0;
            nextLevelItem.Stats.LimitBreakEnchants = nextLevelItem.Stats.Enchants;
            nextLevelItem.Stats.Enchants           = new();
        }

        for (int i = 0; i < scriptResultRates.Tuple.Length; i += 2)
        {
            if (scriptResultRates.Tuple[i].Number == 0)
            {
                continue;
            }
            StatAttribute attribute = (StatAttribute)scriptResultRates.Tuple[i].Number;
            float         boostRate = (float)scriptResultRates.Tuple[i + 1].Number;
            if (!nextLevelItem.Stats.LimitBreakEnchants.ContainsKey(attribute))
            {
                if (boostRate == 0)
                {
                    continue;
                }
                ItemStat stat = new BasicStat(attribute, boostRate, StatAttributeType.Rate);
                if (attribute > (StatAttribute)11000)
                {
                    stat = new SpecialStat(attribute, boostRate, StatAttributeType.Rate);
                }
                stat.ItemAttribute = attribute;

                nextLevelItem.Stats.LimitBreakEnchants[attribute] = stat;
                continue;
            }
            nextLevelItem.Stats.LimitBreakEnchants[attribute].Rate += boostRate;
        }

        for (int i = 0; i < scriptResultFlats.Tuple.Length; i += 2)
        {
            if (scriptResultFlats.Tuple[i].Number == 0)
            {
                continue;
            }
            StatAttribute attribute  = (StatAttribute)scriptResultFlats.Tuple[i].Number;
            int           boostValue = (int)scriptResultFlats.Tuple[i + 1].Number;
            if (!nextLevelItem.Stats.LimitBreakEnchants.ContainsKey(attribute))
            {
                ItemStat stat = new BasicStat(attribute, boostValue, StatAttributeType.Flat);
                if (attribute > (StatAttribute)11000)
                {
                    stat = new SpecialStat(attribute, boostValue, StatAttributeType.Flat);
                }
                stat.ItemAttribute = attribute;

                nextLevelItem.Stats.LimitBreakEnchants[attribute] = stat;
                continue;
            }
            nextLevelItem.Stats.LimitBreakEnchants[attribute].Flat += boostValue;
        }
        nextLevelItem.LimitBreakLevel++;
        return(nextLevelItem);
    }
}