public static string GetResourceName(AGE.Action _action, string _resName, bool _bUseAdvanceSkin)
{
uint num;
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (((refParamObject == null) || (refParamObject.Originator == 0)) || ((refParamObject.Originator.handle.TheActorMeta.ActorType != ActorTypeDef.Actor_Type_Hero) || (refParamObject.Originator.handle.ActorControl == null)))
{
return(_resName);
}
HeroWrapper actorControl = (HeroWrapper)refParamObject.Originator.handle.ActorControl;
if ((actorControl == null) || !actorControl.GetSkinCfgID(out num))
{
return(_resName);
}
int length = _resName.LastIndexOf('/');
StringBuilder builder = new StringBuilder(_resName);
StringBuilder builder2 = new StringBuilder(actorControl.GetSkinEffectPath());
if (length < 0)
{
return(_resName);
}
builder.Remove(0, length);
builder2.Append(builder);
if (_bUseAdvanceSkin)
{
int advanceSkinIndex = actorControl.GetAdvanceSkinIndex();
if (advanceSkinIndex > 0)
{
builder2.AppendFormat("_level{0}", advanceSkinIndex);
}
}
return(builder2.ToString());
}
private void OnDeadExtraEffect(PoolObjHandle <ActorRoot> _attack)
{
BuffSkill skill = null;
ResDT_SkillFunc outSkillFunc = null;
if (_attack != 0)
{
for (int i = 0; i < _attack.handle.BuffHolderComp.SpawnedBuffList.Count; i++)
{
skill = _attack.handle.BuffHolderComp.SpawnedBuffList[i];
if ((skill != null) && skill.FindSkillFunc(0x21, out outSkillFunc))
{
int inSkillCombineId = skill.CustomParams[0];
int num3 = skill.CustomParams[1];
int num4 = skill.CustomParams[2];
int typeMask = skill.CustomParams[3];
int typeSubMask = skill.CustomParams[4];
if ((num4 != 0) && this.CheckTargetSubType(typeMask, typeSubMask))
{
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(_attack);
_attack.handle.SkillControl.SpawnBuff(_attack, inContext, inSkillCombineId, true);
}
}
}
}
}
public void OnDead(PoolObjHandle <ActorRoot> _attack)
{
if (this.clearRule != null)
{
this.clearRule.CheckBuffNoClear(RES_SKILLFUNC_CLEAR_RULE.RES_SKILLFUNC_CLEAR_DEAD);
}
BuffSkill inBuff = null;
ResDT_SkillFunc outSkillFunc = null;
for (int i = 0; i < this.SpawnedBuffList.Count; i++)
{
inBuff = this.SpawnedBuffList[i];
if ((inBuff != null) && inBuff.FindSkillFunc(0x20, out outSkillFunc))
{
int reviveTime = inBuff.CustomParams[0];
int reviveLife = inBuff.CustomParams[1];
bool autoReset = inBuff.CustomParams[2] == 1;
bool bBaseRevive = inBuff.CustomParams[3] == 0;
bool bCDReset = inBuff.CustomParams[4] == 1;
base.actor.ActorControl.SetReviveContext(reviveTime, reviveLife, autoReset, bBaseRevive, bCDReset);
this.RemoveBuff(inBuff);
}
if ((((base.actor.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) && (_attack != 0)) && ((_attack.handle.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) && (inBuff != null))) && ((inBuff.cfgData != null) && (inBuff.cfgData.bIsInheritByKiller == 1)))
{
this.RemoveBuff(inBuff);
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(_attack);
_attack.handle.SkillControl.SpawnBuff(_attack, inContext, inBuff.SkillID, true);
}
}
this.OnDeadExtraEffect(_attack);
}
public void UpperTrigger(PoolObjHandle <ActorRoot> _originator, SkillUseContext inUseContext)
{
if (this.curLayer >= this.cfgData.iTriggerLayer && this.cfgData.iTriggerLayer > 0)
{
this.Trigger(_originator, inUseContext);
}
}
public bool Use(PoolObjHandle <ActorRoot> user, SkillUseContext context)
{
this.skillContext.Copy(context);
this.skillContext.Instigator = this;
DebugHelper.Assert(this.skillContext.Originator);
return(base.Use(user));
}
public static string GetResourceName(Action _action, string _resName, bool _bUseAdvanceSkin)
{
SkillUseContext refParamObject = _action.refParams.GetRefParamObject <SkillUseContext>("SkillContext");
if (refParamObject != null && refParamObject.Originator && refParamObject.Originator.get_handle().TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero && refParamObject.Originator.get_handle().ActorControl != null)
{
HeroWrapper heroWrapper = (HeroWrapper)refParamObject.Originator.get_handle().ActorControl;
uint num;
if (heroWrapper != null && heroWrapper.GetSkinCfgID(out num))
{
int num2 = _resName.LastIndexOf('/');
StringBuilder stringBuilder = new StringBuilder(_resName);
StringBuilder stringBuilder2 = new StringBuilder(heroWrapper.GetSkinEffectPath());
if (num2 >= 0)
{
stringBuilder.Remove(0, num2);
stringBuilder2.Append(stringBuilder);
if (_bUseAdvanceSkin)
{
int advanceSkinIndex = heroWrapper.GetAdvanceSkinIndex();
if (advanceSkinIndex > 0)
{
stringBuilder2.AppendFormat("_level{0}", advanceSkinIndex);
}
}
return(stringBuilder2.ToString());
}
}
}
return(_resName);
}
private void TriggerAction(PoolObjHandle <ActorRoot> _originator)
{
SkillUseContext context = new SkillUseContext();
context.SetOriginator(_originator);
context.TargetActor = this.sourceActor;
this.Use(_originator, context);
}
private void OnDamageExtraEffect(PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType)
{
BuffSkill inBuff = null;
ResDT_SkillFunc outSkillFunc = null;
if (_attack != 0)
{
for (int i = 0; i < _attack.handle.BuffHolderComp.SpawnedBuffList.Count; i++)
{
inBuff = _attack.handle.BuffHolderComp.SpawnedBuffList[i];
if ((inBuff != null) && inBuff.FindSkillFunc(0x21, out outSkillFunc))
{
bool flag = false;
bool flag2 = true;
int inSkillCombineId = inBuff.CustomParams[0];
int num3 = inBuff.CustomParams[1];
int num4 = inBuff.CustomParams[2];
int typeMask = inBuff.CustomParams[3];
int typeSubMask = inBuff.CustomParams[4];
int num7 = inBuff.CustomParams[5];
if ((num4 == 0) && this.CheckTargetSubType(typeMask, typeSubMask))
{
if (num3 == 0)
{
flag = true;
}
else if ((num3 & (((int)1) << _slotType)) > 0)
{
flag = true;
}
if (num7 > 0)
{
if ((Singleton <FrameSynchr> .GetInstance().LogicFrameTick - inBuff.controlTime) >= num7)
{
flag2 = true;
}
else
{
flag2 = false;
}
}
if (flag && flag2)
{
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(_attack);
_attack.handle.SkillControl.SpawnBuff(base.actorPtr, inContext, inSkillCombineId, true);
inBuff.controlTime = Singleton <FrameSynchr> .GetInstance().LogicFrameTick;
if (num7 == -1)
{
_attack.handle.BuffHolderComp.RemoveBuff(inBuff);
}
}
}
}
}
}
}
private int ResistDeadDamage(ref HurtDataInfo _hurt, int _hurtValue)
{
BuffSkill inBuff = null;
ResDT_SkillFunc outSkillFunc = null;
if ((this.buffHolder != null) && (this.buffHolder.actor != null))
{
ActorRoot actor = this.buffHolder.actor;
for (int i = 0; i < actor.BuffHolderComp.SpawnedBuffList.Count; i++)
{
inBuff = actor.BuffHolderComp.SpawnedBuffList[i];
if ((inBuff != null) && inBuff.FindSkillFunc(0x36, out outSkillFunc))
{
int inSkillCombineId = inBuff.CustomParams[0];
if (inBuff.CustomParams[1] == 0)
{
if (actor.ValueComponent.actorHp <= _hurtValue)
{
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(_hurt.atker);
actor.SkillControl.SpawnBuff(actor.SelfPtr, inContext, inSkillCombineId, true);
this.buffHolder.RemoveBuff(inBuff);
DefaultGameEventParam prm = new DefaultGameEventParam(this.buffHolder.actorPtr, _hurt.atker);
Singleton <GameEventSys> .instance.SendEvent <DefaultGameEventParam>(GameEventDef.Event_ActorImmuneDeadHurt, ref prm);
_hurtValue = 0;
}
}
else
{
SkillUseContext context2 = new SkillUseContext();
context2.SetOriginator(_hurt.atker);
actor.SkillControl.SpawnBuff(actor.SelfPtr, context2, inSkillCombineId, true);
this.buffHolder.RemoveBuff(inBuff);
_hurtValue = 0;
}
}
if (((_hurt.atkSlot == SkillSlotType.SLOT_SKILL_0) && (inBuff != null)) && inBuff.FindSkillFunc(0x43, out outSkillFunc))
{
int num4 = inBuff.CustomParams[0];
int num5 = inBuff.CustomParams[4];
switch (num4)
{
case 1:
_hurtValue = (_hurtValue * (0x2710 - num5)) / 0x2710;
break;
case 0:
_hurtValue -= num5;
break;
}
}
}
}
return(_hurtValue);
}
public PoolObjHandle <ActorRoot> GetTargetActor()
{
SkillUseContext skillUseContext = this.GetSkillUseContext();
if (skillUseContext == null)
{
return(new PoolObjHandle <ActorRoot>(null));
}
return(skillUseContext.TargetActor);
}
public void SetCacheSkillContext(IFrameCommand cmd, SkillUseContext _context)
{
if (this.cacheSkill)
{
this.cacheSkillCommand = cmd;
this.cacheSkillContext = _context;
this.bCacheCommonAttack = false;
this.cacheSkillExpire = false;
}
}
private void EnableEquipBuff(CEquipBuffInfo equipBuffInfo)
{
if (!equipBuffInfo.m_isEnabled)
{
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(base.actorPtr);
base.actor.SkillControl.SpawnBuff(base.actorPtr, inContext, (int)equipBuffInfo.m_buffID, false);
equipBuffInfo.m_isEnabled = true;
}
}
public bool Use(PoolObjHandle <ActorRoot> user, SkillUseContext context)
{
base.skillContext.Copy(context);
base.skillContext.Instigator = this;
DebugHelper.Assert((bool)base.skillContext.Originator);
if (!base.Use(user))
{
return(false);
}
return(true);
}
private bool CheckUseRule(SkillUseContext context)
{
if (context.TargetActor.handle.ActorControl.GetNoAbilityFlag(ObjAbilityType.ObjAbility_ImmuneNegative) && ((this.cfgData.dwEffectType == 1) || (this.cfgData.dwEffectType == 2)))
{
return(false);
}
if (context.TargetActor.handle.ActorControl.GetNoAbilityFlag(ObjAbilityType.ObjAbility_ImmuneControl) && (this.cfgData.dwEffectType == 2))
{
return(false);
}
return(true);
}
public override void OnUse()
{
base.OnUse();
this.overlayCount = 0;
this.controlTime = 0L;
Array.Clear(this.CustomParams, 0, this.CustomParams.Length);
this.bExtraBuff = false;
this.cfgData = null;
this.battleParam = null;
this.skillContext = null;
this.ulStartTime = 0L;
}
public void Trigger(PoolObjHandle <ActorRoot> _originator, SkillUseContext inUseContext)
{
if (this.immuneTime == 0)
{
if (this.cfgData != null && this.cfgData.bLayerEffect == 1)
{
this.skillContext.MarkCount = this.curLayer;
}
this.DecLayer(this.cfgData.iCostLayer);
this.immuneTime = this.cfgData.iImmuneTime;
this.TriggerAction(_originator, inUseContext);
}
}
private void TriggerAction(PoolObjHandle <ActorRoot> _originator, SkillUseContext inUseContext)
{
SkillUseParam skillUseParam = default(SkillUseParam);
skillUseParam.Init();
skillUseParam.SetOriginator(_originator);
skillUseParam.TargetActor = this.sourceActor;
if (inUseContext != null)
{
skillUseParam.bExposing = inUseContext.bExposing;
}
this.Use(_originator, ref skillUseParam);
}
public void RecoverClearBuff()
{
int inSkillCombineId = 0;
for (int i = 0; i < this.CacheBufferList.Count; i++)
{
inSkillCombineId = this.CacheBufferList[i];
SkillUseContext inContext = new SkillUseContext();
inContext.SetOriginator(this.buffHolder.actorPtr);
this.buffHolder.actor.SkillControl.SpawnBuff(this.buffHolder.actorPtr, inContext, inSkillCombineId, false);
}
this.CacheBufferList.Clear();
}
public override bool Use(PoolObjHandle <ActorRoot> user, SkillUseContext context)
{
if (context != null)
{
context.Instigator = this;
DebugHelper.Assert((bool)context.Originator);
}
if (!base.Use(user, context))
{
return(false);
}
return(true);
}
private SkillUseContext(SkillUseContext rhs)
{
this.GatherTime = 1;
this.SlotType = rhs.SlotType;
this.AppointType = rhs.AppointType;
this.TargetID = rhs.TargetID;
this.UseVector = rhs.UseVector;
this.EndVector = rhs.EndVector;
this.TargetActor = rhs.TargetActor;
this.Originator = rhs.Originator;
this.Instigator = rhs.Instigator;
this.bSpecialUse = rhs.bSpecialUse;
this.GatherTime = rhs.GatherTime;
}
protected void Trigger()
{
SkillUseContext context = new SkillUseContext(this.passiveSkill.SlotType);
context.SetOriginator(this.sourceActor);
if (this.triggerActor == 0)
{
context.TargetActor = this.sourceActor;
}
else
{
context.TargetActor = this.triggerActor;
}
this.passiveSkill.Use(this.sourceActor, context);
this.deltaTime = this.cfgData.iCoolDown;
}
private void TriggerAction(PoolObjHandle <ActorRoot> _originator, SkillUseContext inUseContext, int triggerLayer)
{
SkillUseParam skillUseParam = default(SkillUseParam);
skillUseParam.Init();
skillUseParam.SetOriginator(_originator);
skillUseParam.TargetActor = this.sourceActor;
if (inUseContext != null)
{
skillUseParam.bExposing = inUseContext.bExposing;
skillUseParam.uiFromId = inUseContext.uiFromId;
skillUseParam.skillUseFrom = inUseContext.skillUseFrom;
skillUseParam.MarkCount = triggerLayer;
}
this.Use(_originator, ref skillUseParam);
}
public void Copy(SkillUseContext rhs)
{
this.SlotType = rhs.SlotType;
this.AppointType = rhs.AppointType;
this.TargetID = rhs.TargetID;
this.UseVector = rhs.UseVector;
this.EndVector = rhs.EndVector;
this.EffectPos = rhs.EffectPos;
this.EffectDir = rhs.EffectDir;
this.BulletPos = rhs.BulletPos;
this.TargetActor = rhs.TargetActor;
this.Originator = rhs.Originator;
this.Instigator = rhs.Instigator;
this.bSpecialUse = rhs.bSpecialUse;
this.GatherTime = rhs.GatherTime;
this.EffectCount = rhs.EffectCount;
this.MarkCount = rhs.MarkCount;
}
public PoolObjHandle <BulletSkill> SpawnBullet(SkillUseContext context, string _actionName, bool _bDeadRemove)
{
PoolObjHandle <BulletSkill> handle = new PoolObjHandle <BulletSkill>();
if (context != null)
{
BulletSkill item = ClassObjPool <BulletSkill> .Get();
item.Init(_actionName, _bDeadRemove);
if (item.Use(base.actorPtr, context.Clone()))
{
this.SpawnedBullets.Add(item);
return(new PoolObjHandle <BulletSkill>(item));
}
item.Release();
}
return(handle);
}
public override bool Use(PoolObjHandle <ActorRoot> user, SkillUseContext context)
{
if (context != null)
{
context.SetOriginator(user);
context.Instigator = user;
}
if (!base.Use(user, context))
{
return(false);
}
this.skillAbort.InitAbort(false);
this.bDelayAbortSkill = false;
this.bProtectAbortSkill = false;
if ((context != null) && (context.SlotType == SkillSlotType.SLOT_SKILL_0))
{
this.SetSkillSpeed(user);
}
return(true);
}
public void AutoTrigger(PoolObjHandle <ActorRoot> _originator, SkillUseContext inUseContext)
{
if (this.curLayer + 1 >= this.cfgData.iMaxLayer && this.cfgData.bAutoTrigger == 1)
{
if (this.triggerCDTime == 0)
{
this.AddLayer(1);
this.triggerCDTime = this.cfgData.iCDTime;
this.Trigger(_originator, inUseContext);
}
else
{
this.curTime = 0;
}
}
else
{
this.AddLayer(1);
}
}
public bool SpawnBuff(PoolObjHandle <ActorRoot> inTargetActor, SkillUseContext inContext, int inSkillCombineId, bool bExtraBuff = false)
{
if (((inTargetActor == 0) || (inContext == null)) || (inSkillCombineId <= 0))
{
return(false);
}
BuffSkill skill = ClassObjPool <BuffSkill> .Get();
skill.Init(inSkillCombineId);
skill.bExtraBuff = bExtraBuff;
skill.skillContext.Copy(inContext);
skill.skillContext.TargetActor = inTargetActor;
skill.skillContext.Instigator = base.actor;
bool flag = skill.Use(base.actorPtr);
if (!flag)
{
skill.Release();
}
return(flag);
}
public bool Use()
{
BuffSkill inBuff = ClassObjPool <BuffSkill> .Get();
inBuff.Init(this.BuffID);
if (inBuff.cfgData == null)
{
inBuff.Release();
return(false);
}
SkillUseContext context = new SkillUseContext(SkillSlotType.SLOT_SKILL_VALID, this.TargetActor.handle.ObjID);
context.SetOriginator(this.SrcActor);
if (!inBuff.Use(this.SrcActor, context))
{
inBuff.Release();
return(false);
}
this.buffSkill = new BuffFense(inBuff);
return(true);
}
private bool InternalUseSkill(SkillUseContext context, bool bImmediate = false)
{
SkillSlot slot;
if (context == null)
{
return(false);
}
if (!this.TryGetSkillSlot(context.SlotType, out slot))
{
return(false);
}
slot.ReadySkillObj();
Skill skillObj = slot.SkillObj;
if (!skillObj.Use(base.actorPtr, context))
{
return(false);
}
if (!bImmediate)
{
this.CurUseSkill = skillObj;
this.CurUseSkillSlot = slot;
}
this.SkillInfoStatistic(ref slot);
this.bIsLastAtkUseSkill = this.bIsCurAtkUseSkill;
if (context.SlotType == SkillSlotType.SLOT_SKILL_0)
{
this.bIsCurAtkUseSkill = false;
}
else
{
this.bIsCurAtkUseSkill = true;
}
ActorSkillEventParam param = new ActorSkillEventParam(base.GetActor(), context.SlotType);
Singleton <GameSkillEventSys> .GetInstance().SendEvent <ActorSkillEventParam>(GameSkillEventDef.Event_UseSkill, base.GetActor(), ref param, GameSkillEventChannel.Channel_AllActor);
return(true);
}
public void Copy(SkillUseContext rhs)
{
this.SlotType = rhs.SlotType;
this.AppointType = rhs.AppointType;
this.TargetID = rhs.TargetID;
this.UseVector = rhs.UseVector;
this.EndVector = rhs.EndVector;
this.EffectPos = rhs.EffectPos;
this.EffectDir = rhs.EffectDir;
this.BulletPos = rhs.BulletPos;
this.TargetActor = rhs.TargetActor;
this.Originator = rhs.Originator;
this.Instigator = rhs.Instigator;
this.bSpecialUse = rhs.bSpecialUse;
this.GatherTime = rhs.GatherTime;
this.EffectCount = rhs.EffectCount;
this.EffectCountInSingleTrigger = rhs.EffectCountInSingleTrigger;
this.MarkCount = rhs.MarkCount;
this.bExposing = rhs.bExposing;
this.skillUseFrom = rhs.skillUseFrom;
this.uiFromId = rhs.uiFromId;
}