Пример #1
0
        public override string ToString()
        {
            string weaponString = base.ToString() + ", ";

            weaponString += NumberHands.ToString() + ", ";
            weaponString += AttackValue.ToString() + ", ";
            weaponString += AttackModifier.ToString() + ", ";
            weaponString += DamageValue.ToString() + ", ";
            weaponString += DamageModifier.ToString();

            foreach (string s in AllowableClasses)
            {
                weaponString += ", " + s;
            }

            return(weaponString);
        }
Пример #2
0
        public override string ToString()
        {
            string weapString = base.ToString() + ", ";

            weapString += NumberHands.ToString() + ", ";
            weapString += AttackValue.ToString() + ", ";
            weapString += AttackModifier.ToString() + ", ";
            weapString += DamageValue.ToString() + ", ";
            weapString += DamageModifier.ToString() + ", ";

            foreach (Type t in allowableClasses)
            {
                weapString += ", " + t.Name;
            }

            return(base.ToString());
        }
Пример #3
0
    public override void ResultExpr(float[] param)
    {
        base.ResultExpr(param);
        if (param == null || param.Length < 5)
        {
            return;
        }
        Actor target = ActorManager.Singleton.Lookup(TargetID);

        if (null == target)
        {
            return;
        }
        Actor source = ActorManager.Singleton.Lookup(SourceID);

        if (null == source)
        {
            return;
        }
        //物理、魔法加成
        float phyAdd = 0, magAdd = 0;
        //攻击力倍数的修正
        float modifyValue = 0;
        //伤害修正
        float           damageModify = 1;
        SkillResultInfo info         = GameTable.SkillResultTableAsset.Lookup(SkillResultID);

        if (null != info)
        {
            if (info.MinComboCount > 0)
            {
                if (source.Combo != null && source.Combo.TotalComboNumber >= info.MinComboCount)
                {
                    phyAdd = info.PhyAttackAdd;
                    magAdd = info.MagAttackAdd;
                }
            }
            if (source.Combo != null)
            {
                int comboNumber = source.Combo.TotalComboNumber;
                if (comboNumber > 44)
                {
                    comboNumber = 44;
                }
                modifyValue = (int)(1.0f / 15.0f * comboNumber) * info.AttackModify;
            }
            if (info.ComboNum > 0)
            {
                damageModify = DamageModify;
            }
            if (info.IsWeakenComboTime)
            {
                target.OnWeakenComboTime(info.WeakenComboTime);
            }
        }
        {//结算
            switch ((ENDamageType)param[0])
            {
                #region enDamageFixed
            case ENDamageType.enDamageFixed:    //固定伤害
            {
                float damage = 0.0f;
                if (param[1] != 0)
                {        //固定伤害
                    damage = param[1];
                }
                if (param[2] != 0)
                {        //百分比上下浮动
                    //目标的伤害系数
                    float woundParam = target.Props.GetProperty_Float(ENProperty.WoundParam);
                    damage *= (woundParam != 0 ? woundParam : 1);
                    damage *= UnityEngine.Random.Range(1 - param[2], 1 + param[2]);
                }
                DamageValue = damage;
            }
            break;

                #endregion
                #region enPhyDamageTimes
            case ENDamageType.enPhyDamageTimes:    //物理攻击倍数伤害
            {
                float srcAttackValue = source.Props.GetProperty_Float(ENProperty.phyattack);
                if (param[1] != 0)
                {        //物理攻击力的倍数
                    srcAttackValue *= (param[1] + modifyValue);
                }
                srcAttackValue += phyAdd;
                float damage = srcAttackValue - target.Props.GetProperty_Float(ENProperty.phydefend);
                float min    = GameTable.WorldParamTableAsset.Lookup((int)ENWorldParamIndex.enPhyAttackMinValue).FloatTypeValue;
                if (damage < srcAttackValue * min)
                {        //伤害最低为物理攻击*物理攻击力的最小值
                    damage = srcAttackValue * min;
                }
                else
                {
                    if (param[2] != 0)
                    {        //百分比上下浮动
                        //目标的伤害系数
                        float woundParam = target.Props.GetProperty_Float(ENProperty.WoundParam);
                        damage *= (woundParam != 0 ? woundParam : 1);
                        damage *= UnityEngine.Random.Range(1 - param[2], 1 + param[2]);
                    }
                }
                DamageValue   = damage;
                m_attackValue = source.Props.GetProperty_Float(ENProperty.phyattack);
            }
            break;

                #endregion
                #region enMagDamageTimes
            case ENDamageType.enMagDamageTimes:    //魔法攻击倍数伤害
            {
                float srcAttackValue = source.Props.GetProperty_Float(ENProperty.magattack);
                if (param[1] != 0)
                {        //魔法攻击力的倍数
                    srcAttackValue *= (param[1] + modifyValue);
                }
                srcAttackValue += magAdd;
                float damage = srcAttackValue - target.Props.GetProperty_Float(ENProperty.magdefend);
                float min    = GameTable.WorldParamTableAsset.Lookup((int)ENWorldParamIndex.enMagAttackMinValue).FloatTypeValue;
                if (damage < srcAttackValue * min)
                {        //伤害最低为魔法攻击的10%
                    damage = srcAttackValue * min;
                }
                else
                {
                    if (param[2] != 0)
                    {        //百分比上下浮动
                        //目标的伤害系数
                        float woundParam = target.Props.GetProperty_Float(ENProperty.WoundParam);
                        damage *= (woundParam != 0 ? woundParam : 1);
                        damage *= UnityEngine.Random.Range(1 - param[2], 1 + param[2]);
                    }
                }
                DamageValue   = damage;
                m_attackValue = source.Props.GetProperty_Float(ENProperty.magattack);
            }
            break;

                #endregion
                #region enDamagePercent
            case ENDamageType.enDamagePercent:
            {
                float percent = param[1];
                if (percent > 0 && percent < 1)
                {
                    float damage = target.MaxHP * percent;
                    float random = param[2];
                    if (random != 0)
                    {        //百分比上下浮动
                        //目标的伤害系数
                        float woundParam = target.Props.GetProperty_Float(ENProperty.WoundParam);
                        damage *= (woundParam != 0 ? woundParam : 1);
                        damage *= UnityEngine.Random.Range(1 - param[2], 1 + param[2]);
                    }
                    DamageValue = damage;
                }
            }
            break;

                #endregion
                #region enDamageSunder
            case ENDamageType.enDamageSunder:
            {
                float srcAttackValue = source.Props.GetProperty_Float(ENProperty.phyattack);
                srcAttackValue += phyAdd;
                float damage = srcAttackValue - target.Props.GetProperty_Float(ENProperty.phydefend) * param[1];
                if (damage < srcAttackValue * 0.1f)
                {        //伤害最低为物理攻击的10%
                    damage = srcAttackValue * 0.1f;
                }
                else
                {
                    if (param[2] != 0)
                    {        //百分比上下浮动
                        //目标的伤害系数
                        float woundParam = target.Props.GetProperty_Float(ENProperty.WoundParam);
                        damage *= (woundParam != 0 ? woundParam : 1);
                        damage *= UnityEngine.Random.Range(1 - param[2], 1 + param[2]);
                    }
                }
                DamageValue   = damage;
                m_attackValue = source.Props.GetProperty_Float(ENProperty.phyattack);
            }
            break;

                #endregion
                #region enDistancePhyDamageTimes
            case ENDamageType.enPhyDamageDistance:
            {
                SkillInfo skillInfo = GameTable.SkillTableAsset.Lookup(SkillID);
                if (skillInfo == null)
                {
                    return;
                }
                float range = 0;
                float d     = ActorTargetManager.GetTargetDistance(source.RealPos, target.RealPos);
                if (d < param[1])
                {
                    range = param[1];
                }
                else if (d > param[2])
                {
                    range = param[2];
                }
                else
                {
                    range = d;
                }
                float attackValue = source.Props.GetProperty_Float(ENProperty.phyattack);
                float defend      = target.Props.GetProperty_Float(ENProperty.phydefend);
                DamageValue = attackValue * (range / skillInfo.AttackDistance) * param[3] - defend;
                float min = GameTable.WorldParamTableAsset.Lookup((int)ENWorldParamIndex.enPhyAttackMinValue).FloatTypeValue;
                if (DamageValue < attackValue * min)
                {
                    DamageValue = attackValue * min;
                }
            }
            break;

                #endregion
                #region enDistanceMagDamageTimes
            case ENDamageType.enMagDamageDistance:
            {
                SkillInfo skillInfo = GameTable.SkillTableAsset.Lookup(SkillID);
                if (skillInfo == null)
                {
                    return;
                }
                float range = 0;
                float d     = ActorTargetManager.GetTargetDistance(source.RealPos, target.RealPos);
                if (d < param[1])
                {
                    range = param[1];
                }
                else if (d > param[2])
                {
                    range = param[2];
                }
                else
                {
                    range = d;
                }
                float attackValue = source.Props.GetProperty_Float(ENProperty.magattack);
                float defend      = target.Props.GetProperty_Float(ENProperty.magdefend);
                DamageValue = attackValue * (range / skillInfo.AttackDistance) * param[3] - defend;
                float min = GameTable.WorldParamTableAsset.Lookup((int)ENWorldParamIndex.enMagAttackMinValue).FloatTypeValue;
                if (DamageValue < attackValue * min)
                {
                    DamageValue = attackValue * min;
                }
            }
            break;

                #endregion
            default:
                break;
            }
            DamageResultType = (ENDamageResultType)param[4];
            if (DamageValue != 0)
            {
                DamageValue *= damageModify;
                if (UnityEngine.Random.Range(0.0f, 1f) < source.Props.GetProperty_Float(ENProperty.crit))
                {//暴击
                    m_isCrit     = true;
                    DamageValue *= (source.Props.GetProperty_Float(ENProperty.critParam));
                }
            }
            else
            {
                Debug.LogWarning("damage result is error, damage is " + DamageValue.ToString()
                                 + ", source actor id is " + source.ID.ToString());
            }
        }
    }