protected static double GetTempDamage(BattleBaseAttrs caster, BattleBaseAttrs target, bool isTargetPlayer)
{
double finalAttack = BattleCalculator.GetFinalAttack(caster, isTargetPlayer);
double finalDefence = BattleCalculator.GetFinalDefence(target);
return(Math.Max(0.2 * finalAttack, Math.Min(finalAttack - finalDefence, 0.8 * finalAttack + Math.Max(0.0, 0.2 * finalAttack - finalDefence) / (double)Math.Max(1, caster.Lv - target.Lv))));
}
protected static double GetIgnoreTargetDamage(BattleBaseAttrs caster, bool isTargetPlayer, XDict <GameData.AttrType, long> casterTempAttrs)
{
if (isTargetPlayer)
{
return(((double)caster.Atk * (1.0 + (double)caster.AtkMulAmend * 0.001) + (double)caster.PvpAtk * (1.0 + (double)caster.PvpAtkMulAmend * 0.001)) * (double)caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, casterTempAttrs) * 0.001);
}
return(((double)caster.Atk * (1.0 + (double)caster.AtkMulAmend * 0.001) + (double)caster.PveAtk * (1.0 + (double)caster.PveAtkMulAmend * 0.001)) * (double)caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, casterTempAttrs) * 0.001);
}
protected static bool CheckHit(BattleBaseAttrs caster, BattleBaseAttrs target, StringBuilder sb = null)
{
int num = Random.Range(0, 1000);
if (sb != null)
{
sb.Append("A: " + num + "\n");
}
return(num < Math.Max(500, Math.Min(1000, caster.HitRatio - target.DodgeRatio)));
}
protected static bool CheckCrit(BattleBaseAttrs caster, BattleBaseAttrs target, out int randomIndex, StringBuilder sb = null)
{
int num = BattleCalculator.serverRandom.Next(0, 1000, out randomIndex);
if (sb != null)
{
sb.Append("B: " + num + "\n");
}
return(num < Math.Max(0, Math.Min(400, caster.CritRatio - target.DecritRatio)));
}
public static void AppDirectAttrChangeByTemplateID(BattleBaseAttrs entityBase, int templateID, bool isAdd = true)
{
if (entityBase == null)
{
return;
}
if (templateID == 0)
{
return;
}
if (isAdd)
{
entityBase.AddValuesByTemplateID(templateID);
}
else
{
entityBase.RemoveValuesByTemplateID(templateID);
}
}
public static int CalculateEffectCasterActPoint(BattleBaseAttrs caster, double effectCasterActPoint)
{
return((int)(effectCasterActPoint * (1.0 + (double)caster.ActPointRecoverSpeedAmend * 0.001)));
}
public static long CalculateTreatment(BattleBaseAttrs caster, BattleBaseAttrs target, bool isTargetPlayer, XDict <GameData.AttrType, long> casterTempAttrs, XDict <GameData.AttrType, long> targetTempAttrs)
{
return((long)(BattleCalculator.GetFinalAttack(caster, isTargetPlayer) * (double)caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, casterTempAttrs) * 0.001 * (1.0 + (double)target.HealIncreasePercent * 0.001) + (double)(target.RealHpLmt * caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, casterTempAttrs)) * 0.001 * (1.0 + (double)target.HealIncreasePercent * 0.001)));
}
public static long CalculateTreat2ment(BattleBaseAttrs target, XDict <GameData.AttrType, long> targetTempAttrs)
{
return(target.TryAddValue(GameData.AttrType.HpRestore, targetTempAttrs));
}
public static int CalculateKillRecover(BattleBaseAttrs source, BattleBaseAttrs target)
{
return(0);
}
public static int CalculateWeak(BattleBaseAttrs caster, XDict <GameData.AttrType, long> casterTempAttrs)
{
return((int)((double)caster.TryAddValue(GameData.AttrType.VpAtk, casterTempAttrs) * (1.0 + (double)caster.VpAtkMulAmend * 0.001)));
}
public static BattleCalculator.DamageResult CalculateDamage(BattleBaseAttrs caster, BattleBaseAttrs target, bool isCasterPlayer, bool isTargetPlayer, XDict <GameData.AttrType, long> casterTempAttrs, XDict <GameData.AttrType, long> targetTempAttrs)
{
FileStream fileStream = null;
StreamWriter streamWriter = null;
StringBuilder stringBuilder = null;
if (ClientApp.Instance.isShowFightLog)
{
string text = Application.get_dataPath() + "/../BattleLog.txt";
try
{
fileStream = new FileStream(text, 4, 3);
streamWriter = new StreamWriter(fileStream, Encoding.get_UTF8());
stringBuilder = new StringBuilder();
}
catch (Exception ex)
{
Debug.LogError("Can't Write Log File!\n" + ex.get_Message());
return(null);
}
stringBuilder.Append("Caster: \n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Atk, caster.Atk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Defence, caster.Defence) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveAtk, caster.PveAtk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpAtk, caster.PvpAtk) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HitRatio, caster.HitRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.CritRatio, caster.CritRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.CritHurtAddRatio, caster.CritHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DeparryRatio, caster.DeparryRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.SuckBloodScale, caster.SuckBloodScale) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HurtAddRatio, caster.HurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveHurtAddRatio, caster.PveHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpHurtAddRatio, caster.PvpHurtAddRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.AtkMulAmend, caster.AtkMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveAtkMulAmend, caster.PveAtkMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpAtkMulAmend, caster.PvpAtkMulAmend) + "\n");
stringBuilder.Append("Target: \n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.Defence, target.Defence) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HpLmt, target.HpLmt) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DodgeRatio, target.DodgeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DecritRatio, target.DecritRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.ParryRatio, target.ParryRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.ParryHurtDeRatio, target.ParryHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HurtDeRatio, target.ParryHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PveHurtDeRatio, target.PveHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.PvpHurtDeRatio, target.PvpHurtDeRatio) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.DefMulAmend, target.DefMulAmend) + "\n");
stringBuilder.Append(AttrUtility.GetStandardDesc(GameData.AttrType.HpLmtMulAmend, target.HpLmtMulAmend) + "\n");
stringBuilder.Append("Calculate: \n");
}
BattleCalculator.DamageResult damageResult = new BattleCalculator.DamageResult();
if (BattleCalculator.CheckHit(caster, target, stringBuilder))
{
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsHit: " + true + "\n");
}
bool flag = BattleCalculator.CheckParry(caster, target, out damageResult.parryRandomIndex, stringBuilder);
double finalParryAddRatio = BattleCalculator.GetFinalParryAddRatio(target, flag);
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsParry: " + flag + "\n");
}
bool flag2 = BattleCalculator.CheckCrit(caster, target, out damageResult.critRandomIndex, stringBuilder);
double finalCritAddRatio = BattleCalculator.GetFinalCritAddRatio(caster, flag2);
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsCrit: " + flag2 + "\n");
}
double tempDamage = BattleCalculator.GetTempDamage(caster, target, isTargetPlayer);
double holyDamage = BattleCalculator.GetHolyDamage(caster, target, casterTempAttrs);
double ignoreTargetDamage = BattleCalculator.GetIgnoreTargetDamage(caster, isTargetPlayer, casterTempAttrs);
double num = (double)BattleCalculator.GetCritAddDamage(caster, flag2);
List <double> list = new List <double>();
list.Add(tempDamage * (double)caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, casterTempAttrs) * 0.001 + (double)caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, casterTempAttrs));
list.Add(finalCritAddRatio);
list.Add(finalParryAddRatio);
list.Add((!isCasterPlayer || !isTargetPlayer) ? Math.Max(0.0, (1000.0 + (double)caster.PveHurtAddRatio - (double)target.PveHurtDeRatio) * 0.001) : Math.Max(0.0, (1000.0 + (double)caster.PvpHurtAddRatio - (double)target.PvpHurtDeRatio) * 0.001));
list.Add(Math.Max(0.0, (double)(1000 + caster.HurtAddRatio - target.HurtDeRatio) * 0.001));
double num2 = BattleCalculator.GetMultipleResult(list) + holyDamage + ignoreTargetDamage + num;
double num3 = Math.Max(1.0, num2 * (double)BattleCalculator.serverRandom.Next(9500, 10500, out damageResult.damageRandomIndex) * 9.9999997473787516E-05);
double num4 = BattleCalculator.CalculateLifeSteal(caster, (int)num3);
damageResult.IsMiss = false;
damageResult.IsCrit = flag2;
damageResult.IsParry = flag;
damageResult.Damage = (long)num3;
damageResult.Lifesteal = (long)num4;
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("TempDamage: " + tempDamage + "\n");
stringBuilder.Append("HolyDamage: " + holyDamage + "\n");
stringBuilder.Append("SkillNmlDmgScale: " + caster.TryAddValue(GameData.AttrType.SkillNmlDmgScale, casterTempAttrs) + "\n");
stringBuilder.Append("SkillNmlDmgAddAmend: " + caster.TryAddValue(GameData.AttrType.SkillNmlDmgAddAmend, casterTempAttrs) + "\n");
stringBuilder.Append("FixFinalDamage: " + num3 + "\n");
stringBuilder.Append("Lifesteal: " + num4 + "\n");
}
}
else
{
damageResult.parryRandomIndex = 0;
damageResult.critRandomIndex = 0;
damageResult.damageRandomIndex = 0;
damageResult.IsMiss = true;
damageResult.IsParry = false;
damageResult.IsCrit = false;
damageResult.Damage = 0L;
damageResult.Lifesteal = 0L;
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("IsHit: " + false + "\n");
}
}
if (ClientApp.Instance.isShowFightLog)
{
stringBuilder.Append("================================================================\n\n");
Debug.LogError(stringBuilder.ToString());
streamWriter.Write(stringBuilder.ToString());
streamWriter.Close();
fileStream.Close();
}
return(damageResult);
}
protected static double CalculateLifeSteal(BattleBaseAttrs caster, int finalDamage)
{
return((double)caster.SuckBloodScale * 0.001 * (double)finalDamage);
}
public static MapObjInfo CreateMonsterMapObjInfo(int poolID, int monsterTypeID, int monsterLevel, long ownerID, int camp, bool isBoss, Vector3 position, bool isFighting = true)
{
Monster monsterData = DataReader <Monster> .Get(monsterTypeID);
if (monsterData == null)
{
EntityWorld.Instance.ForceOut("没有数据", string.Format("Monster表根本没有怪物{0}的数据", monsterTypeID), null);
}
MonsterAttr monsterAttr = Enumerable.FirstOrDefault <MonsterAttr>(DataReader <MonsterAttr> .DataList, (MonsterAttr x) => x.lv == monsterLevel && x.id == monsterData.AttributeTemplateID);
if (monsterAttr == null)
{
EntityWorld.Instance.ForceOut("没有数据", string.Format("怪物属性表里没有模板ID{0} & 等级{1}的数据\n怪物id为{2}", monsterData.AttributeTemplateID, monsterLevel, monsterTypeID), null);
}
MapObjInfo mapObjInfo = new MapObjInfo();
mapObjInfo.objType = GameObjectType.ENUM.Soldier;
mapObjInfo.id = (long)poolID;
mapObjInfo.ownerId = ownerID;
mapObjInfo.typeId = monsterTypeID;
mapObjInfo.modelId = monsterData.model;
mapObjInfo.name = mapObjInfo.id.ToString();
mapObjInfo.rankValue = 0;
mapObjInfo.pos = new Pos();
mapObjInfo.pos.x = (float)((int)position.x * 100);
mapObjInfo.pos.y = (float)((int)position.z * 100);
mapObjInfo.vector = InstanceManager.GetMonsterFixBornDirection(monsterData.monsterBornDirection, position, ownerID, monsterData.scenePoint);
mapObjInfo.mapLayer = 0;
BattleBaseAttrs battleBaseAttrs = new BattleBaseAttrs();
battleBaseAttrs.SetValue(GameData.AttrType.Lv, monsterLevel, true);
battleBaseAttrs.SetValue(GameData.AttrType.HpLmt, monsterAttr.hp, true);
battleBaseAttrs.SetValue(GameData.AttrType.Atk, monsterAttr.atk, true);
battleBaseAttrs.SetValue(GameData.AttrType.Defence, monsterAttr.defence, true);
battleBaseAttrs.SetValue(GameData.AttrType.HitRatio, monsterAttr.hit, true);
battleBaseAttrs.SetValue(GameData.AttrType.DodgeRatio, monsterAttr.dex, true);
battleBaseAttrs.SetValue(GameData.AttrType.CritRatio, monsterAttr.crt, true);
battleBaseAttrs.SetValue(GameData.AttrType.DecritRatio, monsterAttr.penetration, true);
battleBaseAttrs.SetValue(GameData.AttrType.CritHurtAddRatio, monsterAttr.critHurtAddRatio, true);
battleBaseAttrs.SetValue(GameData.AttrType.ParryRatio, monsterAttr.parry, true);
battleBaseAttrs.SetValue(GameData.AttrType.DeparryRatio, monsterAttr.vigour, true);
battleBaseAttrs.SetValue(GameData.AttrType.ParryHurtDeRatio, monsterAttr.parryHurtDeRatio, true);
battleBaseAttrs.SetValue(GameData.AttrType.ActSpeed, monsterAttr.attackSpeed, true);
battleBaseAttrs.SetValue(GameData.AttrType.VpLmt, monsterAttr.Vp, true);
battleBaseAttrs.SetValue(GameData.AttrType.VpResume, monsterAttr.VpResume, true);
battleBaseAttrs.SetValue(GameData.AttrType.IdleVpResume, monsterAttr.IdleVpResume, true);
if (monsterData.propId != 0)
{
battleBaseAttrs.AddValuesByTemplateID(monsterData.propId);
}
battleBaseAttrs.SetValue(GameData.AttrType.HpLmt, (long)((double)battleBaseAttrs.GetValue(GameData.AttrType.HpLmt) * (1.0 + (double)monsterData.HpAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.Atk, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.Atk) * (1.0 + (double)monsterData.AttAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.Defence, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.Defence) * (1.0 + (double)monsterData.DefAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.HitRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.HitRatio) * (1.0 + (double)monsterData.HitAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.DodgeRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.DodgeRatio) * (1.0 + (double)monsterData.DexAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.CritRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.CritRatio) * (1.0 + (double)monsterData.CrtAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.DecritRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.DecritRatio) * (1.0 + (double)monsterData.PenAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.CritHurtAddRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.CritHurtAddRatio) * (1.0 + (double)monsterData.CthAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.ParryRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.ParryRatio) * (1.0 + (double)monsterData.ParAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.DeparryRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.DeparryRatio) * (1.0 + (double)monsterData.VigAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.ParryHurtDeRatio, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.ParryHurtDeRatio) * (1.0 + (double)monsterData.PrhAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.ActSpeed, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.ActSpeed) * (1.0 + (double)monsterData.AtsAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.VpLmt, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.VpLmt) * (1.0 + (double)monsterData.VpAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.VpResume, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.VpResume) * (1.0 + (double)monsterData.VsAmplificationRate * 0.001)), true);
battleBaseAttrs.SetValue(GameData.AttrType.IdleVpResume, (int)((double)battleBaseAttrs.GetValue(GameData.AttrType.IdleVpResume) * (1.0 + (double)monsterData.IvAmplificationRate * 0.001)), true);
mapObjInfo.battleInfo = LocalDimensionMonsterInfoCreator.CreateMonsterBattleBaseInfo(monsterData, battleBaseAttrs, camp, isBoss, isFighting);
return(mapObjInfo);
}
protected static double GetFinalParryAddRatio(BattleBaseAttrs target, bool isParry)
{
return((!isParry) ? 1.0 : ((double)Math.Max(200L, 1000L - BattleCalculator.battleConstParams.get_Item("base_parry_sub_dmg") - (long)target.ParryHurtDeRatio) * 0.001));
}
public static bool CalculateAddBuff(BattleBaseAttrs caster, BattleBaseAttrs target, double baseAddProb, int elementType)
{
double num = Math.Min(Math.Max(0.0, baseAddProb + (double)caster.GetBuffCtrlAttrs(elementType).AddProbAddAmend), 1000.0);
return((double)Random.Range(0, 1000) < num);
}
protected static double GetFinalDefence(BattleBaseAttrs target)
{
return((double)target.Defence * (1.0 + (double)target.DefMulAmend * 0.001));
}
protected static double GetFinalAttack(BattleBaseAttrs caster, bool isTargetPlayer)
{
return((!isTargetPlayer) ? ((double)caster.Atk * (1.0 + (double)caster.AtkMulAmend * 0.001) + (double)caster.PveAtk * (1.0 + (double)caster.PveAtkMulAmend * 0.001)) : ((double)caster.Atk * (1.0 + (double)caster.AtkMulAmend * 0.001) + (double)caster.PvpAtk * (1.0 + (double)caster.PvpAtkMulAmend * 0.001)));
}
protected static int GetCritAddDamage(BattleBaseAttrs caster, bool isCrit)
{
return((!isCrit) ? 0 : caster.CritAddValue);
}
protected static double GetFinalCritAddRatio(BattleBaseAttrs caster, bool isCrit)
{
return((!isCrit) ? 1.0 : ((double)(BattleCalculator.battleConstParams.get_Item("base_crt_dmg_addi") + (long)caster.CritHurtAddRatio) * 0.001));
}
protected static double GetHolyDamage(BattleBaseAttrs caster, BattleBaseAttrs target, XDict <GameData.AttrType, long> casterTempAttrs)
{
return((double)caster.TryAddValue(GameData.AttrType.SkillHolyDmgScaleBOCurHp, casterTempAttrs) * 0.001 * (double)target.Hp + (double)caster.TryAddValue(GameData.AttrType.SkillHolyDmgScaleBOMaxHp, casterTempAttrs) * 0.001 * (double)target.RealHpLmt);
}
protected static BattleBaseInfo CreateMonsterBattleBaseInfo(Monster monsterData, BattleBaseAttrs attrs, int camp, bool isBoss, bool isFighting = true)
{
if (attrs == null)
{
return(null);
}
BattleBaseInfo battleBaseInfo = new BattleBaseInfo();
battleBaseInfo.publicBaseInfo = new PublicBaseInfo();
battleBaseInfo.publicBaseInfo.simpleInfo = new SimpleBaseInfo();
battleBaseInfo.battleBaseAttr = new BattleBaseAttr();
battleBaseInfo.wrapType = GameObjectType.ENUM.Monster;
battleBaseInfo.camp = camp;
battleBaseInfo.publicBaseInfo.simpleInfo.MoveSpeed = DataReader <AvatarModel> .Get(monsterData.model).speed;
battleBaseInfo.publicBaseInfo.simpleInfo.AtkSpeed = attrs.ActSpeed;
battleBaseInfo.publicBaseInfo.simpleInfo.Lv = attrs.Lv;
battleBaseInfo.publicBaseInfo.simpleInfo.Fighting = attrs.Fighting;
battleBaseInfo.publicBaseInfo.simpleInfo.VipLv = attrs.VipLv;
battleBaseInfo.publicBaseInfo.Atk = attrs.Atk;
battleBaseInfo.publicBaseInfo.Defence = attrs.Defence;
battleBaseInfo.publicBaseInfo.HpLmt = attrs.HpLmt;
battleBaseInfo.publicBaseInfo.PveAtk = attrs.PveAtk;
battleBaseInfo.publicBaseInfo.PvpAtk = attrs.PvpAtk;
battleBaseInfo.publicBaseInfo.HitRatio = attrs.HitRatio;
battleBaseInfo.publicBaseInfo.DodgeRatio = attrs.DodgeRatio;
battleBaseInfo.publicBaseInfo.CritRatio = attrs.CritRatio;
battleBaseInfo.publicBaseInfo.DecritRatio = attrs.DecritRatio;
battleBaseInfo.publicBaseInfo.CritHurtAddRatio = attrs.CritHurtAddRatio;
battleBaseInfo.publicBaseInfo.ParryRatio = attrs.ParryRatio;
battleBaseInfo.publicBaseInfo.DeparryRatio = attrs.DeparryRatio;
battleBaseInfo.publicBaseInfo.ParryHurtDeRatio = attrs.ParryHurtDeRatio;
battleBaseInfo.publicBaseInfo.SuckBloodScale = attrs.SuckBloodScale;
battleBaseInfo.publicBaseInfo.HurtAddRatio = attrs.HurtAddRatio;
battleBaseInfo.publicBaseInfo.HurtDeRatio = attrs.HurtDeRatio;
battleBaseInfo.publicBaseInfo.PveHurtAddRatio = attrs.PveHurtAddRatio;
battleBaseInfo.publicBaseInfo.PveHurtDeRatio = attrs.PveHurtDeRatio;
battleBaseInfo.publicBaseInfo.PvpHurtAddRatio = attrs.PvpHurtAddRatio;
battleBaseInfo.publicBaseInfo.PvpHurtDeRatio = attrs.PvpHurtDeRatio;
battleBaseInfo.publicBaseInfo.AtkMulAmend = attrs.AtkMulAmend;
battleBaseInfo.publicBaseInfo.DefMulAmend = attrs.DefMulAmend;
battleBaseInfo.publicBaseInfo.HpLmtMulAmend = attrs.HpLmtMulAmend;
battleBaseInfo.publicBaseInfo.PveAtkMulAmend = attrs.PveAtkMulAmend;
battleBaseInfo.publicBaseInfo.PvpAtkMulAmend = attrs.PvpAtkMulAmend;
battleBaseInfo.battleBaseAttr.ActPointLmt = attrs.ActPointLmt;
battleBaseInfo.publicBaseInfo.ActPointRecoverSpeedAmend = attrs.ActPointRecoverSpeedAmend;
battleBaseInfo.publicBaseInfo.VpLmt = attrs.VpLmt;
battleBaseInfo.publicBaseInfo.VpLmtMulAmend = attrs.VpLmtMulAmend;
battleBaseInfo.publicBaseInfo.VpAtk = attrs.VpAtk;
battleBaseInfo.publicBaseInfo.VpAtkMulAmend = attrs.VpAtkMulAmend;
battleBaseInfo.publicBaseInfo.VpResume = attrs.VpResume;
battleBaseInfo.publicBaseInfo.IdleVpResume = attrs.IdleVpResume;
battleBaseInfo.publicBaseInfo.WaterBuffAddProbAddAmend = attrs.WaterBuffAddProbAddAmend;
battleBaseInfo.publicBaseInfo.WaterBuffDurTimeAddAmend = attrs.WaterBuffDurTimeAddAmend;
battleBaseInfo.publicBaseInfo.ThunderBuffAddProbAddAmend = attrs.ThunderBuffAddProbAddAmend;
battleBaseInfo.publicBaseInfo.ThunderBuffAddProbAddAmend = attrs.ThunderBuffAddProbAddAmend;
battleBaseInfo.publicBaseInfo.HealIncreasePercent = attrs.HealIncreasePercent;
battleBaseInfo.publicBaseInfo.CritAddValue = attrs.CritAddValue;
battleBaseInfo.publicBaseInfo.HpRestore = attrs.HpRestore;
battleBaseInfo.battleBaseAttr.BuffMoveSpeedMulPosAmend = 0;
battleBaseInfo.battleBaseAttr.BuffActSpeedMulPosAmend = 0;
battleBaseInfo.battleBaseAttr.SkillTreatScaleBOAtk = 0;
battleBaseInfo.battleBaseAttr.SkillTreatScaleBOHpLmt = 0;
battleBaseInfo.battleBaseAttr.SkillNmlDmgScale = 0;
battleBaseInfo.battleBaseAttr.SkillNmlDmgAddAmend = 0;
battleBaseInfo.battleBaseAttr.SkillHolyDmgScaleBOMaxHp = 0;
battleBaseInfo.battleBaseAttr.SkillHolyDmgScaleBOCurHp = 0;
battleBaseInfo.battleBaseAttr.Affinity = 0;
battleBaseInfo.battleBaseAttr.OnlineTime = 0;
battleBaseInfo.battleBaseAttr.ActPoint = attrs.ActPoint;
battleBaseInfo.battleBaseAttr.Hp = (long)((double)battleBaseInfo.publicBaseInfo.HpLmt * (1.0 + (double)battleBaseInfo.publicBaseInfo.HpLmtMulAmend * 0.001));
battleBaseInfo.battleBaseAttr.Vp = (int)((double)battleBaseInfo.publicBaseInfo.VpLmt * (1.0 + (double)battleBaseInfo.publicBaseInfo.VpLmtMulAmend * 0.001));
battleBaseInfo.ownedListIdx = 0;
battleBaseInfo.ownedIds.Clear();
for (int i = 0; i < monsterData.skill.get_Count(); i++)
{
battleBaseInfo.skills.Add(new BattleSkillInfo
{
skillIdx = i + 1,
skillId = monsterData.skill.get_Item(i)
});
}
battleBaseInfo.isLoading = false;
battleBaseInfo.isFit = false;
battleBaseInfo.isInFit = false;
battleBaseInfo.isFighting = isFighting;
battleBaseInfo.isFixed = false;
battleBaseInfo.isStatic = false;
battleBaseInfo.isTaunt = false;
battleBaseInfo.isSuperArmor = false;
battleBaseInfo.isIgnoreDmgFormula = false;
battleBaseInfo.isCloseRenderer = false;
battleBaseInfo.isStun = false;
battleBaseInfo.isMoveCast = false;
battleBaseInfo.isAssaulting = false;
battleBaseInfo.isKnocking = false;
battleBaseInfo.isSuspended = false;
battleBaseInfo.isSkillManaging = false;
battleBaseInfo.isSkillPressing = false;
battleBaseInfo.isBorning = true;
battleBaseInfo.isBoss = isBoss;
battleBaseInfo.pressingSkillId = 0;
battleBaseInfo.reliveTimes = 0;
return(battleBaseInfo);
}
