Kg.SeaTime/Service/Application.Domain/Tool/Base/FightCompute.cs

using Dm.util;

namespace Application.Domain;

public class FightCompute
{
    public static FightResultModel ComputeFight(UserAttrModel atkUser, UserAttrModel defUser)
    {
        int result = 0;
        int myHarm = 0;
        int otHarm = 0;
        List<string> myStateData = new List<string>();
        List<FightRemoveData> myRemData = new List<FightRemoveData>();
        List<string> otStateData = new List<string>();
        List<FightRemoveData> otRemData = new List<FightRemoveData>();

        var atkHandle = UnitFight(atkUser, defUser);
        myHarm += atkHandle.atkHarm;
        otHarm += atkHandle.defHarm;
        otStateData.AddRange(atkHandle.stateData);
        otRemData.AddRange(atkHandle.remData);
        if (defUser.IsSystem == 1) {
            var defHandle = UnitFight(defUser, atkUser);
            myHarm += defHandle.defHarm;
            otHarm += defHandle.atkHarm;
            myStateData.AddRange(defHandle.stateData);
            myRemData.AddRange(defHandle.remData);
        }

        return new FightResultModel() {
           result = result,
           myHarm = myHarm,
           otHarm = otHarm,
           myStateData = myStateData,
           myRemData = myRemData,
           otStateData = otStateData,
           otRemData = otRemData
        };
    }

    private static UnitFightResult UnitFight(UserAttrModel atkUser, UserAttrModel defUser)
    {
        int atkHarm = 0;
        int defHarm = 0;
        List<string> stateData = new List<string>();
        List<FightRemoveData> remData = new List<FightRemoveData>();
        //闪避处理
        if (defUser.Dodge > 0)
        {
            decimal dodgeRide = defUser.Dodge - atkUser.Deadly + defUser.DeadlyLess;
            if (dodgeRide > 0)
            {
                if (randomTrigger(dodgeRide))
                {
                    return new UnitFightResult()
                    {
                        atkHarm = 0,
                        defHarm = 0,
                        stateData = stateData,
                        remData = remData
                    };
                }
            }
        }

        //士气处理
        if (atkUser.upMorale > 0)
        {
            atkUser.minAtk = Convert.ToInt32(atkUser.minAtk * (1.0 + (atkUser.morale / atkUser.upMorale) * 0.3));
        }

        if (defUser.upMorale > 0)
        {
            defUser.defense = Convert.ToInt32(defUser.defense * (1.0 + (atkUser.morale / atkUser.upMorale) * 0.3));
        }

        if (atkUser.minAtk > defUser.defense && defUser.defense > 0)
        {
            double harmRide = (atkUser.minAtk - defUser.defense) / defUser.defense;
            harmRide = harmRide > 1.2 ? 1.2 : harmRide;
            double fight_Harm = harmRide * atkUser.maxAtk;
            defHarm +=Convert.ToInt32( 0 - fight_Harm);
        }
        else
        {
            defHarm = -1;
        }

        //暴击处理
        if (atkUser.Crit > 0)
        {
            if (randomTrigger(atkUser.Crit))
            {
                defHarm = Convert.ToInt32(defHarm * 1.5) ;
            }
        }

        //处理反弹
        if (defUser.Rebound > 0)
        {
            decimal reboundRide = defUser.Rebound = atkUser.ReboundLess;
            if (reboundRide > 0)
            {
                atkHarm += Convert.ToInt32( defHarm * reboundRide);
            }
        }

        defHarm +=Convert.ToInt32(0 -  atkUser.Harm_Add) ; //额外伤害
        //连击处理
        if (atkUser.Atk_Next > 0)
        {
            if (randomTrigger(atkUser.Atk_Next))
            {
                defHarm =Convert.ToInt32( defHarm * 1.3);
                atkHarm += Convert.ToInt32(atkHarm * 1.3) ;
            }
        }

        //免伤处理
        if (defUser.NoHarm > 0 && defHarm < -1)
        {
            defHarm = Convert.ToInt32( defHarm * (1 - defUser.NoHarm));
            defHarm = defHarm > 0 ? 0 : defHarm;
        }

        //吸血处理
        if (defHarm < 0 && atkUser.InBlood > 0)
        {
            decimal inBloodRide = atkUser.InBlood - defUser.Punish;
            if (inBloodRide > 0)
            {
                atkHarm += Convert.ToInt32((0 - defHarm) * inBloodRide);
            }
        }

        //#region  状态类处理
        decimal slow = atkUser.Slow - defUser.SlowLess;
        if (randomTrigger(slow))
        {
            stateData.Add("Slow");
        }

        decimal poison = atkUser.Poison - defUser.PoisonLess;
        if (randomTrigger(poison))
        {
            stateData.Add("Poison");
        }

        decimal curse = atkUser.Curse - defUser.CurseLess;
        if (randomTrigger(curse))
        {
            stateData.Add("Curse");
        }

        decimal weaken = atkUser.Weaken - defUser.WeakenLess;
        if (randomTrigger(weaken))
        {
            stateData.Add("Weaken");
        }

        decimal depressed = atkUser.Depressed - defUser.DepressedLess;
        if (randomTrigger(depressed))
        {
            stateData.Add("Depressed");
        }

        decimal breach = atkUser.Breach - defUser.BreachLess;
        if (randomTrigger(breach))
        {
            stateData.Add("Breach");
        }

        decimal palsyatk = atkUser.PalsyAtk - defUser.PalsyAtkLess;
        if (randomTrigger(palsyatk))
        {
            stateData.Add("PalsyAtk");
        }

        if (randomTrigger(atkUser.Del_Fashion))
        {
            if (defUser.code == nameof(UserEnum.AttrCode.Person))
            {
                remData.Add(new FightRemoveData()
                {
                    code = "Equ",
                    par = "Fashion",
                    count = 1
                });
            }
        }

        //#endregion
        
        return new UnitFightResult()
        {
            atkHarm = atkHarm,
            defHarm = defHarm,
            stateData = stateData,
            remData = remData
        };
    }

    private static bool randomTrigger(decimal rate)
    {
        Random random = new Random();
        double rand = random.NextDouble();
        return rand < Convert.ToDouble(rate);
    }
}

public class UnitFightResult
{
    public int atkHarm { get; set; }
    public int defHarm { get; set; }
    public List<string> stateData { get; set; }
    public List<FightRemoveData> remData { get; set; }
}