Пример #1
0
        /// <summary>
        /// NWN stores HP as a field under each level object.
        /// The level for each level is 255. Ensure this value doesn't go over the field limit.
        /// </summary>
        private static void ApplyHP(NWGameObject player, int hp)
        {
            var level = GetLevelByPosition(ClassPosition.First, player);

            // Every level needs at least one HP, so apply that now.
            for (int x = 1; x <= level; x++)
            {
                hp--;
                NWNXCreature.SetMaxHitPointsByLevel(player, x, 1);
            }

            // Now add the remaining HP as needed to each level.
            for (int x = 1; x <= level; level++)
            {
                // Levels can only contain a max of 255 HP.
                if (hp > 255)
                {
                    NWNXCreature.SetMaxHitPointsByLevel(player, x, 255);
                    hp -= 254; // We've already added 1, so reduce by 254.
                }
                // Remaining value gets set to the level (<255 hp)
                else
                {
                    NWNXCreature.SetMaxHitPointsByLevel(player, x, hp + 1);
                    break;
                }
            }

            // If player's current HP is higher than their max, apply damage to put them back to their maximum.
            var currentHP = GetCurrentHitPoints(player);
            var maxHP     = GetMaxHitPoints(player);

            if (currentHP > maxHP)
            {
                int    amount = currentHP - maxHP;
                Effect damage = EffectDamage(amount);
                ApplyEffectToObject(DurationType.Instant, damage, player);
            }
        }
