/// <summary>
/// 普通搜索
/// </summary>
/// <param name="context"></param>
/// <param name="data"></param>
/// <param name="param"></param>
private void NormalSearch(ISkillContext context,
SkillActionData data, CommonParam param)
{
NormalGetTargets(context, data, param);
FilterTarget(context, data, param);
}
private Vector3 GetCenterTarget(ISkillContext context,
SkillActionData data, CommonParam param)
{
var centerType = (SkillTargetCenter)data.Center;
Vector3 pos = Vector3.zero;
switch (centerType)
{
case SkillTargetCenter.Caster:
pos = context.GetSelfActor().GetTransform().position;
break;
case SkillTargetCenter.Target:
pos = param.ActorClicked?.GetTransform().position ?? pos;
break;
case SkillTargetCenter.Point:
pos = param.Postion;
break;
case SkillTargetCenter.Attacker:
//todo
break;
case SkillTargetCenter.Projectile:
//todo
break;
case SkillTargetCenter.ProjectileHitPoint:
//todo
break;
}
return(pos);
}
public static bool ExecRate(out int hitRate, int rate, ISkillContext context, EnumBuffExec execType)
{
hitRate = rate;
int maxRate = SkillDefines.MAXStorePercent;
switch (execType)
{
case EnumBuffExec.None:
return(true);
case EnumBuffExec.IgnoreHit:
if (context.RandomPercent(maxRate) <= rate)
{
hitRate = maxRate;
}
else
{
hitRate = 0;
}
return(true);
case EnumBuffExec.MustHit:
if (context.RandomPercent(maxRate) <= rate)
{
hitRate = maxRate;
}
else
{
hitRate = 0;
}
return(hitRate > 0);
}
return(true);
}
public static void LoadPlayerSkills(ISkillContext context, ISkillPlayer owner, List <string> skills)
{
if (null == owner.SkillCore)
{
owner.SkillCore = new SkillCore(context);
}
owner.SkillCore.LoadSkill(owner, skills);
}
public void Init(ISkillContext context)
{
this.mContext = context;
buffMap = new MapList <int, IBuff>();
stateMap = new Dictionary <int, int>();
buffTimerMap = new Dictionary <int, Queue <int> >();
timerService = ServiceLocate.Instance.GetService <TimerService>();
}
public Skill(ISkillContext context, ISkillOwner owner, string args)
{
this._context = context;
this._owner = owner;
this._args = args;
this.boostCore = new BoostCore(context);
this.SubEffectors = new List <IEffector>();
this.RedoEffectors = new List <IEffector>();
}
public virtual void Init(SkillData skillData, ISkillContext skillContext)
{
data = skillData;
context = skillContext;
id = data?.Id ?? 0;
skillParamDic = new Dictionary <int, CommonParam>();
buffParamDic = new Dictionary <int, CommonParam>();
skillRecordDic = new Dictionary <int, Dictionary <int, int> >();
isInit = true;
OnOwnedSkill(identifyId);
}
public void Init(ISkillContext context)
{
if (context == null)
{
return;
}
skillContext = context;
skills = SkillWorldContext.CreateSKillList(context);
isInit = true;
}
public void GetTargets(ISkillContext context,
SkillActionData data, CommonParam param)
{
if (param.IsBounce && param.BounceParam.BounceTime > 1) //弹射
{
BounceSearch(context, data, param);
}
else
{
NormalSearch(context, data, param);
}
}
public SkillCore(ISkillContext context)
{
this._context = context;
var dic = new Dictionary <EnumSkillTimeType, List <ISkill> >(6);
dic[EnumSkillTimeType.Session] = new List <ISkill>();
dic[EnumSkillTimeType.Section] = new List <ISkill>();
dic[EnumSkillTimeType.Minute] = new List <ISkill>();
dic[EnumSkillTimeType.Round] = new List <ISkill>();
dic[EnumSkillTimeType.PreDecide] = new List <ISkill>();
this._skillDic = dic;
this._skillList = new List <ISkill>();
}
public static int GetTimeWeight(ISkillContext context, EnumSkillTimeType timeType)
{
switch (timeType)
{
case EnumSkillTimeType.Minute:
return(context.RoundPerMinute);
case EnumSkillTimeType.Section:
return(context.RoundPerSection);
default:
return(1);
}
}
private bool IsValid(ISkill skill, int id, int identifyId, bool isBuff, ref SkillActionData data)
{
if (skill == null)
{
SkillUtil.LogError("skill is nullptr");
return(false);
}
data = SkillUtil.GetSkillActionData(id);
ISkillContext skillContext = skill.GetContext();
if (data == null)
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "技能数据尚未初始化");
return(false);
}
if (skillContext == null)
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "技能数据尚未初始化");
return(false);
}
var param = skill.GetParam(identifyId, isBuff);
if (param == null)
{
return(false);
}
SkillTargetSearch.Instance.GetTargets(skillContext, data, param);
if (!param.HasTargets())
{
if (param.IsBounce)
{
SkillUtil.Log(SkillUtil.GetSkillDebugDes(skill) + "技能没有目标 弹射结束");
skill.RemoveSkillAction(data.Id, param);
}
else
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "ActionID->" + id + " 技能没有目标");
}
return(false);
}
return(true);
}
private void FilterTarget(ISkillContext context, SkillActionData data, CommonParam param)
{
removelist.Clear();
var targets = param.Targets;
var needTeamType = (SkillTargetTeamType)data.Team;
for (int i = 0; i < targets.Count; i++)
{
var target = targets[i];
if (needTeamType != SkillTargetTeamType.ALl) //阵营
{
var targetTeamType = target.GetTargetTeamType();
if (target == context.GetSelfActor()) //todo 待数据层成型 删除
{
targetTeamType = SkillTargetTeamType.Friend;
}
if (targetTeamType != needTeamType)
{
removelist.Add(target);
}
}
if (!data.Type.Contains((int)SkillTargetType.All)) //类型
{
for (int j = 0; j < data.Type.Count; j++)
{
var needType = (SkillTargetType)data.Type[j];
if (needType == target.GetTargetType())
{
break;
}
if (j == data.Type.Count - 1)
{
removelist.Add(target);
}
}
}
}
for (int i = 0; i < removelist.Count; i++)
{
targets.Remove(removelist[i]);
}
}
public static void LoadHideSkills(ISkillContext context, ISkillManager owner)
{
var hideSkills = RawSkillCache.Instance().GetHideSkills();
if (hideSkills.Count == 0)
{
return;
}
ISkill skill = null;
foreach (var rawSkill in hideSkills)
{
skill = new Skill(context, owner, "");
skill.Load(rawSkill);
skill.Invoke();
}
}
public static EnumSkillTimeType CheckSkillTime(ISkillContext context)
{
int round = context.MatchRound;
if (round <= 0)
{
return(EnumSkillTimeType.Session);
}
int weight = context.RoundPerSection;
if (weight > 0 && round % weight == 1)
{
return(EnumSkillTimeType.Section);
}
weight = context.RoundPerMinute;
if (weight > 0 && round % weight == 1)
{
return(EnumSkillTimeType.Minute);
}
return(EnumSkillTimeType.Round);
}
static List <ISkill> CreateFakeSkillDatas(ISkillContext skillContext)
{
if (skillContext == null)
{
SkillUtil.LogError("skillContext is Null");
return(null);
}
List <ISkill> dataList = new List <ISkill>();
int skillContextId = skillContext.GetSkillContextId();
if (dic.ContainsKey(skillContextId))
{
var lists = dic[skillContextId];
for (int i = 0; i < lists.Count; i++)
{
ISkill skill = new Skill();
skill.Init(SkillUtil.GetSkillData(lists[i]), skillContext);
dataList.Add(skill);
}
}
return(dataList);
}
public static List <ISkill> CreateSKillList(ISkillContext skillContext)
{
//todo Load skillList index From Role Data
return(CreateFakeSkillDatas(skillContext));
}
public BoostCore(ISkillContext context)
{
this._context = context;
}
public BuffSet(ISkillContext context, IBuff refBuff, int buffId)
{
this._context = context;
this._buffRoot = refBuff.Clone(buffId);
}
public BuffCore(ISkillContext context)
{
this._context = context;
}
/// <summary>
/// 弹射模式下的搜索
/// </summary>
/// <param name="context"></param>
/// <param name="data"></param>
/// <param name="param"></param>
private void BounceSearch(ISkillContext context,
SkillActionData data, CommonParam param)
{
if (data.Id != param.BounceParam.SearchTargetActionId)
{
return;
}
param.ResetTarget();
var bounceData = SkillUtil.GetSkillActionData(param.BounceParam.BounceActionId);
//弹射检查范围
SkillUtil.TryParseWithDebug(bounceData.Para4, out int range, "弹射范围");
bool isIgnoreRepeat = string.Equals("1", data.Para5);
//todo fake data,need real check
var targetArrary = GameObject.FindObjectsOfType <TestSkillActor>();
param.AddTargets(targetArrary);
FilterTarget(context, data, param);
var targets = param.Targets;
//1.排除自己
//2.排除已经弹射过的
//3.找距离最近的
//4.已经死亡的排除
float minDistance = float.MaxValue;
ISkillActor nearestActor = null;
for (int i = 0; i < targets.Count; i++)
{
var target = targets[i];
if (target.IsDead())
{
continue;
}
//todo TestSkillActor remove
if ((TestSkillActor)target == (TestSkillActor)context.GetSelfActor())
{
continue;
}
if (!isIgnoreRepeat && param.BounceParam.HasBounced(target))
{
continue;
}
var distance = Vector3.Distance(target.GetTransform().position,
param.BounceParam.LastBouncedActor.GetTransform().position);
if (distance < minDistance && distance <= range)
{
minDistance = distance;
nearestActor = target;
}
}
param.ResetTarget();
if (nearestActor != null)
{
param.AddTarget(nearestActor);
}
}
private void NormalGetTargets(ISkillContext context,
SkillActionData data, CommonParam param)
{
var rangeType = (SkillTargetRangeType)data.Radius.Key;
var centerType = (SkillTargetCenter)data.Center;
//线性投射会把Hit的目标动态AddTarget进来
//跟踪投射 策划会配置Center为2
if (centerType != SkillTargetCenter.ProjectileHitPoint)
{
param.ResetTarget();
}
if (rangeType == SkillTargetRangeType.None) //不需要检测距离
{
switch (centerType)
{
case SkillTargetCenter.Caster:
//添加技能施放者
param.AddTarget(context.GetSelfActor());
break;
case SkillTargetCenter.Target:
//添加被施法目标
param.AddTarget(param.ActorClicked);
break;
default: //todo delete this later
param.AddTarget(param.ActorClicked);
break;
}
}
else
{
Vector3 center = Vector3.zero;
center = GetCenterTarget(context, data, param);
var range = data.Radius.Value;
switch (rangeType)
{
//todo
case SkillTargetRangeType.Circle:
case SkillTargetRangeType.Rect:
case SkillTargetRangeType.Sector:
//todo fake 暂时都按照 Radius处理
var targetArrary = GameObject.FindObjectsOfType <TestSkillActor>();
for (int i = 0; i < targetArrary.Length; i++)
{
var target = targetArrary[i];
if (target.IsDead())
{
continue;
}
var distance = Vector3.Distance(target.GetTransform().position, center);
if (distance <= range)
{
param.AddTarget(target);
}
}
break;
}
}
}
