public static bool IfPureBuff(IEffect effect, ISkill srcSkill, ISkillPlayer caster)
{
if (effect.PureFlag)
{
return(true);
}
IBoostBuff boost = null;
int maxRate = SkillDefines.MAXStorePercent;
ISkillOwner owner = caster ?? srcSkill.Owner;
owner.TryGetPureBuff(ref boost);
if (srcSkill.TryGetPureBuff(ref boost))
{
int rate = boost.Percent;
if (rate >= maxRate)
{
return(true);
}
if (rate > 0 && rate < maxRate)
{
if (srcSkill.Context.RandomPercent(maxRate) <= rate)
{
return(true);
}
}
}
return(false);
}
protected virtual bool AddBuff(ISkill srcSkill, ISkillPlayer caster, ISkillOwner target, bool pureFlag)
{
if (!pureFlag)
{
if (BoostUtil.IfAntiDebuff(this, srcSkill, target, true, (int)EnumBoostRootType.AntiPropDebuff))
{
return(true);
}
}
if (this.ExecType == EnumBuffExec.MustHit)
{
int rate = this.Rate;
int maxRate = SkillDefines.MAXStorePercent;
if (rate >= 0 && rate < maxRate)
{
if (srcSkill.Context.RandomPercent(maxRate) > rate)
{
return(false);
}
}
}
target.AddBuff(InnerCreatePropBuff(srcSkill, caster));
this.AddTgtShowModel(srcSkill, target, this.Last);
return(true);
}
public static bool IfSilence(ISkill srcSkill, ISkillOwner owner)
{
IBuff blurBuff = null;
if (owner.TryGetBuff((int)EnumBlurType.LockMotion, ref blurBuff))
{
return(true);
}
if (!owner.TryGetBuff((int)EnumBlurType.LockSkill, ref blurBuff))
{
return(false);
}
int maxRate = SkillDefines.MAXStorePercent;
int rate = blurBuff.Rate;
if (rate >= maxRate)
{
return(true);
}
if (rate > 0 && rate < maxRate)
{
if (srcSkill.Context.RandomPercent(maxRate) <= rate)
{
return(true);
}
}
return(false);
}
public Attack(ISkillOwner owner, int damage, Action <IBody> onHit, Action <IBody> onKill)
{
this.owner = owner;
this.damage = damage;
this.onHit = onHit;
this.onKill = onKill;
}
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 bool Active(ISkillOwner owner, Action <IBody> onHit = null, Action <IBody> onKill = null)
{
if (!CanActive())
{
return(false);
}
_activeTime = Time.time;
void ActiveMethod() => Active_(CreateAttack(owner, onHit, onKill), targetTags);
StartCoroutine(ActiveCoroutine(owner, ActiveMethod));
return(true);
}
public void RemoveShowModel(ISkill srcSkill, ISkillOwner owner, bool tgtFlag)
{
var player = owner as ISkillPlayer;
if (null == player || null == player.SkillCore)
{
return;
}
var model = tgtFlag ? this.TgtModelSetting : this.SrcModelSetting;
if (null == model || model.ModelId <= 0)
{
return;
}
player.SkillCore.RemoveShowModel(srcSkill, model.ModelId);
}
public void AddTgtShowModel(ISkill srcSkill, ISkillOwner target, int last)
{
var player = target as ISkillPlayer;
if (null == player || null == player.SkillCore)
{
return;
}
var model = this.TgtModelSetting;
if (null == model || model.ModelId <= 0)
{
return;
}
if (model.ModelLast > 0)
{
last = srcSkill.Context.GetBuffLast(srcSkill, null, model.ModelLast);
}
player.SkillCore.AddShowModel(srcSkill, model.ModelId, last);
}
private IEnumerator ActiveCoroutine(ISkillOwner owner, Action activeMethod)
{
/* ------------------- 선딜레이(캐스팅) -------------- */
PhaseEvent(owner, preDelay);
if (0 < preDelay.during)
{
yield return(new WaitForSeconds(preDelay.during));
}
/* ----------------- 중딜레이(스킬진행중) -------------- */
PhaseEvent(owner, middleDelay);
activeMethod();
if (0 < middleDelay.during)
{
yield return(new WaitForSeconds(middleDelay.during));
}
/* -------------- 후딜레이(스킬 종료 후 경직) -------------- */
PhaseEvent(owner, afterDelay);
/* ------------------------------------ */
}
public void AddShowClip(ISkill srcSkill, ISkillPlayer caster)
{
var clip = this.ClipSetting;
if (null == clip || clip.ClipId <= 0)
{
return;
}
ISkillOwner owner = caster ?? srcSkill.Owner;
if (null == owner.SkillCore)
{
return;
}
byte[] targets = null;
if (clip.ClipType > 0)
{
targets = GetClipTargets(caster);
}
owner.SkillCore.AddShowClip(srcSkill, clip, targets);
}
private void PhaseEvent(ISkillOwner owner, PhaseStatus status)
{
if (status.isCasting)
{
owner.Stun(status.during);
}
// 스킬 액티브 사운드가 존재한다면 실행
if (status.sound != null)
{
AudioManager.PlaySound(status.sound);
}
// 스킬에 애니메이션이 존재한다면 실행
if (status.animator != null && !string.IsNullOrEmpty(status.aniTrigger))
{
status.animator.SetTrigger(status.aniTrigger);
}
// 그 외 추가적인 이벤트 실행
status.elseEvents?.Invoke();
}
protected virtual bool AddBuff(ISkill srcSkill, ISkillPlayer caster, ISkillOwner target, int buffId, bool pureFlag, int last, int point, int percent)
{
if (!pureFlag)
{
if (BoostUtil.IfAntiDebuff(this, srcSkill, target, true, (int)EnumBoostRootType.AntiPropDebuff))
{
return(true);
}
BoostUtil.GetEaseValue(out point, out percent, point, percent, target, ValueBuffUnits(buffId));
if (this.Last > 0)
{
BoostUtil.GetEaseLast(out last, last, target, LastBuffUnits(buffId));
last = srcSkill.Context.GetBuffLast(srcSkill, caster, last);
}
}
if (!target.AddBuff(InnerCreatePropBuff(srcSkill, point, percent, (short)last)))
{
return(false);
}
this.AddTgtShowModel(srcSkill, target, last);
return(true);
}
private Attack CreateAttack(ISkillOwner owner, Action <IBody> onHit, Action <IBody> onKill)
{
int damage = (int)(owner.GetDamage() * this.damage);
Attack attack = new Attack(owner, damage, onHit, onKill);
attack.onHit += target =>
{
if (hitSound != null)
{
AudioManager.PlaySound(hitSound);
}
if (hitEffect != null)
{
var effect = GlobalObjectPool.GetPooledObject(hitEffect);
effect.transform.position = target.GetPosition();
effect.Play();
}
};
return(attack);
}
public static bool IfAntiDebuff(IEffect effect, ISkill srcSkill, ISkillOwner target, bool incRoot, params int[] buffIds)
{
if (effect.PureFlag || !effect.DebuffFlag)
{
return(false);
}
IBoostBuff boost = null;
int maxRate = SkillDefines.MAXStorePercent;
int rate = 0;
if (incRoot)
{
if (target.TryGetAntiDebuff(ref boost))
{
rate = boost.Percent;
if (rate >= maxRate || rate > 0 && srcSkill.Context.RandomPercent(maxRate) <= rate)
{
return(true);
}
boost.Clear();
}
}
if (null == buffIds || buffIds.Length == 0)
{
return(false);
}
if (target.TryGetAntiRate(ref boost, buffIds))
{
do
{
var boostAnti = boost as IBoostAntiBuff;
if (null == boostAnti)
{
break;
}
var antiSKill = boostAnti.AntiSkillType;
if (null == antiSKill || antiSKill.Length == 0)
{
break;
}
int skillType = (int)srcSkill.RawSkill.SrcType;
for (int i = 0; i < antiSKill.Length; i++)
{
if (antiSKill[i] == skillType)
{
break;
}
else if (i == antiSKill.Length - 1)
{
return(false);
}
}
}while (false);
rate = boost.Percent;
if (rate >= maxRate || rate > 0 && srcSkill.Context.RandomPercent(maxRate) <= rate)
{
return(true);
}
}
return(false);
}
public static bool IfAntiDebuff(IEffect effect, ISkill srcSkill, ISkillOwner target, params int[] buffIds)
{
return(IfAntiDebuff(effect, srcSkill, target, false, buffIds));
}
public static bool GetEaseLast(out int last, int inLast, ISkillOwner owner, params int[] buffIds)
{
return(GetLastCore(out last, inLast, EnumBoostType.EaseLast, owner, buffIds));
}
public static bool GetEaseValue(out int point, out int percent, ISkillOwner owner, params int[] buffIds)
{
return(GetValueCore(out point, out percent, EnumBoostType.EaseValue, owner, buffIds));
}
public static void ClearBlur(ISkillOwner owner)
{
owner.RemoveBuff((int)EnumBlurType.LockMotion, 0);
owner.RemoveBuff((int)EnumBlurType.LockSkill, 0);
}
public static bool GetAntiRate(out int rate, ISkillOwner owner, params int[] buffIds)
{
return(GetRateCore(out rate, 0, EnumBoostType.AntiRate, owner, buffIds));
}
public void LoadSkill(ISkillOwner owner, List <string> skills)
{
if (null == skills || skills.Count == 0)
{
return;
}
if (RawSkillCache.Instance().TRACEPlayerSkillFlag&& owner is ISkillPlayer)
{
LogUtil.Info("Loading...Player[{0}] Skills[{1}] ", ((ISkillPlayer)owner).SkillPlayerId, string.Join(",", skills));
}
if (owner is ISkillManager)
{
LogUtil.Info("Loading...Manager[{0}] Skills[{1}] ", ((ISkillManager)owner).InnerId, string.Join(",", skills));
}
var dic = this._context.DicBuffer(1);
dic.Clear();
for (int i = 0; i < this._skillList.Count; i++)
{
dic[_skillList[i].RawSkill.RawSkillId] = i;
}
string skillCode = string.Empty;
string args = string.Empty;
int argsIdx = 0;
IRawSkill rawSkill = null;
ISkill skill = null;
int idx = 0;
foreach (var str in skills)
{
skillCode = str;
argsIdx = str.IndexOf('.');
if (argsIdx >= 0)
{
args = str.Substring(argsIdx + 1);
skillCode = str.Substring(0, argsIdx);
}
if (!RawSkillCache.Instance().TryGetRawSkill(skillCode, out rawSkill))
{
LogUtil.Info("No RawSkill for SkillCode:" + skillCode);
continue;
}
if (dic.TryGetValue(rawSkill.RawSkillId, out idx))
{
dic[rawSkill.RawSkillId] = -1;
_skillList[idx].InvalidFlag = false;
_skillList[idx].FitCasters();
continue;
}
skill = new Skill(this._context, owner, args);
skill.Load(rawSkill);
this._skillList.Add(skill);
switch (rawSkill.TimeType)
{
case EnumSkillTimeType.Session:
_skillDic[EnumSkillTimeType.Session].Add(skill);
break;
case EnumSkillTimeType.Section:
_skillDic[EnumSkillTimeType.Session].Add(skill);
_skillDic[EnumSkillTimeType.Section].Add(skill);
break;
case EnumSkillTimeType.Minute:
_skillDic[EnumSkillTimeType.Section].Add(skill);
_skillDic[EnumSkillTimeType.Minute].Add(skill);
break;
case EnumSkillTimeType.Round:
_skillDic[EnumSkillTimeType.Minute].Add(skill);
_skillDic[EnumSkillTimeType.Round].Add(skill);
break;
case EnumSkillTimeType.PreDecide:
_skillDic[EnumSkillTimeType.PreDecide].Add(skill);
break;
}
this.AddOpenClip(skill);
}
foreach (var kvp in dic)
{
if (kvp.Value < 0)
{
continue;
}
this._skillList[kvp.Value].Revoke();
}
}
public bool Invoke()
{
EnumSkillState skillState = this.SkillState;
if (skillState == EnumSkillState.Effecting)
{
this.Repeat();
return(false);
}
if (skillState != EnumSkillState.Activate)
{
return(false);
}
ISkillOwner owner = null;
if (null == this._casters || this._casters.Count == 0)
{
owner = this.Owner;
}
else if (this._casters.Count == 1)
{
owner = this._casters[0];
}
byte paralFlag = this.RawSkill.ParalFlag;
bool checkFlag = null != owner && null != owner.SkillCore;
if (checkFlag && !owner.SkillCore.GetInvokeFlag(paralFlag))
{
return(false);
}
short rate = this.RawSkill.Rate;
if (rate >= 0 && rate < 100)
{
IBoostBuff boost = null;
if (this.TryGetSkillRate(ref boost))
{
rate = Convert.ToInt16(rate + boost.AsPoint + rate * boost.AsPercent);
}
if (rate <= 0)
{
return(false);
}
if (rate < 100 && this._context.RandomPercent() > rate)
{
return(false);
}
}
if (checkFlag)
{
if (null == this._casters || this._casters.Count == 0)
{
return(InvokeCore(null, true, false, true));
}
else if (this._casters.Count == 1)
{
return(InvokeCore(_casters[0], true, false, true));
}
}
foreach (var caster in this._casters)
{
if (InvokeCore(caster, true, true, true))
{
return(true);
}
}
return(false);
}