Пример #2
0
        public static void ApplyStatChanges(NWPlayer player, NWItem ignoreItem, bool isInitialization = false)
        {
            if (!player.IsPlayer)
            {
                return;
            }
            if (!player.IsInitializedAsPlayer)
            {
                return;
            }
            if (player.GetLocalInt("IS_SHIP") == 1)
            {
                return;
            }

            // Don't fire for ammo as it reapplies bonuses **just** removed from blasters.
            if (ignoreItem != null &&
                (ignoreItem.BaseItemType == BASE_ITEM_BOLT ||
                 ignoreItem.BaseItemType == BASE_ITEM_ARROW ||
                 ignoreItem.BaseItemType == BASE_ITEM_BULLET))
            {
                return;
            }

            Player             pcEntity    = DataService.Get <Player>(player.GlobalID);
            List <PCSkill>     skills      = DataService.Where <PCSkill>(x => x.PlayerID == player.GlobalID && x.Rank > 0).ToList();
            EffectiveItemStats itemBonuses = GetPlayerItemEffectiveStats(player, ignoreItem);

            float strBonus = 0.0f;
            float dexBonus = 0.0f;
            float conBonus = 0.0f;
            float intBonus = 0.0f;
            float wisBonus = 0.0f;
            float chaBonus = 0.0f;

            using (new Profiler("PlayerStatService::ApplyStatChanges::AttributeApplication"))
            {
                foreach (PCSkill pcSkill in skills)
                {
                    Skill           skill     = DataService.Get <Skill>(pcSkill.SkillID);
                    CustomAttribute primary   = (CustomAttribute)skill.Primary;
                    CustomAttribute secondary = (CustomAttribute)skill.Secondary;
                    CustomAttribute tertiary  = (CustomAttribute)skill.Tertiary;

                    // Primary Bonuses
                    if (primary == CustomAttribute.STR)
                    {
                        strBonus += PrimaryIncrease * pcSkill.Rank;
                    }
                    else if (primary == CustomAttribute.DEX)
                    {
                        dexBonus += PrimaryIncrease * pcSkill.Rank;
                    }
                    else if (primary == CustomAttribute.CON)
                    {
                        conBonus += PrimaryIncrease * pcSkill.Rank;
                    }
                    else if (primary == CustomAttribute.INT)
                    {
                        intBonus += PrimaryIncrease * pcSkill.Rank;
                    }
                    else if (primary == CustomAttribute.WIS)
                    {
                        wisBonus += PrimaryIncrease * pcSkill.Rank;
                    }
                    else if (primary == CustomAttribute.CHA)
                    {
                        chaBonus += PrimaryIncrease * pcSkill.Rank;
                    }

                    // Secondary Bonuses
                    if (secondary == CustomAttribute.STR)
                    {
                        strBonus += SecondaryIncrease * pcSkill.Rank;
                    }
                    else if (secondary == CustomAttribute.DEX)
                    {
                        dexBonus += SecondaryIncrease * pcSkill.Rank;
                    }
                    else if (secondary == CustomAttribute.CON)
                    {
                        conBonus += SecondaryIncrease * pcSkill.Rank;
                    }
                    else if (secondary == CustomAttribute.INT)
                    {
                        intBonus += SecondaryIncrease * pcSkill.Rank;
                    }
                    else if (secondary == CustomAttribute.WIS)
                    {
                        wisBonus += SecondaryIncrease * pcSkill.Rank;
                    }
                    else if (secondary == CustomAttribute.CHA)
                    {
                        chaBonus += SecondaryIncrease * pcSkill.Rank;
                    }

                    // Tertiary Bonuses
                    if (tertiary == CustomAttribute.STR)
                    {
                        strBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                    else if (tertiary == CustomAttribute.DEX)
                    {
                        dexBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                    else if (tertiary == CustomAttribute.CON)
                    {
                        conBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                    else if (tertiary == CustomAttribute.INT)
                    {
                        intBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                    else if (tertiary == CustomAttribute.WIS)
                    {
                        wisBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                    else if (tertiary == CustomAttribute.CHA)
                    {
                        chaBonus += TertiaryIncrease * pcSkill.Rank;
                    }
                }
            }


            // Check caps.
            if (strBonus > MaxAttributeBonus)
            {
                strBonus = MaxAttributeBonus;
            }
            if (dexBonus > MaxAttributeBonus)
            {
                dexBonus = MaxAttributeBonus;
            }
            if (conBonus > MaxAttributeBonus)
            {
                conBonus = MaxAttributeBonus;
            }
            if (intBonus > MaxAttributeBonus)
            {
                intBonus = MaxAttributeBonus;
            }
            if (wisBonus > MaxAttributeBonus)
            {
                wisBonus = MaxAttributeBonus;
            }
            if (chaBonus > MaxAttributeBonus)
            {
                chaBonus = MaxAttributeBonus;
            }

            // Apply item bonuses
            strBonus += itemBonuses.Strength;
            dexBonus += itemBonuses.Dexterity;
            conBonus += itemBonuses.Constitution;
            wisBonus += itemBonuses.Wisdom;
            intBonus += itemBonuses.Intelligence;
            chaBonus += itemBonuses.Charisma;

            // Check final caps
            if (strBonus > 100)
            {
                strBonus = 100;
            }
            if (dexBonus > 100)
            {
                dexBonus = 100;
            }
            if (conBonus > 100)
            {
                conBonus = 100;
            }
            if (intBonus > 100)
            {
                intBonus = 100;
            }
            if (wisBonus > 100)
            {
                wisBonus = 100;
            }
            if (chaBonus > 100)
            {
                chaBonus = 100;
            }

            // Apply attributes
            NWNXCreature.SetRawAbilityScore(player, ABILITY_STRENGTH, (int)strBonus + pcEntity.STRBase);
            NWNXCreature.SetRawAbilityScore(player, ABILITY_DEXTERITY, (int)dexBonus + pcEntity.DEXBase);
            NWNXCreature.SetRawAbilityScore(player, ABILITY_CONSTITUTION, (int)conBonus + pcEntity.CONBase);
            NWNXCreature.SetRawAbilityScore(player, ABILITY_INTELLIGENCE, (int)intBonus + pcEntity.INTBase);
            NWNXCreature.SetRawAbilityScore(player, ABILITY_WISDOM, (int)wisBonus + pcEntity.WISBase);
            NWNXCreature.SetRawAbilityScore(player, ABILITY_CHARISMA, (int)chaBonus + pcEntity.CHABase);

            // Apply AC

            using (new Profiler("PlayerStatService::ApplyStatChanges::CalcAC"))
            {
                int ac = EffectiveArmorClass(itemBonuses, player);
                NWNXCreature.SetBaseAC(player, ac);
            }


            // Apply BAB

            using (new Profiler("PlayerStatService::ApplyStatChanges::CalcBAB"))
            {
                int bab = CalculateBAB(player, ignoreItem, itemBonuses);
                NWNXCreature.SetBaseAttackBonus(player, bab);
            }

            // Apply HP

            using (new Profiler("PlayerStatService::ApplyStatChanges::CalcHP"))
            {
                int hp = EffectiveMaxHitPoints(player, itemBonuses);
                for (int level = 1; level <= 5; level++)
                {
                    hp--;
                    NWNXCreature.SetMaxHitPointsByLevel(player, level, 1);
                }

                for (int level = 1; level <= 5; level++)
                {
                    if (hp > 255) // Levels can only contain a max of 255 HP
                    {
                        NWNXCreature.SetMaxHitPointsByLevel(player, level, 255);
                        hp = hp - 254;
                    }
                    else // Remaining value gets set to the level. (<255 hp)
                    {
                        NWNXCreature.SetMaxHitPointsByLevel(player, level, hp + 1);
                        break;
                    }
                }
            }



            if (player.CurrentHP > player.MaxHP)
            {
                int    amount = player.CurrentHP - player.MaxHP;
                Effect damage = _.EffectDamage(amount);
                _.ApplyEffectToObject(DURATION_TYPE_INSTANT, damage, player.Object);
            }

            // Apply FP
            using (new Profiler("PlayerStatService::ApplyStatChanges::CalcFP"))
            {
                pcEntity.MaxFP = EffectiveMaxFP(player, itemBonuses);

                if (isInitialization)
                {
                    pcEntity.CurrentFP = pcEntity.MaxFP;
                }

                DataService.SubmitDataChange(pcEntity, DatabaseActionType.Update);
            }
        }
Пример #3
0
        public static void ApplyStatChanges(NWPlayer player, NWItem ignoreItem, bool isInitialization = false)
        {
            if (!player.IsPlayer)
            {
                return;
            }
            if (!player.IsInitializedAsPlayer)
            {
                return;
            }
            if (player.GetLocalInt("IS_SHIP") == 1)
            {
                return;
            }

            // Don't fire for ammo as it reapplies bonuses we **just** removed from blasters.
            if (ignoreItem != null &&
                (ignoreItem.BaseItemType == BaseItem.Bolt ||
                 ignoreItem.BaseItemType == BaseItem.Arrow ||
                 ignoreItem.BaseItemType == BaseItem.Bullet))
            {
                return;
            }

            Player         pcEntity = DataService.Player.GetByID(player.GlobalID);
            List <PCSkill> skills   = DataService.PCSkill
                                      .GetAllByPlayerID(player.GlobalID)
                                      .Where(x => x.Rank > 0).ToList();
            EffectiveItemStats itemBonuses = GetPlayerItemEffectiveStats(player, ignoreItem);

            float strBonus = 0.0f;
            float dexBonus = 0.0f;
            float conBonus = 0.0f;
            float intBonus = 0.0f;
            float wisBonus = 0.0f;
            float chaBonus = 0.0f;

            foreach (PCSkill pcSkill in skills)
            {
                Skill           skill     = DataService.Skill.GetByID(pcSkill.SkillID);
                CustomAttribute primary   = (CustomAttribute)skill.Primary;
                CustomAttribute secondary = (CustomAttribute)skill.Secondary;
                CustomAttribute tertiary  = (CustomAttribute)skill.Tertiary;

                // Primary Bonuses
                if (primary == CustomAttribute.STR)
                {
                    strBonus += PrimaryIncrease * pcSkill.Rank;
                }
                else if (primary == CustomAttribute.DEX)
                {
                    dexBonus += PrimaryIncrease * pcSkill.Rank;
                }
                else if (primary == CustomAttribute.CON)
                {
                    conBonus += PrimaryIncrease * pcSkill.Rank;
                }
                else if (primary == CustomAttribute.INT)
                {
                    intBonus += PrimaryIncrease * pcSkill.Rank;
                }
                else if (primary == CustomAttribute.WIS)
                {
                    wisBonus += PrimaryIncrease * pcSkill.Rank;
                }
                else if (primary == CustomAttribute.CHA)
                {
                    chaBonus += PrimaryIncrease * pcSkill.Rank;
                }

                // Secondary Bonuses
                if (secondary == CustomAttribute.STR)
                {
                    strBonus += SecondaryIncrease * pcSkill.Rank;
                }
                else if (secondary == CustomAttribute.DEX)
                {
                    dexBonus += SecondaryIncrease * pcSkill.Rank;
                }
                else if (secondary == CustomAttribute.CON)
                {
                    conBonus += SecondaryIncrease * pcSkill.Rank;
                }
                else if (secondary == CustomAttribute.INT)
                {
                    intBonus += SecondaryIncrease * pcSkill.Rank;
                }
                else if (secondary == CustomAttribute.WIS)
                {
                    wisBonus += SecondaryIncrease * pcSkill.Rank;
                }
                else if (secondary == CustomAttribute.CHA)
                {
                    chaBonus += SecondaryIncrease * pcSkill.Rank;
                }

                // Tertiary Bonuses
                if (tertiary == CustomAttribute.STR)
                {
                    strBonus += TertiaryIncrease * pcSkill.Rank;
                }
                else if (tertiary == CustomAttribute.DEX)
                {
                    dexBonus += TertiaryIncrease * pcSkill.Rank;
                }
                else if (tertiary == CustomAttribute.CON)
                {
                    conBonus += TertiaryIncrease * pcSkill.Rank;
                }
                else if (tertiary == CustomAttribute.INT)
                {
                    intBonus += TertiaryIncrease * pcSkill.Rank;
                }
                else if (tertiary == CustomAttribute.WIS)
                {
                    wisBonus += TertiaryIncrease * pcSkill.Rank;
                }
                else if (tertiary == CustomAttribute.CHA)
                {
                    chaBonus += TertiaryIncrease * pcSkill.Rank;
                }
            }

            // Check caps.
            if (strBonus > MaxAttributeBonus)
            {
                strBonus = MaxAttributeBonus;
            }
            if (dexBonus > MaxAttributeBonus)
            {
                dexBonus = MaxAttributeBonus;
            }
            if (conBonus > MaxAttributeBonus)
            {
                conBonus = MaxAttributeBonus;
            }
            if (intBonus > MaxAttributeBonus)
            {
                intBonus = MaxAttributeBonus;
            }
            if (wisBonus > MaxAttributeBonus)
            {
                wisBonus = MaxAttributeBonus;
            }
            if (chaBonus > MaxAttributeBonus)
            {
                chaBonus = MaxAttributeBonus;
            }

            // Apply item bonuses
            strBonus += itemBonuses.Strength;
            dexBonus += itemBonuses.Dexterity;
            conBonus += itemBonuses.Constitution;
            wisBonus += itemBonuses.Wisdom;
            intBonus += itemBonuses.Intelligence;
            chaBonus += itemBonuses.Charisma;

            // Check final caps
            if (strBonus > 55)
            {
                strBonus = 55;
            }
            if (dexBonus > 55)
            {
                dexBonus = 55;
            }
            if (conBonus > 55)
            {
                conBonus = 55;
            }
            if (intBonus > 55)
            {
                intBonus = 55;
            }
            if (wisBonus > 55)
            {
                wisBonus = 55;
            }
            if (chaBonus > 55)
            {
                chaBonus = 55;
            }

            // Apply attributes
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Strength, (int)strBonus + pcEntity.STRBase);
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Dexterity, (int)dexBonus + pcEntity.DEXBase);
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Constitution, (int)conBonus + pcEntity.CONBase);
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Intelligence, (int)intBonus + pcEntity.INTBase);
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Wisdom, (int)wisBonus + pcEntity.WISBase);
            NWNXCreature.SetRawAbilityScore(player, AbilityType.Charisma, (int)chaBonus + pcEntity.CHABase);

            // Apply AC
            int ac = EffectiveArmorClass(player, ignoreItem, itemBonuses);

            NWNXCreature.SetBaseAC(player, ac);

            // Apply BAB
            int bab = CalculateBAB(player, ignoreItem, itemBonuses);

            NWNXCreature.SetBaseAttackBonus(player, bab);

            // Apply HP
            int hp = EffectiveMaxHitPoints(player, itemBonuses);

            for (int level = 1; level <= 5; level++)
            {
                hp--;
                NWNXCreature.SetMaxHitPointsByLevel(player, level, 1);
            }

            for (int level = 1; level <= 5; level++)
            {
                if (hp >= 255) // Levels can only contain a max of 255 HP
                {
                    NWNXCreature.SetMaxHitPointsByLevel(player, level, 255);
                    hp = hp - 254;
                }
                else // Remaining value gets set to the level. (<255 hp)
                {
                    NWNXCreature.SetMaxHitPointsByLevel(player, level, hp + 1);
                    break;
                }
            }

            if (player.CurrentHP > player.MaxHP)
            {
                int amount = player.CurrentHP - player.MaxHP;
                var damage = _.EffectDamage(amount);
                _.ApplyEffectToObject(DurationType.Instant, damage, player.Object);
            }

            // Apply FP
            pcEntity.MaxFP = EffectiveMaxFP(player, itemBonuses);

            if (isInitialization)
            {
                pcEntity.CurrentFP = pcEntity.MaxFP;
            }

            DataService.SubmitDataChange(pcEntity, DatabaseActionType.Update);

            // Attempt a refresh of the character sheet UI in a second.
            _.DelayCommand(1.0f, () =>
            {
                NWNXPlayer.UpdateCharacterSheet(player);
            });
        }