protected void HandleRangedFX(EResultType pResult, FXArgs fxArgs, Action pOnFXFinished)
{
String text;
if (pResult == EResultType.BLOCK)
{
text = m_EffectAttackRangedBlockedPath;
}
else
{
text = m_EffectAttackRangedPath;
}
if (!String.IsNullOrEmpty(text))
{
FXDescription fxdescription = Helper.ResourcesLoad <FXDescription>(text, false);
if (fxdescription != null)
{
fxdescription = Helper.Instantiate <FXDescription>(fxdescription);
fxdescription.Finished += delegate(Object sender, EventArgs e)
{
ChangeStateFromAttackToIdle(pOnFXFinished);
};
fxdescription.Configurate(m_AnimationEventHandler, fxArgs);
return;
}
}
ChangeStateFromAttackToIdle(pOnFXFinished);
Debug.LogError("Ranged FX not found!");
}
private void OnCharacterAttackOrCastSpell(Object p_sender, EventArgs p_args)
{
Monster monster = MyController as Monster;
Int32 num = monster.CurrentHealth;
Boolean flag = false;
Boolean flag2 = false;
if (p_sender is Summon)
{
OnEntityTakeHitCastSpell_OnFxHit(p_sender, p_args);
return;
}
if (p_args is AttacksEventArgs)
{
AttacksEventArgs attacksEventArgs = (AttacksEventArgs)p_args;
foreach (AttacksEventArgs.AttackedTarget attackedTarget in attacksEventArgs.Attacks)
{
if (attackedTarget.AttackTarget == MyController)
{
EResultType result = attackedTarget.AttackResult.Result;
if (result == EResultType.EVADE)
{
flag2 = true;
}
else if (result == EResultType.BLOCK)
{
flag = true;
}
if (result != EResultType.BLOCK && result != EResultType.EVADE)
{
num -= attackedTarget.AttackResult.DamageDone;
}
}
}
if (flag && num > 0)
{
m_animatorControl.Block();
return;
}
if (flag2 && num > 0)
{
m_animatorControl.Evade();
return;
}
}
}
public static EResultType Show(EMessageBoxType pType, string pMsg, params string[] ps)
{
EResultType re = EResultType.Cancel;
switch (pType)
{
case EMessageBoxType.Alert:
CustomAlertDialog cad = new CustomAlertDialog(pMsg, ps);
cad.ShowDialog();
break;
case EMessageBoxType.Confirm:
CustomConfirmDialog ccd = new CustomConfirmDialog(pMsg, ps);
ccd.ShowDialog();
re = ccd.ConfirmResult;
break;
default:
break;
}
return(re);
}
private void OnCharacterAttackOrSpell(Object p_sender, EventArgs p_args)
{
if (p_args is AttacksEventArgs)
{
AttacksEventArgs attacksEventArgs = (AttacksEventArgs)p_args;
foreach (AttacksEventArgs.AttackedTarget attackedTarget in attacksEventArgs.Attacks)
{
if (attackedTarget.AttackTarget == MyController)
{
m_LastAttackOrSpellFrameCount = Time.frameCount;
EResultType result = attackedTarget.AttackResult.Result;
if (result == EResultType.BLOCK || result == EResultType.EVADE)
{
PlayAnimation(EAnimType.DEFEND, EState.HIT, -1f, 1f);
break;
}
}
}
}
else if (p_args is SpellEventArgs)
{
if (p_sender is Summon)
{
OnTakeHitSpell_OnFxHit(p_sender, p_args);
return;
}
SpellEventArgs spellEventArgs = (SpellEventArgs)p_args;
foreach (AttackedTarget attackedTarget2 in spellEventArgs.SpellTargetsOfType <AttackedTarget>())
{
if (attackedTarget2.Target == MyController)
{
m_LastAttackOrSpellFrameCount = Time.frameCount;
break;
}
}
}
}
private FXQueue GetRangedFX(Boolean p_isTryingToPushToParty, Character p_attacker, EResultType p_attackResult)
{
Int32 num = 0;
BaseItem itemAt = p_attacker.Equipment.GetItemAt(EEquipSlots.RANGE_WEAPON);
if (p_isTryingToPushToParty)
{
num += 2;
}
else if (itemAt != null && itemAt is RangedWeapon && (itemAt as RangedWeapon).GetWeaponType() == EEquipmentType.CROSSBOW)
{
num++;
}
if (p_attackResult == EResultType.BLOCK)
{
num += 10;
}
else if (p_attackResult == EResultType.EVADE)
{
num += 20;
}
Int32 num2 = num;
FXQueue result;
switch (num2)
{
case 10:
result = m_EffectAttackRangedLongbowBlocked;
break;
case 11:
result = m_EffectAttackRangedCrossbowBlocked;
break;
case 12:
result = m_EffectAttackRangedHarpoonSnatchBlocked;
break;
default:
switch (num2)
{
case 20:
result = m_EffectAttackRangedLongbowEvaded;
break;
case 21:
result = m_EffectAttackRangedCrossbowEvaded;
break;
case 22:
result = m_EffectAttackRangedHarpoonSnatchEvaded;
break;
default:
if (num2 != 1)
{
if (num2 != 2)
{
result = m_EffectAttackRangedLongbow;
}
else
{
result = m_EffectAttackRangedHarpoonSnatch;
}
}
else
{
result = m_EffectAttackRangedCrossbow;
}
break;
}
break;
}
return(result);
}
private void OnCharacterAttacksRanged(Object p_sender, EventArgs p_args)
{
AttacksEventArgs attacksEventArgs = (AttacksEventArgs)p_args;
if (attacksEventArgs.Attacks.Count == 0)
{
OnCharacterFXDone(p_sender, p_args);
return;
}
Character character = (Character)p_sender;
Boolean flag = true;
foreach (AttacksEventArgs.AttackedTarget attackedTarget in attacksEventArgs.Attacks)
{
Monster monster = (Monster)attackedTarget.AttackTarget;
EResultType result = attackedTarget.AttackResult.Result;
FXQueue rangedFX = GetRangedFX(attacksEventArgs.IsTryingToPushToParty, character, result);
if (rangedFX != null)
{
Vector3 p_slotOriginPosition;
Vector3 p_slotForward;
Vector3 p_slotLeft;
Vector3 p_slotTargetPosition;
ViewManager.GetSlotDatas(((Party)MyController).Position, monster.Position, out p_slotOriginPosition, out p_slotForward, out p_slotLeft, out p_slotTargetPosition);
GameObject memberGameObject = m_PartyView.GetMemberGameObject(character.Index);
GameObject gameObject = null;
GameObject gameObject2 = null;
if (result == EResultType.EVADE)
{
gameObject = ViewManager.Instance.FindView(monster);
gameObject2 = new GameObject("Miss hit point on the ground");
Destroy(gameObject2, 30f);
gameObject2.transform.position = gameObject.transform.position + (transform.position - gameObject.transform.position).normalized + transform.right * 2f * (UnityEngine.Random.value - 0.5f);
}
else
{
FXTags fxtags = ViewManager.Instance.FindViewAndGetComponent <FXTags>(monster);
if (fxtags != null)
{
gameObject = fxtags.gameObject;
gameObject2 = fxtags.FindOne((result != EResultType.BLOCK) ? "HitSpot" : "BlockHitSpot");
}
}
if (memberGameObject == null || gameObject == null || gameObject2 == null)
{
if (flag)
{
OnRangedFXHit(p_sender, p_args);
}
OnCharacterFXDone(p_sender, p_args);
Debug.LogError(String.Concat(new Object[]
{
"Attacker/Target not found!\nAttacker=",
memberGameObject,
"\ntargetGO=",
gameObject,
"\nfxEndpointGO=",
gameObject2
}));
break;
}
FXArgs args = new FXArgs(memberGameObject, gameObject, memberGameObject, gameObject2, p_slotOriginPosition, p_slotForward, p_slotLeft, p_slotTargetPosition);
FXQueue fxqueue = Helper.Instantiate <FXQueue>(rangedFX);
fxqueue.Execute(args);
if (flag)
{
flag = false;
fxqueue.Finished += delegate(Object o, EventArgs e)
{
OnRangedFXHit(p_sender, p_args);
};
}
}
else
{
if (flag)
{
flag = false;
OnRangedFXHit(p_sender, p_args);
}
OnCharacterFXDone(p_sender, p_args);
Debug.LogError("Ranged FX(" + result + ") missing!");
}
}
}
public override void AttackRanged(FXArgs p_fxArgs, Action p_fxFinishedCallback, EResultType p_Result)
{
m_CommandQueue.Enqueue(delegate
{
m_State.ChangeState(EState.IDLE, Random.Range(0f, 0.3f));
});
m_CommandQueue.Enqueue(delegate
{
HandleAnimationOverrideFX(EAnimType.ATTACK_RANGED, p_fxArgs);
HandleRangedFX(p_Result, p_fxArgs, p_fxFinishedCallback);
PlayAnimation(EAnimType.ATTACK_RANGED, EState.ATTACK_RANGED, -1f, 1f, 2f);
});
}
private void xCloseButton_Click(object sender, RoutedEventArgs e)
{
ConfirmResult = EResultType.Cancel;
this.Close();
}
private void xOK_Click(object sender, RoutedEventArgs e)
{
ConfirmResult = EResultType.OK;
this.Close();
}
public abstract void AttackRanged(FXArgs p_fxArgs, Action p_fxFinishedCallback, EResultType p_Result);
protected virtual void OnMonsterAttacksGeneric(Object p_sender, AttacksEventArgs p_args, Boolean p_isRanged)
{
PlayerEntityView playerEntity = FXHelper.GetPlayerEntity();
Vector3 p_slotOriginPosition;
Vector3 p_slotForward;
Vector3 p_slotLeft;
Vector3 p_slotTargetPosition;
ViewManager.GetSlotDatas(MyController.Position, LegacyLogic.Instance.WorldManager.Party.Position, out p_slotOriginPosition, out p_slotForward, out p_slotLeft, out p_slotTargetPosition);
Boolean flag = false;
GameObject gameObject = null;
List <Action> callbacks = new List <Action>(p_args.Attacks.Count);
EResultType eresultType = EResultType.HIT;
Int32 num = 0;
List <Character> targets = new List <Character>();
AttacksEventArgs.AttackedTarget attack;
foreach (AttacksEventArgs.AttackedTarget attack2 in p_args.Attacks)
{
attack = attack2;
num++;
if (attack.AttackTarget is Character)
{
Character chara = (Character)attack.AttackTarget;
AttackResult result = attack.AttackResult;
targets.Add(chara);
if (playerEntity != null)
{
gameObject = playerEntity.GetMemberGameObject(chara.Index);
}
if (gameObject == null)
{
Debug.LogError("Could not find target character! Char-Index: " + chara.Index);
}
else
{
flag |= attack.IsCriticalAttack;
callbacks.Add(delegate
{
if (p_sender is Monster && ((Monster)p_sender).AbilityHandler.HasEntriesForPhase(EExecutionPhase.BEFORE_MONSTER_ATTACK))
{
((Monster)p_sender).AbilityHandler.FlushActionLog(EExecutionPhase.BEFORE_MONSTER_ATTACK);
chara.ConditionHandler.FlushActionLog();
}
if (((Monster)p_sender).AbilityHandler.HasEntriesForPhase(EExecutionPhase.AFTER_DAMAGE_CALCULATION))
{
((Monster)p_sender).AbilityHandler.FlushActionLog(EExecutionPhase.AFTER_DAMAGE_CALCULATION);
}
CombatEntryEventArgs p_args2 = new CombatEntryEventArgs(p_sender, chara, result, attack.BloodMagicEventArgs);
LegacyLogic.Instance.ActionLog.PushEntry(p_args2);
if (LegacyLogic.Instance.WorldManager.Party.Buffs.HasBuff(EPartyBuffs.SHADOW_CLOAK) && result.Result == EResultType.EVADE)
{
LegacyLogic.Instance.WorldManager.Party.Buffs.RemoveBuff(EPartyBuffs.SHADOW_CLOAK);
}
if (LegacyLogic.Instance.WorldManager.Party.Buffs.HasBuff(EPartyBuffs.CELESTIAL_ARMOR))
{
if (LegacyLogic.Instance.WorldManager.Party.Buffs.GetBuff(EPartyBuffs.CELESTIAL_ARMOR).IsExpired())
{
LegacyLogic.Instance.WorldManager.Party.Buffs.RemoveBuff(EPartyBuffs.CELESTIAL_ARMOR);
}
LegacyLogic.Instance.WorldManager.Party.Buffs.FlushActionLog();
}
chara.FightHandler.FlushCounterAttackActionLog();
LegacyLogic.Instance.WorldManager.Party.Buffs.FlushActionLog();
if (p_sender is Monster && ((Monster)p_sender).AbilityHandler.HasEntriesForPhase(EExecutionPhase.AFTER_MONSTER_ATTACK))
{
((Monster)p_sender).AbilityHandler.FlushActionLog(EExecutionPhase.AFTER_MONSTER_ATTACK);
chara.ConditionHandler.FlushActionLog();
}
});
if (attack.AttackResult.Result == EResultType.BLOCK)
{
eresultType = EResultType.BLOCK;
}
else if (eresultType != EResultType.BLOCK && attack.AttackResult.Result == EResultType.EVADE)
{
eresultType = EResultType.EVADE;
}
}
}
}
Action action = delegate
{
DelayedEventManager.InvokeEvent(EDelayType.ON_FX_HIT, (!p_isRanged) ? EEventType.MONSTER_ATTACKS : EEventType.MONSTER_ATTACKS_RANGED, p_sender, p_args);
if (!p_isRanged)
{
foreach (AttacksEventArgs.AttackedTarget attackedTarget in p_args.Attacks)
{
((Monster)MyController).CombatHandler.TriggerCounterAttacks(attackedTarget.AttackTarget, attackedTarget.AttackResult);
}
}
foreach (Action action2 in callbacks)
{
action2();
}
foreach (Character character in targets)
{
character.ConditionHandler.FlushDelayedActionLog();
}
};
if (gameObject == null)
{
gameObject = playerEntity.GetMemberGameObject(UnityEngine.Random.Range(0, 4));
if (gameObject == null)
{
Debug.LogError("No target character could be found! Will skip whole FX! Num of Attacks = " + p_args.Attacks.Count);
action();
return;
}
}
FXArgs p_fxArgs = new FXArgs(this.gameObject, gameObject, this.gameObject, gameObject, p_slotOriginPosition, p_slotForward, p_slotLeft, p_slotTargetPosition);
if (p_isRanged)
{
AttackRanged(p_fxArgs, action, (!flag) ? eresultType : EResultType.CRITICAL_HIT);
}
else if (flag)
{
AttackCritical(p_fxArgs, action);
}
else
{
Attack(p_fxArgs, action);
}
}
public override void AttackRanged(FXArgs p_fxArgs, Action p_fxFinishedCallback, EResultType p_Result)
{
m_CommandQueue.Enqueue(delegate
{
m_State.ChangeState(EState.IDLE, Random.Range(0f, 0.1f));
});
m_CommandQueue.Enqueue(delegate
{
HandleAnimationOverrideFX(EAnimType.ATTACK_RANGED, p_fxArgs);
HandleRangedFX(p_Result, p_fxArgs, p_fxFinishedCallback);
Single length = m_animator.GetCurrentAnimatorStateInfo(0).length;
m_State.ChangeState(EState.ATTACK_RANGED, length);
m_animatorControl.AttackRange();
});
}
