/// <summary>
/// 创建中立障碍物
/// </summary>
/// <param name="vo">数据</param>
private DisplayOwner CreateNPCObstacle(VOBase vo, CreateActorParam otherParam)
{
_npcObstacleDict.Add(vo.ObjID.ID, vo);
var fixItem = GameObject.CreatePrimitive(PrimitiveType.Cube);
// 设置父级
ParentManager.Instance().SetParent(fixItem, ParentManager.ObstacleParent);
fixItem.layer = LayerMask.NameToLayer("Scenery");
//fixItem.name += i;
var fix = fixItem.AddComponent<FixtureData>();
var unitWidth = ClusterManager.Single.UnitWidth;
var mapWidth = ClusterManager.Single.MapWidth;
var mapHeight = ClusterManager.Single.MapHeight;
var offsetPos = LoadMap.Single.transform.position;
fix.AllData.MemberData = new VOBase()
{
ObjID = new ObjectID(ObjectID.ObjectType.NPCObstacle),
SpaceSet = 1,
};
fix.transform.localScale = new Vector3(unitWidth, unitWidth, unitWidth);
fix.transform.position = Utils.NumToPosition(offsetPos, new Vector2(otherParam.X, otherParam.Y), unitWidth, mapWidth, mapHeight);
fix.X = otherParam.X * unitWidth - mapWidth * unitWidth * 0.5f + offsetPos.x;
fix.Y = otherParam.Y * unitWidth - mapHeight * unitWidth * 0.5f + offsetPos.z;
fix.Diameter = 1;
var result = new DisplayOwner(fixItem, fix);
// 添加至ClusterManager中
//ClusterManager.Single.Add(fix);
DisplayerManager.Single.AddElement(vo.ObjID, result);
return result;
}
static int CreateSkillInfo(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(SkillManager), typeof(int), typeof(int)))
{
SkillManager obj = (SkillManager)ToLua.ToObject(L, 1);
int arg0 = (int)LuaDLL.lua_tonumber(L, 2);
int arg1 = (int)LuaDLL.lua_tonumber(L, 3);
SkillInfo o = obj.CreateSkillInfo(arg0, arg1);
ToLua.PushObject(L, o);
return(1);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(SkillManager), typeof(int), typeof(DisplayOwner), typeof(int)))
{
SkillManager obj = (SkillManager)ToLua.ToObject(L, 1);
int arg0 = (int)LuaDLL.lua_tonumber(L, 2);
DisplayOwner arg1 = (DisplayOwner)ToLua.ToObject(L, 3);
int arg2 = (int)LuaDLL.lua_tonumber(L, 4);
SkillInfo o = obj.CreateSkillInfo(arg0, arg1, arg2);
ToLua.PushObject(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: SkillManager.CreateSkillInfo"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// 获取减伤
/// </summary>
/// <param name="active"></param>
/// <param name="target"></param>
/// <returns></returns>
private static float GetDemageLower(DisplayOwner active, DisplayOwner target)
{
var result = 0f;
// 计算减免加成与概率
if (target.ClusterData.AllData.SkillInfoList != null && target.ClusterData.AllData.SkillInfoList.Count > 0)
{
foreach (var skill in target.ClusterData.AllData.SkillInfoList)
{
if (skill.IsActive)
{
continue;
}
result += GetDemageChange(skill, target);
}
}
if (target.ClusterData.AllData.BuffInfoList != null && target.ClusterData.AllData.BuffInfoList.Count > 0)
{
foreach (var buff in target.ClusterData.AllData.BuffInfoList)
{
result += GetDemageChange(buff, target);
}
}
return(result);
}
/// <summary>
/// 加载buff类
/// 如果缓存中没有就从文件照片那个加载
/// </summary>
/// <param name="buffId">buffID</param>
/// <param name="receive">buff的接受者</param>
/// <param name="release">buff的释放者</param>
/// <param name="buffRank">Buff等级</param>
/// <returns></returns>
public BuffInfo CreateBuffInfo(int buffId, DisplayOwner receive, DisplayOwner release, int buffRank = 1)
{
BuffInfo result = null;
// 验证技能ID的有效性
if (buffId > 0)
{
// 检查缓存
if (buffDic.ContainsKey(buffId))
{
// 复制buff
result = buffDic[buffId];
}
else
{
// 加载文件内容
var buffTxt = GetBuffScript(buffId, SkillManager.Single.RunType);
if (!string.IsNullOrEmpty(buffTxt))
{
result = FormulaConstructor.BuffConstructor(buffTxt);
// 将其放入缓存
AddBuffInfo(result);
}
}
}
result = CopyBuffInfo(result);
result.ReplaceData(buffRank);
// 将实现放入实现列表
buffInstanceDic.Add(result.AddtionId, result);
result.ReceiveMember = receive;
result.ReleaseMember = release;
result.BuffRank = buffRank;
return(result);
}
/// <summary>
/// 将对象放入对象池
/// </summary>
/// <param name="objID"></param>
/// <param name="obj"></param>
public void PushPool(ObjectID objID, DisplayOwner obj)
{
var control = obj.GameObj.GetComponent <RanderControl>();
// 回收未确认下兵的单位时randerControl为null
if (control != null)
{
control.DestoryFSM();
if (control.bloodBarCom != null)
{
control.bloodBarCom.DestorySelf();
}
control.gameObject.SetActive(false);
GameObject.Destroy(control);
}
var soldierType = obj.ClusterData.AllData.MemberData.Name;
// 清理数据
ClearDisplayer(obj);
if (!displayPool.ContainsKey(soldierType))
{
displayPool.Add(soldierType, new Stack <GameObject>());
}
// 设置父级
obj.GameObj.transform.parent = ParentManager.Instance().GetParent(ParentManager.PoolParent).transform;
displayPool[soldierType].Push(obj.GameObj);
}
/// <summary>
/// 创建技能实例
/// </summary>
/// <param name="skillIdList">技能ID列表</param>
/// <param name="skillHolder">技能持有者</param>
/// <returns>技能信息列表</returns>
public IList <SkillInfo> CreateSkillInfoList(IList <int> skillIdList, DisplayOwner skillHolder = null)
{
List <SkillInfo> result = null;
if (skillIdList != null && skillIdList.Count > 0)
{
result = new List <SkillInfo>();
foreach (var skillId in skillIdList)
{
var skillInfo = CreateSkillInfo(skillId, skillHolder);
if (skillInfo != null)
{
result.Add(skillInfo);
}
}
// 根据CD时间排序
result.Sort((a, b) =>
{
if (a.CDTime > b.CDTime)
{
return(1);
}
return(-1);
});
}
return(result);
}
/// <summary>
/// 加载并创建技能实例
/// </summary>
/// <param name="skillNum">技能ID</param>
/// <param name="skillHolder">技能持有单位</param>
/// <param name="skillLevel">技能等级</param>
/// <returns>技能实例</returns>
public SkillInfo CreateSkillInfo(int skillNum, DisplayOwner skillHolder, int skillLevel = 1)
{
SkillInfo result = null;
// 验证技能ID的有效性
if (skillNum <= 0)
{
return(null);
}
// 检查缓存
if (SkillInfoDic.ContainsKey(skillNum))
{
// 复制技能数据
result = SkillInfoDic[skillNum];
}
else
{
// 从AB文件中加载
var skillTxt = GetSkillScript(skillNum, SkillManager.Single.RunType);
if (!string.IsNullOrEmpty(skillTxt))
{
result = FormulaConstructor.SkillConstructor(skillTxt);
// 将其放入缓存
AddSkillInfo(result);
}
}
result = CopySkillInfo(result);
result.ReleaseMember = skillHolder;
result.ReplaceData(skillLevel);
// 将技能实现放入实现列表
skillInstanceDic.Add(result.AddtionId, result);
return(result);
}
/// <summary>
/// 检测当前单位的触发事件
/// </summary>
private void CheckTrigger(DisplayOwner display)
{
var allData = display.ClusterData.AllData;
if (allData.MemberData != null)
{
// 触发当前单位的所有事件
SkillManager.Single.SetEachAction(allData.MemberData.ObjID, (type1, type2, trigger) =>
{
if (allData.SkillInfoList != null)
{
//Debug.Log("触发技能");
// 触发skill类
SkillManager.Single.CheckAndDoSkillInfo(allData.SkillInfoList, trigger);
}
if (allData.BuffInfoList != null)
{
//Debug.Log("触发buff");
// 技能触发完毕开始触发buff类
BuffManager.Single.CheckAndDoBuffInfo(allData.BuffInfoList, trigger);
}
// 计算伤害
settlementDamageOrCure(type1, type2, trigger, allData);
}, true);
PushTriggerData();
}
}
static int _CreateDisplayOwner(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 2)
{
UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.CheckUnityObject(L, 1, typeof(UnityEngine.GameObject));
PositionObject arg1 = (PositionObject)ToLua.CheckUnityObject(L, 2, typeof(PositionObject));
DisplayOwner obj = new DisplayOwner(arg0, arg1);
ToLua.PushObject(L, obj);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.GameObject), typeof(PositionObject), typeof(RanderControl)))
{
UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.CheckUnityObject(L, 1, typeof(UnityEngine.GameObject));
PositionObject arg1 = (PositionObject)ToLua.CheckUnityObject(L, 2, typeof(PositionObject));
RanderControl arg2 = (RanderControl)ToLua.CheckUnityObject(L, 3, typeof(RanderControl));
DisplayOwner obj = new DisplayOwner(arg0, arg1, arg2);
ToLua.PushObject(L, obj);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to ctor method: DisplayOwner.New"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// 计算技能伤害/治疗
/// </summary>
/// <param name="member"></param>
/// <param name="target">技能目标</param>
/// <param name="type">伤害或治疗</param>
/// <param name="unitType">伤害/治疗值类型</param>
/// <param name="calculationType">计算类型</param>
/// <param name="value">具体值, 必须大于等于0</param>
/// <returns>伤害/治疗具体量</returns>
public static float GetHurtForSkill(DisplayOwner member, DisplayOwner target, DemageOrCure type, HealthChangeType unitType, HealthChangeCalculationType calculationType, float value)
{
if (member == null ||
member.ClusterData == null ||
target == null ||
target.ClusterData == null ||
target.ClusterData.AllData.MemberData == null)
{
throw new Exception("目标对象为空.");
}
if (value < 0)
{
throw new Exception("伤害/治疗值不能为负数.");
}
var result = 0f;
// 区分伤害类型
switch (calculationType)
{
case HealthChangeCalculationType.Fix:
{
var zhanqianJueduizhi = member.ClusterData.AllData.MemberData.Attack1;
var zhandouJueduizhiAdd = 0.0f;
var zhanqianBaifenbiAdd = 0.0f;
var zhandouBaifenbiAdd = 0.0f;
// 伤害能力
var huoli = (zhanqianJueduizhi + zhandouJueduizhiAdd) * (1 + zhanqianBaifenbiAdd + zhandouBaifenbiAdd);
// 减伤
var jianshanglv = AdjustJianshang(member, target);
// 克制关系
var kezhixishu = AdjustKezhi(member, target);
//if (unitType == HealthChangeType.Percentage)
//{
// result = target.ClusterData.AllData.MemberData.TotalHp*value;
//}
var shanghaijiacheng = 0.0f;
var mianyijiacheng = 0.0f;
var jinengjiacheng = 0.0f;
// 计算增伤
shanghaijiacheng = GetDemageUpper(member, target);
// 计算减伤
mianyijiacheng = GetDemageLower(member, target);
result = huoli * (1 - jianshanglv) * kezhixishu *
(1 + Mathf.Max(-0.8f, (shanghaijiacheng - mianyijiacheng))) + jinengjiacheng;
}
break;
case HealthChangeCalculationType.Calculation:
break;
}
return(result);
}
public void StartFSM([NotNull] DisplayOwner obj)
{
//初始化状态机
fsm = new SoldierFSMSystem();
fsm.Display = obj;
// 初始化行为状态机
InitState(obj.ClusterData.AllData.MemberData.BehaviorType);
}
/// <summary>
/// 获取Display
/// </summary>
/// <param name="pObj">display对应的pObj</param>
/// <returns>pObj对应的DisplayOwner</returns>
public DisplayOwner GetElementByPositionObject(PositionObject pObj)
{
DisplayOwner result = null;
if (pObj != null)
{
result = GetElementById(pObj.AllData.MemberData.ObjID);
}
return(result);
}
/// <summary>
/// 判断攻守防是否满足克制关系
/// </summary>
/// <param name="active"></param>
/// <param name="target"></param>
/// <returns></returns>
public static float AdjustKezhi(DisplayOwner active, DisplayOwner target)
{
// TODO 本地缓存数据
//var config = SData_kezhi_c.Single.GetDataOfID(active.ClusterData.AllData.MemberData.ArmyType);
//if (config.KezhiType == target.ClusterData.AllData.MemberData.ArmyType)
//{
// return 1 + config.KezhiAdd;
//}
return(1.0f);
}
/// <summary>
/// 清空显示单位身上的脚本
/// </summary>
/// <param name="display">被清理单位包装类</param>
private void ClearDisplayer(DisplayOwner display)
{
if (display != null)
{
ClusterManager.Single.Remove(display.ClusterData);
display.GameObj.RemoveComponents(typeof(ClusterData));
display.ClusterData = null;
display.GameObj.RemoveComponents(typeof(TriggerRunner));
display.GameObj.RemoveComponents(typeof(RanderControl));
display.RanderControl = null;
}
}
static int CleanData(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
DisplayOwner obj = (DisplayOwner)ToLua.CheckObject(L, 1, typeof(DisplayOwner));
obj.CleanData();
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// 普通战斗伤害结算
/// </summary>
/// <param name="active">伤害发起的主动方</param>
/// <param name="target">伤害被动方</param>
/// <returns></returns>
public static float GetHurt(DisplayOwner active, DisplayOwner target)
{
var zhanqianJueduizhi = active.ClusterData.AllData.MemberData.Attack1;
var zhandouJueduizhiAdd = 0.0f;
var zhanqianBaifenbiAdd = 0.0f;
var zhandouBaifenbiAdd = 0.0f;
// 伤害能力
var huoli = (zhanqianJueduizhi + zhandouJueduizhiAdd) * (1 + zhanqianBaifenbiAdd + zhandouBaifenbiAdd);
// 暴击
var baojixishu = AdjustIsBaoji(active, target);
var hurtAdd = 0.0f;
var antiHurtAdd = 0.0f;
// 减伤
var jianshanglv = AdjustJianshang(active, target);
// 克制关系
var kezhixishu = AdjustKezhi(active, target);
var shanghaijiacheng = 0.0f;
var mianyijiacheng = 0.0f;
var jinengjiacheng = 0.0f;
/**
* 最终伤害=进攻方火力*（1-减伤率）*（IF（本次暴击，暴击伤害系数，1））*
* （IF（满足克制关系，1+克制伤害加成，1））*
* （1+Max（-40%，（进攻方伤害加成-防守方免伤加成）））+
* 攻守双方技能绝对值加成和
**/
if (baojixishu > 1)
{
IsCrit = true;
}
else
{
IsCrit = false;
}
// 计算增伤
shanghaijiacheng = GetDemageUpper(active, target);
// 计算减伤
mianyijiacheng = GetDemageLower(active, target);
var hurt = huoli * (1 - jianshanglv) * baojixishu * kezhixishu *
(1 + Mathf.Max(-0.8f, (shanghaijiacheng - mianyijiacheng))) + jinengjiacheng;
return(hurt);
}
///// <summary>
///// 创建技能数据包装类
///// 点对点方式
///// </summary>
///// <param name="startPos">技能起始位置</param>
///// <param name="targetPos">技能目标位置</param>
///// <param name="targetMaxCount">技能目标上限 如果-1则无数量限制</param>
///// <param name="skill">被释放技能</param>
///// <param name="isNotLethal">是否不致死</param>
///// <returns>数据包装类</returns>
//public FormulaParamsPacker GetFormulaParamsPacker(Vector3 startPos, Vector3 targetPos, int targetMaxCount, SkillBase skill, bool isNotLethal = false)
//{
// var result = new FormulaParamsPacker
// {
// StartPos = startPos,
// TargetPos = targetPos,
// TargetMaxCount = targetMaxCount,
// IsNotLethal = isNotLethal,
// Skill = skill
// };
// return result;
//}
/// <summary>
/// 创建技能数据包装类
/// 对象对对象方式
/// </summary>
/// <param name="startObj">起始对象</param>
/// <param name="targetObj">目标对象</param>
/// <param name="skill">被释放技能</param>
/// <param name="targetMaxCount">技能目标上限 如果-1则无数量限制</param>
/// <param name="isNotLethal">是否不致死</param>
/// <returns>数据包装类</returns>
public FormulaParamsPacker GetFormulaParamsPacker(DisplayOwner startObj, DisplayOwner targetObj, SkillBase skill, int targetMaxCount, bool isNotLethal = false)
{
var result = new FormulaParamsPacker()
{
ReleaseMember = startObj,
ReceiverMenber = targetObj,
TargetMaxCount = targetMaxCount,
IsNotLethal = isNotLethal,
Skill = skill,
StartPos = startObj != null ? startObj.ClusterData.transform.position : Vector3.zero,
TargetPos = targetObj != null ? targetObj.ClusterData.transform.position : Vector3.zero,
SkillLevel = skill == null ? 1 : skill.Level
};
return(result);
}
static int CreateUnit(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
int arg0 = (int)LuaDLL.luaL_checknumber(L, 1);
CreateActorParam arg1 = (CreateActorParam)ToLua.CheckObject(L, 2, typeof(CreateActorParam));
DisplayOwner o = FightUnitFactory.CreateUnit(arg0, arg1);
ToLua.PushObject(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static int get_ClusterData(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
PositionObject ret = obj.ClusterData;
ToLua.Push(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index ClusterData on a nil value" : e.Message));
}
}
/// <summary>
/// 伤害增强/减免计算
/// </summary>
/// <param name="skill">被计算技能</param>
/// <param name="target">被计算目标</param>
/// <returns></returns>
private static float GetDemageChange(SkillBase skill, DisplayOwner target)
{
var result = 0f;
if (skill.DemageChangeProbability > 0 && skill.DemageChange > 0)
{
if (skill.DemageChangeProbability >= 1 ||
RandomPacker.Single.GetRangeI(0, 100) <= skill.DemageChangeProbability * 100)
{
if (Check(skill, target.ClusterData.AllData.MemberData))
{
result += skill.DemageChange;
}
}
}
return(result);
}
static int set_GameObj(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
UnityEngine.GameObject arg0 = (UnityEngine.GameObject)ToLua.CheckUnityObject(L, 2, typeof(UnityEngine.GameObject));
obj.GameObj = arg0;
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index GameObj on a nil value" : e.Message));
}
}
static int set_ReleaseMember(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
AbilityBase obj = (AbilityBase)o;
DisplayOwner arg0 = (DisplayOwner)ToLua.CheckObject(L, 2, typeof(DisplayOwner));
obj.ReleaseMember = arg0;
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index ReleaseMember on a nil value" : e.Message));
}
}
static int get_ReleaseMember(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
AbilityBase obj = (AbilityBase)o;
DisplayOwner ret = obj.ReleaseMember;
ToLua.PushObject(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index ReleaseMember on a nil value" : e.Message));
}
}
static int get_RanderControl(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
RanderControl ret = obj.RanderControl;
ToLua.Push(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index RanderControl on a nil value" : e.Message));
}
}
static int CreateSkillInfoList(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
SkillManager obj = (SkillManager)ToLua.CheckObject(L, 1, typeof(SkillManager));
System.Collections.Generic.IList <int> arg0 = (System.Collections.Generic.IList <int>)ToLua.CheckObject(L, 2, typeof(System.Collections.Generic.IList <int>));
DisplayOwner arg1 = (DisplayOwner)ToLua.CheckObject(L, 3, typeof(DisplayOwner));
System.Collections.Generic.IList <SkillInfo> o = obj.CreateSkillInfoList(arg0, arg1);
ToLua.PushObject(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static int get_GameObj(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
UnityEngine.GameObject ret = obj.GameObj;
ToLua.Push(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index GameObj on a nil value" : e.Message));
}
}
static int set_ClusterData(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
PositionObject arg0 = (PositionObject)ToLua.CheckUnityObject(L, 2, typeof(PositionObject));
obj.ClusterData = arg0;
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index ClusterData on a nil value" : e.Message));
}
}
static int set_RanderControl(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
DisplayOwner obj = (DisplayOwner)o;
RanderControl arg0 = (RanderControl)ToLua.CheckUnityObject(L, 2, typeof(RanderControl));
obj.RanderControl = arg0;
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index RanderControl on a nil value" : e.Message));
}
}
/// <summary>
/// 判断是否穿甲
/// </summary>
/// <param name="active">攻击方</param>
/// <param name="target">被攻击方</param>
/// <returns></returns>
public static float AdjustJianshang(DisplayOwner active, DisplayOwner target)
{
/**
* 穿甲=（战前值+战斗中绝对值加成和）*（1+战前加成和+战斗中百分比加成和）
* PS1:战斗中加成目前已知来源：被附加的BUFF，友方的光环
* PS2:战斗中的加成因为BUFF的属性，所以这里的加成和是计算增益减益和
* 防御=（战前值+战斗中绝对值加成和）*（1+战前加成和+战斗中百分比加成和）
* 装甲=（战前值+战斗中绝对值加成和）*（1+战前加成和+战斗中百分比加成和）
* */
//战斗中绝对值加成和
var chuanjiaJueduizhiAdd = 0.0f;
var chuanjiaBaifenbiAdd = 0.0f;
var chuanjiaZhanqianAdd = 0.0f;
var chuanjiashuxing = active.ClusterData.AllData.MemberData.AntiArmor;
var chuanjia = (chuanjiashuxing + chuanjiaJueduizhiAdd) * (1 + chuanjiaZhanqianAdd + chuanjiaBaifenbiAdd);
var fangyuJueduizhiAdd = 0.0f;
var fangyuBaifenbiAdd = 0.0f;
var fangyuZhanqianAdd = 0.0f;
var fangyuShuxing = target.ClusterData.AllData.MemberData.Defence;
var fangyu = (fangyuShuxing + chuanjiaJueduizhiAdd) * (1 + fangyuZhanqianAdd + fangyuBaifenbiAdd);
var zhuangjiaJueduizhiADD = 0.0f;
var zhuangjiaBaifenbiiADD = 0.0f;
var zhuangjiaZhanqianADD = 0.0f;
var zhuangjiaShuxing = target.ClusterData.AllData.MemberData.Armor;
var zhuangjia = (zhuangjiaShuxing + zhuangjiaJueduizhiADD) * (1 + zhuangjiaZhanqianADD + zhuangjiaBaifenbiiADD);
//判定攻击是否无视防御或装甲,攻击方有几率无视防御或装甲的技能，在1 - 1000中取随机整数a
var wushifangyu = 0.0f;
var wushizhuangjia = 0.0f;
// TODO 包装随机
//var ran = new QKRandom((int)DateTime.Now.Ticks);
var a = RandomPacker.Single.GetRangeI(0, 1000);
var a1 = RandomPacker.Single.GetRangeI(0, 1000);
fangyu = a <= wushifangyu * 1000 ? 0 : fangyu;
zhuangjia = a1 <= wushizhuangjia * 1000 ? 0 : zhuangjia;
return((fangyu + Mathf.Max(0, zhuangjia - chuanjia)) /
(fangyu + Mathf.Max(0, zhuangjia - chuanjia) + 2000));
}
///// <summary>
///// 创建技能数据包装类
///// 对象对对象方式
///// </summary>
///// <param name="startPos">技能起始位置</param>
///// <param name="targetPos">技能目标位置</param>
///// <param name="startObj">起始对象</param>
///// <param name="targetObj">目标对象</param>
///// <param name="skill">被释放技能</param>
///// <param name="targetMaxCount">技能目标上限 如果-1则无数量限制</param>
///// <param name="isNotLethal">是否不致死</param>
///// <returns>数据包装类</returns>
//public FormulaParamsPacker GetFormulaParamsPacker(Vector3 startPos, Vector3 targetPos, DisplayOwner startObj, DisplayOwner targetObj, SkillBase skill, int targetMaxCount, bool isNotLethal = false)
//{
// var result = new FormulaParamsPacker()
// {
// ReleaseMember = startObj,
// ReceiverMenber = targetObj,
// TargetMaxCount = targetMaxCount,
// IsNotLethal = isNotLethal,
// Skill = skill
// };
// return result;
//}
/// <summary>
/// 创建技能数据包装类
/// 对象对对象方式
/// </summary>
/// <param name="skill">技能对象</param>
/// <param name="startObj">起始对象</param>
/// <param name="targetObj">目标对象</param>
/// <param name="isNotLethal">是否不致死</param>
/// <returns>数据包装类</returns>
public FormulaParamsPacker GetFormulaParamsPacker(SkillBase skill, DisplayOwner startObj, DisplayOwner targetObj, bool isNotLethal = false)
{
var result = new FormulaParamsPacker()
{
DataList = skill.DataList,
// TODO 技能等级, 最大目标数量
SkillLevel = skill.Level,
SkillNum = skill.Num,
ReceiverMenber = targetObj,
ReleaseMember = startObj,
StartPos = startObj.ClusterData.gameObject.transform.position,
TargetPos = targetObj.ClusterData.gameObject.transform.position,
IsNotLethal = isNotLethal,
Skill = skill,
};
return(result);
}
