8100 lines
237 KiB
C#
8100 lines
237 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using DarkTonic.MasterAudio;
|
|
using Pathfinding;
|
|
using UnityEngine;
|
|
|
|
// Token: 0x02000011 RID: 17
|
|
public class Actions : MonoBehaviour
|
|
{
|
|
// Token: 0x06000111 RID: 273 RVA: 0x00013EC1 File Offset: 0x000120C1
|
|
private void Start()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000112 RID: 274 RVA: 0x00013EC3 File Offset: 0x000120C3
|
|
public void SetSelectedTarget(bool state, Character t, GameObject obj, GameObject objAI)
|
|
{
|
|
this.hasTarget = state;
|
|
this.selectedTarget = t;
|
|
this.selectedTargetInteractive = obj;
|
|
this.selectedAITargetInteractive = objAI;
|
|
}
|
|
|
|
// Token: 0x06000113 RID: 275 RVA: 0x00013EE4 File Offset: 0x000120E4
|
|
public void ChooseAction()
|
|
{
|
|
if (this.character.dead || this.character.stunned)
|
|
{
|
|
this.EndTurn(false);
|
|
this.EndActions();
|
|
return;
|
|
}
|
|
bool flag = false;
|
|
this.spellScroll = null;
|
|
if (Links.x.combat.inRally && this.character == Links.x.combat.rallyCharacter)
|
|
{
|
|
flag = true;
|
|
}
|
|
this.ResetAction();
|
|
if (this.hasTarget && this.character.mainSelected)
|
|
{
|
|
if (!this.character.mainSelected && !flag)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (this.selectedTarget && (this.selectedTarget.dead || (!Records.x.kill && this.selectedTarget.stunned)))
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (this.selectedTargetInteractive || this.selectedAITargetInteractive)
|
|
{
|
|
GameObject gameObject = this.selectedTargetInteractive;
|
|
if (this.selectedAITargetInteractive)
|
|
{
|
|
gameObject = this.selectedAITargetInteractive;
|
|
}
|
|
if (!gameObject.activeSelf)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
else
|
|
{
|
|
BreakableActions component = gameObject.GetComponent<BreakableActions>();
|
|
ChestActions component2 = gameObject.GetComponent<ChestActions>();
|
|
DoorActions component3 = gameObject.GetComponent<DoorActions>();
|
|
PuzzleActions component4 = gameObject.GetComponent<PuzzleActions>();
|
|
if (component && component.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component2 && component2.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component3 && component3.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component4 && component4.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[8];
|
|
array[0] = "Choosing action for ";
|
|
int num = 1;
|
|
Character character = this.character;
|
|
array[num] = ((character != null) ? character.ToString() : null);
|
|
array[2] = ", has target: ";
|
|
array[3] = this.hasTarget.ToString();
|
|
array[4] = ", selected target is: ";
|
|
int num2 = 5;
|
|
Character character2 = this.selectedTarget;
|
|
array[num2] = ((character2 != null) ? character2.ToString() : null);
|
|
array[6] = " ";
|
|
int num3 = 7;
|
|
GameObject gameObject2 = this.selectedTargetInteractive;
|
|
array[num3] = ((gameObject2 != null) ? gameObject2.ToString() : null);
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (!this.character.mainSelected)
|
|
{
|
|
this.moveAttempts = 1;
|
|
this.character.StartTurn();
|
|
this.ai.DoSomething1();
|
|
return;
|
|
}
|
|
this.choosingTurn = false;
|
|
}
|
|
|
|
// Token: 0x06000114 RID: 276 RVA: 0x00014168 File Offset: 0x00012368
|
|
public void SelectActionRealTime(Character target, GameObject targetInteractive)
|
|
{
|
|
this.lastMainActionTime = Time.timeSinceLevelLoad;
|
|
if (this.channeling)
|
|
{
|
|
this.EndChanneling(false);
|
|
}
|
|
this.EndVine();
|
|
this.quickAttack = false;
|
|
this.character.animator.SetBool("Combat", true);
|
|
if ((target || targetInteractive) && Records.x.pocketPause)
|
|
{
|
|
Links.x.hudControl.ToggleAttackTimer(false);
|
|
}
|
|
this.character.timelineIcon.overridePause = true;
|
|
if (this.character.mainSelected)
|
|
{
|
|
this.character.portrait.skillBag.SetSelectedState();
|
|
}
|
|
this.ClearTargetCharacters();
|
|
if (this.character.moving)
|
|
{
|
|
this.character.TargetReached();
|
|
this.character.waypoint.transform.position = Links.x.gameplay.farPosition;
|
|
}
|
|
if (Links.x.pocketWheel.selected.Contains("Special Attack"))
|
|
{
|
|
bool mainSelected = this.character.mainSelected;
|
|
}
|
|
this.specialAttack1 = false;
|
|
this.specialAttack2 = false;
|
|
this.specialAttack3 = false;
|
|
if (Links.x.pocketWheel.selected.Contains("Special Attack 1"))
|
|
{
|
|
this.specialAttack1 = true;
|
|
Links.x.pocketWheel.SelectLightAttack();
|
|
Links.x.hudControl.RemoveRallyBar((float)Records.x.GetRallyAttackCosts(1, this.character));
|
|
}
|
|
if (!this.specialAttack1)
|
|
{
|
|
Links.x.pocketWheel.Close(false);
|
|
}
|
|
if (Links.x.combat.pickingRally && this.character != Links.x.combat.rallyCharacter)
|
|
{
|
|
Links.x.combat.inRally = true;
|
|
Links.x.combat.rallyCharacter.OverridePocketPause();
|
|
Links.x.combat.rallyCharacter.TargetReached();
|
|
Links.x.combat.rallyCharacter.actions.CheckIfRunningAI();
|
|
Links.x.combat.rallyCharacter.actions.ClearSelectedActionRealTime();
|
|
Links.x.combat.RemoveFromNeedsTurn(Links.x.combat.rallyCharacter);
|
|
if (Links.x.combat.rallyCharacter.moving)
|
|
{
|
|
Links.x.combat.rallyCharacter.EndPath();
|
|
}
|
|
Links.x.combat.rallyCharacter.actions.SelectActionRealTime(target, targetInteractive);
|
|
Links.x.combat.pickingRally = false;
|
|
this.ClearDamageLists();
|
|
Links.x.combat.rallyCharacter.actions.ClearDamageLists();
|
|
}
|
|
if (this.character.mainSelected && !Links.x.combat.inRally && Records.x.pocketPause && !Links.x.pocketWheel.Charming())
|
|
{
|
|
Links.x.combat.pocketTarget = target;
|
|
if (target)
|
|
{
|
|
Links.x.combat.pocketTargetPosition = target.currentPosition;
|
|
}
|
|
}
|
|
this.readyToAttack = false;
|
|
this.secondAttack = false;
|
|
if (target)
|
|
{
|
|
target.HoverOut(false);
|
|
if (Records.x.pocketPause)
|
|
{
|
|
target.body.Hover(false, true);
|
|
}
|
|
this.rallyInteractiveTarget = null;
|
|
}
|
|
else if (targetInteractive)
|
|
{
|
|
if (this.specialAttack1)
|
|
{
|
|
this.rallyInteractiveTarget = targetInteractive;
|
|
}
|
|
else
|
|
{
|
|
this.rallyInteractiveTarget = null;
|
|
}
|
|
}
|
|
Links.x.combat.RemoveFromNeedsTurn(this.character);
|
|
this.QueueIcon(false);
|
|
this.character.inAction = false;
|
|
if (targetInteractive)
|
|
{
|
|
target = targetInteractive.gameObject.GetComponent<Character>();
|
|
}
|
|
this.AddTarget(target);
|
|
this.QueueIcon(true);
|
|
this.readyToAttack = true;
|
|
this.secondAttack = false;
|
|
if (!targetInteractive && !Links.x.pocketWheel.Charming() && Records.x.pocketPause)
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, "Combat");
|
|
}
|
|
Links.x.gameplay.joystickTarget.SetActive(false);
|
|
Links.x.combat.ClearPossibleTargets();
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 1f);
|
|
this.ResetItemActions();
|
|
if (Links.x.pocketWheel.Charming())
|
|
{
|
|
this.StartAction("Charm");
|
|
return;
|
|
}
|
|
if (this.charging)
|
|
{
|
|
this.charging = false;
|
|
if (targetInteractive)
|
|
{
|
|
this.ai.ChargeTarget(targetInteractive.GetComponent<Character>());
|
|
}
|
|
else
|
|
{
|
|
this.ai.ChargeTarget(target);
|
|
}
|
|
Links.x.pocketWheel.SelectLightAttack();
|
|
return;
|
|
}
|
|
if (this.pinning)
|
|
{
|
|
this.ai.PinTarget(target);
|
|
this.pinning = false;
|
|
Links.x.pocketWheel.SelectLightAttack();
|
|
return;
|
|
}
|
|
if (this.specialAttack1)
|
|
{
|
|
base.StartCoroutine(this.Pocket());
|
|
return;
|
|
}
|
|
this.StartAction("Attack");
|
|
}
|
|
|
|
// Token: 0x06000115 RID: 277 RVA: 0x0001466A File Offset: 0x0001286A
|
|
public void SelectCharge(Character target)
|
|
{
|
|
this.charging = true;
|
|
if (target.interactiveObject)
|
|
{
|
|
this.SelectActionRealTime(null, target.gameObject);
|
|
return;
|
|
}
|
|
this.SelectActionRealTime(target, null);
|
|
}
|
|
|
|
// Token: 0x06000116 RID: 278 RVA: 0x00014691 File Offset: 0x00012891
|
|
public void SelectPin(Character target)
|
|
{
|
|
this.pinning = true;
|
|
this.SelectActionRealTime(target, null);
|
|
}
|
|
|
|
// Token: 0x06000117 RID: 279 RVA: 0x000146A4 File Offset: 0x000128A4
|
|
public void Interrupt()
|
|
{
|
|
this.EndVine();
|
|
this.castingSpell = false;
|
|
this.movingToPin = false;
|
|
this.givingItem = false;
|
|
this.spellScroll = null;
|
|
if (this.channeling)
|
|
{
|
|
this.EndChanneling(false);
|
|
}
|
|
this.readyToAttack = false;
|
|
this.choosingTurn = false;
|
|
this.character.inRecovery = false;
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.Clear();
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
if (this.spellCasterFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(69, this.spellCasterFX);
|
|
this.spellCasterFX = null;
|
|
}
|
|
if (this.spellWaveFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(88, this.spellWaveFX);
|
|
this.spellWaveFX = null;
|
|
}
|
|
if (this.spellCasterTargetFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(70, this.spellCasterTargetFX);
|
|
this.spellCasterTargetFX = null;
|
|
}
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
this.character.body.EndBlink();
|
|
this.QueueIcon(false);
|
|
if (!this.character.npc && !this.character.summoned)
|
|
{
|
|
this.character.portrait.skillBag.RemoveSelectedButton();
|
|
}
|
|
if (this.character.inAction)
|
|
{
|
|
this.character.PlayIdle();
|
|
}
|
|
this.ClearTargetCharacters();
|
|
if (this.character.party)
|
|
{
|
|
Links.x.gameplay.ClearWaypointEffect(this.character);
|
|
}
|
|
if (this.startAttackCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.startAttackCoroutine);
|
|
this.startAttackCoroutine = null;
|
|
}
|
|
if (this.castCompleteCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.castCompleteCoroutine);
|
|
this.castCompleteCoroutine = null;
|
|
}
|
|
if (this.actionCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.actionCoroutine);
|
|
this.actionCoroutine = null;
|
|
}
|
|
if (this.wordCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.wordCoroutine);
|
|
this.wordCoroutine = null;
|
|
}
|
|
this.character.inAction = false;
|
|
if (this.character.animID == 14)
|
|
{
|
|
this.character.animID = 0;
|
|
}
|
|
this.ai.lastAction = "";
|
|
if (this.character.npc && this.ai.findingAction)
|
|
{
|
|
this.ai.StopLookingForAction();
|
|
}
|
|
this.RemoveAbility();
|
|
this.ResetItemActions();
|
|
if (this.canEndAttackTime)
|
|
{
|
|
this.EndAttackTime(0f);
|
|
}
|
|
this.canEndAttackTime = false;
|
|
if (!this.character.moving)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
if (Records.x.paused)
|
|
{
|
|
Links.x.combat.GetTargets(false, false, null);
|
|
}
|
|
this.hasWaypoint = false;
|
|
}
|
|
|
|
// Token: 0x06000118 RID: 280 RVA: 0x000149A4 File Offset: 0x00012BA4
|
|
public void StopAction()
|
|
{
|
|
if (this.channeling)
|
|
{
|
|
this.EndChanneling(false);
|
|
}
|
|
this.EndVine();
|
|
this.castingSpell = false;
|
|
this.movingToPin = false;
|
|
this.givingItem = false;
|
|
if (this.spellWaveFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(88, this.spellWaveFX);
|
|
this.spellWaveFX = null;
|
|
}
|
|
if (this.spellCasterFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(69, this.spellCasterFX);
|
|
this.spellCasterFX = null;
|
|
}
|
|
if (this.spellCasterTargetFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(70, this.spellCasterTargetFX);
|
|
this.spellCasterTargetFX = null;
|
|
}
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
this.spellScroll = null;
|
|
if (this.playingMusic)
|
|
{
|
|
this.EndPlayingInstrument();
|
|
}
|
|
this.ai.lastAction = "";
|
|
if (this.character.party && this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.readyToAttack = false;
|
|
if (!this.character.waitingToUseItem)
|
|
{
|
|
this.QueueIcon(false);
|
|
}
|
|
else
|
|
{
|
|
this.QueueIcon(true);
|
|
}
|
|
this.ClearTargetCharacters();
|
|
this.character.PlayIdle();
|
|
if (this.startAttackCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.startAttackCoroutine);
|
|
this.startAttackCoroutine = null;
|
|
}
|
|
if (this.castCompleteCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.castCompleteCoroutine);
|
|
this.castCompleteCoroutine = null;
|
|
}
|
|
if (this.actionCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.actionCoroutine);
|
|
this.actionCoroutine = null;
|
|
}
|
|
if (this.instrumentCoroutine != null)
|
|
{
|
|
this.EndPlayingInstrument();
|
|
base.StopCoroutine(this.instrumentCoroutine);
|
|
this.instrumentCoroutine = null;
|
|
}
|
|
if (this.wordCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.wordCoroutine);
|
|
this.wordCoroutine = null;
|
|
}
|
|
this.character.inAction = false;
|
|
this.ResetItemActions();
|
|
if (Records.x.paused)
|
|
{
|
|
Links.x.combat.GetTargets(false, false, null);
|
|
}
|
|
this.ClearInteractiveSheen();
|
|
this.hasWaypoint = false;
|
|
if (this.canEndAttackTime)
|
|
{
|
|
this.EndAttackTime(0f);
|
|
}
|
|
this.canEndAttackTime = false;
|
|
this.RemoveAbility();
|
|
this.EndTurn(false);
|
|
}
|
|
|
|
// Token: 0x06000119 RID: 281 RVA: 0x00014C1C File Offset: 0x00012E1C
|
|
public void ClearSelectedActionRealTime()
|
|
{
|
|
this.canEndAttackTime = false;
|
|
this.ai.lastAction = "";
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
this.ClearTargetCharacters();
|
|
if (this.playingMusic)
|
|
{
|
|
this.EndPlayingInstrument();
|
|
}
|
|
if (this.channeling)
|
|
{
|
|
this.EndChanneling(false);
|
|
}
|
|
this.EndVine();
|
|
this.castingSpell = false;
|
|
if (this.spellWaveFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(88, this.spellWaveFX);
|
|
this.spellWaveFX = null;
|
|
}
|
|
if (this.spellCasterFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(69, this.spellCasterFX);
|
|
this.spellCasterFX = null;
|
|
}
|
|
if (this.spellCasterTargetFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(70, this.spellCasterTargetFX);
|
|
this.spellCasterTargetFX = null;
|
|
}
|
|
if (this.spellCasterTargetFailFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(78, this.spellCasterTargetFailFX);
|
|
this.spellCasterTargetFailFX = null;
|
|
}
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
if (!this.character.waitingToUseItem)
|
|
{
|
|
this.QueueIcon(false);
|
|
}
|
|
else
|
|
{
|
|
this.QueueIcon(true);
|
|
}
|
|
Links.x.combat.GetTargets(false, false, null);
|
|
this.ClearInteractiveSheen();
|
|
this.hasWaypoint = false;
|
|
}
|
|
|
|
// Token: 0x0600011A RID: 282 RVA: 0x00014DA8 File Offset: 0x00012FA8
|
|
public void ClearInteractiveSheen()
|
|
{
|
|
if (this.prevSelectedTargetInteractive)
|
|
{
|
|
BreakableActions component = this.prevSelectedTargetInteractive.GetComponent<BreakableActions>();
|
|
ChestActions component2 = this.prevSelectedTargetInteractive.GetComponent<ChestActions>();
|
|
DoorActions component3 = this.prevSelectedTargetInteractive.GetComponent<DoorActions>();
|
|
PuzzleActions component4 = this.prevSelectedTargetInteractive.GetComponent<PuzzleActions>();
|
|
if (component && !component.destroyed)
|
|
{
|
|
component.CombatSheen(0);
|
|
}
|
|
if (component2 && !component2.destroyed)
|
|
{
|
|
component2.CombatSheen(0);
|
|
}
|
|
if (component3 && !component3.destroyed)
|
|
{
|
|
component3.CombatSheen(0);
|
|
}
|
|
if (component4 && !component4.destroyed)
|
|
{
|
|
component4.CombatSheen(0);
|
|
}
|
|
this.prevSelectedTargetInteractive = null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600011B RID: 283 RVA: 0x00014E60 File Offset: 0x00013060
|
|
public void ResetItemActions()
|
|
{
|
|
this.givingItem = false;
|
|
this.movingToPin = false;
|
|
this.usingItem = false;
|
|
this.movingToPlaySong = false;
|
|
this.pickingUpItem = false;
|
|
}
|
|
|
|
// Token: 0x0600011C RID: 284 RVA: 0x00014E88 File Offset: 0x00013088
|
|
public void ResetAction()
|
|
{
|
|
this.ResetItemActions();
|
|
this.abilities.Clear();
|
|
this.choosingTurn = true;
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = false;
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.character.body.lookAtController.EndLook();
|
|
this.targetMovePosition = null;
|
|
if (this.character.inactive)
|
|
{
|
|
this.character.TurnScriptsOn();
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600011D RID: 285 RVA: 0x00014F1C File Offset: 0x0001311C
|
|
public void TryingToInterruptInventoryWait()
|
|
{
|
|
this.str.Clear();
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
this.str.Append(this.character.stats.GetName());
|
|
this.str.Append("</color>");
|
|
this.str.Append(" cannot do this while arranging equipment");
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
this.character.StartQuip("I'm adjusting my bag");
|
|
string text = "Inventory wait ";
|
|
Character character = this.character;
|
|
Debug.Log(text + ((character != null) ? character.ToString() : null));
|
|
}
|
|
|
|
// Token: 0x0600011E RID: 286 RVA: 0x00014FE0 File Offset: 0x000131E0
|
|
public void EndTurn(bool setIconAtBeginning)
|
|
{
|
|
if (this.ai.busy)
|
|
{
|
|
return;
|
|
}
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
this.currentAction = "";
|
|
if (this.songsWordsQueued.Count <= 0)
|
|
{
|
|
if (this)
|
|
{
|
|
if (this.actionCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.actionCoroutine);
|
|
this.actionCoroutine = null;
|
|
}
|
|
if (this.startAttackCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.startAttackCoroutine);
|
|
this.startAttackCoroutine = null;
|
|
}
|
|
if (this.spellCasterFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(69, this.spellCasterFX);
|
|
this.spellCasterFX = null;
|
|
}
|
|
if (this.spellWaveFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(88, this.spellWaveFX);
|
|
this.spellWaveFX = null;
|
|
}
|
|
if (this.spellCasterTargetFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(70, this.spellCasterTargetFX);
|
|
this.spellCasterTargetFX = null;
|
|
}
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
}
|
|
if (this.character.mainSelected)
|
|
{
|
|
this.EndAttackTime(0f);
|
|
Links.x.combat.pocketTarget = null;
|
|
}
|
|
this.character.inQueuedAbility = false;
|
|
if (this.cannotInterrupt)
|
|
{
|
|
Debug.Log("Resetting cannot interrupt " + ((this != null) ? this.ToString() : null));
|
|
}
|
|
this.choosingTurn = false;
|
|
if (this.character.party && this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.character.inRecovery = false;
|
|
this.character.actionNumber -= 1f;
|
|
this.ClearTargetCharacters();
|
|
this.character.inAction = false;
|
|
this.channeling = false;
|
|
this.currentTileEffect = null;
|
|
this.ammoRow = null;
|
|
this.castingSpell = false;
|
|
this.character.body.EndBlink();
|
|
this.character.stats.lastActionModifier = 1f;
|
|
this.charming = false;
|
|
if (this.playingMusic)
|
|
{
|
|
this.EndPlayingInstrument();
|
|
}
|
|
this.moveAttempts = 0;
|
|
if (this.character.mainSelected || this.character == Links.x.combat.rallyCharacter)
|
|
{
|
|
this.character.body.CombatSheen(0);
|
|
Links.x.cameraEffects.RemoveCombatCharacters();
|
|
}
|
|
this.queueInterrupt = false;
|
|
if (this.character.overlapping)
|
|
{
|
|
Links.x.combat.EndEnemyTurnFromOverlap(this.character);
|
|
}
|
|
else if (this.character.npc)
|
|
{
|
|
Links.x.combat.EndEnemyTurn(this.character, setIconAtBeginning);
|
|
}
|
|
if (this.character.party)
|
|
{
|
|
if (Records.x.InCombat(false) && Records.x.turnBased)
|
|
{
|
|
Records.x.RemoveControls(true);
|
|
}
|
|
if (Records.x.turnBased)
|
|
{
|
|
Records.x.playerTurn = false;
|
|
}
|
|
if (Records.x.InCombat(false) || this.selectedTarget || this.selectedTargetInteractive)
|
|
{
|
|
Links.x.combat.EndTurn(true, this.character, setIconAtBeginning);
|
|
}
|
|
}
|
|
else if (!this.character.npc)
|
|
{
|
|
Links.x.combat.EndTurn(true, this.character, setIconAtBeginning);
|
|
}
|
|
this.character.overlapping = false;
|
|
this.character.centerOfAttention = false;
|
|
this.character.CircleAnimation("");
|
|
if (!Records.x.combat && !this.selectedTarget && !this.selectedTargetInteractive)
|
|
{
|
|
this.EndActions();
|
|
}
|
|
return;
|
|
}
|
|
if (this.character.inQueuedAbility && this.instrumentCoroutine == null)
|
|
{
|
|
this.StartAbilityQueue();
|
|
return;
|
|
}
|
|
this.StartSongsWordsQueued(true, false);
|
|
}
|
|
|
|
// Token: 0x0600011F RID: 287 RVA: 0x00015410 File Offset: 0x00013610
|
|
public void AddTarget(Character target)
|
|
{
|
|
if (!target)
|
|
{
|
|
this.actionTargets.Add(null);
|
|
return;
|
|
}
|
|
if (target.interactiveObject)
|
|
{
|
|
if (this.actionInteractives.IndexOf(target.gameObject) == -1)
|
|
{
|
|
this.actionInteractives.Add(target.gameObject);
|
|
return;
|
|
}
|
|
}
|
|
else if (this.actionTargets.IndexOf(target) == -1)
|
|
{
|
|
this.actionTargets.Add(target);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000120 RID: 288 RVA: 0x0001547B File Offset: 0x0001367B
|
|
public void StartAttackFromDelay()
|
|
{
|
|
this.StartAction("Attack");
|
|
}
|
|
|
|
// Token: 0x06000121 RID: 289 RVA: 0x00015488 File Offset: 0x00013688
|
|
public void ClearTargetCharacters()
|
|
{
|
|
this.actionTargets.Clear();
|
|
this.actionInteractives.Clear();
|
|
this.ClearInteractiveSheen();
|
|
}
|
|
|
|
// Token: 0x06000122 RID: 290 RVA: 0x000154A8 File Offset: 0x000136A8
|
|
public bool CheckForRepathWhileWaitingToAttack()
|
|
{
|
|
if (this.ai.findingAction || this.castingSpell || this.character.mainSelected || Links.x.combat.inPocketAttack)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.repathing)
|
|
{
|
|
return true;
|
|
}
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
Character character = this.actionTargets[0];
|
|
if (character)
|
|
{
|
|
if (this.InAttackRange(character))
|
|
{
|
|
return false;
|
|
}
|
|
if (this.character.timelineIcon.doingAction)
|
|
{
|
|
return false;
|
|
}
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character2 = this.character;
|
|
Debug.Log(((character2 != null) ? character2.ToString() : null) + " needs to repath");
|
|
}
|
|
this.readyToAttack = true;
|
|
this.repathing = true;
|
|
this.ChooseAction();
|
|
return true;
|
|
}
|
|
}
|
|
if (this.actionInteractives.Count > 0)
|
|
{
|
|
GameObject gameObject = this.actionInteractives[0];
|
|
if (gameObject)
|
|
{
|
|
if (this.InAttackRangeObject(gameObject))
|
|
{
|
|
return false;
|
|
}
|
|
if (this.character.timelineIcon.doingAction)
|
|
{
|
|
return false;
|
|
}
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character3 = this.character;
|
|
Debug.Log(((character3 != null) ? character3.ToString() : null) + " needs to repath");
|
|
}
|
|
this.readyToAttack = true;
|
|
this.repathing = true;
|
|
this.ChooseAction();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000123 RID: 291 RVA: 0x00015604 File Offset: 0x00013804
|
|
public bool CheckIfMoveComplete()
|
|
{
|
|
if (this.castingSpell)
|
|
{
|
|
return true;
|
|
}
|
|
Character character = null;
|
|
GameObject gameObject = null;
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
character = this.actionTargets[0];
|
|
}
|
|
if (this.actionInteractives.Count > 0)
|
|
{
|
|
gameObject = this.actionInteractives[0];
|
|
}
|
|
if (this.character.inCircle && this.ai.circleMovement)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.character.mainSelected || (Links.x.combat.inPocketAttack && Links.x.pocketWheel.selectedRallyCharacter == this.character))
|
|
{
|
|
return false;
|
|
}
|
|
if (Links.x.combat.inPocketAttack && this.character.party && Links.x.pocketWheel.selectedRallyCharacter == this.character)
|
|
{
|
|
return false;
|
|
}
|
|
if (this.character.CanChooseActions())
|
|
{
|
|
if (this.character.fleeing || this.character.stats.Stuck() > 0)
|
|
{
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
return true;
|
|
}
|
|
if (Records.x.combatConsoleDebugging && this.character.node != null && this.character.sphere)
|
|
{
|
|
string[] array = new string[14];
|
|
array[0] = "Move complete: ";
|
|
int num = 1;
|
|
Character character2 = this.character;
|
|
array[num] = ((character2 != null) ? character2.ToString() : null);
|
|
array[2] = " ";
|
|
array[3] = ((Vector3)this.character.node.position).ToString();
|
|
array[4] = " ";
|
|
array[5] = this.character.sphere.transform.position.ToString();
|
|
array[6] = " ";
|
|
array[7] = this.readyToAttack.ToString();
|
|
array[8] = " ";
|
|
int num2 = 9;
|
|
Character character3 = character;
|
|
array[num2] = ((character3 != null) ? character3.ToString() : null);
|
|
array[10] = " ";
|
|
array[11] = this.movingToPlaySong.ToString();
|
|
array[12] = " ";
|
|
array[13] = this.character.moving.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
bool flag3;
|
|
if (character && !this.movingToPlaySong && !this.givingItem && !this.pickingUpItem && !this.movingToPin)
|
|
{
|
|
bool flag = false;
|
|
if (character)
|
|
{
|
|
flag = this.InAttackRange(character);
|
|
}
|
|
if (gameObject)
|
|
{
|
|
flag = this.InAttackRangeObject(gameObject);
|
|
}
|
|
if (flag)
|
|
{
|
|
if (this.character.moving)
|
|
{
|
|
this.character.sphere.transform.position = this.character.tr.position;
|
|
this.character.TargetReached();
|
|
}
|
|
this.StartAction("Attack");
|
|
return true;
|
|
}
|
|
bool flag2 = false;
|
|
if (!this.character.moving)
|
|
{
|
|
flag2 = true;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string text = "target too far from planned waypoint, repathing ";
|
|
Character character4 = this.character;
|
|
string text2 = ((character4 != null) ? character4.ToString() : null);
|
|
string text3 = " ";
|
|
Character character5 = character;
|
|
Debug.Log(text + text2 + text3 + ((character5 != null) ? character5.ToString() : null));
|
|
}
|
|
}
|
|
else if (this.character.savedPathTarget != null && character && (this.TargetOutOfSight(character) || (this.GetPosition(character) - (Vector3)this.character.savedPathTarget.position).sqrMagnitude > (this.AttackRange(character) + 4f) * (this.AttackRange(character) + 4f)))
|
|
{
|
|
flag2 = true;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array2 = new string[8];
|
|
array2[0] = "target out of sight or attack range, repathing ";
|
|
int num3 = 1;
|
|
Character character6 = this.character;
|
|
array2[num3] = ((character6 != null) ? character6.ToString() : null);
|
|
array2[2] = " ";
|
|
int num4 = 3;
|
|
Character character7 = character;
|
|
array2[num4] = ((character7 != null) ? character7.ToString() : null);
|
|
array2[4] = ", saved path position is: ";
|
|
array2[5] = ((Vector3)this.character.savedPathTarget.position).ToString();
|
|
array2[6] = ", attack range is : ";
|
|
array2[7] = this.AttackRange(character).ToString();
|
|
Debug.Log(string.Concat(array2));
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
return false;
|
|
}
|
|
flag3 = true;
|
|
}
|
|
else
|
|
{
|
|
if (this.movingToPlaySong)
|
|
{
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
this.movingToPlaySong = false;
|
|
return true;
|
|
}
|
|
if (this.pickingUpItem)
|
|
{
|
|
if (this.InItemRange(this.character, this.pickupItem.tr.position))
|
|
{
|
|
this.StartAction("Use");
|
|
return true;
|
|
}
|
|
flag3 = true;
|
|
}
|
|
else if (this.movingToPin)
|
|
{
|
|
if (this.InItemRange(this.character, this.pinTarget))
|
|
{
|
|
this.ai.PinTarget(this.pinTarget);
|
|
this.movingToPin = false;
|
|
return true;
|
|
}
|
|
flag3 = true;
|
|
}
|
|
else if (this.givingItem)
|
|
{
|
|
if (this.giveCharacter)
|
|
{
|
|
if (this.InItemRange(this.giveCharacter, this.character))
|
|
{
|
|
if (!this.actionTargets.Contains(this.giveCharacter))
|
|
{
|
|
this.ClearTargetCharacters();
|
|
this.AddTarget(this.giveCharacter);
|
|
}
|
|
this.StartAction("Use");
|
|
return true;
|
|
}
|
|
Debug.Log(((this != null) ? this.ToString() : null) + " target missing for giving item");
|
|
this.givingItem = false;
|
|
flag3 = true;
|
|
}
|
|
else
|
|
{
|
|
flag3 = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (character || gameObject)
|
|
{
|
|
this.EndTurn(true);
|
|
return true;
|
|
}
|
|
if (this.character.moving)
|
|
{
|
|
return false;
|
|
}
|
|
float num5 = 6.25f;
|
|
if (this.character.radius > 1f)
|
|
{
|
|
num5 = 9f;
|
|
}
|
|
if (this.character.sailing)
|
|
{
|
|
num5 = 25f;
|
|
}
|
|
if ((this.GetPosition(this.character) - this.character.sphere.transform.position).sqrMagnitude <= num5)
|
|
{
|
|
this.EndTurn(true);
|
|
return true;
|
|
}
|
|
flag3 = true;
|
|
}
|
|
}
|
|
if (flag3)
|
|
{
|
|
if (character || gameObject)
|
|
{
|
|
this.Repath();
|
|
return false;
|
|
}
|
|
this.moveAttempts++;
|
|
if (this.moveAttempts > 3)
|
|
{
|
|
this.Repath();
|
|
return true;
|
|
}
|
|
Vector3 position = this.character.sphere.transform.position;
|
|
GraphNode graphNode = this.character.NearNode(position, true, 0, -1, this.character.CheckCircleID());
|
|
if (graphNode != null)
|
|
{
|
|
this.character.MoveBackEmpty();
|
|
this.character.MakePath(graphNode, 100, false, false, true);
|
|
return false;
|
|
}
|
|
this.Repath();
|
|
return true;
|
|
}
|
|
}
|
|
else if (this.character.GetNodeCount() > 0)
|
|
{
|
|
this.character.TargetReached();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000124 RID: 292 RVA: 0x00015CEE File Offset: 0x00013EEE
|
|
public void Repath()
|
|
{
|
|
if (this.character.mainSelected)
|
|
{
|
|
return;
|
|
}
|
|
this.readyToAttack = true;
|
|
this.ChooseAction();
|
|
}
|
|
|
|
// Token: 0x06000125 RID: 293 RVA: 0x00015D0C File Offset: 0x00013F0C
|
|
public void StartSearch(Character target)
|
|
{
|
|
Links.x.sensory.LookAtObject(base.transform, 30f, false, this.character, 4f, 0.5f, null, 3);
|
|
this.startSearchTime = Links.x.gameplay.seconds;
|
|
this.character.searching = true;
|
|
if (!this.character.inCircle)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - this.character.tr.position), true, false);
|
|
this.character.StartGetPathToTarget(target.node, target, null, null, null, null, null, null, this.character, null, false, false, true, "Searching", false);
|
|
}
|
|
this.character.noiseImmune = false;
|
|
this.character.CircleAnimation("");
|
|
this.currentTarget = target;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character = this.character;
|
|
Debug.Log(((character != null) ? character.ToString() : null) + " starting search");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000126 RID: 294 RVA: 0x00015E20 File Offset: 0x00014020
|
|
public void CheckSearchTime()
|
|
{
|
|
if (!this.character.moving && !this.character && !this.character.inCircle)
|
|
{
|
|
this.character.StartGetPathToTarget(this.currentTarget.node, this.currentTarget, null, null, null, null, null, null, this.character, null, false, false, true, "Searching", false);
|
|
}
|
|
if (Links.x.gameplay.seconds >= this.startSearchTime + 500f && this.startSearchTime > 0f && !this.character.inCombat)
|
|
{
|
|
this.EndSearch();
|
|
}
|
|
if (Records.x.InCombat(false))
|
|
{
|
|
this.character.centerOfAttention = false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000127 RID: 295 RVA: 0x00015EDC File Offset: 0x000140DC
|
|
public void EndSearch()
|
|
{
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Debug.Log(((this != null) ? this.ToString() : null) + " ending search");
|
|
}
|
|
string quip = Links.x.quips.GetQuip("End Search", this.character.quipIndex);
|
|
this.character.StartQuip(quip);
|
|
this.character.searching = false;
|
|
this.character.inCombat = false;
|
|
this.character.creatures.ReturnToPatrol(this.character);
|
|
this.character.noiseImmune = true;
|
|
this.EndActions();
|
|
this.character.centerOfAttention = false;
|
|
this.character.CircleAnimation("");
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character = this.character;
|
|
Debug.Log(((character != null) ? character.ToString() : null) + " ending search");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000128 RID: 296 RVA: 0x00015FC8 File Offset: 0x000141C8
|
|
public void Ability(string abilityName, string spellName, bool needNodes, bool fromAI)
|
|
{
|
|
Library.Abilities abilityRow = Links.x.library.GetAbilityRow(abilityName);
|
|
this.abilities.Add(abilityRow);
|
|
bool isSpell = abilityRow._IsSpell;
|
|
Links.x.library.GetEffectRow(abilityName);
|
|
this.currentSpellName = spellName;
|
|
if (isSpell)
|
|
{
|
|
this.spell = abilityRow;
|
|
}
|
|
this.QueueIcon(true);
|
|
}
|
|
|
|
// Token: 0x06000129 RID: 297 RVA: 0x00016020 File Offset: 0x00014220
|
|
public void SongWordTriggered(string n, string triggerType, Library.Abilities row, out int returnMultiTargets)
|
|
{
|
|
returnMultiTargets = 0;
|
|
this.songsWordsQueued.Add(n);
|
|
if (row._AddsToAttack)
|
|
{
|
|
bool flag = false;
|
|
if (this.targetsInteractive.Count > 0 && this.targetsInteractive[0] != null)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
this.saveTargets = new GameObject[this.targetsInteractive.Count];
|
|
for (int i = 0; i < this.targetsInteractive.Count; i++)
|
|
{
|
|
this.saveTargets[i] = this.targetsInteractive[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.saveTargets = new GameObject[this.targets.Count];
|
|
for (int j = 0; j < this.targets.Count; j++)
|
|
{
|
|
this.saveTargets[j] = this.targets[j].gameObject;
|
|
}
|
|
}
|
|
this.queuedSongWordsTargets.Add(this.saveTargets);
|
|
}
|
|
else
|
|
{
|
|
this.queuedSongWordsTargets.Add(null);
|
|
}
|
|
bool flag2 = false;
|
|
if (this.character.inAction || this.character.inRecovery || this.character.inQueuedAbility)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (!(triggerType == "CombatStart") && !(triggerType == "OnHit") && !(triggerType == "OnEvade") && !row._AddsToAttack && (!(triggerType == "OnPartyKill") || flag2) && (!(triggerType == "OnFriendDown") || flag2))
|
|
{
|
|
if (triggerType == "PreAttack")
|
|
{
|
|
returnMultiTargets = row._MultiTarget;
|
|
if (row._AddsToAttack)
|
|
{
|
|
this.songsWordsQueuedTrigger.Add(false);
|
|
return;
|
|
}
|
|
int num = this.queuedSongWordsTargets.Count - 1;
|
|
this.songsWordsQueued.RemoveAt(num);
|
|
this.queuedSongWordsTargets.RemoveAt(num);
|
|
if (!row._IsSong)
|
|
{
|
|
this.character.emphasizeQuip = true;
|
|
this.character.StartQuip(row._DisplayName + "!");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.songsWordsQueuedTrigger.Add(false);
|
|
}
|
|
return;
|
|
}
|
|
this.songsWordsQueuedTrigger.Add(true);
|
|
if (!this.character.inQueuedAbility && !Records.x.pocketPause && !this.character.inRecovery && !this.character.inAction && this.instrumentCoroutine == null)
|
|
{
|
|
this.StartSongsWordsQueued(false, true);
|
|
return;
|
|
}
|
|
this.StartAbilityQueue();
|
|
}
|
|
|
|
// Token: 0x0600012A RID: 298 RVA: 0x00016278 File Offset: 0x00014478
|
|
public bool WaitingForQueuedAbility()
|
|
{
|
|
return this.checkAbilityQueues != null;
|
|
}
|
|
|
|
// Token: 0x0600012B RID: 299 RVA: 0x00016285 File Offset: 0x00014485
|
|
private void StartAbilityQueue()
|
|
{
|
|
if (this.checkAbilityQueues == null)
|
|
{
|
|
this.checkAbilityQueues = this.CheckAbilityQueues();
|
|
base.StartCoroutine(this.checkAbilityQueues);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600012C RID: 300 RVA: 0x000162A8 File Offset: 0x000144A8
|
|
private IEnumerator CheckAbilityQueues()
|
|
{
|
|
while (this.character.inQueuedAbility || this.character.inRecovery || this.character.stunned || !this.character.IsSentient() || Records.x.pocketPause || Records.x.paused || this.character.dead || this.instrumentCoroutine != null || this.ai.findingAction || this.character.jumping || this.character.evading || this.character.isHit || this.character.stats.pinned || this.character.stats.pinning || Links.x.combat.inPocketAttack)
|
|
{
|
|
yield return null;
|
|
}
|
|
int num = 0;
|
|
int num2 = -1;
|
|
for (int i = 0; i < this.songsWordsQueuedTrigger.Count; i++)
|
|
{
|
|
if (this.songsWordsQueuedTrigger[i])
|
|
{
|
|
num++;
|
|
num2 = i;
|
|
}
|
|
}
|
|
if (num2 > -1 && this.instrumentCoroutine == null)
|
|
{
|
|
this.StartSongsWordsQueued(false, true);
|
|
}
|
|
if (num > 1)
|
|
{
|
|
this.checkAbilityQueues = null;
|
|
yield return new WaitForSeconds(0.1f);
|
|
this.StartAbilityQueue();
|
|
}
|
|
else
|
|
{
|
|
this.checkAbilityQueues = null;
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600012D RID: 301 RVA: 0x000162B8 File Offset: 0x000144B8
|
|
public void StartSongsWordsQueued(bool all, bool immediate)
|
|
{
|
|
bool flag = false;
|
|
int count = this.songsWordsQueued.Count;
|
|
string text = "";
|
|
int num = -1;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (all)
|
|
{
|
|
if (!flag)
|
|
{
|
|
text = this.songsWordsQueued[i];
|
|
flag = true;
|
|
num = i;
|
|
}
|
|
else
|
|
{
|
|
this.songsWordsQueuedTrigger[i] = true;
|
|
}
|
|
}
|
|
else if (this.songsWordsQueuedTrigger[i])
|
|
{
|
|
text = this.songsWordsQueued[i];
|
|
flag = true;
|
|
num = i;
|
|
}
|
|
}
|
|
if (flag && this.character.IsSentient())
|
|
{
|
|
Library.Abilities abilityRow = Links.x.library.GetAbilityRow(text);
|
|
this.StartSong(abilityRow, false);
|
|
this.songsWordsQueued.RemoveAt(num);
|
|
this.songsWordsQueuedTrigger.RemoveAt(num);
|
|
this.queuedSongWordsTargets.RemoveAt(num);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600012E RID: 302 RVA: 0x00016387 File Offset: 0x00014587
|
|
public void RemoveAbility()
|
|
{
|
|
if (this.character.party)
|
|
{
|
|
Links.x.gameplay.ClearWaypointEffect(this.character);
|
|
}
|
|
this.abilities.Clear();
|
|
}
|
|
|
|
// Token: 0x0600012F RID: 303 RVA: 0x000163B8 File Offset: 0x000145B8
|
|
public void StartAction(string type)
|
|
{
|
|
this.canEndAttackTime = true;
|
|
if (Records.x.turnBased)
|
|
{
|
|
this.ContinueAction();
|
|
return;
|
|
}
|
|
this.repathing = false;
|
|
this.QueueIcon(true);
|
|
this.character.attackSpeed = 1f;
|
|
this.character.ClearNodePath();
|
|
this.character.waitingForPath = 0;
|
|
this.currentAction = type;
|
|
if (this.startAttackCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.startAttackCoroutine);
|
|
this.startAttackCoroutine = null;
|
|
}
|
|
this.startAttackCoroutine = this.StartingAction(type);
|
|
base.StartCoroutine(this.startAttackCoroutine);
|
|
}
|
|
|
|
// Token: 0x06000130 RID: 304 RVA: 0x00016450 File Offset: 0x00014650
|
|
private IEnumerator StartingAction(string type)
|
|
{
|
|
this.rolling = true;
|
|
this.secondAttack = false;
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
bool canAttack = true;
|
|
this.character.moveBackTarget = null;
|
|
if (this.character.dodging)
|
|
{
|
|
this.character.EndDodge();
|
|
}
|
|
this.character.inAction = true;
|
|
this.character.inActionTime = Links.x.gameplay.seconds;
|
|
bool needsToTurn = false;
|
|
Quaternion look = this.character.rot;
|
|
if (!this.character.mainSelected)
|
|
{
|
|
while (this.character.turning)
|
|
{
|
|
yield return null;
|
|
}
|
|
while (this.character.moving)
|
|
{
|
|
yield return null;
|
|
}
|
|
while (this.character.body.IsHit())
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (this.character.mainSelected)
|
|
{
|
|
Links.x.combat.ClearPossibleTargets();
|
|
}
|
|
if (this.actionTargets.Count > 0 && type != "Charm" && !this.givingItem && !this.pickingUpItem && this.actionTargets[0] && this.character)
|
|
{
|
|
if (!this.InAttackRange(this.actionTargets[0]) && !this.character.mainSelected)
|
|
{
|
|
if (this.combatCharacters == null)
|
|
{
|
|
this.combatCharacters = Links.x.diorama.characters;
|
|
}
|
|
Character character = this.actionTargets[0];
|
|
bool flag = false;
|
|
for (int i = 0; i < this.combatCharacters.Count; i++)
|
|
{
|
|
Character character2 = this.combatCharacters[i];
|
|
if (character2 && character2 != character && this.ai.CanAttack(character2) && this.InAttackRange(character2) && this.InAttackDirection(character2))
|
|
{
|
|
this.actionTargets[0] = character2;
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
canAttack = false;
|
|
}
|
|
}
|
|
if (canAttack)
|
|
{
|
|
look = Quaternion.LookRotation(this.actionTargets[0].tr.position - this.character.tr.position);
|
|
this.character.alwaysTurn = true;
|
|
this.character.SetRotation(look, false, this.character.mainSelected);
|
|
if (this.character.GetRotationAngle(look, this.character.body.tr.rotation) >= 40f)
|
|
{
|
|
needsToTurn = true;
|
|
}
|
|
}
|
|
this.quickAttack = false;
|
|
}
|
|
if (this.character.npc && this.hasTarget && this.selectedTarget)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (this.actionInteractives.Count > 0 && this.actionInteractives[0] && this.character)
|
|
{
|
|
look = Quaternion.LookRotation(this.actionInteractives[0].transform.position - this.character.tr.position);
|
|
this.character.alwaysTurn = true;
|
|
this.character.SetRotation(look, false, this.character.mainSelected);
|
|
if (this.character.GetRotationAngle(look, this.character.body.tr.rotation) >= 40f && !this.character.mainSelected)
|
|
{
|
|
needsToTurn = true;
|
|
}
|
|
}
|
|
if (type == "Charm" && this.actionTargets.Count > 0)
|
|
{
|
|
if (this.actionTargets[0])
|
|
{
|
|
this.charming = true;
|
|
look = Quaternion.LookRotation(this.actionTargets[0].tr.position - this.character.tr.position);
|
|
this.character.alwaysTurn = true;
|
|
this.character.SetRotation(look, false, false);
|
|
canAttack = true;
|
|
}
|
|
else
|
|
{
|
|
this.charming = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.charming = false;
|
|
}
|
|
if (canAttack)
|
|
{
|
|
if (needsToTurn && !this.character.mainSelected)
|
|
{
|
|
yield return new WaitForSeconds(0.1f);
|
|
}
|
|
float startTime = Time.time;
|
|
while (this.character.turning && !this.character.mainSelected)
|
|
{
|
|
if (Time.time > startTime + 1f)
|
|
{
|
|
this.character.SetRotation(look, false, false);
|
|
startTime = Time.time;
|
|
}
|
|
yield return null;
|
|
}
|
|
if (this.character.timelineIcon)
|
|
{
|
|
if (this.character.mainSelected || this.character == Links.x.combat.rallyCharacter)
|
|
{
|
|
this.character.timelineIcon.WaitForAction(0.01f, true, this.readyToAttack);
|
|
}
|
|
else
|
|
{
|
|
this.character.timelineIcon.WaitForAction(this.GetActionSpeed(type), true, this.readyToAttack);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character3 = this.character;
|
|
Debug.Log(((character3 != null) ? character3.ToString() : null) + " cannot attack ");
|
|
}
|
|
yield return new WaitForSeconds(0.01f);
|
|
this.ClearDamageLists();
|
|
this.ClearTargetCharacters();
|
|
this.canEndAttackTime = true;
|
|
this.readyToAttack = false;
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = false;
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
this.character.timelineIcon.Clear();
|
|
}
|
|
this.rolling = false;
|
|
this.startAttackCoroutine = null;
|
|
this.EndTurn(true);
|
|
}
|
|
this.startAttackCoroutine = null;
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x06000131 RID: 305 RVA: 0x00016468 File Offset: 0x00014668
|
|
public int GetHand()
|
|
{
|
|
this.currentHand = 0;
|
|
this.invRow = this.character.invRow1;
|
|
if (!this.firstAttack)
|
|
{
|
|
if (this.character.GetInvNum(2) > 1)
|
|
{
|
|
if (this.character.invRow2._EquipSlotID == 0)
|
|
{
|
|
this.currentHand = 1;
|
|
this.invRow = this.character.invRow2;
|
|
}
|
|
}
|
|
else if (this.character.stats.GetSkill(9) >= 50f && this.character.GetInvNum(0) <= 1)
|
|
{
|
|
this.currentHand = 1;
|
|
this.invRow = this.character.invRow2;
|
|
}
|
|
}
|
|
return this.currentHand;
|
|
}
|
|
|
|
// Token: 0x06000132 RID: 306 RVA: 0x00016518 File Offset: 0x00014718
|
|
public void ContinueAction()
|
|
{
|
|
this.readyToAttack = false;
|
|
this.character.inAction = true;
|
|
this.character.inActionTime = Links.x.gameplay.seconds;
|
|
this.rangeIndex = -1;
|
|
this.ammoRow = null;
|
|
bool flag = false;
|
|
for (int i = 0; i < this.abilities.Count; i++)
|
|
{
|
|
Library.Abilities abilities = this.abilities[i];
|
|
if (abilities != null)
|
|
{
|
|
if (this.IsInstrument(abilities._WeaponReq) || this.IsWord(abilities._MainSkill) || abilities._IsSpell || abilities._WeaponReq.Contains("Elixir") || abilities._MainSkill.Contains("Charm"))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (abilities._IsSpell)
|
|
{
|
|
this.spell = abilities;
|
|
}
|
|
}
|
|
}
|
|
this.ClearDamageLists();
|
|
this.character.doingAction = true;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[17];
|
|
int num = 0;
|
|
Character character = this.character;
|
|
array[num] = ((character != null) ? character.ToString() : null);
|
|
array[1] = ": using items is ";
|
|
array[2] = this.usingItem.ToString();
|
|
array[3] = ", giving item is ";
|
|
array[4] = this.givingItem.ToString();
|
|
array[5] = ", picking up item is ";
|
|
array[6] = this.pickingUpItem.ToString();
|
|
array[7] = ", action targets count is ";
|
|
array[8] = this.actionTargets.Count.ToString();
|
|
array[9] = ", abilities count is ";
|
|
array[10] = this.abilities.Count.ToString();
|
|
array[11] = ", ability to target ground is ";
|
|
array[12] = flag.ToString();
|
|
array[13] = ", weapon is ";
|
|
array[14] = this.character.invRow1._DisplayName;
|
|
array[15] = " moving to pin ";
|
|
array[16] = this.movingToPin.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (this.givingItem)
|
|
{
|
|
this.GiveItem();
|
|
return;
|
|
}
|
|
if (this.usingItem)
|
|
{
|
|
this.UsingItem();
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
return;
|
|
}
|
|
if (this.pickingUpItem)
|
|
{
|
|
this.PickUpItem();
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
return;
|
|
}
|
|
if (this.charming)
|
|
{
|
|
this.character.CheckForCharm(this.actionTargets[0]);
|
|
this.charming = false;
|
|
this.character.ZeroAttackTime(0f);
|
|
this.EndTurn(true);
|
|
return;
|
|
}
|
|
if (!this.character.stats.pinned && this.character.IsSentient() && (this.actionTargets.Count > 0 || this.actionInteractives.Count > 0 || flag))
|
|
{
|
|
if (!Links.x.combat.inRally)
|
|
{
|
|
if (this.character.mainSelected && (this.specialAttack1 || this.specialAttack2 || this.specialAttack3))
|
|
{
|
|
base.StartCoroutine(this.Pocket());
|
|
return;
|
|
}
|
|
this.firstAttack = true;
|
|
if (this.doBubbleAttack && this.bubbleTarget)
|
|
{
|
|
this.ClearDamageLists();
|
|
this.ClearTargetCharacters();
|
|
this.AddTarget(this.bubbleTarget);
|
|
}
|
|
this.ActionRolls(false, false, null, null);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character2 = this.character;
|
|
Debug.Log(((character2 != null) ? character2.ToString() : null) + " cannot attack, has no targets ");
|
|
}
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000133 RID: 307 RVA: 0x00016898 File Offset: 0x00014A98
|
|
public void ClearDamageLists()
|
|
{
|
|
this.hits.Clear();
|
|
this.targets.Clear();
|
|
this.targetsInteractive.Clear();
|
|
this.hitText.Clear();
|
|
this.attackTotal.Clear();
|
|
this.defenseTotal.Clear();
|
|
this.damages.Clear();
|
|
}
|
|
|
|
// Token: 0x06000134 RID: 308 RVA: 0x000168F4 File Offset: 0x00014AF4
|
|
public void RallyClearLists()
|
|
{
|
|
this.hits.Clear();
|
|
this.targets.Clear();
|
|
this.targetsInteractive.Clear();
|
|
this.hitText.Clear();
|
|
this.attackTotal.Clear();
|
|
this.defenseTotal.Clear();
|
|
this.damages.Clear();
|
|
}
|
|
|
|
// Token: 0x06000135 RID: 309 RVA: 0x00016950 File Offset: 0x00014B50
|
|
public void CheckIfRunningAI()
|
|
{
|
|
if (this.ai.findingAction)
|
|
{
|
|
if (this.character.npc)
|
|
{
|
|
this.ai.StopAI();
|
|
}
|
|
else
|
|
{
|
|
this.ai.StopLookingForAction();
|
|
}
|
|
}
|
|
Links.x.combat.RemoveFromNeedsTurn(this.character);
|
|
}
|
|
|
|
// Token: 0x06000136 RID: 310 RVA: 0x000169A4 File Offset: 0x00014BA4
|
|
public void StartSong(Library.Abilities song, bool fromAI)
|
|
{
|
|
this.rolling = true;
|
|
if (!fromAI)
|
|
{
|
|
this.CheckIfRunningAI();
|
|
Links.x.combat.RemoveFromNeedsTurn(this.character);
|
|
this.character.animator.SetBool("Combat", true);
|
|
Links.x.pocketWheel.Close(false);
|
|
Links.x.gameplay.joystickTarget.SetActive(false);
|
|
Links.x.combat.ClearPossibleTargets();
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 1f);
|
|
this.character.body.CombatSheen(1);
|
|
}
|
|
if (this.character.npc)
|
|
{
|
|
Links.x.sensory.AddNoise(this.character.gameObject, this.character.node, "Combat Aggro", this.character);
|
|
}
|
|
this.actionTargets.Clear();
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[6];
|
|
array[0] = "Starting song ";
|
|
int num = 1;
|
|
Character character = this.character;
|
|
array[num] = ((character != null) ? character.ToString() : null);
|
|
array[2] = " for ";
|
|
array[3] = song._Name;
|
|
array[4] = " tiles, ability count is ";
|
|
array[5] = this.abilities.Count.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
if (this.instrumentCoroutine == null)
|
|
{
|
|
Library.Inventory instrumentType = this.character.GetInstrumentType(song._WeaponReq);
|
|
GraphNode graphNode = this.character.node;
|
|
if (graphNode == null)
|
|
{
|
|
this.character.FindCurrentNode(false);
|
|
graphNode = this.character.node;
|
|
}
|
|
if (song != null && graphNode != null && instrumentType != null)
|
|
{
|
|
this.UpdateSoundAlerts(null);
|
|
this.character.inQueuedAbility = true;
|
|
this.character.inQueuedAbilityTime = Time.timeSinceLevelLoad;
|
|
bool flag = true;
|
|
float num2 = 0f;
|
|
this.character.CreateEquippedItems(instrumentType._ID, 1, Vector3.zero, Vector3.zero, 0, false);
|
|
if (song._WeaponReq == "Flute")
|
|
{
|
|
this.character.PlayAnimation("Instrument", 0f);
|
|
}
|
|
else if (song._WeaponReq == "Horn")
|
|
{
|
|
this.character.PlayAnimation("Instrument_Horn", 0f);
|
|
}
|
|
else
|
|
{
|
|
this.character.PlayAnimation("Instrument_Pipes", 0f);
|
|
}
|
|
this.instrumentCoroutine = this.InstrumentWait(flag, song._Name, song, instrumentType, graphNode, num2);
|
|
base.StartCoroutine(this.instrumentCoroutine);
|
|
}
|
|
}
|
|
this.abilities.Clear();
|
|
this.rolling = false;
|
|
}
|
|
|
|
// Token: 0x06000137 RID: 311 RVA: 0x00016C58 File Offset: 0x00014E58
|
|
private IEnumerator InstrumentWait(bool passedRoll, string uniqueName, Library.Abilities songRow, Library.Inventory instrumentRow, GraphNode startNode, float severity)
|
|
{
|
|
this.character.inQueuedAbility = true;
|
|
this.character.inQueuedAbilityTime = Time.timeSinceLevelLoad;
|
|
float radius = 0f;
|
|
this.playingMusic = true;
|
|
int num = 34;
|
|
if (songRow._WeaponReq != "Horn")
|
|
{
|
|
num = 72;
|
|
}
|
|
GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(num);
|
|
if (pooledGameObject)
|
|
{
|
|
pooledGameObject.transform.position = this.character.body.GetNeck().position + new Vector3(0f, 1.25f, 0f) + Links.x.worldCamera.transform.right * 1.25f;
|
|
pooledGameObject.SetActive(true);
|
|
}
|
|
while (Records.x.removeControls || Records.x.pocketPause)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (passedRoll)
|
|
{
|
|
TileEffects tileEffects = Links.x.tileEffects.AddComponent<TileEffects>();
|
|
tileEffects.gameObject.SetActive(true);
|
|
tileEffects.severity = severity;
|
|
tileEffects.spellIndex = this.spellIndex;
|
|
tileEffects.paganRow = null;
|
|
tileEffects.mainSkill = songRow._MainSkill;
|
|
tileEffects.spellScroll = null;
|
|
tileEffects.isSong = true;
|
|
float num2;
|
|
if (songRow._WeaponReq == "Flute")
|
|
{
|
|
num2 = this.character.stats.GetSkill(26);
|
|
}
|
|
else if (songRow._WeaponReq == "Horn")
|
|
{
|
|
num2 = this.character.stats.GetSkill(27);
|
|
}
|
|
else
|
|
{
|
|
num2 = this.character.stats.GetSkill(29);
|
|
}
|
|
tileEffects.sourceLevel = num2;
|
|
tileEffects.itemInfo = instrumentRow._Effect;
|
|
tileEffects.radius = radius;
|
|
tileEffects.startNode = startNode;
|
|
tileEffects.Setup(songRow, null, null, null, null, this.character);
|
|
}
|
|
int overallTime = songRow._OverallTime;
|
|
this.character.inRecovery = false;
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.character.inAction = true;
|
|
this.character.inActionTime = Links.x.gameplay.seconds;
|
|
Library.Effects effectRow = Links.x.library.GetEffectRow(songRow._Name);
|
|
this.character.stats.AddSkillProgress(this.character.stats.GetCombatSkillID(songRow._MainSkill), songRow._Difficulty, null);
|
|
if (passedRoll)
|
|
{
|
|
MasterAudio.PlaySound3DAtTransform("Instruments", this.character.tr, 1f, new float?(1f), 0f, effectRow._Sound, null, false, false);
|
|
}
|
|
else if (songRow._WeaponReq == "Flute")
|
|
{
|
|
MasterAudio.PlaySound3DAtTransform("Instruments", this.character.tr, 1f, new float?(1f), 0f, "Flute Fail", null, false, false);
|
|
}
|
|
else if (songRow._WeaponReq == "Horn")
|
|
{
|
|
MasterAudio.PlaySound3DAtTransform("Instruments", this.character.tr, 1f, new float?(1f), 0f, "Horn Fail", null, false, false);
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.PlaySound3DAtTransform("Instruments", this.character.tr, 1f, new float?(1f), 0f, "Pipes Fail", null, false, false);
|
|
}
|
|
float timeToLerp = 0.75f;
|
|
float percentage = 0f;
|
|
float startTime = Time.time;
|
|
if (this.character.npc)
|
|
{
|
|
timeToLerp = 1f;
|
|
}
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
yield return null;
|
|
}
|
|
this.EndPlayingInstrument();
|
|
if (this.character.mainSelected)
|
|
{
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 0f);
|
|
this.character.body.CombatSheen(0);
|
|
}
|
|
this.character.inRecovery = false;
|
|
if (!Records.x.combat)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurnAfterAction();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.endActionsAfterTurn = false;
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
this.pocketQueued = false;
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x06000138 RID: 312 RVA: 0x00016C90 File Offset: 0x00014E90
|
|
public void EndPlayingInstrument()
|
|
{
|
|
this.instrumentCoroutine = null;
|
|
this.character.inQueuedAbility = false;
|
|
this.character.CreateEquippedItems(this.character.GetInvNum(0), this.character.GetInvNum(1), this.character.GetSocketNum(0), this.character.GetSocketNum(1), 0, false);
|
|
this.character.doingAction = false;
|
|
this.character.inRecovery = false;
|
|
this.character.inAction = false;
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.playingMusic = false;
|
|
if (this.character.IsSentient())
|
|
{
|
|
this.character.PlayAnimation("Idle", 0f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000139 RID: 313 RVA: 0x00016D60 File Offset: 0x00014F60
|
|
public void CastSpell(Character targetingCharacter, bool fromAI, GraphNode centerNode, Vector3 centerPoint, bool singleTarget, bool immediate)
|
|
{
|
|
this.rolling = true;
|
|
if (!this.character.timelineIcon)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
if (!fromAI)
|
|
{
|
|
Links.x.hudControl.ToggleAttackTimer(false);
|
|
this.CheckIfRunningAI();
|
|
this.ClearSelectedActionRealTime();
|
|
Links.x.combat.RemoveFromNeedsTurn(this.character);
|
|
this.character.timelineIcon.overridePause = true;
|
|
}
|
|
this.castingSpell = true;
|
|
this.spellNode = centerNode;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Character character = this.character;
|
|
Debug.Log(((character != null) ? character.ToString() : null) + " casting spell " + this.abilities[0]._Name);
|
|
}
|
|
if (!Records.x.banquetIsle && !this.character.stats.semizenMagic && this.character.stats.magicPointsBase > 0)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("SpellcastingVol", this.character.tr.position, 1f, new float?(1f), 0.25f, "", null);
|
|
if (!this.spellCasterFX)
|
|
{
|
|
this.spellCasterFX = Links.x.cellar.GetPooledGameObject(69);
|
|
}
|
|
this.spellCasterFX.transform.position = this.character.tr.position + new Vector3(0f, 0.2f, 0f);
|
|
this.spellCasterFX.SetActive(true);
|
|
this.spellCasterFX.transform.rotation = this.character.circleRot;
|
|
}
|
|
if (!Records.x.banquetIsle && this.character.stats.magicPointsBase <= 0 && !this.character.party)
|
|
{
|
|
this.chargeUpNum = 109;
|
|
if (!this.character.stats.xmlName.Contains("Poison"))
|
|
{
|
|
this.chargeUpNum = 114;
|
|
}
|
|
if (!this.chargeUpFX)
|
|
{
|
|
this.chargeUpFX = Links.x.cellar.GetPooledGameObject(this.chargeUpNum);
|
|
}
|
|
this.chargeUpFX.transform.SetParent(this.character.body.GetNeck(), true);
|
|
this.chargeUpFX.transform.localPosition = Vector3.zero;
|
|
this.chargeUpFX.SetActive(true);
|
|
MasterAudio.PlaySound3DAtTransform("SpecialAttacks", this.character.tr, 0.2f, new float?(1f), 0f, "ChargeUp", null, false, false);
|
|
}
|
|
if ((Records.x.banquetIsle || this.character.stats.semizenMagic) && (targetingCharacter || this.spellNode != null))
|
|
{
|
|
if (!this.spellWaveFX)
|
|
{
|
|
this.spellWaveFX = Links.x.cellar.GetPooledGameObject(88);
|
|
}
|
|
Transform transform = this.character.body.GetSlot(1);
|
|
if (!transform)
|
|
{
|
|
transform = this.character.body.headBone;
|
|
}
|
|
this.spellWaveFX.transform.SetParent(transform);
|
|
this.spellWaveFX.transform.localPosition = new Vector3(0f, 0f, 0f);
|
|
this.spellWaveFX.transform.localRotation = Quaternion.Euler(new Vector3(0f, 0f, 0f));
|
|
this.spellWaveFX.transform.localScale = Vector3.one;
|
|
LineWave component = this.spellWaveFX.GetComponent<LineWave>();
|
|
Library.Pagan pagan = Links.x.library.GetPaganRow(this.abilities[0]._Name);
|
|
if (pagan._LineColor == "Red")
|
|
{
|
|
component.traceMaterial = component.redMaterial;
|
|
}
|
|
else if (pagan._LineColor == "Green")
|
|
{
|
|
component.traceMaterial = component.greenMaterial;
|
|
}
|
|
else
|
|
{
|
|
component.traceMaterial = component.blueMaterial;
|
|
}
|
|
this.spellWaveFX.SetActive(true);
|
|
if (targetingCharacter)
|
|
{
|
|
component.targetOptional = targetingCharacter.gameObject;
|
|
}
|
|
else
|
|
{
|
|
component.targetOptional = this.spellCasterTargetFX.gameObject;
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Semizen Magic", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
}
|
|
if (this.character.npc)
|
|
{
|
|
if (targetingCharacter)
|
|
{
|
|
Links.x.sensory.AddNoise(targetingCharacter.gameObject, this.character.node, "Combat Aggro", targetingCharacter);
|
|
}
|
|
else
|
|
{
|
|
Links.x.sensory.AddNoise(this.character.gameObject, this.character.node, "Combat Aggro", this.character);
|
|
}
|
|
}
|
|
this.actionTargets.Clear();
|
|
if (targetingCharacter && singleTarget)
|
|
{
|
|
this.actionTargets.Add(targetingCharacter);
|
|
}
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[8];
|
|
array[0] = "Ground spell starting from ";
|
|
int num = 1;
|
|
Character character2 = this.character;
|
|
array[num] = ((character2 != null) ? character2.ToString() : null);
|
|
array[2] = " for ";
|
|
int num2 = 3;
|
|
GraphNode graphNode = this.spellNode;
|
|
array[num2] = ((graphNode != null) ? graphNode.ToString() : null);
|
|
array[4] = " tiles, ability count is ";
|
|
array[5] = this.abilities.Count.ToString();
|
|
array[6] = " ";
|
|
array[7] = ((targetingCharacter != null) ? targetingCharacter.ToString() : null);
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (this.spellNode != null)
|
|
{
|
|
Vector3 vector = (Vector3)this.spellNode.position;
|
|
if (this.castCompleteCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.castCompleteCoroutine);
|
|
this.castCompleteCoroutine = null;
|
|
}
|
|
this.castCompleteCoroutine = this.CastWait(vector, immediate);
|
|
base.StartCoroutine(this.castCompleteCoroutine);
|
|
}
|
|
else
|
|
{
|
|
Character character3 = this.character;
|
|
Debug.Log(((character3 != null) ? character3.ToString() : null) + " has no spell nodes");
|
|
this.EndTurn(false);
|
|
this.castingSpell = false;
|
|
}
|
|
if (Links.x.gameplay.actionCharacter == this.character)
|
|
{
|
|
Links.x.gameplay.actionCharacter = null;
|
|
Links.x.gameplay.currentAbility = "";
|
|
}
|
|
if (this.character.mainSelected)
|
|
{
|
|
Links.x.pocketWheel.Close(false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600013A RID: 314 RVA: 0x000173FC File Offset: 0x000155FC
|
|
private IEnumerator CastWait(Vector3 pt, bool immediate)
|
|
{
|
|
if (!immediate)
|
|
{
|
|
if (this.actionTargets.Count > 0 && this.actionTargets[0])
|
|
{
|
|
pt = this.actionTargets[0].currentPosition;
|
|
}
|
|
Quaternion look = Quaternion.LookRotation(pt - this.character.tr.position);
|
|
if (this.character.moving)
|
|
{
|
|
this.character.ClearNodePath();
|
|
}
|
|
while (this.character.moving || (Records.x.pocketPause && !this.character.mainSelected))
|
|
{
|
|
yield return null;
|
|
}
|
|
this.character.alwaysTurn = true;
|
|
this.character.SetRotation(look, false, true);
|
|
float sTime = Time.timeSinceLevelLoad;
|
|
yield return new WaitForSeconds(0.05f);
|
|
while (this.character.turning && Time.timeSinceLevelLoad < sTime + 2f)
|
|
{
|
|
yield return null;
|
|
}
|
|
this.character.EndTurning(false);
|
|
this.character.PlayAnimation("Cast", 0f);
|
|
this.character.timelineIcon.WaitForAction(this.GetActionSpeed("Spell"), true, false);
|
|
this.character.inAction = true;
|
|
look = default(Quaternion);
|
|
}
|
|
this.castCompleteCoroutine = null;
|
|
if (immediate)
|
|
{
|
|
this.TriggerCastFromCastAnimation();
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600013B RID: 315 RVA: 0x0001741C File Offset: 0x0001561C
|
|
public void AddActionRoll(Character t, GameObject ti, int h, float d, string atk, string def, string txt)
|
|
{
|
|
this.damages.Add(d);
|
|
this.targets.Add(t);
|
|
this.targetsInteractive.Add(ti);
|
|
this.hits.Add(h);
|
|
this.attackTotal.Add(atk);
|
|
this.defenseTotal.Add(def);
|
|
this.hitText.Add(txt);
|
|
}
|
|
|
|
// Token: 0x0600013C RID: 316 RVA: 0x00017481 File Offset: 0x00015681
|
|
private IEnumerator Pocket()
|
|
{
|
|
this.rolling = true;
|
|
Records.x.RemoveControls(true);
|
|
this.ClearDamageLists();
|
|
Links.x.combat.inPocketAttack = true;
|
|
this.readyToAttack = false;
|
|
this.character.inAction = true;
|
|
this.character.inActionTime = Links.x.gameplay.seconds;
|
|
this.rangeIndex = -1;
|
|
this.ammoRow = null;
|
|
this.repathing = false;
|
|
Links.x.combat.lastRallyTarget = null;
|
|
this.QueueIcon(true);
|
|
this.character.attackSpeed = 1f;
|
|
this.character.ClearNodePath();
|
|
this.character.waitingForPath = 0;
|
|
this.character.moveBackTarget = null;
|
|
if (this.character.dodging)
|
|
{
|
|
this.character.EndDodge();
|
|
}
|
|
this.character.inAction = true;
|
|
this.character.inActionTime = Links.x.gameplay.seconds;
|
|
Links.x.combat.ClearPossibleTargets();
|
|
this.character.doingAction = true;
|
|
this.character.ChangePocketPauseState();
|
|
Links.x.pocketWheel.Close(false);
|
|
Links.x.attackDome.SetActive(false);
|
|
if (this.rallyInteractiveTarget)
|
|
{
|
|
Links.x.combat.rallyTarget = this.rallyInteractiveTarget.GetComponent<Character>();
|
|
if (this.actionInteractives.Count == 0)
|
|
{
|
|
this.AddTarget(this.rallyInteractiveTarget.GetComponent<Character>());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Links.x.combat.rallyTarget = this.actionTargets[0];
|
|
Links.x.combat.rallyTarget.body.CombatSheen(0);
|
|
}
|
|
Links.x.hudControl.ChangeHudVisibility(false, true);
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 1f);
|
|
Character c = this.character;
|
|
Character cTarget = null;
|
|
Character rallyFriend = null;
|
|
Character rallyFriend2 = null;
|
|
GraphNode rallyNode = null;
|
|
bool movedRally = false;
|
|
bool movedRally2 = false;
|
|
bool zoomed = false;
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
cTarget = this.actionTargets[0];
|
|
Links.x.combat.rallyTarget = cTarget;
|
|
}
|
|
if (!cTarget)
|
|
{
|
|
cTarget = this.actionInteractives[0].GetComponent<Character>();
|
|
}
|
|
Links.x.combat.rallyStartPosition = Links.x.combat.rallyTarget.tr.position;
|
|
Vector3 position = cTarget.tr.position;
|
|
List<Character> ditheredCharacters = new List<Character>();
|
|
c.MoveBackEmpty();
|
|
c.ignoreRemoveControls = true;
|
|
c.inRecovery = false;
|
|
c.isHit = false;
|
|
c.inAction = false;
|
|
c.body.CombatSheen(1);
|
|
c.SetActiveStateWorldUI(0);
|
|
Quaternion quaternion = Quaternion.LookRotation(new Vector3(cTarget.tr.position.x, this.character.tr.position.y, cTarget.tr.position.z) - this.character.tr.position);
|
|
int currentProjectileCount = this.projectiles.Count;
|
|
Links.x.rtsCamera.pocketPoint = Vector3.Lerp(c.tr.position, cTarget.tr.position, 0.25f);
|
|
c.SetRotation(Quaternion.LookRotation(cTarget.tr.position - c.tr.position), false, true);
|
|
if (!Links.x.pocketWheel.selectedRally.Contains("Both"))
|
|
{
|
|
if (c.invRow1._MeleeRangeEnd > 5f)
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTERange");
|
|
}
|
|
else
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTE");
|
|
}
|
|
zoomed = true;
|
|
}
|
|
this.allCharacters = Links.x.diorama.characters;
|
|
for (int j = 0; j < this.allCharacters.Count; j++)
|
|
{
|
|
Character character = this.allCharacters[j];
|
|
if (character && character != c && character != cTarget && (!character.inactive || character.party))
|
|
{
|
|
character.SetMeshState(false);
|
|
ditheredCharacters.Add(character);
|
|
}
|
|
}
|
|
Records.x.StartUIFade(true, false);
|
|
yield return new WaitForSeconds(0.1f);
|
|
if (this.pocketAttackRoutine == null)
|
|
{
|
|
this.pocketAttackRoutine = this.PocketAttack(c, cTarget, this.rallyInteractiveTarget);
|
|
base.StartCoroutine(this.pocketAttackRoutine);
|
|
while (this.pocketAttackRoutine != null)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (this.specialAttack3)
|
|
{
|
|
while (Links.x.rallyStage.playing)
|
|
{
|
|
yield return null;
|
|
}
|
|
yield return new WaitForSeconds(0.75f);
|
|
}
|
|
else
|
|
{
|
|
yield return new WaitForSeconds(0.25f);
|
|
if (this.character.stats.HandCount() > 1f)
|
|
{
|
|
yield return new WaitForSeconds(0.25f);
|
|
}
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
while (this.projectiles.Count - currentProjectileCount > 0 && Time.timeSinceLevelLoad < startRallyTime + 1f)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
c.ignoreRemoveControls = false;
|
|
c.ignoreNodeIDs = false;
|
|
bool comboBreakable = false;
|
|
if (this.rallyInteractiveTarget)
|
|
{
|
|
comboBreakable = true;
|
|
Links.x.combat.lastRallyTarget = this.rallyInteractiveTarget;
|
|
}
|
|
bool canceledCombo = false;
|
|
int num5;
|
|
for (int i = 0; i < 2; i = num5 + 1)
|
|
{
|
|
if (Links.x.fellowship.rally + Links.x.fellowship.rallyBoost >= Links.x.hudControl.rallyInterval && !canceledCombo)
|
|
{
|
|
Character pastRallyFriend = this.character;
|
|
if (i == 1)
|
|
{
|
|
pastRallyFriend = rallyFriend;
|
|
}
|
|
for (int k = 0; k < this.allCharacters.Count; k++)
|
|
{
|
|
Character character2 = this.allCharacters[k];
|
|
if (character2 && character2.party)
|
|
{
|
|
character2.SetMeshState(true);
|
|
character2.PlayAnimation("Idle", 0f);
|
|
character2.SetAnimatorSpeed(1f);
|
|
}
|
|
}
|
|
bool flag = true;
|
|
if (cTarget.dead || cTarget.stunned)
|
|
{
|
|
flag = false;
|
|
for (int l = 0; l < this.allCharacters.Count; l++)
|
|
{
|
|
if (!flag)
|
|
{
|
|
Character character3 = this.allCharacters[l];
|
|
if (pastRallyFriend.actions.ai.CanAttack(character3) && !character3.dead && !character3.stunned && Links.x.combat.NearAnyParty(character3.currentPosition, 100f))
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (comboBreakable)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
cTarget.SetMeshState(false);
|
|
}
|
|
}
|
|
if (i == 0)
|
|
{
|
|
Links.x.pocketWheel.rally1 = pastRallyFriend;
|
|
Links.x.pocketWheel.rally2 = null;
|
|
}
|
|
else
|
|
{
|
|
Links.x.pocketWheel.rally2 = pastRallyFriend;
|
|
}
|
|
if (flag)
|
|
{
|
|
this.party = Links.x.portraitOrder;
|
|
bool flag2 = false;
|
|
for (int m = 0; m < this.party.Count; m++)
|
|
{
|
|
if (flag)
|
|
{
|
|
if (comboBreakable)
|
|
{
|
|
if (Links.x.pocketWheel.CanRally(this.party[m], false))
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
else if (Links.x.pocketWheel.CanRally(this.party[m], true))
|
|
{
|
|
flag2 = true;
|
|
}
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 0f);
|
|
Links.x.pocketWheel.OpenRallyWheel(true);
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTERallyPick");
|
|
if (pastRallyFriend)
|
|
{
|
|
pastRallyFriend.body.CombatSheen(0);
|
|
for (int n = 0; n < this.allCharacters.Count; n++)
|
|
{
|
|
Character character4 = this.allCharacters[n];
|
|
if (pastRallyFriend.actions.ai.CanAttack(character4) && !character4.dead && !character4.stunned && Links.x.combat.NearAnyParty(character4.currentPosition, 100f))
|
|
{
|
|
character4.SetMeshState(true);
|
|
}
|
|
}
|
|
}
|
|
this.rallyInteractiveTarget = null;
|
|
Links.x.hudControl.gameCardAnimator.Play("WindowsIn");
|
|
Links.x.hudControl.cardCanvasGroup.interactable = true;
|
|
yield return new WaitForSeconds(0.001f);
|
|
Links.x.gameplay.rallyTargetSelected = null;
|
|
Links.x.gameplay.rallyTargetInteractiveSelected = null;
|
|
for (int num = 0; num < ditheredCharacters.Count; num++)
|
|
{
|
|
Character character5 = ditheredCharacters[num];
|
|
if (character5 && character5 != cTarget && !character5.party)
|
|
{
|
|
character5.ChangePocketPauseState();
|
|
}
|
|
}
|
|
while (!Links.x.gameplay.rallyTargetSelected && !Links.x.gameplay.rallyTargetInteractiveSelected && Links.x.pocketWheel.rallyWheelOpen)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (Links.x.gameplay.rallyTargetSelected || Links.x.gameplay.rallyTargetInteractiveSelected)
|
|
{
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 1f);
|
|
if (!Links.x.gameplay.rallyTargetInteractiveSelected)
|
|
{
|
|
cTarget = Links.x.gameplay.rallyTargetSelected;
|
|
Links.x.combat.rallyTarget = cTarget;
|
|
cTarget.body.CombatSheen(0);
|
|
}
|
|
else
|
|
{
|
|
Links.x.combat.rallyTarget = Links.x.gameplay.rallyTargetInteractiveSelected.GetComponent<Character>();
|
|
Links.x.gameplay.rallyTargetInteractiveSelected = null;
|
|
}
|
|
for (int num2 = 0; num2 < ditheredCharacters.Count; num2++)
|
|
{
|
|
Character character6 = ditheredCharacters[num2];
|
|
if (character6 && character6 != cTarget && !character6.party)
|
|
{
|
|
character6.SetMeshState(false);
|
|
character6.ChangePocketPauseState();
|
|
}
|
|
}
|
|
if (Links.x.pocketWheel.rallyWheelOpen && Links.x.pocketWheel.selectedRallyCharacter && Links.x.pocketWheel.selectedRally != "")
|
|
{
|
|
Links.x.pocketWheel.Close(false);
|
|
yield return new WaitForSeconds(0.001f);
|
|
Character rallyFriend3 = Links.x.pocketWheel.selectedRallyCharacter;
|
|
if (i == 0)
|
|
{
|
|
rallyFriend = rallyFriend3;
|
|
}
|
|
if (i == 1)
|
|
{
|
|
rallyFriend2 = rallyFriend3;
|
|
}
|
|
if (pastRallyFriend)
|
|
{
|
|
pastRallyFriend.ChangePocketPauseState();
|
|
}
|
|
if (!rallyFriend3.actions)
|
|
{
|
|
Links.x.combat.GivePartyActions(rallyFriend3, false);
|
|
}
|
|
rallyFriend3.slideNode = null;
|
|
rallyFriend3.actions.CheckIfRunningAI();
|
|
rallyFriend3.ChangePocketPauseState();
|
|
rallyFriend3.SetMeshState(true);
|
|
rallyFriend3.EndDodge();
|
|
rallyFriend3.StopEvading();
|
|
rallyFriend3.ForceEndJump();
|
|
rallyFriend3.ClearNodePath();
|
|
rallyFriend3.timelineIcon.Clear();
|
|
rallyNode = rallyFriend3.node;
|
|
List<Projectile> rallyProjectiles = rallyFriend3.actions.projectiles;
|
|
currentProjectileCount = rallyProjectiles.Count;
|
|
for (int num3 = 0; num3 < this.allCharacters.Count; num3++)
|
|
{
|
|
Character character7 = this.allCharacters[num3];
|
|
if (character7 && character7 != rallyFriend3 && character7 != cTarget && !character7.inactive)
|
|
{
|
|
character7.SetMeshState(false);
|
|
}
|
|
}
|
|
rallyFriend3.SetActiveStateWorldUI(0);
|
|
float num4 = rallyFriend3.AttackRange();
|
|
if (Vector3.Distance(rallyFriend3.tr.position, cTarget.currentPosition) > num4 + 0.5f && !Links.x.pocketWheel.selectedRally.Contains("Both") && !rallyFriend3.sailing)
|
|
{
|
|
quaternion = Quaternion.LookRotation(new Vector3(cTarget.tr.position.x, rallyFriend3.tr.position.y, cTarget.tr.position.z) - rallyFriend3.tr.position);
|
|
Vector3 newPosition = cTarget.tr.position + quaternion * Vector3.forward * ((num4 - 0.5f) * -1f);
|
|
RaycastHit raycastHit;
|
|
if (Physics.Raycast(newPosition + new Vector3(0f, 20f, 0f), Vector3.up * -1f, out raycastHit, 100f, 4194305))
|
|
{
|
|
newPosition.y = raycastHit.point.y;
|
|
}
|
|
GraphNode openNode = rallyFriend3.NearNode(newPosition, false, 0, -1, 0);
|
|
if (openNode == null)
|
|
{
|
|
openNode = cTarget.node;
|
|
}
|
|
if ((rallyFriend3.tr.position - newPosition).sqrMagnitude > 1600f || rallyFriend3.inCircle)
|
|
{
|
|
rallyFriend3.SetMeshState(false);
|
|
yield return new WaitForSeconds(0.001f);
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
while (rallyFriend3.body.dithering && Time.timeSinceLevelLoad < startRallyTime + 1f)
|
|
{
|
|
yield return null;
|
|
}
|
|
rallyFriend3.SetPosition(newPosition, null);
|
|
rallyFriend3.ClaimNode(openNode, newPosition, false);
|
|
rallyFriend3.SetMeshState(true);
|
|
rallyFriend3.SetRotation(Quaternion.LookRotation(cTarget.tr.position - rallyFriend3.tr.position), false, true);
|
|
yield return new WaitForSeconds(0.001f);
|
|
startRallyTime = Time.timeSinceLevelLoad;
|
|
while (rallyFriend3.body.dithering)
|
|
{
|
|
if (Time.timeSinceLevelLoad >= startRallyTime + 1f)
|
|
{
|
|
break;
|
|
}
|
|
rallyFriend3.SetRotation(Quaternion.LookRotation(cTarget.tr.position - rallyFriend3.tr.position), false, true);
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rallyFriend3.ignoreNodeIDs = true;
|
|
rallyFriend3.ignoreRemoveControls = true;
|
|
rallyFriend3.inAction = false;
|
|
rallyFriend3.inRecovery = false;
|
|
rallyFriend3.running = true;
|
|
rallyFriend3.SetMeshState(true);
|
|
rallyFriend3.MakePath(openNode, 100, false, false, true);
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
while (!rallyFriend3.moving && Time.timeSinceLevelLoad < startRallyTime + 1f)
|
|
{
|
|
yield return null;
|
|
}
|
|
startRallyTime = Time.timeSinceLevelLoad;
|
|
while (rallyFriend3.moving && Time.timeSinceLevelLoad < startRallyTime + 3f)
|
|
{
|
|
yield return null;
|
|
}
|
|
rallyFriend3.ignoreNodeIDs = false;
|
|
rallyFriend3.ignoreRemoveControls = false;
|
|
rallyFriend3.SetRotation(Quaternion.LookRotation(cTarget.tr.position - rallyFriend3.tr.position), false, true);
|
|
if ((rallyFriend3.tr.position - newPosition).sqrMagnitude > 25f)
|
|
{
|
|
rallyFriend3.SetPosition(newPosition, null);
|
|
rallyFriend3.ClaimNode(openNode, newPosition, false);
|
|
rallyFriend3.SetMeshState(true);
|
|
rallyFriend3.SetRotation(Quaternion.LookRotation(cTarget.tr.position - rallyFriend3.tr.position), false, true);
|
|
}
|
|
}
|
|
if (i == 0)
|
|
{
|
|
movedRally = true;
|
|
}
|
|
else
|
|
{
|
|
movedRally2 = true;
|
|
}
|
|
newPosition = default(Vector3);
|
|
openNode = null;
|
|
}
|
|
rallyFriend3.SetRotation(Quaternion.LookRotation(cTarget.tr.position - rallyFriend3.tr.position), false, true);
|
|
if (!Links.x.pocketWheel.selectedRally.Contains("Both"))
|
|
{
|
|
Links.x.rtsCamera.pocketPoint = Vector3.Lerp(rallyFriend3.tr.position, cTarget.tr.position, 0.25f);
|
|
if (rallyFriend3.invRow1._MeleeRangeEnd > 5f)
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTERange");
|
|
}
|
|
else
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTE");
|
|
}
|
|
zoomed = true;
|
|
}
|
|
if (this.pocketAttackRoutine == null)
|
|
{
|
|
this.pocketAttackRoutine = this.PocketAttack(rallyFriend3, cTarget, this.rallyInteractiveTarget);
|
|
base.StartCoroutine(this.pocketAttackRoutine);
|
|
while (this.pocketAttackRoutine != null)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
Links.x.hudControl.RemoveRallyBar((float)Records.x.GetRallyAttackCosts(1, rallyFriend3));
|
|
if (this.specialAttack3)
|
|
{
|
|
while (Links.x.rallyStage.playing)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
yield return new WaitForSeconds(0.25f);
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
while (rallyProjectiles.Count - currentProjectileCount > 0 && Time.timeSinceLevelLoad < startRallyTime + 2f)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
if (i == 0 && !this.specialAttack3)
|
|
{
|
|
if (movedRally)
|
|
{
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
rallyFriend3.ClaimNode(null, rallyFriend3.tr.position, false);
|
|
while (rallyFriend3.IsAttacking(rallyFriend3.body.currentHash) && Time.timeSinceLevelLoad < startRallyTime + 2f)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (rallyFriend3.inCircle)
|
|
{
|
|
rallyFriend3.SetMeshState(false);
|
|
yield return new WaitForSeconds(0.25f);
|
|
rallyFriend3.SetPosition((Vector3)rallyNode.position, rallyNode);
|
|
rallyFriend3.ClaimNode(rallyNode, (Vector3)rallyNode.position, false);
|
|
yield return new WaitForSeconds(0.25f);
|
|
rallyFriend3.SetMeshState(true);
|
|
movedRally = false;
|
|
}
|
|
else
|
|
{
|
|
rallyFriend3.ignoreNodeIDs = true;
|
|
rallyFriend3.ignoreRemoveControls = true;
|
|
rallyFriend3.inAction = false;
|
|
rallyFriend3.inRecovery = false;
|
|
rallyFriend3.running = true;
|
|
rallyFriend3.MakePath(rallyNode, 100, false, false, true);
|
|
}
|
|
}
|
|
rallyFriend3.ignoreNodeIDs = false;
|
|
rallyFriend3.ignoreRemoveControls = false;
|
|
if (movedRally && Links.x.fellowship.rally + Links.x.fellowship.rallyBoost < Links.x.hudControl.rallyInterval)
|
|
{
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
while (!rallyFriend3.moving && Time.timeSinceLevelLoad < startRallyTime + 0.5f)
|
|
{
|
|
yield return null;
|
|
}
|
|
startRallyTime = Time.timeSinceLevelLoad;
|
|
while (rallyFriend3.moving && Time.timeSinceLevelLoad < startRallyTime + 0.75f)
|
|
{
|
|
yield return null;
|
|
}
|
|
rallyFriend3.SetPosition((Vector3)rallyNode.position, rallyNode);
|
|
}
|
|
}
|
|
if (i == 1 && !this.specialAttack3)
|
|
{
|
|
if (movedRally2)
|
|
{
|
|
float startRallyTime = Time.timeSinceLevelLoad;
|
|
rallyFriend3.ClaimNode(null, rallyFriend3.tr.position, false);
|
|
while (rallyFriend3.IsAttacking(rallyFriend3.body.currentHash) && Time.timeSinceLevelLoad < startRallyTime + 2f)
|
|
{
|
|
yield return null;
|
|
}
|
|
rallyFriend3.ignoreNodeIDs = true;
|
|
rallyFriend3.ignoreRemoveControls = true;
|
|
rallyFriend3.inAction = false;
|
|
rallyFriend3.inRecovery = false;
|
|
rallyFriend3.running = true;
|
|
rallyFriend3.MakePath(rallyNode, 100, false, false, true);
|
|
float startMoveTime = Time.timeSinceLevelLoad;
|
|
while (!rallyFriend3.moving && Time.timeSinceLevelLoad < startMoveTime + 0.5f)
|
|
{
|
|
yield return null;
|
|
}
|
|
startMoveTime = Time.timeSinceLevelLoad;
|
|
while (rallyFriend3.moving && Time.timeSinceLevelLoad < startMoveTime + 0.75f)
|
|
{
|
|
yield return null;
|
|
}
|
|
rallyFriend3.SetPosition((Vector3)rallyNode.position, rallyNode);
|
|
}
|
|
else
|
|
{
|
|
yield return new WaitForSeconds(0.5f);
|
|
}
|
|
}
|
|
rallyFriend3 = null;
|
|
rallyProjectiles = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
canceledCombo = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
canceledCombo = true;
|
|
if (i == 0)
|
|
{
|
|
yield return new WaitForSeconds(0.5f);
|
|
}
|
|
}
|
|
pastRallyFriend = null;
|
|
}
|
|
num5 = i;
|
|
}
|
|
if (zoomed)
|
|
{
|
|
Links.x.rtsCamera.Zoom(false, "MainCharacterQTE");
|
|
}
|
|
Links.x.combat.inRally = false;
|
|
Links.x.combat.rallyTarget = null;
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 0f);
|
|
for (int num6 = 0; num6 < ditheredCharacters.Count; num6++)
|
|
{
|
|
Character character8 = ditheredCharacters[num6];
|
|
if (character8)
|
|
{
|
|
character8.SetMeshState(true);
|
|
}
|
|
}
|
|
c = this.character;
|
|
c.SetActiveStateWorldUI(1);
|
|
c.actions.damageBonus = 0f;
|
|
c.actions.effectBonus = 0f;
|
|
c.actions.specialAttack1 = false;
|
|
c.actions.specialAttack2 = false;
|
|
c.actions.specialAttack3 = false;
|
|
if (rallyFriend)
|
|
{
|
|
rallyFriend.SetActiveStateWorldUI(1);
|
|
if (rallyFriend.actions)
|
|
{
|
|
rallyFriend.actions.damageBonus = 0f;
|
|
rallyFriend.actions.effectBonus = 0f;
|
|
rallyFriend.actions.specialAttack1 = false;
|
|
rallyFriend.actions.specialAttack2 = false;
|
|
rallyFriend.actions.specialAttack3 = false;
|
|
}
|
|
}
|
|
if (rallyFriend2)
|
|
{
|
|
rallyFriend2.SetActiveStateWorldUI(1);
|
|
if (rallyFriend2.actions)
|
|
{
|
|
rallyFriend2.actions.damageBonus = 0f;
|
|
rallyFriend2.actions.effectBonus = 0f;
|
|
rallyFriend2.actions.specialAttack1 = false;
|
|
rallyFriend2.actions.specialAttack2 = false;
|
|
rallyFriend2.actions.specialAttack3 = false;
|
|
}
|
|
}
|
|
if (cTarget && cTarget.body)
|
|
{
|
|
cTarget.body.SetDeadRendererLayers(20);
|
|
}
|
|
Links.x.sensory.SetDeadRendererLayers(20);
|
|
Links.x.hudControl.ChangeHudVisibility(true, true);
|
|
Records.x.StartUIFade(false, false);
|
|
Records.x.RemoveControls(false);
|
|
Links.x.rtsCamera.pocketPoint = Vector3.zero;
|
|
Links.x.hudControl.ScaleRallyBar(false);
|
|
Links.x.gameCard.badgesCanvasGroup.alpha = 1f;
|
|
Links.x.gameplay.rallyTargetInteractiveSelected = null;
|
|
Links.x.gameplay.rallyTargetSelected = null;
|
|
Links.x.pocketWheel.SelectLightAttack();
|
|
Links.x.combat.lastRallyTarget = null;
|
|
Links.x.combat.inPocketAttack = false;
|
|
Links.x.combat.pocketTarget = null;
|
|
Links.x.pocketWheel.rally1 = null;
|
|
Links.x.pocketWheel.rally2 = null;
|
|
this.character.ZeroAttackTime(0f);
|
|
Links.x.gameplay.PocketPause(false);
|
|
yield return new WaitForSeconds(0.001f);
|
|
if (Records.x.InCombat(false))
|
|
{
|
|
Links.x.hudControl.ToggleAttackTimer(true);
|
|
}
|
|
Links.x.pocketWheel.Open(this.character);
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600013D RID: 317 RVA: 0x00017490 File Offset: 0x00015690
|
|
private IEnumerator PocketAttack(Character c1, Character cTarget, GameObject interactiveTarget)
|
|
{
|
|
this.rolling = true;
|
|
c1.MoveBackEmpty();
|
|
if (c1.stats.pinning)
|
|
{
|
|
c1.stats.pinning = false;
|
|
c1.stats.HealEffect("Pinning");
|
|
}
|
|
c1.ignoreRemoveControls = true;
|
|
c1.inRecovery = false;
|
|
c1.isHit = false;
|
|
c1.inAction = false;
|
|
c1.body.CombatSheen(1);
|
|
Links.x.combat.rallyCharacterStartPosition = c1.tr.position;
|
|
while (Links.x.qte.Holding2())
|
|
{
|
|
yield return null;
|
|
}
|
|
bool rallyStage = false;
|
|
c1.actions.specialAttack2 = false;
|
|
c1.actions.specialAttack3 = false;
|
|
if (!Links.x.pocketWheel.selectedRally.Contains("Damage") && !Links.x.pocketWheel.selectedRally.Contains("Both"))
|
|
{
|
|
c1.actions.specialAttack2 = true;
|
|
}
|
|
if (Links.x.pocketWheel.selectedRally.Contains("Both"))
|
|
{
|
|
c1.actions.specialAttack3 = true;
|
|
rallyStage = true;
|
|
}
|
|
bool flag = false;
|
|
if (!Records.x.editor)
|
|
{
|
|
flag = false;
|
|
}
|
|
if (flag)
|
|
{
|
|
Links.x.pocketWheel.selectedRally = "Both";
|
|
rallyStage = true;
|
|
this.specialAttack3 = true;
|
|
}
|
|
if (rallyStage)
|
|
{
|
|
if (interactiveTarget)
|
|
{
|
|
rallyStage = false;
|
|
}
|
|
if (rallyStage)
|
|
{
|
|
Library.Inventory invRow = c1.invRow1;
|
|
string text = "";
|
|
if (c1.stats.race != "Yeti")
|
|
{
|
|
if (invRow._MainSkill == "Scepter")
|
|
{
|
|
if (invRow._TwoHanded)
|
|
{
|
|
text = "Impact";
|
|
}
|
|
else
|
|
{
|
|
text = "ScepterSingle";
|
|
}
|
|
}
|
|
if (invRow._MainSkill == "Whip")
|
|
{
|
|
text = "Whip";
|
|
}
|
|
if (invRow._MainSkill == "Pole")
|
|
{
|
|
text = "Pole";
|
|
}
|
|
if (invRow._MainSkill == "ShortSword")
|
|
{
|
|
text = "ShortSword";
|
|
}
|
|
if (invRow._MainSkill == "Sword")
|
|
{
|
|
text = "LongSword";
|
|
}
|
|
if (invRow._MainSkill == "Sling")
|
|
{
|
|
text = "Sling";
|
|
}
|
|
if (invRow._MainSkill == "Ax")
|
|
{
|
|
text = "Ax";
|
|
}
|
|
if (invRow._MainSkill == "Bow")
|
|
{
|
|
text = "Bow";
|
|
}
|
|
if (invRow._MainSkill == "Elixir")
|
|
{
|
|
text = "Elyxir";
|
|
}
|
|
if (invRow._MainSkill == "Hand-to-Hand")
|
|
{
|
|
text = "Unarmed";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (invRow._MainSkill == "Pole")
|
|
{
|
|
text = "Yeti_Spear";
|
|
}
|
|
if (invRow._MainSkill == "Hand-to-Hand")
|
|
{
|
|
text = "Yeti_Unarmed";
|
|
}
|
|
if (invRow._MainSkill == "Scepter")
|
|
{
|
|
text = "Yeti_Scepter";
|
|
}
|
|
if (text == "")
|
|
{
|
|
text = "Yeti_Sword";
|
|
}
|
|
}
|
|
Links.x.rallyStage.SetupStage(text, c1, cTarget);
|
|
}
|
|
cTarget.ChangePocketPauseState();
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.PlaySoundAndForget("Feedback", 1f, new float?(1f), 0f, "RallyDamage2", null);
|
|
Links.x.combat.pocketParticle.transform.position = c1.tr.position + new Vector3(0f, 5f, 0f);
|
|
Links.x.combat.pocketParticle.SetActive(true);
|
|
}
|
|
c1.actions.firstAttack = true;
|
|
c1.attackSpeed = 1f;
|
|
c1.actions.specialAttack1 = true;
|
|
if (!rallyStage)
|
|
{
|
|
if (this.specialAttack2)
|
|
{
|
|
c1.PlayAnimation("SynergyAttack2", 0f);
|
|
}
|
|
else
|
|
{
|
|
c1.PlayAnimation("SynergyAttack1", 0f);
|
|
}
|
|
}
|
|
if (cTarget)
|
|
{
|
|
c1.SetRotation(Quaternion.LookRotation(cTarget.tr.position - c1.tr.position), false, true);
|
|
}
|
|
else
|
|
{
|
|
c1.SetRotation(Quaternion.LookRotation(interactiveTarget.transform.position - c1.tr.position), false, true);
|
|
}
|
|
if (!rallyStage)
|
|
{
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
if (this.specialAttack2)
|
|
{
|
|
Links.x.qte.bonusType = "Effects";
|
|
}
|
|
else
|
|
{
|
|
Links.x.qte.bonusType = "";
|
|
}
|
|
Links.x.qte.playing = true;
|
|
Links.x.qte.StartQTE("MoonPunch", 4f);
|
|
float startTimeScale = Time.timeScale;
|
|
float timeToLerp = 0.25f;
|
|
float percentage = 0f;
|
|
float startTime = Time.realtimeSinceStartup;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.realtimeSinceStartup - startTime) / timeToLerp;
|
|
Time.timeScale = Mathf.Lerp(startTimeScale, 0.25f, percentage);
|
|
if (cTarget)
|
|
{
|
|
c1.SetRotation(Quaternion.LookRotation(cTarget.tr.position - c1.tr.position), false, true);
|
|
}
|
|
else
|
|
{
|
|
c1.SetRotation(Quaternion.LookRotation(interactiveTarget.transform.position - c1.tr.position), false, true);
|
|
}
|
|
yield return null;
|
|
}
|
|
while (Links.x.qte.playing)
|
|
{
|
|
yield return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
}
|
|
if (Links.x.pocketWheel.selectedRally.Contains("Damage"))
|
|
{
|
|
c1.actions.damageBonus = Links.x.qte.bonus;
|
|
}
|
|
else
|
|
{
|
|
c1.actions.effectBonus = Links.x.qte.bonus;
|
|
}
|
|
c1.actions.ClearDamageLists();
|
|
c1.actions.ClearTargetCharacters();
|
|
if (interactiveTarget)
|
|
{
|
|
c1.actions.AddTarget(interactiveTarget.GetComponent<Character>());
|
|
}
|
|
else
|
|
{
|
|
c1.actions.AddTarget(cTarget);
|
|
}
|
|
c1.actions.firstAttack = true;
|
|
c1.actions.secondAttack = false;
|
|
c1.actions.ActionRolls(false, false, null, null);
|
|
c1.actions.rolling = false;
|
|
if (rallyStage)
|
|
{
|
|
float num = this.damages[0];
|
|
bool flag2 = Records.x.kill;
|
|
if (cTarget.summoned)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (cTarget.ghost)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if (cTarget.name.Contains("LocalGraveKeeper") && Links.x.diorama.mapCanResurrect)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
if ((float)cTarget.stats.HealthCurrent() - num <= 0f && flag2)
|
|
{
|
|
Links.x.rallyStage.targetDies = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.PlaySoundAndForget("Synergy Pass", 1f, new float?(1f), 0f, "", null);
|
|
Links.x.rtsCamera.pocketPoint = cTarget.tr.position;
|
|
Links.x.rtsCamera.MinOrtho = 7f;
|
|
Links.x.rtsCamera.Ortho = 7f;
|
|
float startTime = Time.timeScale;
|
|
float percentage = 0.5f;
|
|
float timeToLerp = 0f;
|
|
float startTimeScale = Time.realtimeSinceStartup;
|
|
while (timeToLerp < 1f)
|
|
{
|
|
timeToLerp = (Time.realtimeSinceStartup - startTimeScale) / percentage;
|
|
Time.timeScale = Mathf.Lerp(startTime, 1f, timeToLerp);
|
|
yield return null;
|
|
}
|
|
yield return new WaitForSeconds(0.75f);
|
|
while (!this.character.inRecovery)
|
|
{
|
|
yield return null;
|
|
}
|
|
Links.x.combat.pocketParticle.SetActive(false);
|
|
}
|
|
if (rallyStage)
|
|
{
|
|
while (Links.x.rallyStage.playing)
|
|
{
|
|
yield return null;
|
|
}
|
|
this.MultiHit(cTarget, interactiveTarget, false, false, false, false, c1.invRow1);
|
|
}
|
|
this.pocketAttackRoutine = null;
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600013E RID: 318 RVA: 0x000174B4 File Offset: 0x000156B4
|
|
public void StartMiniEvent(Character target, Character ally, string type, bool stopGameplay)
|
|
{
|
|
if (this.miniCoroutine == null && !Links.x.combat.miniEvent)
|
|
{
|
|
this.miniCoroutine = this.MiniEvent(target, ally, type, stopGameplay);
|
|
base.StartCoroutine(this.miniCoroutine);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600013F RID: 319 RVA: 0x000174ED File Offset: 0x000156ED
|
|
private IEnumerator MiniEvent(Character target, Character ally, string type, bool stopGameplay)
|
|
{
|
|
this.ai.busy = true;
|
|
bool canDoEvent = true;
|
|
while (Links.x.combat.inPocketAttack)
|
|
{
|
|
yield return null;
|
|
}
|
|
if (canDoEvent)
|
|
{
|
|
this.rolling = true;
|
|
if (stopGameplay)
|
|
{
|
|
Links.x.combat.miniEvent = true;
|
|
}
|
|
if (type.Contains("Bubble Evade") || type == "Bubble Attack")
|
|
{
|
|
if (stopGameplay)
|
|
{
|
|
Links.x.combat.bubbleEvent = true;
|
|
Links.x.combat.bubbleEventTarget = this.character;
|
|
Links.x.combat.bubbleEventTargetPosition = this.character.tr.position;
|
|
}
|
|
this.character.meshAlwaysOn = true;
|
|
this.character.SetMeshState(true);
|
|
}
|
|
if (stopGameplay)
|
|
{
|
|
Records.x.RemoveControls(true);
|
|
Links.x.gameplay.PocketPause(true);
|
|
Links.x.hudControl.ChangeHudVisibility(false, true);
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 1f);
|
|
Shader.SetGlobalVector("_CinematicRevealPosition", this.character.gameObject.transform.position);
|
|
}
|
|
Character c = this.character;
|
|
new List<Character>();
|
|
if (type == "Free Attack")
|
|
{
|
|
target.body.StartBlink2(13, "");
|
|
}
|
|
if (type != "Bubble Evade" && type != "Bubble Attack" && type != "Dragoon")
|
|
{
|
|
this.ClearDamageLists();
|
|
this.ClearTargetCharacters();
|
|
this.AddTarget(target);
|
|
}
|
|
MasterAudio.PlaySoundAndForget("Synergy Pass", 1f, new float?(1f), 0f, "", null);
|
|
c.MoveBackEmpty();
|
|
if (type == "Dodge" || type.Contains("Dragoon"))
|
|
{
|
|
c.ClearNodePath();
|
|
c.EndDodge();
|
|
if (!c.jumping)
|
|
{
|
|
c.StopEvading();
|
|
}
|
|
}
|
|
c.ignoreRemoveControls = true;
|
|
c.inRecovery = false;
|
|
c.isHit = false;
|
|
if (!type.Contains("Bubble Evade") && type != "Bubble Attack")
|
|
{
|
|
c.inAction = false;
|
|
c.body.CombatSheen(1);
|
|
c.actions.firstAttack = true;
|
|
}
|
|
if (!type.Contains("Bubble Evade"))
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.currentPosition - this.character.currentPosition), false, true);
|
|
}
|
|
string camZoom = "TargetSelect";
|
|
if (type != "Free Attack")
|
|
{
|
|
camZoom = "MainCharacterQTE";
|
|
}
|
|
if (type != "Bubble Attack" && stopGameplay && !type.Contains("Dragoon"))
|
|
{
|
|
Links.x.rtsCamera.Zoom(true, camZoom);
|
|
}
|
|
int currentProjectileCount = this.projectiles.Count;
|
|
this.allCharacters = Links.x.diorama.characters;
|
|
if (stopGameplay)
|
|
{
|
|
Records.x.StartUIFade(true, false);
|
|
}
|
|
Links.x.qte.Reset();
|
|
c.attackSpeed = 1f;
|
|
if (type == "Free Attack")
|
|
{
|
|
c.PlayAnimation("BasicAttack", 0f);
|
|
Links.x.combat.StartSlowTime("Synergy");
|
|
}
|
|
else if (type == "Dodge")
|
|
{
|
|
c.PlayAnimation("BasicAttack", 0f);
|
|
}
|
|
else if (type.Contains("Dragoon"))
|
|
{
|
|
c.PlayAnimation("Idle", 0f);
|
|
}
|
|
if (type == "Dodge" || type.Contains("Bubble Evade") || type == "Bubble Attack")
|
|
{
|
|
yield return new WaitForSeconds(0.001f);
|
|
float num = 0.2f;
|
|
this.m_CurrentClipInfo = this.character.animator.GetCurrentAnimatorClipInfo(0);
|
|
if (this.m_CurrentClipInfo != null && this.m_CurrentClipInfo.Length != 0)
|
|
{
|
|
AnimationClip clip = this.m_CurrentClipInfo[0].clip;
|
|
if (clip != null)
|
|
{
|
|
this.events = clip.events;
|
|
if (this.events != null)
|
|
{
|
|
for (int i = 0; i < this.events.Length; i++)
|
|
{
|
|
if (this.events[i].functionName.Contains("ttack"))
|
|
{
|
|
num = this.events[i].time - 0.3f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (type.Contains("Bubble Evade"))
|
|
{
|
|
if (type.Contains("Dragoon"))
|
|
{
|
|
Vector3 jumpTo = target.tr.position + Quaternion.LookRotation((Vector3)this.ai.jumpNode.position - target.tr.position) * Vector3.forward * 2.5f;
|
|
Vector3 jumpToHold = jumpTo;
|
|
jumpToHold.y += 20f;
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTE");
|
|
float startValue = 0f;
|
|
float endValue = 1f;
|
|
float timeToLerp = 0.5f;
|
|
float percentage = 0f;
|
|
float startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - this.character.currentPosition), false, true);
|
|
yield return null;
|
|
}
|
|
this.character.PlayAnimation("SynergyAttack1", 0f);
|
|
Vector3 position = this.character.tr.position;
|
|
this.character.tr.position + new Vector3(0f, 20f, 0f);
|
|
bool dithered = false;
|
|
startValue = 0f;
|
|
endValue = 1f;
|
|
timeToLerp = 1f;
|
|
percentage = 0f;
|
|
startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
if (percentage > 0.2f && (!dithered || this.character.visible == 1))
|
|
{
|
|
this.character.meshAlwaysOn = false;
|
|
this.character.SetMeshState(false);
|
|
dithered = true;
|
|
}
|
|
yield return null;
|
|
}
|
|
Links.x.rtsCamera.Zoom(true, "MainCharacterQTERange");
|
|
Links.x.combat.bubbleEventTargetPosition = jumpTo;
|
|
this.character.SetPosition(jumpToHold, null);
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
Links.x.qte.playing = true;
|
|
Links.x.qte.bonusType = "Evasion";
|
|
Links.x.qte.StartQTE("MoonPunch", 1f);
|
|
timeToLerp = 1f;
|
|
percentage = 0f;
|
|
startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
this.character.SetPosition(jumpToHold, null);
|
|
yield return null;
|
|
}
|
|
this.character.PlayAnimation("SynergyAttack2", 0f);
|
|
this.character.animator.Update(0f);
|
|
this.character.SetPosition(jumpTo, null);
|
|
this.character.meshAlwaysOn = true;
|
|
this.character.SetMeshState(true);
|
|
this.character.body.SetMeshState(true, false);
|
|
startValue = 0f;
|
|
endValue = 1f;
|
|
timeToLerp = 0.233f;
|
|
percentage = 0f;
|
|
startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - jumpTo), false, true);
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
Mathf.Lerp(startValue, endValue, percentage);
|
|
yield return null;
|
|
}
|
|
this.evasionBonus = Links.x.qte.bonus;
|
|
this.firstAttack = true;
|
|
this.rolling = true;
|
|
this.ActionRolls(false, false, null, null);
|
|
this.rolling = false;
|
|
target.OverridePocketPause();
|
|
this.TriggerHitFromAttackAnimation();
|
|
this.AttackAnimationDone();
|
|
this.character.ClaimNode(this.ai.jumpNode, jumpTo, true);
|
|
timeToLerp = 1.5f;
|
|
percentage = 0f;
|
|
startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
yield return null;
|
|
}
|
|
this.character.alwaysOn = false;
|
|
jumpTo = default(Vector3);
|
|
jumpToHold = default(Vector3);
|
|
}
|
|
else
|
|
{
|
|
c.body.hold();
|
|
if (type == "Bubble Evade")
|
|
{
|
|
yield return new WaitForSeconds(0.5f);
|
|
}
|
|
this.damageBonus = 0f;
|
|
this.effectBonus = 0f;
|
|
Links.x.qte.playing = true;
|
|
Links.x.qte.StartQTE("MoonPunch", 1f);
|
|
while (Links.x.qte.playing)
|
|
{
|
|
yield return null;
|
|
}
|
|
yield return new WaitForSeconds(0.5f);
|
|
c.body.animationHold = false;
|
|
c.SetAnimatorSpeed(1f);
|
|
this.doSlowTime = true;
|
|
target.OverridePocketPause();
|
|
yield return new WaitForSeconds(0.25f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
yield return new WaitForSeconds(num);
|
|
if (stopGameplay)
|
|
{
|
|
target.OverridePocketPause();
|
|
}
|
|
if (stopGameplay)
|
|
{
|
|
this.doSlowTime = true;
|
|
}
|
|
}
|
|
}
|
|
if (type != "Bubble Evade" && type != "Bubble Attack" && type != "Dragoon Bubble Evade")
|
|
{
|
|
this.firstAttack = true;
|
|
this.rolling = true;
|
|
this.ActionRolls(false, false, null, null);
|
|
this.rolling = false;
|
|
}
|
|
if (type == "Bubble Attack")
|
|
{
|
|
yield return new WaitForSeconds(0.5f);
|
|
if (stopGameplay)
|
|
{
|
|
Links.x.combat.bubbleEventTarget = target;
|
|
}
|
|
int count = this.projectiles.Count;
|
|
float startTime = Time.timeSinceLevelLoad;
|
|
while (this.projectiles.Count - currentProjectileCount > 0 && Time.timeSinceLevelLoad < startTime + 3f)
|
|
{
|
|
yield return null;
|
|
}
|
|
yield return new WaitForSeconds(1f);
|
|
}
|
|
if (type == "Free Attack")
|
|
{
|
|
float startTime = 1f;
|
|
float percentage = 0f;
|
|
float timeToLerp = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - timeToLerp) / startTime;
|
|
this.character.SetRotation(Quaternion.LookRotation(target.currentPosition - this.character.currentPosition), false, true);
|
|
yield return null;
|
|
}
|
|
target.body.EndBlink2();
|
|
}
|
|
else if (type == "Dodge")
|
|
{
|
|
float timeToLerp = 0.3f;
|
|
float percentage = 0f;
|
|
float startTime = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - startTime) / timeToLerp;
|
|
this.character.SetRotation(Quaternion.LookRotation(target.currentPosition - this.character.currentPosition), false, true);
|
|
yield return null;
|
|
}
|
|
}
|
|
else if (type.Contains("Bubble Evade") || type == "Bubble Attack")
|
|
{
|
|
float startTime = 0.5f;
|
|
float percentage = 0f;
|
|
float timeToLerp = Time.time;
|
|
while (percentage < 1f)
|
|
{
|
|
percentage = (Time.time - timeToLerp) / startTime;
|
|
yield return null;
|
|
}
|
|
this.character.ZeroAttackTime(0f);
|
|
}
|
|
if (false)
|
|
{
|
|
this.character.ignoreNodeIDs = true;
|
|
this.character.ignoreRemoveControls = true;
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = false;
|
|
this.character.running = false;
|
|
this.character.Jump(this.ai.jumpNode, (Vector3)this.ai.jumpNode.position, true, false);
|
|
float timeToLerp = Time.timeSinceLevelLoad;
|
|
while (!this.character.moving && Time.timeSinceLevelLoad < timeToLerp + 1f)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - this.character.tr.position), false, true);
|
|
yield return null;
|
|
}
|
|
timeToLerp = Time.timeSinceLevelLoad;
|
|
while (this.character.moving && Time.timeSinceLevelLoad < timeToLerp + 3f)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - this.character.tr.position), false, true);
|
|
yield return null;
|
|
}
|
|
this.character.ignoreNodeIDs = false;
|
|
this.character.ignoreRemoveControls = false;
|
|
this.character.SetRotation(Quaternion.LookRotation(target.tr.position - this.character.tr.position), false, true);
|
|
}
|
|
if (stopGameplay)
|
|
{
|
|
Shader.SetGlobalFloat("_NoCharacterFX", 0f);
|
|
Records.x.StartUIFade(false, false);
|
|
Links.x.hudControl.ChangeHudVisibility(true, true);
|
|
Records.x.RemoveControls(false);
|
|
}
|
|
Links.x.combat.miniEvent = false;
|
|
Links.x.combat.bubbleEvent = false;
|
|
Links.x.combat.bubbleEventTarget = null;
|
|
if (stopGameplay)
|
|
{
|
|
Links.x.gameplay.PocketPause(false);
|
|
Links.x.rtsCamera.Zoom(false, camZoom);
|
|
Shader.SetGlobalVector("_CinematicRevealPosition", new Vector3(-100000f, -100000f, -100000f));
|
|
}
|
|
this.character.inRecovery = false;
|
|
this.character.inAction = false;
|
|
this.character.meshAlwaysOn = false;
|
|
c = null;
|
|
camZoom = null;
|
|
}
|
|
this.doBubbleAttack = false;
|
|
this.savedEnemy = null;
|
|
this.ai.busy = false;
|
|
this.miniCoroutine = null;
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x06000140 RID: 320 RVA: 0x00017512 File Offset: 0x00015712
|
|
public void ActionRolls(bool grazing, bool afterAnimationFlag, Character onlyTarget, GameObject onlyInteractive)
|
|
{
|
|
if (this.actionCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.actionCoroutine);
|
|
this.actionCoroutine = null;
|
|
}
|
|
this.actionCoroutine = this.Action(grazing, afterAnimationFlag, onlyTarget, onlyInteractive);
|
|
base.StartCoroutine(this.actionCoroutine);
|
|
}
|
|
|
|
// Token: 0x06000141 RID: 321 RVA: 0x0001754D File Offset: 0x0001574D
|
|
private IEnumerator Action(bool grazing, bool afterAnimationFlag, Character onlyTarget, GameObject onlyInteractive)
|
|
{
|
|
this.rolling = true;
|
|
bool flag = false;
|
|
this.canEndAttackTime = true;
|
|
if (this.channeling)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (this.abilities.Count > 0 && !afterAnimationFlag)
|
|
{
|
|
if (this.abilities[0]._IsSpell)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (this.character.party)
|
|
{
|
|
Links.x.gameplay.ClearWaypointEffect(this.character);
|
|
}
|
|
}
|
|
Character rallyCharacter = Links.x.combat.rallyCharacter;
|
|
int num = 0;
|
|
for (int i = 0; i < this.actionTargets.Count; i++)
|
|
{
|
|
if (this.actionTargets[i] && (this.actionTargets[i].dead || (this.actionTargets[i].stunned && !Records.x.kill)))
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
bool flag2 = false;
|
|
if (num == this.actionTargets.Count && this.actionTargets.Count > 0 && !flag)
|
|
{
|
|
flag2 = true;
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
this.character.StopMoveToRoutine();
|
|
float num2 = 0f;
|
|
float num3 = 0f;
|
|
if (flag)
|
|
{
|
|
num2 = this.character.stats.PaganHitChance(false, this.spell._MainSkill);
|
|
float num4;
|
|
float num5;
|
|
this.character.stats.PaganSpellCost(this.currentSpellName, true, out num4, out num5);
|
|
}
|
|
bool flag3 = false;
|
|
if (this.firstAttack)
|
|
{
|
|
if (this.character.mainSelected)
|
|
{
|
|
this.lightAttack = true;
|
|
this.heavyAttack = false;
|
|
if (this.character.invRow1._MeleeRangeEnd < 5f)
|
|
{
|
|
this.lightAttack = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = true;
|
|
if (!afterAnimationFlag && flag4)
|
|
{
|
|
if (this.character.npc)
|
|
{
|
|
if (this.character.invRow1._MeleeRangeEnd < 5f)
|
|
{
|
|
this.lightAttack = false;
|
|
}
|
|
}
|
|
else if (this.character.party)
|
|
{
|
|
flag4 = true;
|
|
if (this.character.invRow1._MeleeRangeEnd < 5f)
|
|
{
|
|
this.lightAttack = false;
|
|
}
|
|
}
|
|
}
|
|
if (!flag4)
|
|
{
|
|
this.lightAttack = true;
|
|
this.heavyAttack = false;
|
|
}
|
|
}
|
|
}
|
|
if (this.character.stats.onlyLightAtks > 0)
|
|
{
|
|
this.lightAttack = true;
|
|
}
|
|
string text = "Attack";
|
|
if (!this.lightAttack && !this.quickAttack && !this.heavyAttack)
|
|
{
|
|
text = "Multi Attack";
|
|
flag3 = true;
|
|
}
|
|
if (afterAnimationFlag && flag3)
|
|
{
|
|
this.heavyAttack = false;
|
|
}
|
|
if (this.lightAttack)
|
|
{
|
|
text = "Attack";
|
|
}
|
|
if (this.heavyAttack)
|
|
{
|
|
text = "Heavy Attack";
|
|
}
|
|
if (this.specialAttack1)
|
|
{
|
|
text = "Spirit Attack 1";
|
|
}
|
|
if (!flag2)
|
|
{
|
|
if (flag)
|
|
{
|
|
if (this.character.IsCasting(this.character.body.currentHash))
|
|
{
|
|
GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(10);
|
|
pooledGameObject.transform.position = this.character.body.HeadPosition(0f);
|
|
pooledGameObject.SetActive(true);
|
|
}
|
|
else
|
|
{
|
|
this.character.PlayAnimation("Cast", 0f);
|
|
}
|
|
}
|
|
else if (!afterAnimationFlag)
|
|
{
|
|
this.character.body.ignoreAttackEvent = false;
|
|
this.character.attackSpeed = 1f;
|
|
this.GetHand();
|
|
if (this.firstAttack || this.character.stats.HandCount() < 1f || this.character.summoned)
|
|
{
|
|
bool flag5 = false;
|
|
if (this.character.invRow1._MeleeRangeEnd >= 5f)
|
|
{
|
|
if (this.specialAttack2 && this.character.invRow1._MainSkill != "Bow")
|
|
{
|
|
int selectedAmmoID = Links.x.pocketWheel.GetSelectedAmmoID();
|
|
if (selectedAmmoID > -1)
|
|
{
|
|
this.ammoRow = Links.x.library.GetInvRowByIndex(selectedAmmoID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int ammoIndex = this.character.GetAmmoIndex(this.character.invRow1);
|
|
if (ammoIndex > -1)
|
|
{
|
|
this.ammoRow = Links.x.library.GetInvRowByIndex(this.character.GetInvNum(ammoIndex));
|
|
if (this.ammoRow._DmgMax <= 0 && this.ammoRow._Effect != "")
|
|
{
|
|
this.chargeUpNum = 109;
|
|
if (!this.character.stats.xmlName.Contains("Poison"))
|
|
{
|
|
this.chargeUpNum = 114;
|
|
}
|
|
if (!this.chargeUpFX)
|
|
{
|
|
this.chargeUpFX = Links.x.cellar.GetPooledGameObject(this.chargeUpNum);
|
|
}
|
|
this.chargeUpFX.transform.SetParent(this.character.body.GetNeck(), true);
|
|
this.chargeUpFX.transform.localPosition = Vector3.zero;
|
|
this.chargeUpFX.SetActive(true);
|
|
MasterAudio.PlaySound3DAtTransform("SpecialAttacks", this.character.tr, 0.2f, new float?(1f), 0f, "ChargeUp", null, false, false);
|
|
this.character.PlayAnimation("SynergyAttack2", 0f);
|
|
flag5 = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ((!this.character.party || !Links.x.combat.inPocketAttack) && !flag5)
|
|
{
|
|
if (flag3 && !this.character.summoned && !this.character.stats.animal && !this.specialAttack1 && !this.specialAttack2)
|
|
{
|
|
this.character.PlayAnimation("BasicAttackMulti", 0f);
|
|
}
|
|
else if (!Links.x.combat.miniEvent || !this.character.mainSelected)
|
|
{
|
|
this.character.PlayAnimation("BasicAttack", 0f);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.secondAttack = true;
|
|
this.character.PlayAnimation("SecondAttack", 0f);
|
|
}
|
|
if (this.character.invRow1._MainSkill == "Elixir")
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Elixir Start", this.character.tr.position, Random.Range(0.8f, 1f), new float?(1f), 0f, "", null);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.character.inAction = false;
|
|
}
|
|
if (Records.x.pocketPause && (this.character.mainSelected || this.character == Links.x.combat.rallyCharacter) && !afterAnimationFlag)
|
|
{
|
|
this.character.body.CombatSheen(1);
|
|
}
|
|
for (int j = 0; j < this.actionTargets.Count; j++)
|
|
{
|
|
if (this.actionTargets[j] && (!onlyTarget || onlyTarget == this.actionTargets[j]))
|
|
{
|
|
if (this.firstAttack && !Links.x.combat.inPocketAttack && !afterAnimationFlag)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(this.actionTargets[j].tr.position - this.character.tr.position), false, true);
|
|
}
|
|
string text2 = "0";
|
|
num2 = this.character.stats.WeaponHitChance(false, this.currentHand);
|
|
string text3 = this.character.stats.HitChanceCalculation(this.currentHand);
|
|
int count = this.damages.Count;
|
|
if ((j >= this.damages.Count || !afterAnimationFlag || this.addDamageBonus || this.reroll) && !this.actionTargets[j].dead && (!this.actionTargets[j].stunned || (this.actionTargets[j].stunned && Records.x.kill)))
|
|
{
|
|
Character character = this.actionTargets[j];
|
|
float num6 = 0f;
|
|
bool flag6 = false;
|
|
if (!this.character.HasAmmoOrMelee(this.character.invRow1, false) && !this.specialAttack2)
|
|
{
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
flag2 = true;
|
|
flag6 = true;
|
|
}
|
|
if (!flag2)
|
|
{
|
|
if (!flag6 || (flag6 && afterAnimationFlag))
|
|
{
|
|
bool flag7 = false;
|
|
if (character)
|
|
{
|
|
bool flag8 = true;
|
|
if (this.character.body.sneaking)
|
|
{
|
|
flag8 = false;
|
|
}
|
|
if (character.stats.pinned)
|
|
{
|
|
flag8 = false;
|
|
}
|
|
if (character.jumping && !character.evading && !character.dodging)
|
|
{
|
|
flag8 = false;
|
|
}
|
|
if (character.isHit && (character.body.downStartHash == character.body.currentHash || character.body.downHash == character.body.currentHash || character.body.bounceHash == character.body.currentHash))
|
|
{
|
|
flag8 = false;
|
|
}
|
|
if (!flag && flag8)
|
|
{
|
|
float num7 = 0f;
|
|
if (this.firstAttack && character.dazedCount > 0)
|
|
{
|
|
num7 = (float)character.dazedCount;
|
|
}
|
|
float num8 = 0f;
|
|
num6 = character.stats.EvasionChance(false, num7, out num8);
|
|
if (this.evasionBonus > 1f)
|
|
{
|
|
num6 *= this.evasionBonus;
|
|
}
|
|
else
|
|
{
|
|
this.evasionBonus = 0f;
|
|
}
|
|
text2 = character.stats.EvadeChanceCalculation(this.evasionBonus, num8, false);
|
|
this.evasionBonus = 0f;
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array = new string[9];
|
|
int num9 = 0;
|
|
Character character2 = this.character;
|
|
array[num9] = ((character2 != null) ? character2.ToString() : null);
|
|
array[1] = " attacking ";
|
|
int num10 = 2;
|
|
Character character3 = character;
|
|
array[num10] = ((character3 != null) ? character3.ToString() : null);
|
|
array[3] = ", atk roll: ";
|
|
array[4] = num2.ToString();
|
|
array[5] = ", evade roll: ";
|
|
array[6] = num6.ToString();
|
|
array[7] = " attack type modifier ";
|
|
array[8] = num3.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
}
|
|
}
|
|
float num11 = num2 - num6;
|
|
float num12 = 0f;
|
|
string text4 = "";
|
|
if (Records.x.showRuleset && !flag)
|
|
{
|
|
string[] array2 = new string[9];
|
|
int num13 = 0;
|
|
Character character4 = this.character;
|
|
array2[num13] = ((character4 != null) ? character4.ToString() : null);
|
|
array2[1] = " attacking ";
|
|
int num14 = 2;
|
|
Character character5 = character;
|
|
array2[num14] = ((character5 != null) ? character5.ToString() : null);
|
|
array2[3] = " with hand ";
|
|
array2[4] = this.currentHand.ToString();
|
|
array2[5] = " , severity: ";
|
|
array2[6] = num11.ToString();
|
|
array2[7] = " pass ";
|
|
array2[8] = j.ToString();
|
|
Debug.Log(string.Concat(array2));
|
|
}
|
|
bool flag9 = false;
|
|
this.blocked = false;
|
|
if (character.GetInvNum(2) > 1)
|
|
{
|
|
flag9 = true;
|
|
}
|
|
if (character.stats.HasEffect("VineCocoon"))
|
|
{
|
|
flag7 = true;
|
|
}
|
|
if (num11 > 0f && !flag)
|
|
{
|
|
if (!afterAnimationFlag)
|
|
{
|
|
if (this.firstAttack)
|
|
{
|
|
this.character.stats.AddSkillProgress(this.character.stats.MainSkillIndex(0), (float)character.combatLevel / 2f, character);
|
|
}
|
|
if (this.secondAttack && this.currentHand > 0)
|
|
{
|
|
this.character.stats.AddSkillProgress(9, (float)character.combatLevel / 2f, character);
|
|
}
|
|
}
|
|
float num15 = 0f;
|
|
bool flag10 = false;
|
|
bool flag11 = false;
|
|
if (this.lightAttack)
|
|
{
|
|
flag11 = true;
|
|
}
|
|
if (character.dazedCount > 0)
|
|
{
|
|
flag10 = true;
|
|
}
|
|
num12 = this.character.stats.DamageRoll(false, this.currentHand, out num15, flag11, flag10, character);
|
|
float num16 = 1f;
|
|
if (this.heavyAttack)
|
|
{
|
|
num16 = 0.25f;
|
|
}
|
|
if (grazing)
|
|
{
|
|
num16 = 0.5f;
|
|
}
|
|
if (this.damageBonus > 0f && (this.addDamageBonus || !afterAnimationFlag))
|
|
{
|
|
num16 = this.damageBonus;
|
|
}
|
|
if (this.damageBonus > 0f && afterAnimationFlag && !this.addDamageBonus)
|
|
{
|
|
num16 = this.damageBonus * 0.5f;
|
|
}
|
|
float num17 = character.stats.ArmorNumber(false, true);
|
|
num17 /= 10f;
|
|
num17 = character.stats.R1(num17 + character.stats.ArmorAura(1) / 100f);
|
|
num17 = 1f - num17;
|
|
bool flag12 = this.character.stats.AttackIsPoison(this.firstAttack, this.ammoRow);
|
|
if (flag12)
|
|
{
|
|
num17 = 1f;
|
|
}
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array3 = new string[15];
|
|
int num18 = 0;
|
|
Character character6 = this.character;
|
|
array3[num18] = ((character6 != null) ? character6.ToString() : null);
|
|
array3[1] = " damages ";
|
|
int num19 = 2;
|
|
Character character7 = character;
|
|
array3[num19] = ((character7 != null) ? character7.ToString() : null);
|
|
array3[3] = " for ";
|
|
array3[4] = (num12 * num11 - num17).ToString();
|
|
array3[5] = ", dmg: ";
|
|
array3[6] = num12.ToString();
|
|
array3[7] = ", armor: ";
|
|
array3[8] = num17.ToString();
|
|
array3[9] = ", severity is: ";
|
|
array3[10] = num11.ToString();
|
|
array3[11] = ", is heavy attack? ";
|
|
array3[12] = this.heavyAttack.ToString();
|
|
array3[13] = ", is light attack? ";
|
|
array3[14] = num16.ToString();
|
|
Debug.Log(string.Concat(array3));
|
|
}
|
|
num12 += num11;
|
|
num12 *= num17;
|
|
if (grazing && this.damageBonus == 0f)
|
|
{
|
|
text = "Grazing";
|
|
}
|
|
bool flag13 = false;
|
|
if (this.currentHand > 0 && this.secondAttack)
|
|
{
|
|
num12 *= 0.5f;
|
|
flag13 = true;
|
|
}
|
|
num12 *= num16;
|
|
text4 = this.character.stats.DamageCalculation(false, num15, num11, num17, flag13, num16, text, false, flag12, character);
|
|
}
|
|
else if (flag9 || flag7)
|
|
{
|
|
this.blocked = true;
|
|
}
|
|
if ((flag9 || flag7) && !afterAnimationFlag)
|
|
{
|
|
Library.Inventory inventory = Links.x.library.GetInvRowByIndex(character.GetInvNum(2));
|
|
if (inventory != null && inventory._EquipSlotID == 1)
|
|
{
|
|
int durabilityLoss = inventory._DurabilityLoss;
|
|
character.UpdateDurability(1, durabilityLoss, true, true);
|
|
}
|
|
if (flag7)
|
|
{
|
|
Effects existingEffect = character.stats.GetExistingEffect("VineCocoon");
|
|
string text5 = "Has cocoon ";
|
|
Effects effects = existingEffect;
|
|
Debug.Log(text5 + ((effects != null) ? effects.ToString() : null));
|
|
if (existingEffect)
|
|
{
|
|
existingEffect.UpdateEffectDurability(1f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
inventory = Links.x.library.GetInvRowByIndex(character.GetInvNum(2));
|
|
character.stats.AddSkillProgress(character.stats.GetCombatSkillID(inventory._MainSkill), (float)this.character.combatLevel / 2f, character);
|
|
}
|
|
}
|
|
num12 = Mathf.Round(num12);
|
|
if (j >= this.damages.Count)
|
|
{
|
|
this.attackTotal.Add(text3);
|
|
this.defenseTotal.Add(text2);
|
|
if (num12 >= 0.5f && num11 > 0f)
|
|
{
|
|
this.hits.Add(0);
|
|
this.hitText.Add(text4);
|
|
}
|
|
else if (num11 > 0f)
|
|
{
|
|
this.hits.Add(2);
|
|
this.hitText.Add(text4);
|
|
}
|
|
else
|
|
{
|
|
this.hits.Add(1);
|
|
this.hitText.Add("");
|
|
}
|
|
this.targets.Add(character);
|
|
this.targetsInteractive.Add(null);
|
|
this.damages.Add(Mathf.Round(num12));
|
|
}
|
|
else
|
|
{
|
|
this.attackTotal[j] = text3;
|
|
this.defenseTotal[j] = text2;
|
|
if (num12 >= 0.5f && num11 > 0f)
|
|
{
|
|
this.hits[j] = 0;
|
|
this.hitText[j] = text4;
|
|
}
|
|
else if (num11 > 0f)
|
|
{
|
|
this.hits[j] = 2;
|
|
this.hitText[j] = text4;
|
|
}
|
|
else
|
|
{
|
|
this.hits[j] = 1;
|
|
this.hitText[j] = "";
|
|
}
|
|
this.targets[j] = character;
|
|
this.targetsInteractive[j] = null;
|
|
this.damages[j] = Mathf.Round(num12);
|
|
}
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array4 = new string[5];
|
|
int num20 = 0;
|
|
Character character8 = this.character;
|
|
array4[num20] = ((character8 != null) ? character8.ToString() : null);
|
|
array4[1] = " damages ";
|
|
int num21 = 2;
|
|
Character character9 = character;
|
|
array4[num21] = ((character9 != null) ? character9.ToString() : null);
|
|
array4[3] = " for ";
|
|
array4[4] = num12.ToString();
|
|
Debug.Log(string.Concat(array4));
|
|
}
|
|
if (j == 0)
|
|
{
|
|
this.ai.previouslyAttacked = character;
|
|
}
|
|
if (this.secondAttack)
|
|
{
|
|
this.secondAttackIndex = this.damages.Count - 1;
|
|
}
|
|
if ((this.character.stats.hasEveryAttackAI || this.doBubbleAttack) && (character.mainSelected || this.doBubbleAttack) && this.firstAttack && !afterAnimationFlag)
|
|
{
|
|
if (num12 > 0f && (this.character.stats.characterRow._EveryAttackAI == "BubbleEvade" || this.doBubbleAttack))
|
|
{
|
|
if (this.doBubbleAttack)
|
|
{
|
|
this.StartMiniEvent(character, null, "Bubble Attack", this.bubbleAttackStopsGameplay);
|
|
}
|
|
else
|
|
{
|
|
this.StartMiniEvent(character, null, "Bubble Evade", true);
|
|
}
|
|
this.bubbleTarget = null;
|
|
this.bubbleAttackStopsGameplay = false;
|
|
}
|
|
if (this.character.stats.characterRow._EveryAttackAI == "ShroomBomb")
|
|
{
|
|
this.character.Explode();
|
|
this.hits[0] = 0;
|
|
this.damages[0] = 5f;
|
|
this.attackTotal[0] = "";
|
|
this.defenseTotal[0] = "";
|
|
this.hitText[0] = "";
|
|
this.targets[j] = this.character;
|
|
this.targetsInteractive[j] = null;
|
|
this.OnAttackComplete(this.targets[0], this.targetsInteractive[0], (float)this.hits[0], this.damages[0], this.attackTotal[0], this.defenseTotal[0], this.hitText[0], false, this.character.invRow1, j, false);
|
|
this.ClearDamageLists();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append("'s attack failed, ");
|
|
this.str.Append(" out of ammunition");
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int k = 0; k < this.actionInteractives.Count; k++)
|
|
{
|
|
bool flag14 = false;
|
|
if (onlyInteractive && onlyInteractive == this.actionInteractives[k])
|
|
{
|
|
flag14 = true;
|
|
}
|
|
if (this.actionInteractives[k] && (!onlyInteractive || flag14))
|
|
{
|
|
GameObject gameObject = this.actionInteractives[k];
|
|
num2 = this.character.stats.WeaponHitChance(false, this.currentHand);
|
|
string text6 = this.character.stats.HitChanceCalculation(this.currentHand);
|
|
bool flag15 = false;
|
|
BreakableActions component = gameObject.GetComponent<BreakableActions>();
|
|
ChestActions component2 = gameObject.GetComponent<ChestActions>();
|
|
DoorActions component3 = gameObject.GetComponent<DoorActions>();
|
|
PuzzleActions component4 = gameObject.GetComponent<PuzzleActions>();
|
|
if (gameObject)
|
|
{
|
|
Vector3 position = gameObject.transform.position;
|
|
if (component3)
|
|
{
|
|
Vector3 lockColliderPosition = component3.lockColliderPosition;
|
|
}
|
|
}
|
|
if (!this.character.HasAmmoOrMelee(this.character.invRow1, false))
|
|
{
|
|
gameObject = null;
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
flag2 = true;
|
|
}
|
|
if (!flag2)
|
|
{
|
|
float num22 = 0f;
|
|
if (Records.x.showRuleset && !flag)
|
|
{
|
|
string[] array5 = new string[7];
|
|
int num23 = 0;
|
|
Character character10 = this.character;
|
|
array5[num23] = ((character10 != null) ? character10.ToString() : null);
|
|
array5[1] = " attacking ";
|
|
int num24 = 2;
|
|
GameObject gameObject2 = gameObject;
|
|
array5[num24] = ((gameObject2 != null) ? gameObject2.ToString() : null);
|
|
array5[3] = " with hand ";
|
|
array5[4] = this.currentHand.ToString();
|
|
array5[5] = " , severity: ";
|
|
array5[6] = num22.ToString();
|
|
Debug.Log(string.Concat(array5));
|
|
}
|
|
bool flag16 = true;
|
|
float num25 = 0f;
|
|
if (component2)
|
|
{
|
|
num25 = (float)component2.chest.health / 10f;
|
|
}
|
|
else if (component3)
|
|
{
|
|
num25 = (float)component3.door.health / 10f;
|
|
}
|
|
else if (component)
|
|
{
|
|
num25 = (float)component.breakable.health / 10f;
|
|
}
|
|
else if (component4)
|
|
{
|
|
num25 = (float)component4.puzzle.health / 10f;
|
|
}
|
|
float num26 = 0f;
|
|
float num27 = this.character.stats.DamageRoll(false, this.currentHand, out num26, false, false, null);
|
|
if (num27 > 0f)
|
|
{
|
|
if (!afterAnimationFlag)
|
|
{
|
|
this.character.stats.AddSkillProgress(this.character.stats.MainSkillIndex(this.currentHand), num25, null);
|
|
}
|
|
if (this.secondAttack && this.currentHand > 0 && !afterAnimationFlag)
|
|
{
|
|
this.character.stats.AddSkillProgress(9, num25 / 2f, null);
|
|
}
|
|
}
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array6 = new string[5];
|
|
int num28 = 0;
|
|
Character character11 = this.character;
|
|
array6[num28] = ((character11 != null) ? character11.ToString() : null);
|
|
array6[1] = " attacking ";
|
|
int num29 = 2;
|
|
GameObject gameObject3 = gameObject;
|
|
array6[num29] = ((gameObject3 != null) ? gameObject3.ToString() : null);
|
|
array6[3] = " dmg ";
|
|
array6[4] = num27.ToString();
|
|
Debug.Log(string.Concat(array6));
|
|
}
|
|
float num30 = 0f;
|
|
Breakable.BreakableEffectRequired breakableEffectRequired = Breakable.BreakableEffectRequired.Damage;
|
|
if (component2)
|
|
{
|
|
num30 = (float)component2.chest.armor;
|
|
breakableEffectRequired = component2.chest.effectRequired;
|
|
}
|
|
if (component3)
|
|
{
|
|
num30 = (float)component3.door.armor;
|
|
breakableEffectRequired = component3.door.effectRequired;
|
|
}
|
|
if (component)
|
|
{
|
|
num30 = (float)component.breakable.armor;
|
|
breakableEffectRequired = component.breakable.effectRequired;
|
|
}
|
|
if (component4)
|
|
{
|
|
num30 = 0f;
|
|
breakableEffectRequired = Breakable.BreakableEffectRequired.Damage;
|
|
}
|
|
float num31 = 1f;
|
|
if (this.damageBonus > 0f && (this.addDamageBonus || !afterAnimationFlag))
|
|
{
|
|
num31 = this.character.stats.R1(this.damageBonus);
|
|
}
|
|
if (this.specialAttack1 && grazing)
|
|
{
|
|
num31 = 1f;
|
|
}
|
|
num30 /= 20f;
|
|
num30 = 1f - num30;
|
|
num30 = this.character.stats.R1(num30);
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array7 = new string[11];
|
|
int num32 = 0;
|
|
Character character12 = this.character;
|
|
array7[num32] = ((character12 != null) ? character12.ToString() : null);
|
|
array7[1] = " damages ";
|
|
int num33 = 2;
|
|
GameObject gameObject4 = gameObject;
|
|
array7[num33] = ((gameObject4 != null) ? gameObject4.ToString() : null);
|
|
array7[3] = " for ";
|
|
array7[4] = (num27 * num30).ToString();
|
|
array7[5] = ", dmg: ";
|
|
array7[6] = num27.ToString();
|
|
array7[7] = ", armor: ";
|
|
array7[8] = num30.ToString();
|
|
array7[9] = ", effect required: ";
|
|
array7[10] = breakableEffectRequired.ToString();
|
|
Debug.Log(string.Concat(array7));
|
|
}
|
|
string text7 = this.character.stats.DamageCalculation(false, num26, 0f, num30, this.secondAttack, num31, text, true, false, null);
|
|
num27 *= num30;
|
|
if (this.secondAttack && this.currentHand > 0)
|
|
{
|
|
num27 *= 0.5f;
|
|
}
|
|
num27 *= num31;
|
|
if (num27 < 0.5f)
|
|
{
|
|
flag16 = false;
|
|
flag15 = true;
|
|
}
|
|
if (breakableEffectRequired != Breakable.BreakableEffectRequired.Damage)
|
|
{
|
|
flag16 = false;
|
|
flag15 = false;
|
|
}
|
|
this.attackTotal.Add(text6);
|
|
this.defenseTotal.Add("");
|
|
if (flag16)
|
|
{
|
|
this.hits.Add(0);
|
|
num27 = Mathf.Round(num27);
|
|
if (num27 <= 0f)
|
|
{
|
|
num27 = 1f;
|
|
}
|
|
this.hitText.Add(text7);
|
|
}
|
|
else if (flag15)
|
|
{
|
|
this.hits.Add(1);
|
|
this.hitText.Add(text7);
|
|
}
|
|
else
|
|
{
|
|
this.hits.Add(2);
|
|
this.hitText.Add("");
|
|
}
|
|
this.targets.Add(null);
|
|
this.targetsInteractive.Add(gameObject);
|
|
this.damages.Add(num27);
|
|
if (this.secondAttack)
|
|
{
|
|
this.secondAttackIndex = this.damages.Count - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
if (this.actionTargets.Count == 0 && this.targetsInteractive.Count == 0)
|
|
{
|
|
this.hits.Add(0);
|
|
this.hitText.Add("");
|
|
this.targets.Add(null);
|
|
this.targetsInteractive.Add(null);
|
|
this.damages.Add(0f);
|
|
this.attackTotal.Add(num2.ToString());
|
|
this.defenseTotal.Add("0");
|
|
}
|
|
this.rolling = false;
|
|
}
|
|
if (this.secondAttack)
|
|
{
|
|
yield return new WaitForSeconds(0.0001f);
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.AddSecondAttack();
|
|
}
|
|
}
|
|
this.actionCoroutine = null;
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x06000142 RID: 322 RVA: 0x0001757C File Offset: 0x0001577C
|
|
public void GetLastListSet(out float h, out float d, out string at, out string dt, out string ht)
|
|
{
|
|
int num = 0;
|
|
if (this.hits.Count > 0)
|
|
{
|
|
num = this.hits.Count - 1;
|
|
}
|
|
if (this.hits.Count == 0)
|
|
{
|
|
num = -1;
|
|
}
|
|
if (num > -1)
|
|
{
|
|
h = (float)this.hits[num];
|
|
d = this.damages[num];
|
|
at = this.attackTotal[num];
|
|
dt = this.defenseTotal[num];
|
|
ht = this.hitText[num];
|
|
return;
|
|
}
|
|
h = 4f;
|
|
d = 0f;
|
|
at = "0";
|
|
dt = "0";
|
|
ht = "";
|
|
}
|
|
|
|
// Token: 0x06000143 RID: 323 RVA: 0x0001762C File Offset: 0x0001582C
|
|
public void GetListSet(Character c, out float h, out float d, out string at, out string dt, out string ht)
|
|
{
|
|
int num = this.targets.IndexOf(c);
|
|
h = (float)this.hits[num];
|
|
d = this.damages[num];
|
|
at = this.attackTotal[num];
|
|
dt = this.defenseTotal[num];
|
|
ht = this.hitText[num];
|
|
}
|
|
|
|
// Token: 0x06000144 RID: 324 RVA: 0x00017690 File Offset: 0x00015890
|
|
public bool HasListTarget(Character c)
|
|
{
|
|
return this.targets.IndexOf(c) > -1;
|
|
}
|
|
|
|
// Token: 0x06000145 RID: 325 RVA: 0x000176A4 File Offset: 0x000158A4
|
|
public int SpellCount()
|
|
{
|
|
return this.abilities.Count;
|
|
}
|
|
|
|
// Token: 0x06000146 RID: 326 RVA: 0x000176B4 File Offset: 0x000158B4
|
|
public void TriggerCastFromCastAnimation()
|
|
{
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Debug.Log("Cast start " + ((this != null) ? this.ToString() : null));
|
|
}
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = true;
|
|
this.character.inRecoveryTime = Links.x.gameplay.seconds;
|
|
this.currentAction = "";
|
|
this.OnCastComplete();
|
|
if (this.pocketQueued && this.character.mainSelected && !Records.x.pocketPause)
|
|
{
|
|
Links.x.gameplay.PocketPause(true);
|
|
}
|
|
this.pocketQueued = false;
|
|
if (this.character.npc && this.character.stats.magicPointsBase > 0)
|
|
{
|
|
this.character.stats.AddSpirit(Random.Range(15, 20));
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000147 RID: 327 RVA: 0x000177A0 File Offset: 0x000159A0
|
|
public void OnCastComplete()
|
|
{
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
Debug.Log("Cast complete " + ((this != null) ? this.ToString() : null));
|
|
}
|
|
if (!Records.x.combat)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
}
|
|
else
|
|
{
|
|
this.endActionsAfterTurn = false;
|
|
}
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
if (this.spellScrollID <= 0)
|
|
{
|
|
num2 = this.character.stats.SpellDifficulty(this.currentSpellName, out num);
|
|
}
|
|
float num3 = this.character.stats.PaganHitChance(false, this.spell._MainSkill);
|
|
if (Records.x.showRuleset)
|
|
{
|
|
string[] array = new string[7];
|
|
array[0] = this.character.stats.GetName();
|
|
array[1] = "'s spell difficulty: ";
|
|
array[2] = num2.ToString();
|
|
array[3] = " vs. hit chance: ";
|
|
array[4] = num3.ToString();
|
|
array[5] = " ";
|
|
int num4 = 6;
|
|
Library.Inventory inventory = this.spellScroll;
|
|
array[num4] = ((inventory != null) ? inventory.ToString() : null);
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (!Records.x.banquetIsle && !this.character.stats.semizenMagic)
|
|
{
|
|
this.RemoveAbility();
|
|
}
|
|
if (num3 >= num2 || this.character.npc || this.spellScrollID > 0)
|
|
{
|
|
if (this.character.party)
|
|
{
|
|
this.character.portrait.UpdateMP();
|
|
}
|
|
this.vineComplete = false;
|
|
this.castingSpell = false;
|
|
if (this.spellNode != null)
|
|
{
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
this.UpdateSoundAlerts(this.actionTargets[0]);
|
|
}
|
|
else
|
|
{
|
|
this.UpdateSoundAlerts(null);
|
|
}
|
|
this.character.stats.UpdateAbilityTriggers();
|
|
Character character = null;
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
character = this.actionTargets[0];
|
|
}
|
|
this.spellCoroutine = this.SpellEnd(this.spell, 0f, num, character, null, true, this.currentSpellName);
|
|
base.StartCoroutine(this.spellCoroutine);
|
|
}
|
|
else
|
|
{
|
|
string text = "No spell nodes ";
|
|
Character character2 = this.character;
|
|
Debug.Log(text + ((character2 != null) ? character2.ToString() : null));
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurnAfterAction();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.spellCasterTargetFailFX == null)
|
|
{
|
|
this.spellCasterTargetFailFX = Links.x.cellar.GetPooledGameObject(78);
|
|
}
|
|
this.spellCasterTargetFailFX.transform.position = (Vector3)this.spellNode.position + new Vector3(0f, 1f, 0f);
|
|
this.spellCasterTargetFailFX.SetActive(true);
|
|
if (this.character.mainSelected)
|
|
{
|
|
Links.x.cellar.GetAnimatedText("NPCDmg", "Failed", true).gameObject.transform.position = this.character.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
}
|
|
this.vineComplete = false;
|
|
this.castingSpell = false;
|
|
this.spellCoroutine = this.SpellEnd(this.spell, num3 - num2, num, null, null, false, this.currentSpellName);
|
|
base.StartCoroutine(this.spellCoroutine);
|
|
}
|
|
this.ClearTargetCharacters();
|
|
if (this.character)
|
|
{
|
|
this.character.animID = 0;
|
|
this.character.stats.UpdateAbilityTriggers();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000148 RID: 328 RVA: 0x00017B30 File Offset: 0x00015D30
|
|
private void AddSpellTiles(Library.Abilities vineSpell, float tether, Character spellTarget, GameObject targetInteractive)
|
|
{
|
|
this.currentTileEffect = Links.x.tileEffects.AddComponent<TileEffects>();
|
|
this.currentTileEffect.startNode = this.spellNode;
|
|
this.currentTileEffect.gameObject.SetActive(true);
|
|
this.currentTileEffect.severity = 0f;
|
|
this.currentTileEffect.spellTarget = spellTarget;
|
|
this.currentTileEffect.spellIndex = this.spellIndex;
|
|
this.currentTileEffect.paganRow = this.paganRow;
|
|
this.currentTileEffect.mainSkill = vineSpell._MainSkill;
|
|
this.currentTileEffect.tether = tether;
|
|
this.currentTileEffect.sourceLevel = 0f;
|
|
this.currentTileEffect.doSpellScroll = false;
|
|
if (this.spellScrollID > 0)
|
|
{
|
|
this.currentTileEffect.doSpellScroll = true;
|
|
}
|
|
this.currentTileEffect.spellScroll = this.spellScroll;
|
|
if (this.actionTargets.Count > 0 && (vineSpell._RadiusCenter.Contains("Target") || vineSpell._RadiusCenter.Contains("Self")))
|
|
{
|
|
this.currentTileEffect.singleTarget = this.actionTargets[0];
|
|
}
|
|
if (this.actionInteractives.Count > 0)
|
|
{
|
|
this.currentTileEffect.singleTargetInteractive = this.actionInteractives[0];
|
|
}
|
|
this.currentTileEffect.Setup(vineSpell, null, this, null, null, this.character);
|
|
}
|
|
|
|
// Token: 0x06000149 RID: 329 RVA: 0x00017C95 File Offset: 0x00015E95
|
|
private IEnumerator SpellEnd(Library.Abilities vineSpell, float severity, float tether, Character target, GameObject targetInteractive, bool passed, string currentSpellName)
|
|
{
|
|
this.EndVine();
|
|
this.vine = null;
|
|
this.character.SetIdle(true);
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
if (passed)
|
|
{
|
|
this.character.stats.UpdateRallyCount(true, 0f);
|
|
if (this.character.stats.hasCustomAI && target)
|
|
{
|
|
Quaternion quaternion = Quaternion.LookRotation(target.tr.position - this.character.tr.position);
|
|
this.character.SetRotation(quaternion, false, true);
|
|
}
|
|
this.AddSpellTiles(vineSpell, tether, target, targetInteractive);
|
|
if (this.character.stats.semizenMagic && vineSpell._Name == "RainSpell")
|
|
{
|
|
this.party = Links.x.party;
|
|
for (int i = 0; i < this.party.Count; i++)
|
|
{
|
|
if (this.party[i] && this.party[i] != target && this.character.GetLKPlayerBool(this.party[i]))
|
|
{
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
this.actionTargets[0] = this.party[i];
|
|
}
|
|
this.AddSpellTiles(vineSpell, tether, this.party[i], null);
|
|
}
|
|
}
|
|
}
|
|
this.spellScroll = null;
|
|
if (this.spellScrollID > 0)
|
|
{
|
|
Links.x.inventory.RemoveBeltItem(this.spellScrollID, this.character);
|
|
}
|
|
this.spellScrollID = 0;
|
|
this.channeling = vineSpell._Channel;
|
|
}
|
|
if (!this.character.npc && this.character.portrait)
|
|
{
|
|
this.character.portrait.skillBag.RemoveSelectedButton();
|
|
}
|
|
this.character.stats.UpdateAbilityTriggers();
|
|
this.character.doingAction = false;
|
|
this.castCompleteCoroutine = null;
|
|
this.ClearDamageLists();
|
|
if (this.character.mainSelected)
|
|
{
|
|
yield return new WaitForSeconds(0.1f);
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
}
|
|
else
|
|
{
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
}
|
|
this.spellCoroutine = null;
|
|
if (!Records.x.combat)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurnAfterAction();
|
|
}
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
// Token: 0x0600014A RID: 330 RVA: 0x00017CCA File Offset: 0x00015ECA
|
|
public void ReturnChargeUpFX()
|
|
{
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014B RID: 331 RVA: 0x00017CFC File Offset: 0x00015EFC
|
|
public void EndAttackTime(float attackTimeReduction)
|
|
{
|
|
if (!this.canEndAttackTime)
|
|
{
|
|
return;
|
|
}
|
|
this.canEndAttackTime = false;
|
|
if (this.pocketAttack)
|
|
{
|
|
return;
|
|
}
|
|
if (Records.x.pocketPause && this.character.mainSelected && !Links.x.combat.rallyTarget)
|
|
{
|
|
Links.x.gameplay.PocketPause(false);
|
|
}
|
|
if (this.character.party && this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
if (this.character.mainSelected)
|
|
{
|
|
this.character.body.CombatSheen(0);
|
|
Links.x.cameraEffects.RemoveCombatCharacters();
|
|
if (Records.x.InCombat(false) && Links.x.combat.npcCount > 0)
|
|
{
|
|
Links.x.hudControl.ToggleAttackTimer(true);
|
|
return;
|
|
}
|
|
if (!Links.x.combat.attackingInteractiveOutsideOfCombat)
|
|
{
|
|
Links.x.hudControl.ToggleAttackTimer(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014C RID: 332 RVA: 0x00017E10 File Offset: 0x00016010
|
|
public void FireRangeWeapon()
|
|
{
|
|
if (this.character.mainSelected)
|
|
{
|
|
MasterAudio.PlaySoundAndForget("Main Attacking", 1f, new float?(1f), 0f, "", null);
|
|
}
|
|
int num = 0;
|
|
if (this.specialAttack2 && this.character.invRow1._MainSkill != "Bow")
|
|
{
|
|
int selectedAmmoID = Links.x.pocketWheel.GetSelectedAmmoID();
|
|
this.ammoRow = Links.x.library.GetInvRowByIndex(selectedAmmoID);
|
|
if (this.ammoRow != null)
|
|
{
|
|
this.character.RemoveItem(this.ammoRow._ID, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num = this.character.GetAmmoIndex(this.character.invRow1);
|
|
}
|
|
this.character.inRecovery = true;
|
|
this.character.inRecoveryTime = Links.x.gameplay.seconds;
|
|
this.character.ZeroAttackTime(0f);
|
|
if (num > -1 || this.specialAttack2)
|
|
{
|
|
if (!this.specialAttack2 || (this.specialAttack2 && this.character.invRow1._MainSkill == "Bow"))
|
|
{
|
|
this.ammoRow = Links.x.library.GetInvRowByIndex(this.character.GetInvNum(num));
|
|
}
|
|
else
|
|
{
|
|
int selectedAmmoID2 = Links.x.pocketWheel.GetSelectedAmmoID();
|
|
this.ammoRow = Links.x.library.GetInvRowByIndex(selectedAmmoID2);
|
|
}
|
|
bool flag = false;
|
|
if (this.ammoRow != null)
|
|
{
|
|
for (int i = 0; i < this.targetsInteractive.Count; i++)
|
|
{
|
|
if (this.targetsInteractive[i])
|
|
{
|
|
this.CreateAmmo(this.ammoRow, i, null, this.targetsInteractive[i]);
|
|
if (!this.specialAttack2)
|
|
{
|
|
this.character.UseAmmo(num);
|
|
}
|
|
flag = true;
|
|
}
|
|
}
|
|
for (int j = 0; j < this.targets.Count; j++)
|
|
{
|
|
if ((this.targets[j] || (Records.x.freeAttack && this.quickAttack && this.firstAttack && this.character.mainSelected)) && (j == 0 || this.character.party))
|
|
{
|
|
this.CreateAmmo(this.ammoRow, j, this.targets[j], null);
|
|
if (!this.specialAttack2)
|
|
{
|
|
this.character.UseAmmo(num);
|
|
}
|
|
flag = true;
|
|
}
|
|
}
|
|
bool flag2 = false;
|
|
if (this.firstAttack && !this.lightAttack && !this.heavyAttack && (this.targets.Count > 0 || this.targetsInteractive.Count > 0) && flag2)
|
|
{
|
|
Character character = null;
|
|
GameObject gameObject = null;
|
|
Vector3 vector = Vector3.zero;
|
|
if (this.targetsInteractive.Count > 0)
|
|
{
|
|
gameObject = this.targetsInteractive[0];
|
|
}
|
|
if (this.targets.Count > 0 && !gameObject)
|
|
{
|
|
character = this.targets[0];
|
|
}
|
|
if (character)
|
|
{
|
|
vector = character.currentPosition;
|
|
}
|
|
if (gameObject)
|
|
{
|
|
vector = gameObject.transform.position;
|
|
}
|
|
if (vector != Vector3.zero && this.character.invRow1._MainSkill != "Sling")
|
|
{
|
|
this.MultiHitObjects(vector, character, gameObject, true, false, false, true, this.ammoRow, num);
|
|
}
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
if (Records.x.editor)
|
|
{
|
|
Debug.Log(((this != null) ? this.ToString() : null) + " no range target found");
|
|
}
|
|
this.EndTurn(true);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Character character2 = this.character;
|
|
Debug.LogWarning(((character2 != null) ? character2.ToString() : null) + " is trying to use range weapon mistake");
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014D RID: 333 RVA: 0x000181F8 File Offset: 0x000163F8
|
|
private void CreateAmmo(Library.Inventory ammoRow, int i, Character target, GameObject targetInteractive)
|
|
{
|
|
GameObject gameObject = Links.x.archives.GetItemPrefabBody(ammoRow._CharacterModel);
|
|
if (!gameObject)
|
|
{
|
|
gameObject = Links.x.archives.GetItemPrefabBody(ammoRow._CharacterModel + "_projectile");
|
|
}
|
|
Vector3 localScale = gameObject.transform.localScale;
|
|
Transform transform = this.character.body.GetSlot(2);
|
|
if (ammoRow._MainSkill == "Bow")
|
|
{
|
|
transform = this.character.body.GetSlot(0);
|
|
}
|
|
if (ammoRow._Name.Contains("PoisonBubble") || this.character.stats.animal)
|
|
{
|
|
transform = this.character.body.GetHead();
|
|
}
|
|
if (transform == null)
|
|
{
|
|
transform = this.character.body.GetHand();
|
|
}
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
gameObject.gameObject.transform.SetParent(transform, false);
|
|
gameObject.gameObject.transform.localPosition = new Vector3(0f, 0f, 0f);
|
|
gameObject.gameObject.transform.localRotation = Quaternion.Euler(Vector3.zero);
|
|
gameObject.gameObject.transform.SetParent(Links.x.archives.transform, true);
|
|
gameObject.gameObject.transform.localScale = localScale;
|
|
gameObject.SetActive(true);
|
|
Projectile projectile = gameObject.gameObject.AddComponent<Projectile>();
|
|
this.projectiles.Add(projectile);
|
|
projectile.item = gameObject.transform;
|
|
projectile.action = this;
|
|
if (target)
|
|
{
|
|
if (ammoRow._MainSkill == "Bow")
|
|
{
|
|
projectile.targetPosition = target.torsoPosition;
|
|
}
|
|
else
|
|
{
|
|
projectile.targetPosition = target.body.HeadPosition(-0.4f);
|
|
}
|
|
projectile.targetNode = target.node;
|
|
}
|
|
else if (targetInteractive)
|
|
{
|
|
Vector3 vector = targetInteractive.transform.position;
|
|
DoorActions component = targetInteractive.GetComponent<DoorActions>();
|
|
if (component)
|
|
{
|
|
vector = component.lockColliderPosition;
|
|
}
|
|
projectile.targetPosition = vector;
|
|
}
|
|
else if (this.character.invRow1._Ammo1.Contains("Vial"))
|
|
{
|
|
projectile.targetPosition = this.character.currentPosition + this.character.tr.forward * 5f;
|
|
}
|
|
else if (Links.x.mk)
|
|
{
|
|
projectile.targetPosition = gameObject.gameObject.transform.position + this.character.tr.forward * Mathf.Clamp(Vector3.Distance(this.character.currentPosition, Links.x.gameplay.mousePoint), 2f, 30f);
|
|
}
|
|
else
|
|
{
|
|
projectile.targetPosition = gameObject.gameObject.transform.position + this.character.tr.forward * 10f;
|
|
}
|
|
projectile.inventoryRow = ammoRow;
|
|
projectile.index = i;
|
|
projectile.hasEffect = false;
|
|
if (this.character.invRow1._Ammo1.Contains("Dart"))
|
|
{
|
|
projectile.type = 1;
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Dart Start", this.character.tr.position, Random.Range(0.8f, 1f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (this.character.invRow1._Ammo1.Contains("Arrow"))
|
|
{
|
|
projectile.type = 0;
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Bow Start", this.character.tr.position, Random.Range(0.8f, 1f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (this.character.invRow1._Ammo1.Contains("Vial"))
|
|
{
|
|
projectile.type = 2;
|
|
}
|
|
else
|
|
{
|
|
projectile.type = 3;
|
|
}
|
|
if (i == -1)
|
|
{
|
|
projectile.SetInfo(this.actionTargets[0], null, -1f, 0f, "", "", "", this.hasPowerDraw);
|
|
return;
|
|
}
|
|
if (i < this.targets.Count)
|
|
{
|
|
projectile.SetInfo(this.targets[i], this.targetsInteractive[i], (float)this.hits[i], this.damages[i], this.attackTotal[i], this.defenseTotal[i], this.hitText[i], this.hasPowerDraw);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014E RID: 334 RVA: 0x00018710 File Offset: 0x00016910
|
|
public void TriggerHitFromAttackAnimation()
|
|
{
|
|
if (this.character.mainSelected)
|
|
{
|
|
MasterAudio.PlaySoundAndForget("Main Attacking", 1f, new float?(1f), 0f, "", null);
|
|
}
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = true;
|
|
this.character.inRecoveryTime = Links.x.gameplay.seconds;
|
|
this.character.ZeroAttackTime(0f);
|
|
this.currentAction = "";
|
|
this.character.SetAnimatorSpeed(1f);
|
|
int num = 0;
|
|
if (this.secondAttack)
|
|
{
|
|
num = this.secondAttackIndex;
|
|
}
|
|
GameObject gameObject = null;
|
|
Vector3 zero = Vector3.zero;
|
|
if (this.targetsInteractive.Count > 0)
|
|
{
|
|
gameObject = this.targetsInteractive[0];
|
|
}
|
|
if (this.targets.Count > 0 && !gameObject)
|
|
{
|
|
Character character = this.targets[0];
|
|
}
|
|
if (num > -1 && num < this.damages.Count)
|
|
{
|
|
this.OnAttackComplete(this.targets[num], this.targetsInteractive[num], (float)this.hits[num], this.damages[num], this.attackTotal[num], this.defenseTotal[num], this.hitText[num], false, this.character.invRow1, num, false);
|
|
}
|
|
if (this.pocketQueued && this.character.mainSelected && !Records.x.pocketPause)
|
|
{
|
|
Links.x.gameplay.PocketPause(true);
|
|
}
|
|
this.pocketQueued = false;
|
|
if (this.character.party && !this.character.mainSelected && this.character != Links.x.combat.rallyCharacter)
|
|
{
|
|
this.character.SetAnimatorSpeed(1f);
|
|
}
|
|
if (this.quickAttack && this.character.attackTime < 1f)
|
|
{
|
|
this.character.UpdateAtkTime(-0.5f);
|
|
}
|
|
if (this.character.npc)
|
|
{
|
|
if (this.character.stats.magicPointsBase > 0)
|
|
{
|
|
this.character.stats.AddSpirit(Random.Range(5, 10));
|
|
}
|
|
this.character.stats.AddStamina(-6f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014F RID: 335 RVA: 0x0001897C File Offset: 0x00016B7C
|
|
private void SpecialAttack2(Character target, GameObject targetInteractive, Library.Inventory itemRow, bool fromMultiHit)
|
|
{
|
|
if (target)
|
|
{
|
|
string text = "";
|
|
Library.Inventory invRow = this.character.invRow1;
|
|
float num = this.effectBonus;
|
|
if (Links.x.rallyStage.playing)
|
|
{
|
|
this.effectBonus = (Links.x.qte.bonus - 1f) * (float)this.character.stats.level;
|
|
if (this.effectBonus < 0f)
|
|
{
|
|
this.effectBonus = 0f;
|
|
}
|
|
}
|
|
if (fromMultiHit)
|
|
{
|
|
num *= 0.5f;
|
|
}
|
|
if (invRow._MainSkill == "Sling" || invRow._MainSkill == "Elixir")
|
|
{
|
|
Effects effects = target.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = target;
|
|
effects.fromLoad = false;
|
|
effects.effectName = itemRow._Effect;
|
|
effects.sourceLevel = num;
|
|
effects.Inflicted(false);
|
|
return;
|
|
}
|
|
if (invRow._MainSkill == "Scepter")
|
|
{
|
|
text = "CripplingScepter";
|
|
}
|
|
if (invRow._MainSkill == "Whip")
|
|
{
|
|
text = "CripplingWhip";
|
|
}
|
|
if (invRow._MainSkill == "Pole")
|
|
{
|
|
text = "CripplingPole";
|
|
}
|
|
if (invRow._MainSkill == "ShortSword")
|
|
{
|
|
text = "CripplingShortSword";
|
|
}
|
|
if (invRow._MainSkill == "Sword")
|
|
{
|
|
text = "CripplingLongSword";
|
|
}
|
|
if (invRow._MainSkill == "Ax")
|
|
{
|
|
text = "CripplingAx";
|
|
}
|
|
if (invRow._MainSkill == "Bow")
|
|
{
|
|
if (Links.x.rallyStage.playing)
|
|
{
|
|
text = "CripplingArrowPin";
|
|
}
|
|
else
|
|
{
|
|
text = "CripplingArrow";
|
|
}
|
|
}
|
|
if (invRow._MainSkill == "Elixir")
|
|
{
|
|
text = "";
|
|
}
|
|
if (invRow._MainSkill == "Unarmed")
|
|
{
|
|
text = "CripplingUnarmed";
|
|
}
|
|
if (Records.x.editor)
|
|
{
|
|
Debug.Log(text);
|
|
}
|
|
Effects effects2 = target.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects2);
|
|
effects2.gameObject.SetActive(true);
|
|
effects2.source = this.character;
|
|
effects2.target = target;
|
|
effects2.fromLoad = false;
|
|
effects2.effectName = text;
|
|
effects2.sourceLevel = num;
|
|
effects2.Inflicted(false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000150 RID: 336 RVA: 0x00018BF5 File Offset: 0x00016DF5
|
|
public void AttackAnimationDone()
|
|
{
|
|
this.ai.SetMoveTargetAsAttack();
|
|
this.character.doingAction = false;
|
|
}
|
|
|
|
// Token: 0x06000151 RID: 337 RVA: 0x00018C10 File Offset: 0x00016E10
|
|
private void UpdateSoundAlerts(Character target)
|
|
{
|
|
Links.x.sensory.AddFootstep(this.character);
|
|
if (target)
|
|
{
|
|
Links.x.sensory.AddFootstep(target);
|
|
if (target.npc && target.creatures.inGroup)
|
|
{
|
|
Links.x.sensory.AlertGroupFromCombatSounds(target, this.character);
|
|
}
|
|
if (this.character.npc && this.character.creatures.inGroup)
|
|
{
|
|
Links.x.sensory.AlertGroupFromCombatSounds(this.character, target);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000152 RID: 338 RVA: 0x00018CAA File Offset: 0x00016EAA
|
|
public void RemoveProjectile(Projectile projectile)
|
|
{
|
|
if (this.projectiles.Contains(projectile))
|
|
{
|
|
this.projectiles.Remove(projectile);
|
|
}
|
|
if (this.endActionsAfterTurn)
|
|
{
|
|
this.EndActions();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000153 RID: 339 RVA: 0x00018CD5 File Offset: 0x00016ED5
|
|
public void AddBlood()
|
|
{
|
|
if (this.targets.Count > 0 && this.targets[0])
|
|
{
|
|
this.character.AddBlood(this.targets[0]);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000154 RID: 340 RVA: 0x00018D10 File Offset: 0x00016F10
|
|
public void OnAttackComplete(Character target, GameObject targetInteractive, float hit, float damage, string attackTotals, string defenseTotals, string hitTexts, bool fromProjectile, Library.Inventory itemRow, int index, bool checkingMultiTarget)
|
|
{
|
|
bool flag = false;
|
|
if (itemRow._DmgMax <= 0 && itemRow._Effect != "")
|
|
{
|
|
flag = true;
|
|
}
|
|
bool flag2 = false;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[6];
|
|
array[0] = "Attack complete for ";
|
|
int num = 1;
|
|
Character character = this.character;
|
|
array[num] = ((character != null) ? character.ToString() : null);
|
|
array[2] = " against ";
|
|
array[3] = ((target != null) ? target.ToString() : null);
|
|
array[4] = " hit is ";
|
|
array[5] = hit.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (this.character.mainSelected && Records.x.pocketPause)
|
|
{
|
|
if (!Links.x.combat.npcsInCombat && targetInteractive)
|
|
{
|
|
Links.x.combat.attackingInteractiveOutsideOfCombat = true;
|
|
}
|
|
Links.x.combat.npcsInCombat = true;
|
|
Links.x.combat.preDome = false;
|
|
Links.x.combat.playerStartedCombat = false;
|
|
if (Links.x.gaia.boroControls && !Links.x.combat.attackingInteractiveOutsideOfCombat && Links.x.combat.npcCount > 0)
|
|
{
|
|
Links.x.gaia.boroControls.LeavingForCombat();
|
|
}
|
|
}
|
|
if (target && !fromProjectile && !checkingMultiTarget && !targetInteractive && !Records.x.pocketPause && !this.character.mainSelected && !this.specialAttack1 && !this.specialAttack2 && !this.specialAttack3 && (!this.InAttackRange(target) || !this.InAttackDirection(target)))
|
|
{
|
|
hit = 4f;
|
|
if (target.evading || target.dodging)
|
|
{
|
|
bool flag3 = true;
|
|
if (!Records.x.editor)
|
|
{
|
|
flag3 = false;
|
|
}
|
|
float num2 = this.DodgeCalculation(target);
|
|
if (num2 < 1f)
|
|
{
|
|
int num3;
|
|
target.stats.CheckForSongsAndWords("OnEvade", out num3);
|
|
}
|
|
if (((flag3 && num2 <= 1f) || num2 == 0f) && target.mainSelected)
|
|
{
|
|
Links.x.cellar.GetAnimatedText("Defend", "", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(0f, 3f, 0f);
|
|
MasterAudio.PlaySoundAndForget("Main Block", 1f, new float?(1f), 0f, "", null);
|
|
Links.x.combat.PerfectDodge(target, this.character);
|
|
}
|
|
}
|
|
}
|
|
if (target && (this.firstAttack || this.secondAttack) && !Links.x.combat.inPocketAttack && !checkingMultiTarget && hit != 4f && !this.specialAttack1)
|
|
{
|
|
this.reroll = true;
|
|
this.ActionRolls(false, true, target, null);
|
|
if (this.targets.Contains(target))
|
|
{
|
|
this.GetListSet(target, out hit, out damage, out attackTotals, out defenseTotals, out hitTexts);
|
|
}
|
|
this.reroll = false;
|
|
}
|
|
if (hit == 0f && target && !flag)
|
|
{
|
|
if (Links.x.combat.bubbleEvent && target.mainSelected)
|
|
{
|
|
if (Links.x.qte.bonus > 1f)
|
|
{
|
|
damage = 0f;
|
|
hit = 1f;
|
|
}
|
|
}
|
|
else if ((target.evading || target.dodging) && !this.specialAttack3)
|
|
{
|
|
float num4 = this.DodgeCalculation(target);
|
|
damage *= num4;
|
|
if (damage <= 1f && target.npc)
|
|
{
|
|
damage = 1f;
|
|
}
|
|
if (damage < 0.5f && !target.npc)
|
|
{
|
|
damage = 0f;
|
|
hit = 1f;
|
|
}
|
|
bool flag4 = true;
|
|
if (!Records.x.editor)
|
|
{
|
|
flag4 = false;
|
|
}
|
|
if (num4 < 1f || flag4)
|
|
{
|
|
string text = hitTexts;
|
|
hitTexts = this.character.stats.DefenseStance(text, num4);
|
|
int num5;
|
|
target.stats.CheckForSongsAndWords("OnEvade", out num5);
|
|
if (target.mainSelected && (damage == 0f || (flag4 && num4 < 1f)))
|
|
{
|
|
flag2 = true;
|
|
Links.x.cellar.GetAnimatedText("Defend", "", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(0f, 3f, 0f);
|
|
MasterAudio.PlaySoundAndForget("Main Block", 1f, new float?(1f), 0f, "", null);
|
|
Links.x.combat.PerfectDodge(target, this.character);
|
|
}
|
|
}
|
|
}
|
|
if ((checkingMultiTarget || this.secondAttack) && Links.x.combat.inPocketAttack && !Links.x.rallyStage.playing)
|
|
{
|
|
target.SetMeshState(true);
|
|
target.OverridePocketPause();
|
|
}
|
|
}
|
|
if (target)
|
|
{
|
|
if ((this.character.mainSelected || (this.character.party && Links.x.combat.inPocketAttack)) && Records.x.pocketPause)
|
|
{
|
|
if (target.hasActions && target.inAction)
|
|
{
|
|
target.actions.Interrupt();
|
|
}
|
|
if (!Links.x.rallyStage.playing)
|
|
{
|
|
target.OverridePocketPause();
|
|
}
|
|
}
|
|
if (Links.x.rallyStage.playing && !this.specialAttack2 && this.firstAttack && !checkingMultiTarget)
|
|
{
|
|
if (Records.x.editor)
|
|
{
|
|
Debug.Log(string.Concat(new string[]
|
|
{
|
|
damage.ToString(),
|
|
" ",
|
|
hitTexts,
|
|
" ",
|
|
(target != null) ? target.ToString() : null,
|
|
" ",
|
|
Links.x.qte.bonus.ToString(),
|
|
" ",
|
|
this.specialAttack3.ToString()
|
|
}));
|
|
}
|
|
this.damageBonus = Links.x.qte.bonus;
|
|
if (this.specialAttack3)
|
|
{
|
|
this.damageBonus *= 1.5f;
|
|
}
|
|
this.addDamageBonus = true;
|
|
this.ActionRolls(false, true, target, null);
|
|
this.addDamageBonus = false;
|
|
this.GetLastListSet(out hit, out damage, out attackTotals, out defenseTotals, out hitTexts);
|
|
if (Records.x.editor)
|
|
{
|
|
Debug.Log(string.Concat(new string[]
|
|
{
|
|
damage.ToString(),
|
|
" ",
|
|
hitTexts,
|
|
" ",
|
|
(target != null) ? target.ToString() : null
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
if ((hit == 3f || hit == 2f) && targetInteractive)
|
|
{
|
|
GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(86);
|
|
pooledGameObject.transform.position = targetInteractive.transform.position + new Vector3(0f, 0.5f, 0f);
|
|
pooledGameObject.SetActive(true);
|
|
}
|
|
Vector3 vector = this.character.tr.position;
|
|
if (target)
|
|
{
|
|
vector = target.tr.position;
|
|
}
|
|
if (hit != 1f && hit != 4f && !flag)
|
|
{
|
|
if (this.character.stats.animal && itemRow._MeleeRangeEnd < 5f)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MeleeRangeEnd < 5f)
|
|
{
|
|
if (itemRow._MainSkill == "ShortSword")
|
|
{
|
|
if (!this.quickAttack)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Sword Hit", vector, Random.Range(0.3f, 0.4f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill == "Whip")
|
|
{
|
|
if (!this.quickAttack)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Whip Hit", vector, Random.Range(0.5f, 0.7f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill == "Pole")
|
|
{
|
|
if (!this.quickAttack)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Spear Hit", vector, Random.Range(0.6f, 0.7f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill == "Scepter")
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Blunt Hit", vector, Random.Range(0.6f, 0.8f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill == "Sword")
|
|
{
|
|
if (!this.quickAttack)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Sword Hit", vector, Random.Range(0.3f, 0.4f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill.Contains("Dagger"))
|
|
{
|
|
if (!this.quickAttack)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.5f, 0.6f), new float?(1f), 0f, "", null);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Dagger Hit", vector, Random.Range(0.6f, 0.7f), new float?(1f), 0f, "", null);
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, vector, Random.Range(0.6f, 0.8f), new float?(1f), 0f, "", null);
|
|
}
|
|
}
|
|
else if (itemRow._MainSkill == "Sling")
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Dart Hit", vector, Random.Range(0.2f, 0.35f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (itemRow._MainSkill == "Bow")
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Arrow Hit", vector, Random.Range(0.3f, 0.35f), new float?(1f), 0f, "", null);
|
|
}
|
|
else if (!(itemRow._MainSkill == "Elixir"))
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Skull Crush", vector, Random.Range(0.3f, 0.35f), new float?(1f), 0f, "", null);
|
|
}
|
|
}
|
|
this.AddPlayerToCombat(target);
|
|
bool flag5 = false;
|
|
if (hit == 0f && target && !flag)
|
|
{
|
|
if (Records.x.showRuleset)
|
|
{
|
|
Debug.Log(string.Concat(new string[]
|
|
{
|
|
this.character.stats.GetName(),
|
|
" attack complete ",
|
|
damage.ToString(),
|
|
" ",
|
|
hit.ToString(),
|
|
" ",
|
|
(target != null) ? target.ToString() : null
|
|
}));
|
|
}
|
|
if (target.party && !Records.x.banquetIsle && target.GetInvNum(18) > 1)
|
|
{
|
|
Library.Inventory invRowByIndex = Links.x.library.GetInvRowByIndex(target.GetInvNum(18));
|
|
target.stats.AddSkillProgress(target.stats.GetArmorSkillID(invRowByIndex._MainSkill), (float)this.character.combatLevel / 2f, target);
|
|
}
|
|
if (this.character.body.sneaking && this.character.mainSelected)
|
|
{
|
|
Links.x.cellar.GetAnimatedText("Text", "Stealth", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), 2f, 0f);
|
|
}
|
|
if (this.firstAttack && (this.specialAttack3 || this.specialAttack2))
|
|
{
|
|
bool flag6 = false;
|
|
if (checkingMultiTarget)
|
|
{
|
|
flag6 = true;
|
|
}
|
|
this.SpecialAttack2(target, targetInteractive, itemRow, flag6);
|
|
}
|
|
if (this.character.stats.characterRow._UnarmedImpactSound != "")
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedImpactSound, target.tr.position, Random.Range(0.9f, 1f), new float?(1f), 0f, "", null);
|
|
}
|
|
if (this.firstAttack)
|
|
{
|
|
int num6;
|
|
this.character.stats.CheckForSongsAndWords("Attack", out num6);
|
|
}
|
|
int num7 = this.currentHand;
|
|
int num8 = this.character.invRow1._DurabilityLoss;
|
|
if (num7 == 1)
|
|
{
|
|
num8 = this.character.invRow2._DurabilityLoss;
|
|
}
|
|
this.character.UpdateDurability(num7, num8, false, true);
|
|
if (!target.dead && (!target.stunned || (target.stunned && Records.x.kill)) && target.actions)
|
|
{
|
|
int num9;
|
|
target.stats.CheckForSongsAndWords("OnHit", out num9);
|
|
target.actions.ai.hitBy = this.character;
|
|
}
|
|
bool flag7 = true;
|
|
if (!this.firstAttack && !this.secondAttack)
|
|
{
|
|
flag7 = false;
|
|
}
|
|
string text2 = "None";
|
|
if (this.firstAttack)
|
|
{
|
|
text2 = "Bounce";
|
|
}
|
|
float num10 = itemRow._HitTimeIncrease;
|
|
float num11 = itemRow._StaminaReduction;
|
|
if (this.character.invRow1._MeleeRangeEnd >= 5f)
|
|
{
|
|
num10 += this.character.invRow1._HitTimeIncrease;
|
|
num11 += this.character.invRow1._StaminaReduction;
|
|
}
|
|
this.character.AddDamage(target, damage, true, false, flag7, text2, num10, num11);
|
|
this.DamageFX(target, damage, hit);
|
|
if (this.character.party && Links.x.rallyStage.playing && this.firstAttack)
|
|
{
|
|
Links.x.rallyStage.targetDamage = damage;
|
|
}
|
|
if (!target.dead && !target.stunned && this.firstAttack)
|
|
{
|
|
this.savedEnemy = target;
|
|
}
|
|
if (target && !checkingMultiTarget)
|
|
{
|
|
int num12;
|
|
this.CheckForEnchantedWeapon("Attack", target, null, target.node, out num12);
|
|
}
|
|
if (this.doSlowTime)
|
|
{
|
|
Links.x.combat.StartSlowTime("Synergy");
|
|
}
|
|
if (this.firstAttack && !checkingMultiTarget && !this.quickAttack && !this.specialAttack1 && !this.specialAttack2)
|
|
{
|
|
this.character.stats.UpdateRallyCount(true, 0f);
|
|
}
|
|
if (!checkingMultiTarget)
|
|
{
|
|
int num13 = 9;
|
|
if (target.GetInvNum(18) > 1)
|
|
{
|
|
float num14 = itemRow._DurabilityReductionBonus + 1f + target.stats.EqArmorReduction();
|
|
if (this.character.invRow1._MeleeRangeEnd >= 5f)
|
|
{
|
|
num14 += this.character.invRow1._DurabilityReductionBonus;
|
|
}
|
|
target.UpdateDurability(num13, (int)num14, false, true);
|
|
}
|
|
}
|
|
this.doSlowTime = false;
|
|
Links.x.sensory.AddNoise(target.gameObject, target.node, "Hit", this.character);
|
|
if (target.dead || target.stunned)
|
|
{
|
|
int num15;
|
|
this.character.stats.CheckForSongsAndWords("OnKill", out num15);
|
|
Links.x.fellowship.CheckForPartySongs("OnPartyKill");
|
|
if (target.party)
|
|
{
|
|
Links.x.fellowship.CheckForPartySongs("OnFriendDown");
|
|
}
|
|
Links.x.sensory.AddNoise(target.gameObject, target.node, "Death", this.character);
|
|
}
|
|
}
|
|
else if (target && !flag)
|
|
{
|
|
if (this.character.party && Links.x.rallyStage.playing)
|
|
{
|
|
Links.x.rallyStage.targetDamage = 0f;
|
|
}
|
|
if (hit == 4f)
|
|
{
|
|
if (!fromProjectile)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Swing", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
}
|
|
this.str.Clear();
|
|
if (!target.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(target));
|
|
}
|
|
this.str.Append(target.stats.GetName());
|
|
if (!target.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" moved out of range of ");
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>'s attack");
|
|
}
|
|
else
|
|
{
|
|
this.str.Append("'s attack");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
else
|
|
{
|
|
if (target.body.lookAtController)
|
|
{
|
|
target.body.lookAtController.SetNewTarget(this.character.body.headBone, 2f, 0f, false);
|
|
}
|
|
if (hit == 1f)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Block Dodge", this.character.tr.position, 1f, new float?(1f), 0.3f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Swing", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
if (!target.moving || Records.x.pocketPause)
|
|
{
|
|
target.PlayAnimation("Block_dodge", 0f);
|
|
}
|
|
if (!flag2)
|
|
{
|
|
this.DamageFX(target, 0f, hit);
|
|
}
|
|
int num16;
|
|
target.stats.CheckForSongsAndWords("OnEvade", out num16);
|
|
if ((target.mainSelected || this.character.mainSelected) && !flag2)
|
|
{
|
|
if (this.blocked)
|
|
{
|
|
Links.x.cellar.GetAnimatedText("Blocked", "", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
}
|
|
else
|
|
{
|
|
Links.x.cellar.GetAnimatedText("Evaded", "", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
}
|
|
}
|
|
}
|
|
else if (hit == 2f || hit == 3f)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Block Armor", this.character.tr.position, 1f, new float?(1f), 0.3f, "", null);
|
|
if (!target.moving || Records.x.pocketPause)
|
|
{
|
|
target.PlayAnimation("Block_armor", 0f);
|
|
}
|
|
if (this.character.mainSelected)
|
|
{
|
|
Links.x.cellar.GetAnimatedText("Absorbed", "", Records.x.IsTextLeft(this.character, target)).gameObject.transform.position = target.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
}
|
|
if (this.firstAttack && (this.specialAttack3 || this.specialAttack2))
|
|
{
|
|
bool flag8 = false;
|
|
if (checkingMultiTarget)
|
|
{
|
|
flag8 = true;
|
|
}
|
|
this.SpecialAttack2(target, targetInteractive, itemRow, flag8);
|
|
}
|
|
this.DamageFX(target, 0f, hit);
|
|
if (!checkingMultiTarget)
|
|
{
|
|
int num17 = 9;
|
|
if (target.GetInvNum(18) > 1)
|
|
{
|
|
float num18 = itemRow._DurabilityReductionBonus + 1f + target.stats.EqArmorReduction();
|
|
if (this.character.invRow1._MeleeRangeEnd >= 5f)
|
|
{
|
|
num18 += this.character.invRow1._DurabilityReductionBonus;
|
|
}
|
|
target.UpdateDurability(num17, (int)num18, false, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (hit == 0f && targetInteractive && !flag)
|
|
{
|
|
BreakableActions component = targetInteractive.GetComponent<BreakableActions>();
|
|
ChestActions component2 = targetInteractive.GetComponent<ChestActions>();
|
|
DoorActions component3 = targetInteractive.GetComponent<DoorActions>();
|
|
PuzzleActions component4 = targetInteractive.GetComponent<PuzzleActions>();
|
|
string text3 = "";
|
|
int num19 = 0;
|
|
Vector3 vector2 = targetInteractive.transform.position;
|
|
if (component)
|
|
{
|
|
vector2 = component.mainCollider.bounds.center + new Vector3(0f, 1f, 0f);
|
|
}
|
|
if (component3)
|
|
{
|
|
vector2 = component3.lockColliderPosition;
|
|
}
|
|
if (component2)
|
|
{
|
|
vector2 = component2.tr.position + new Vector3(0f, 2.5f, 0f);
|
|
}
|
|
if (component4)
|
|
{
|
|
vector2 = component4.gameObject.transform.position + new Vector3(0f, component4.interactionPointY, 0f);
|
|
}
|
|
if (targetInteractive)
|
|
{
|
|
int num20;
|
|
this.CheckForEnchantedWeapon("Attack", null, targetInteractive, null, out num20);
|
|
}
|
|
if (targetInteractive.GetComponent<Character>())
|
|
{
|
|
Links.x.sensory.AddNoise(targetInteractive.gameObject, targetInteractive.GetComponent<Character>().node, "Hit", this.character);
|
|
}
|
|
if (component2)
|
|
{
|
|
component2.currentHealth -= (int)damage;
|
|
if (component2.currentHealth <= 0)
|
|
{
|
|
component2.ClickToBreak(this.character, false);
|
|
}
|
|
else
|
|
{
|
|
component2.Damage(this.character);
|
|
}
|
|
text3 = "Chest";
|
|
num19 = component2.currentHealth;
|
|
component2.AlertOwner(true, this.character);
|
|
}
|
|
if (component3)
|
|
{
|
|
component3.currentHealth -= (int)damage;
|
|
if (component3.currentHealth <= 0)
|
|
{
|
|
component3.ClickToBreak(this.character, false);
|
|
}
|
|
else
|
|
{
|
|
component3.Damage(this.character);
|
|
}
|
|
text3 = "Door";
|
|
num19 = component3.currentHealth;
|
|
component3.AlertOwner(true, this.character);
|
|
}
|
|
if (component)
|
|
{
|
|
component.currentHealth -= (int)damage;
|
|
if (component.currentHealth <= 0)
|
|
{
|
|
component.ClickToBreak(this.character, false, false);
|
|
}
|
|
else
|
|
{
|
|
component.Damage(this.character);
|
|
}
|
|
text3 = component.breakable.type.ToString();
|
|
num19 = component.currentHealth;
|
|
}
|
|
if (component4)
|
|
{
|
|
component4.currentHealth -= (int)damage;
|
|
if (component4.currentHealth <= 0)
|
|
{
|
|
component4.ClickToBreak();
|
|
}
|
|
else
|
|
{
|
|
component4.Damage();
|
|
}
|
|
text3 = component4.puzzle.displayNameIfHoverable;
|
|
num19 = component4.currentHealth;
|
|
}
|
|
Animator animatedText = Links.x.cellar.GetAnimatedText("NPCDmg", Mathf.Round(damage).ToString(), false);
|
|
animatedText.gameObject.transform.position = vector2 + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
animatedText.gameObject.SetActive(true);
|
|
Links.x.sensory.AddNoise(this.character.gameObject, this.character.node, "Break", this.character);
|
|
int num21 = this.currentHand;
|
|
int num22 = this.character.invRow1._DurabilityLoss;
|
|
if (num21 == 1)
|
|
{
|
|
num22 = this.character.invRow2._DurabilityLoss;
|
|
}
|
|
if (num21 == 2)
|
|
{
|
|
num22 = this.character.invRow3._DurabilityLoss;
|
|
}
|
|
if (num21 == 3)
|
|
{
|
|
num22 = this.character.invRow4._DurabilityLoss;
|
|
}
|
|
this.character.UpdateDurability(num21, num22, false, true);
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedImpactSound, targetInteractive.transform.position, 1f, new float?(1f), 0f, "", null);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" hit ");
|
|
this.str.Append(text3);
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(attackTotals);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
if (damage > 0f)
|
|
{
|
|
this.str.Clear();
|
|
this.str.Append(text3);
|
|
this.str.Append(" took ");
|
|
this.str.Append(damage);
|
|
this.str.Append(" breaking damage");
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(hitTexts);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
if (num19 <= 0)
|
|
{
|
|
this.str.Clear();
|
|
this.str.Append(text3);
|
|
this.str.Append(" is broken");
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
else if (targetInteractive && hit != 0f && !flag)
|
|
{
|
|
BreakableActions component5 = targetInteractive.GetComponent<BreakableActions>();
|
|
ChestActions component6 = targetInteractive.GetComponent<ChestActions>();
|
|
DoorActions component7 = targetInteractive.GetComponent<DoorActions>();
|
|
PuzzleActions component8 = targetInteractive.GetComponent<PuzzleActions>();
|
|
string text4 = "";
|
|
if (component6)
|
|
{
|
|
text4 = "Chest";
|
|
}
|
|
if (component7)
|
|
{
|
|
text4 = "Door";
|
|
}
|
|
if (component5)
|
|
{
|
|
text4 = component5.breakable.type.ToString();
|
|
}
|
|
if (component8)
|
|
{
|
|
text4 = component8.puzzle.displayNameIfHoverable;
|
|
}
|
|
Vector3 vector3 = targetInteractive.transform.position;
|
|
if (component5)
|
|
{
|
|
vector3 = component5.mainCollider.bounds.center;
|
|
}
|
|
if (component7)
|
|
{
|
|
vector3 = component7.lockColliderPosition;
|
|
}
|
|
if (component6)
|
|
{
|
|
vector3 = component6.tr.position + new Vector3(0f, 2.5f, 0f);
|
|
}
|
|
if (component8)
|
|
{
|
|
vector3 = component8.gameObject.transform.position + new Vector3(0f, component8.interactionPointY, 0f);
|
|
}
|
|
if (hit == 1f || hit == 4f)
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Block Armor", this.character.tr.position, 1f, new float?(1f), 0.3f, "", null);
|
|
Animator animatedText2 = Links.x.cellar.GetAnimatedText("Blocked", "", false);
|
|
animatedText2.gameObject.transform.position = vector3 + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f) + new Vector3(0f, 2f, 0f);
|
|
animatedText2.gameObject.SetActive(true);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append("'s attack was absorbed by ");
|
|
this.str.Append(text4);
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(hitTexts);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" hit ");
|
|
this.str.Append(text4);
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(attackTotals);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
this.str.Clear();
|
|
this.str.Append(text4);
|
|
this.str.Append(" absorbed attack ");
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(hitTexts);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
else
|
|
{
|
|
MasterAudio.PlaySound3DAtVector3AndForget(this.character.stats.characterRow._UnarmedAttackSound, this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Block Armor", this.character.tr.position, 1f, new float?(1f), 0.3f, "", null);
|
|
Animator animatedText3 = Links.x.cellar.GetAnimatedText("NPCDmg", "No effect!", false);
|
|
animatedText3.gameObject.transform.position = vector3 + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f) + new Vector3(0f, 2f, 0f);
|
|
animatedText3.gameObject.SetActive(true);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append("'s attack had no effect on ");
|
|
this.str.Append(text4);
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (!flag && target && hit != 4f && hitTexts != "")
|
|
{
|
|
this.UpdateGameFeed(target, hit, damage, attackTotals, defenseTotals, hitTexts, flag5);
|
|
}
|
|
this.UpdateSoundAlerts(target);
|
|
this.castCompleteCoroutine = null;
|
|
if (this.selectedTarget && (this.selectedTarget.dead || (this.selectedTarget.stunned && Records.x.kill)))
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (this.selectedTargetInteractive || this.selectedAITargetInteractive)
|
|
{
|
|
GameObject gameObject = this.selectedTargetInteractive;
|
|
if (!gameObject)
|
|
{
|
|
gameObject = this.selectedAITargetInteractive;
|
|
}
|
|
BreakableActions component9 = gameObject.GetComponent<BreakableActions>();
|
|
ChestActions component10 = gameObject.GetComponent<ChestActions>();
|
|
DoorActions component11 = gameObject.GetComponent<DoorActions>();
|
|
PuzzleActions component12 = gameObject.GetComponent<PuzzleActions>();
|
|
if (component9 && component9.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component10 && component10.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component11 && component11.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
if (component12 && component12.destroyed)
|
|
{
|
|
this.SetSelectedTarget(false, null, null, null);
|
|
}
|
|
}
|
|
bool flag9 = false;
|
|
if (fromProjectile && itemRow._Name.Contains("Vial"))
|
|
{
|
|
flag9 = true;
|
|
}
|
|
if (hit == 0f && this.firstAttack && !checkingMultiTarget && damage > 0f)
|
|
{
|
|
this.AddSpecialAttack(target);
|
|
}
|
|
bool flag10 = this.firstAttack;
|
|
bool flag11 = this.secondAttack;
|
|
if ((target || targetInteractive) && !checkingMultiTarget && !fromProjectile && (this.firstAttack || (this.character.stats.HandCount() > 1f && this.secondAttack)) && !this.heavyAttack && !this.lightAttack && !flag)
|
|
{
|
|
this.firstAttack = false;
|
|
if (!Links.x.rallyStage.playing)
|
|
{
|
|
this.MultiHit(target, targetInteractive, false, false, false, false, itemRow);
|
|
}
|
|
}
|
|
if (this.firstAttack && (target || targetInteractive) && !checkingMultiTarget && fromProjectile && !flag && this.specialAttack2 && Links.x.combat.inPocketAttack && (itemRow._Name.Contains("Vial") || itemRow._Name.Contains("Dart")))
|
|
{
|
|
Vector3 vector4 = Vector3.zero;
|
|
if (target)
|
|
{
|
|
vector4 = target.currentPosition;
|
|
}
|
|
if (targetInteractive)
|
|
{
|
|
vector4 = targetInteractive.transform.position;
|
|
}
|
|
this.MultiHitObjects(vector4, target, targetInteractive, false, true, false, fromProjectile, itemRow, 0);
|
|
}
|
|
if (hit == 0f && (target || targetInteractive) && !checkingMultiTarget && flag9 && this.firstAttack && !flag && itemRow._Name.Contains("Bomb"))
|
|
{
|
|
Vector3 vector5 = Vector3.zero;
|
|
if (target)
|
|
{
|
|
vector5 = target.currentPosition;
|
|
}
|
|
if (targetInteractive)
|
|
{
|
|
vector5 = targetInteractive.transform.position;
|
|
}
|
|
this.MultiHitObjects(vector5, target, targetInteractive, false, false, true, fromProjectile, itemRow, 0);
|
|
}
|
|
if ((target || targetInteractive) && this.character.stats.HandCount() > 1f && !checkingMultiTarget && flag10 && !Links.x.combat.inPocketAttack && !flag11)
|
|
{
|
|
this.firstAttack = false;
|
|
Character character2 = target;
|
|
GameObject gameObject2 = null;
|
|
if (targetInteractive)
|
|
{
|
|
gameObject2 = targetInteractive;
|
|
}
|
|
if (target && target.dead)
|
|
{
|
|
character2 = null;
|
|
if (this.combatCharacters == null)
|
|
{
|
|
this.combatCharacters = Links.x.diorama.characters;
|
|
}
|
|
float num23 = this.character.AttackRange();
|
|
int count = this.combatCharacters.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (i < this.combatCharacters.Count && !character2)
|
|
{
|
|
Character character3 = this.combatCharacters[i];
|
|
if (character3 && character3 != target && (character3.tr.position - target.tr.position).sqrMagnitude < num23 * num23 && this.ai.CanAttack(character3) && this.InAttackDirection(character3))
|
|
{
|
|
character2 = character3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (character2 || gameObject2)
|
|
{
|
|
this.ClearDamageLists();
|
|
this.ClearTargetCharacters();
|
|
if (target)
|
|
{
|
|
this.actionTargets.Add(character2);
|
|
}
|
|
else
|
|
{
|
|
this.actionInteractives.Add(gameObject2);
|
|
}
|
|
if (target)
|
|
{
|
|
this.character.SetRotation(Quaternion.LookRotation(target.currentPosition - this.character.currentPosition), false, true);
|
|
}
|
|
this.ActionRolls(false, false, character2, gameObject2);
|
|
}
|
|
}
|
|
if (!Records.x.combat && this.targets.Count == 0 && !checkingMultiTarget && this.firstAttack && !this.cannotInterrupt)
|
|
{
|
|
this.EndTurnAfterAction();
|
|
}
|
|
if (!checkingMultiTarget)
|
|
{
|
|
this.character.stats.attackCount++;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000155 RID: 341 RVA: 0x0001B780 File Offset: 0x00019980
|
|
public void MultiHit(Character target, GameObject targetInteractive, bool isRange, bool isDart, bool elixirBomb, bool fromProjectile, Library.Inventory itemRow)
|
|
{
|
|
Vector3 vector = Vector3.zero;
|
|
if (target)
|
|
{
|
|
vector = target.currentPosition;
|
|
}
|
|
if (targetInteractive)
|
|
{
|
|
vector = targetInteractive.transform.position;
|
|
}
|
|
this.MultiHitObjects(vector, target, targetInteractive, false, false, false, fromProjectile, itemRow, 0);
|
|
}
|
|
|
|
// Token: 0x06000156 RID: 342 RVA: 0x0001B7C8 File Offset: 0x000199C8
|
|
private void FoundMultiHit(bool isRange, bool isDart, bool elixirBomb, Vector3 position, Character target, GameObject targetInteractive, Character checking, GameObject checkingInteractive, bool fromProjectile, Library.Inventory itemRow, int ammoIndex)
|
|
{
|
|
if (((targetInteractive && targetInteractive != checkingInteractive) || !targetInteractive) && ((target && target != checking) || !target))
|
|
{
|
|
if (elixirBomb)
|
|
{
|
|
float num = 3f;
|
|
Vector3 vector = Vector3.zero;
|
|
if (checking)
|
|
{
|
|
vector = checking.currentPosition;
|
|
}
|
|
else
|
|
{
|
|
vector = checkingInteractive.transform.position;
|
|
}
|
|
if ((vector - position).sqrMagnitude < num * num)
|
|
{
|
|
if (checking)
|
|
{
|
|
this.actionTargets.Add(checking);
|
|
}
|
|
else
|
|
{
|
|
this.actionInteractives.Add(checkingInteractive);
|
|
}
|
|
this.ActionRolls(true, true, checking, checkingInteractive);
|
|
int num2 = this.damages.Count - 1;
|
|
if (num2 < this.hits.Count && num2 > -1)
|
|
{
|
|
if (checking)
|
|
{
|
|
for (int i = 0; i < this.targets.Count; i++)
|
|
{
|
|
if (this.targets[i] == checking)
|
|
{
|
|
num2 = i;
|
|
}
|
|
}
|
|
}
|
|
if (checkingInteractive)
|
|
{
|
|
for (int j = 0; j < this.targetsInteractive.Count; j++)
|
|
{
|
|
if (this.targetsInteractive[j] == checkingInteractive)
|
|
{
|
|
num2 = j;
|
|
}
|
|
}
|
|
}
|
|
if (num2 > -1)
|
|
{
|
|
this.OnAttackComplete(checking, checkingInteractive, (float)this.hits[num2], this.damages[num2], this.attackTotal[num2], this.defenseTotal[num2], this.hitText[num2], fromProjectile, itemRow, num2, true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag = false;
|
|
Vector3 vector2 = this.character.currentPosition;
|
|
if (Links.x.rallyStage.playing)
|
|
{
|
|
vector2 = Links.x.combat.rallyCharacterStartPosition;
|
|
}
|
|
if (checking)
|
|
{
|
|
if (checking.InAttackShape(target, position, this.character, vector2, checking.currentPosition, this.character.invRow1))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else if (this.character.InAttackShape(null, position, this.character, vector2, checkingInteractive.transform.position, this.character.invRow1))
|
|
{
|
|
flag = true;
|
|
}
|
|
if (flag)
|
|
{
|
|
if (!isDart)
|
|
{
|
|
if (isRange)
|
|
{
|
|
if (checking)
|
|
{
|
|
this.actionTargets.Add(checking);
|
|
}
|
|
else
|
|
{
|
|
this.actionInteractives.Add(checkingInteractive);
|
|
}
|
|
this.ActionRolls(true, true, checking, checkingInteractive);
|
|
if (checking)
|
|
{
|
|
this.CreateAmmo(this.ammoRow, this.targets.IndexOf(checking), checking, null);
|
|
}
|
|
else
|
|
{
|
|
this.CreateAmmo(this.ammoRow, this.targetsInteractive.IndexOf(checkingInteractive), null, checkingInteractive);
|
|
}
|
|
this.character.UseAmmo(ammoIndex);
|
|
return;
|
|
}
|
|
if (checking)
|
|
{
|
|
this.actionTargets.Add(checking);
|
|
}
|
|
else
|
|
{
|
|
this.actionInteractives.Add(checkingInteractive);
|
|
}
|
|
this.ActionRolls(true, true, checking, checkingInteractive);
|
|
int num3 = this.damages.Count - 1;
|
|
if (num3 < this.hits.Count && num3 > -1)
|
|
{
|
|
if (checking)
|
|
{
|
|
for (int k = 0; k < this.targets.Count; k++)
|
|
{
|
|
if (this.targets[k] == checking)
|
|
{
|
|
num3 = k;
|
|
}
|
|
}
|
|
}
|
|
if (checkingInteractive)
|
|
{
|
|
for (int l = 0; l < this.targetsInteractive.Count; l++)
|
|
{
|
|
if (this.targetsInteractive[l] == checkingInteractive)
|
|
{
|
|
num3 = l;
|
|
}
|
|
}
|
|
}
|
|
if (num3 > -1)
|
|
{
|
|
this.OnAttackComplete(checking, checkingInteractive, (float)this.hits[num3], this.damages[num3], this.attackTotal[num3], this.defenseTotal[num3], this.hitText[num3], fromProjectile, itemRow, num3, true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (checking)
|
|
{
|
|
checking.PlayAnimation("Hit", 0f);
|
|
}
|
|
Effects effects;
|
|
if (checking)
|
|
{
|
|
effects = checking.gameObject.AddComponent<Effects>();
|
|
}
|
|
else
|
|
{
|
|
effects = checkingInteractive.AddComponent<Effects>();
|
|
}
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = checking;
|
|
effects.targetInteractive = checkingInteractive;
|
|
effects.fromLoad = false;
|
|
effects.effectName = itemRow._Effect;
|
|
effects.sourceLevel = Mathf.Round((float)itemRow._DmgMax / 2f);
|
|
effects.Inflicted(false);
|
|
if (Links.x.combat.inPocketAttack && !Links.x.rallyStage.playing && checking)
|
|
{
|
|
checking.SetMeshState(true);
|
|
checking.OverridePocketPause();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000157 RID: 343 RVA: 0x0001BCD0 File Offset: 0x00019ED0
|
|
public void MultiHitObjects(Vector3 hoverPosition, Character target, GameObject targetInteractive, bool isRange, bool isDart, bool elixirBomb, bool fromProjectile, Library.Inventory itemRow, int ammoIndex)
|
|
{
|
|
if (this.diaDoors == null)
|
|
{
|
|
this.currentTileEffects = Links.x.cellar.currentTileEffects;
|
|
this.timedBreakables = Links.x.cellar.combatBreakables;
|
|
this.diaBreakables = Links.x.diorama.breakableActions;
|
|
this.diaDoors = Links.x.diorama.doorActions;
|
|
this.diaChests = Links.x.diorama.chestActions;
|
|
}
|
|
if (hoverPosition != Vector3.zero)
|
|
{
|
|
if (this.combatCharacters == null)
|
|
{
|
|
this.combatCharacters = Links.x.diorama.characters;
|
|
}
|
|
this.multiHitCharacters.Clear();
|
|
for (int i = 0; i < this.combatCharacters.Count; i++)
|
|
{
|
|
this.multiHitCharacters.Add(this.combatCharacters[i]);
|
|
}
|
|
for (int j = 0; j < this.multiHitCharacters.Count; j++)
|
|
{
|
|
Character character = this.multiHitCharacters[j];
|
|
if (character && character != target && this.ai.CanAttack(character))
|
|
{
|
|
bool flag = true;
|
|
if (fromProjectile && !isDart && itemRow._Name.Contains("Arrow"))
|
|
{
|
|
flag = Links.x.combat.InRangeSight(this.character, character);
|
|
}
|
|
if (flag)
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, character, null, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
}
|
|
for (int k = 0; k < this.timedBreakables.Count; k++)
|
|
{
|
|
TimedBreakable timedBreakable = this.timedBreakables[k];
|
|
if (timedBreakable && !timedBreakable.breakable.destroyed && (this.CheckInteractiveLineOfSight(timedBreakable.breakable.transform.position, timedBreakable.breakable, null, null, null) || isDart))
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, null, timedBreakable.breakable.gameObject, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
for (int l = 0; l < this.currentTileEffects.Count; l++)
|
|
{
|
|
TileEffects tileEffects = this.currentTileEffects[l];
|
|
if (tileEffects && tileEffects.isWall)
|
|
{
|
|
foreach (BreakableActions breakableActions in tileEffects.breakables)
|
|
{
|
|
if (breakableActions && !breakableActions.destroyed && (this.CheckInteractiveLineOfSight(breakableActions.transform.position, breakableActions, null, null, null) || isDart))
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, null, breakableActions.gameObject, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int m = 0; m < this.diaBreakables.Count; m++)
|
|
{
|
|
BreakableActions breakableActions2 = this.diaBreakables[m];
|
|
if (breakableActions2 && !breakableActions2.destroyed && (this.CheckInteractiveLineOfSight(breakableActions2.transform.position, breakableActions2, null, null, null) || isDart))
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, null, breakableActions2.gameObject, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
for (int n = 0; n < this.diaChests.Count; n++)
|
|
{
|
|
ChestActions chestActions = this.diaChests[n];
|
|
if (chestActions && !chestActions.destroyed && (this.CheckInteractiveLineOfSight(chestActions.transform.position, null, null, chestActions, null) || isDart))
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, null, chestActions.gameObject, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
for (int num = 0; num < this.diaDoors.Count; num++)
|
|
{
|
|
DoorActions doorActions = this.diaDoors[num];
|
|
if (doorActions && !doorActions.destroyed && doorActions.lockCollider && (this.CheckInteractiveLineOfSight(doorActions.lockColliderPosition, null, doorActions, null, null) || isDart))
|
|
{
|
|
this.FoundMultiHit(isRange, isDart, elixirBomb, hoverPosition, target, targetInteractive, null, doorActions.gameObject, fromProjectile, itemRow, ammoIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000158 RID: 344 RVA: 0x0001C10C File Offset: 0x0001A30C
|
|
private bool CheckInteractiveLineOfSight(Vector3 mainPoint, BreakableActions breakable, DoorActions door, ChestActions chest, PuzzleActions puzzle)
|
|
{
|
|
Vector3 vector = mainPoint;
|
|
GameObject gameObject = null;
|
|
if (Records.x.pocketPause && (Links.x.gameplay.spellTargetingGround || Links.x.gameplay.spellTargetingEnemy || Links.x.gameplay.spellTargetingParty))
|
|
{
|
|
return false;
|
|
}
|
|
if (breakable)
|
|
{
|
|
vector = breakable.mainCollider.bounds.center;
|
|
gameObject = breakable.gameObject;
|
|
}
|
|
if (door)
|
|
{
|
|
vector = door.lockColliderPosition;
|
|
gameObject = door.gameObject;
|
|
}
|
|
if (puzzle)
|
|
{
|
|
vector = puzzle.gameObject.transform.position;
|
|
gameObject = puzzle.gameObject;
|
|
}
|
|
if (chest)
|
|
{
|
|
vector = chest.tr.position + new Vector3(0f, 1f, 0f);
|
|
gameObject = chest.mainCollider.gameObject;
|
|
}
|
|
vector.y += 0.5f;
|
|
RaycastHit raycastHit;
|
|
bool flag = Physics.SphereCast(Links.x.main.raycastPosition, 0.1f, vector - Links.x.main.raycastPosition, out raycastHit, this.character.AttackRange(), 2163200);
|
|
if (flag)
|
|
{
|
|
if (raycastHit.collider.gameObject == gameObject)
|
|
{
|
|
flag = false;
|
|
}
|
|
else if (raycastHit.collider.gameObject.transform.parent && raycastHit.collider.gameObject.transform.parent.gameObject == gameObject)
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
return !flag;
|
|
}
|
|
|
|
// Token: 0x06000159 RID: 345 RVA: 0x0001C2AC File Offset: 0x0001A4AC
|
|
private float DodgeCalculation(Character target)
|
|
{
|
|
float num = Mathf.Clamp((Links.x.gameplay.seconds - target.blockDodgeStartTime) / 20f, 0f, 1f);
|
|
if (num < 0.25f && target.mainSelected)
|
|
{
|
|
num = 0f;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600015A RID: 346 RVA: 0x0001C2FC File Offset: 0x0001A4FC
|
|
public void AddPlayerToCombat(Character target)
|
|
{
|
|
if (target)
|
|
{
|
|
if (!Records.x.combat && target.hostility < 2 && !this.character.npc && !target.attackingUntilBribe)
|
|
{
|
|
Links.x.combat.StartCombat(null, this.character, true, true);
|
|
}
|
|
if (!this.doBubbleAttack)
|
|
{
|
|
Links.x.sensory.AddPlayerFromDamage(target, this.character);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600015B RID: 347 RVA: 0x0001C374 File Offset: 0x0001A574
|
|
public void RemoveTarget(Character character, GameObject obj)
|
|
{
|
|
Debug.Log("Remove target");
|
|
if (!obj)
|
|
{
|
|
int num = this.targets.IndexOf(character);
|
|
if (num > -1)
|
|
{
|
|
this.targets.RemoveAt(num);
|
|
this.targetsInteractive.RemoveAt(num);
|
|
this.hits.RemoveAt(num);
|
|
this.damages.RemoveAt(num);
|
|
this.attackTotal.RemoveAt(num);
|
|
this.defenseTotal.RemoveAt(num);
|
|
this.hitText.RemoveAt(num);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num2 = this.targetsInteractive.IndexOf(obj);
|
|
if (num2 > -1)
|
|
{
|
|
this.targetsInteractive.RemoveAt(num2);
|
|
this.targets.RemoveAt(num2);
|
|
this.hits.RemoveAt(num2);
|
|
this.damages.RemoveAt(num2);
|
|
this.attackTotal.RemoveAt(num2);
|
|
this.defenseTotal.RemoveAt(num2);
|
|
this.hitText.RemoveAt(num2);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600015C RID: 348 RVA: 0x0001C464 File Offset: 0x0001A664
|
|
public void EndChanneling(bool endTurn)
|
|
{
|
|
this.channeling = false;
|
|
if (this.currentTileEffect)
|
|
{
|
|
this.currentTileEffect.Remove();
|
|
}
|
|
this.EndVine();
|
|
this.currentTileEffect = null;
|
|
this.character.inRecovery = false;
|
|
this.spellScroll = null;
|
|
if (endTurn)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600015D RID: 349 RVA: 0x0001C4BA File Offset: 0x0001A6BA
|
|
public void EndVine()
|
|
{
|
|
if (this.vine)
|
|
{
|
|
this.vine = null;
|
|
if (this.castCompleteCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.castCompleteCoroutine);
|
|
}
|
|
this.castCompleteCoroutine = null;
|
|
this.character.inRecovery = false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600015E RID: 350 RVA: 0x0001C4F8 File Offset: 0x0001A6F8
|
|
public void EndTurnAfterAction()
|
|
{
|
|
this.character.inRecovery = false;
|
|
this.character.inAction = false;
|
|
if (this.character.timelineIcon && !Records.x.pocketPause)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
if (this.character.doingAction && !Records.x.combat)
|
|
{
|
|
return;
|
|
}
|
|
if (this.targets.Count > 0 && this.targetsInteractive.Count > 0 && !Records.x.combat)
|
|
{
|
|
return;
|
|
}
|
|
if (!this.endActionsAfterTurn || this.selectedTarget || this.selectedTargetInteractive)
|
|
{
|
|
this.EndTurn(true);
|
|
return;
|
|
}
|
|
if (this.songsWordsQueued.Count == 0)
|
|
{
|
|
this.EndActions();
|
|
return;
|
|
}
|
|
this.StartAbilityQueue();
|
|
}
|
|
|
|
// Token: 0x0600015F RID: 351 RVA: 0x0001C5D4 File Offset: 0x0001A7D4
|
|
public float AddEffect(string abilityName, Character target)
|
|
{
|
|
Effects effects = target.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = target;
|
|
effects.fromLoad = false;
|
|
effects.effectName = abilityName;
|
|
effects.sourceLevel = 0f;
|
|
effects.Inflicted(false);
|
|
return 0f;
|
|
}
|
|
|
|
// Token: 0x06000160 RID: 352 RVA: 0x0001C644 File Offset: 0x0001A844
|
|
public void DamageFX(Character actionTarget, float damage, float hit)
|
|
{
|
|
if (this.character.party && Links.x.rallyStage.playing)
|
|
{
|
|
return;
|
|
}
|
|
string text = Mathf.Round(damage).ToString();
|
|
if (actionTarget.stats && actionTarget.dodging && hit == 0f)
|
|
{
|
|
text += "<line-height=1.2em>\n<cspace=.5em>.<size=2em> ^</size>";
|
|
}
|
|
Animator animator;
|
|
if (actionTarget.npc)
|
|
{
|
|
if ((this.specialAttack1 || this.specialAttack2) && this.firstAttack)
|
|
{
|
|
animator = Links.x.cellar.GetAnimatedText("RallyDmgTotal", text, Records.x.IsTextLeft(this.character, actionTarget));
|
|
}
|
|
else if (this.character.mainSelected)
|
|
{
|
|
animator = Links.x.cellar.GetAnimatedText("PocketDmg", text, Records.x.IsTextLeft(this.character, actionTarget));
|
|
}
|
|
else
|
|
{
|
|
animator = Links.x.cellar.GetAnimatedText("NPCDmg", text, Records.x.IsTextLeft(this.character, actionTarget));
|
|
}
|
|
}
|
|
else if (Links.x.combat.bubbleEvent)
|
|
{
|
|
animator = Links.x.cellar.GetAnimatedText("RallyDmgTotal", text, Records.x.IsTextLeft(this.character, actionTarget));
|
|
}
|
|
else
|
|
{
|
|
animator = Links.x.cellar.GetAnimatedText("PartyDmg", text, Records.x.IsTextLeft(this.character, actionTarget));
|
|
}
|
|
animator.gameObject.transform.position = actionTarget.body.HeadPosition(0f) + new Vector3(Random.Range(0f, 1f), Random.Range(0f, 1f), 0f);
|
|
animator.gameObject.SetActive(true);
|
|
if (!actionTarget.npc)
|
|
{
|
|
if (actionTarget.portrait)
|
|
{
|
|
actionTarget.portrait.SetHealthColor();
|
|
actionTarget.characterSheetPortrait.SetHealthColor();
|
|
actionTarget.portrait.AnimatorShake();
|
|
}
|
|
if (actionTarget.dockFriend)
|
|
{
|
|
actionTarget.dockFriend.UpdateHealth();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000161 RID: 353 RVA: 0x0001C864 File Offset: 0x0001AA64
|
|
public void UpdateGameFeed(Character actionTarget, float outcome, float damageAmount, string attackRollTotal, string defenseRollTotal, string dmgText, bool usingDart)
|
|
{
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.displayName);
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
if (outcome == 0f)
|
|
{
|
|
this.str.Append(" hit ");
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(actionTarget));
|
|
}
|
|
this.str.Append(actionTarget.stats.GetName());
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
}
|
|
else if (outcome == 2f)
|
|
{
|
|
this.str.Append("'s attack was absorbed by ");
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(actionTarget));
|
|
}
|
|
this.str.Append(actionTarget.stats.GetName());
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
}
|
|
else if (outcome == 1f)
|
|
{
|
|
this.str.Append("'s attack was evaded by ");
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(actionTarget));
|
|
}
|
|
this.str.Append(actionTarget.stats.GetName());
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
}
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(attackRollTotal);
|
|
this.str.Append(" vs. ");
|
|
this.str.Append(defenseRollTotal);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
if ((outcome == 0f || outcome == 2f) && !usingDart)
|
|
{
|
|
this.str.Clear();
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(actionTarget));
|
|
}
|
|
this.str.Append(actionTarget.stats.GetName());
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" lost ");
|
|
this.str.Append(Mathf.Round(damageAmount));
|
|
this.str.Append(" health");
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(dmgText);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
if ((outcome == 0f || outcome == 2f) && usingDart)
|
|
{
|
|
this.str.Clear();
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(actionTarget));
|
|
}
|
|
this.str.Append(actionTarget.stats.GetName());
|
|
if (!actionTarget.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" pierced with stone, will do ");
|
|
this.str.Append(Mathf.Round(damageAmount));
|
|
this.str.Append(" poison damage");
|
|
if (Records.x.showRulesetInfo)
|
|
{
|
|
this.str.Append(" <color #857C6C>... ");
|
|
this.str.Append(dmgText);
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000162 RID: 354 RVA: 0x0001CCB8 File Offset: 0x0001AEB8
|
|
public void GiveItem()
|
|
{
|
|
this.QueueIcon(true);
|
|
if (Records.x.editor && this.givingItemID > -1)
|
|
{
|
|
Debug.Log("Giving item " + ((this != null) ? this.ToString() : null) + " " + this.givingItemID.ToString());
|
|
}
|
|
this.character.PlayAnimation("Use", 0f);
|
|
GameObject gameObject = null;
|
|
if (this.giveCharacter)
|
|
{
|
|
if (this.givingItemID == -1)
|
|
{
|
|
if (this.character.party && this.giveCharacter.dead && !Links.x.fellowship.AnyoneResurrecting(this.giveCharacter))
|
|
{
|
|
this.ai.busy = true;
|
|
this.ai.PartyResurrection(this.giveCharacter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Records.x.editor)
|
|
{
|
|
Character character = this.giveCharacter;
|
|
Debug.Log(((character != null) ? character.ToString() : null) + " has item now");
|
|
}
|
|
int invNum = this.character.GetInvNum(this.givingItemID);
|
|
int invNum2 = this.character.GetInvNum(this.givingItemID + 1);
|
|
Vector3 socketNum = this.character.GetSocketNum(this.givingItemID);
|
|
Vector3 socketNum2 = this.character.GetSocketNum(this.givingItemID + 1);
|
|
Vector4 durabilityNum = this.character.GetDurabilityNum(this.givingItemID / 2);
|
|
this.giveCharacter.GiveItem(invNum, invNum2, socketNum, socketNum2, durabilityNum, true);
|
|
this.character.RemoveItem(invNum, 1);
|
|
this.giveCharacter.PlayAnimation("Use", 0f);
|
|
gameObject = Links.x.cellar.GetPooledGameObject(16);
|
|
gameObject.transform.position = this.giveCharacter.transform.position + new Vector3(0f, 1f, 0f);
|
|
gameObject.SetActive(true);
|
|
Library.Inventory inventory = Links.x.library.GetInvRow(invNum);
|
|
MasterAudio.PlaySoundAndForget("Inventory", 1f, new float?(1f), 0f, inventory._Sound, null);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" gives item to ");
|
|
if (!this.giveCharacter.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.giveCharacter));
|
|
}
|
|
this.str.Append(this.giveCharacter.stats.GetName());
|
|
if (!this.giveCharacter.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
int num = this.giveCharacter.HasItem(invNum);
|
|
if (this.giveCharacter.actions)
|
|
{
|
|
this.giveCharacter.actions.ConsumeItem(num);
|
|
this.str.Clear();
|
|
if (!this.giveCharacter.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.giveCharacter));
|
|
}
|
|
this.str.Append(this.giveCharacter.stats.GetName());
|
|
if (!this.giveCharacter.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" consumed ");
|
|
this.str.Append(inventory._DisplayName);
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
}
|
|
}
|
|
}
|
|
this.giveCharacter = null;
|
|
this.givingItem = false;
|
|
if (gameObject != null)
|
|
{
|
|
gameObject.SetActive(false);
|
|
}
|
|
this.ClearTargetCharacters();
|
|
if (!this.cannotInterrupt && !this.ai.busy)
|
|
{
|
|
this.EndTurn(true);
|
|
this.canEndAttackTime = true;
|
|
this.EndAttackTime(0f);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000163 RID: 355 RVA: 0x0001D130 File Offset: 0x0001B330
|
|
public void UsingItem()
|
|
{
|
|
this.QueueIcon(true);
|
|
GameObject gameObject = null;
|
|
this.usingItem = false;
|
|
int invNum = this.character.GetInvNum(this.usingItemID);
|
|
this.AddEffectFromItem(invNum);
|
|
if (this.character.npc)
|
|
{
|
|
this.character.RemoveItem(invNum, 1);
|
|
}
|
|
else if (this.usingItemID / 2 < 19)
|
|
{
|
|
Links.x.inventory.RemoveBeltItem(this.usingItemID / 2, this.character);
|
|
}
|
|
else
|
|
{
|
|
this.character.RemoveItem(invNum, 1);
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Amphora", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
Library.Inventory inventory = Links.x.library.GetInvRow(invNum);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" consumed ");
|
|
this.str.Append(inventory._DisplayName);
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
if (gameObject != null)
|
|
{
|
|
gameObject.SetActive(false);
|
|
}
|
|
this.QueueIcon(false);
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000164 RID: 356 RVA: 0x0001D2E4 File Offset: 0x0001B4E4
|
|
public void PickUpItem()
|
|
{
|
|
this.QueueIcon(true);
|
|
int id = this.pickupItem.ID;
|
|
GameObject gameObject = null;
|
|
if (this.pickupItem != null)
|
|
{
|
|
if (this.character.npc)
|
|
{
|
|
this.character.GiveItem(this.pickupItem.ID, this.pickupItem.stackSize, this.pickupItem.socketA, this.pickupItem.socketB, this.pickupItem.durability, false);
|
|
gameObject = Links.x.cellar.GetPooledGameObject(16);
|
|
gameObject.transform.position = this.pickupItem.transform.position + new Vector3(0f, 0.5f, 0f);
|
|
gameObject.SetActive(true);
|
|
MasterAudio.PlaySoundAndForget("Inventory", 1f, new float?(1f), 0f, this.pickupItem.invRow._Sound, null);
|
|
this.pickupItem.DestroyItem(false, false);
|
|
}
|
|
else
|
|
{
|
|
this.pickupItem.Clicked(this.character);
|
|
}
|
|
}
|
|
this.pickupItem = null;
|
|
this.pickingUpItem = false;
|
|
if (gameObject != null)
|
|
{
|
|
gameObject.SetActive(false);
|
|
}
|
|
Library.Inventory inventory = Links.x.library.GetInvRow(id);
|
|
this.str.Clear();
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append(Links.x.gameFeed.GetPartyColorText(this.character));
|
|
}
|
|
this.str.Append(this.character.stats.GetName());
|
|
if (!this.character.npc)
|
|
{
|
|
this.str.Append("</color>");
|
|
}
|
|
this.str.Append(" found ");
|
|
this.str.Append(inventory._DisplayName);
|
|
Links.x.gameFeed.AddFeed(this.str.ToString());
|
|
this.character.StartQuip("Found Item");
|
|
if ((float)this.character.stats.HealthCurrent() / (float)this.character.stats.HealthMax() < 0.3f)
|
|
{
|
|
int num = this.character.HasItem(id);
|
|
this.character.actions.ConsumeItem(num);
|
|
}
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000165 RID: 357 RVA: 0x0001D55C File Offset: 0x0001B75C
|
|
public void ConsumeItem(int item)
|
|
{
|
|
if (item > 0)
|
|
{
|
|
int invNum = this.character.GetInvNum(item);
|
|
this.AddEffectFromItem(invNum);
|
|
this.character.RemoveItem(invNum, 1);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Amphora", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
if (!this.cannotInterrupt)
|
|
{
|
|
this.EndTurn(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000166 RID: 358 RVA: 0x0001D5DC File Offset: 0x0001B7DC
|
|
public void AddEffectFromItem(int itemID)
|
|
{
|
|
Library.Inventory invRowByIndex = Links.x.library.GetInvRowByIndex(itemID);
|
|
this.AddEffect(invRowByIndex._Effect, (float)((int)invRowByIndex._Level));
|
|
}
|
|
|
|
// Token: 0x06000167 RID: 359 RVA: 0x0001D610 File Offset: 0x0001B810
|
|
public void AddEffect(string abilityName, float lvl)
|
|
{
|
|
Effects effects = this.character.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = null;
|
|
effects.target = this.character;
|
|
effects.fromLoad = false;
|
|
effects.effectName = abilityName;
|
|
effects.removeAtSceneSwitch = false;
|
|
effects.tileEffect = null;
|
|
effects.sourceLevel = lvl;
|
|
effects.Inflicted(false);
|
|
}
|
|
|
|
// Token: 0x06000168 RID: 360 RVA: 0x0001D688 File Offset: 0x0001B888
|
|
public void CheckForPowerWord(string evt, Character target, GameObject interactiveTarget, GraphNode startNode, string abilityName)
|
|
{
|
|
if (this.character.stats.GetWordsOfPower() && abilityName == "")
|
|
{
|
|
this.words = this.character.stats.words;
|
|
for (int i = 0; i < this.words.Count; i++)
|
|
{
|
|
string text = this.words[i];
|
|
text = text.Substring(0, text.Length - 4);
|
|
Library.Abilities abilityRow = Links.x.library.GetAbilityRow(text);
|
|
if (abilityRow != null && abilityRow._AINotes == evt)
|
|
{
|
|
Effects effects = this.character.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = target;
|
|
effects.fromLoad = false;
|
|
effects.effectName = text;
|
|
effects.removeAtSceneSwitch = false;
|
|
effects.tileEffect = null;
|
|
effects.sourceLevel = 0f;
|
|
effects.Inflicted(false);
|
|
}
|
|
}
|
|
}
|
|
if (abilityName != "")
|
|
{
|
|
Effects effects2 = this.character.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects2);
|
|
effects2.gameObject.SetActive(true);
|
|
effects2.source = this.character;
|
|
effects2.target = target;
|
|
effects2.fromLoad = false;
|
|
effects2.effectName = abilityName;
|
|
effects2.removeAtSceneSwitch = false;
|
|
effects2.tileEffect = null;
|
|
effects2.sourceLevel = 0f;
|
|
effects2.Inflicted(false);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000169 RID: 361 RVA: 0x0001D824 File Offset: 0x0001BA24
|
|
public void AddSpecialAttack(Character target)
|
|
{
|
|
if (this.character.stats.hasEveryAttackAI && !this.character.stats.pinned)
|
|
{
|
|
string everyAttackAI = this.character.stats.everyAttackAI;
|
|
if (everyAttackAI == "Evade")
|
|
{
|
|
Vector3 vector = this.character.currentPosition + Quaternion.LookRotation(this.character.currentPosition - target.currentPosition) * Vector3.forward * 2.5f * 1f;
|
|
this.nodeConstraint.walkable = true;
|
|
this.nodeConstraint.constrainWalkability = true;
|
|
this.nodeConstraint.constrainTags = true;
|
|
this.nodeConstraint.passID = this.character.nodeStationaryID;
|
|
this.nodeConstraint.passID2 = this.character.nodeMovingID;
|
|
this.nodeConstraint.checkCircleID = 0;
|
|
this.nodeConstraint.checkConnections = this.character.ConnectionNumber();
|
|
this.nodeConstraint.constrainToArea = (int)this.character.node.Area;
|
|
GraphNode slideNode = this.character.GetSlideNode(vector, this.character.node, true, 0, 2);
|
|
if (slideNode != null && this.character.stats.Stuck() == 0 && !this.character.jumping && ((Vector3)slideNode.position - this.character.currentPosition).sqrMagnitude < 25f && PathUtilities.IsPathPossible(slideNode, this.character.node))
|
|
{
|
|
this.character.Jump(slideNode, (Vector3)slideNode.position, true, false);
|
|
this.character.evading = true;
|
|
this.character.blockDodgeStartTime = Links.x.gameplay.seconds;
|
|
}
|
|
}
|
|
if (everyAttackAI == "Knockback")
|
|
{
|
|
GraphNode graphNode = target.node;
|
|
if (graphNode == null)
|
|
{
|
|
graphNode = target.NearNode(target.currentPosition, false, 0, -1, 0);
|
|
}
|
|
if (graphNode != null && this.ai)
|
|
{
|
|
string text = "Cannonball";
|
|
if (Random.Range(0, 2) == 0)
|
|
{
|
|
text += "1";
|
|
}
|
|
else
|
|
{
|
|
text += "2";
|
|
}
|
|
MasterAudio.PlaySound3DAtVector3AndForget("SpecialAttacks", this.character.currentPosition, 0.5f, new float?(1f), 0f, text, null);
|
|
GameObject pooledGameObject = Links.x.cellar.GetPooledGameObject(112);
|
|
pooledGameObject.transform.position = target.currentPosition;
|
|
pooledGameObject.SetActive(true);
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
Vector3 vector2 = (Vector3)graphNode.position;
|
|
GraphNode graphNode2;
|
|
if (i < 8)
|
|
{
|
|
graphNode2 = graphNode.ConnectionFromIndex(i);
|
|
}
|
|
else
|
|
{
|
|
vector2 = this.character.currentPosition;
|
|
graphNode2 = graphNode;
|
|
}
|
|
if (graphNode2 != null && graphNode2.ID != 0 && graphNode2.ID != this.character.nodeStationaryID && graphNode2.ID != this.character.nodeMovingID)
|
|
{
|
|
Character nodeCharacter = this.character.GetNodeCharacter(graphNode2.ID);
|
|
if (nodeCharacter)
|
|
{
|
|
nodeCharacter.Knockback(vector2, 1, false, true, false);
|
|
if (nodeCharacter != target)
|
|
{
|
|
nodeCharacter.PlayAnimation("HitInterrupt", 0f);
|
|
}
|
|
if (this.ai.CanAttack(nodeCharacter) && nodeCharacter != target)
|
|
{
|
|
nodeCharacter.SetRotation(Quaternion.LookRotation(this.character.currentPosition - nodeCharacter.currentPosition), false, true);
|
|
Effects effects = nodeCharacter.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = nodeCharacter;
|
|
effects.effectName = "Impact";
|
|
effects.sourceLevel = Records.x.ChargeAmount((float)this.character.stats.level);
|
|
effects.Inflicted(true);
|
|
MasterAudio.PlaySound3DAtVector3AndForget("Swing", this.character.tr.position, 1f, new float?(1f), 0f, "", null);
|
|
MasterAudio.PlaySound3DAtVector3AndForget(nodeCharacter.stats.characterRow._UnarmedAttackSound, nodeCharacter.currentPosition, Random.Range(0.2f, 0.3f), new float?(1f), 0f, "", null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600016A RID: 362 RVA: 0x0001DCF8 File Offset: 0x0001BEF8
|
|
public void CheckForEnchantedWeapon(string evt, Character target, GameObject interactiveTarget, GraphNode startNode, out int multiTargetCount)
|
|
{
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
Vector3 vector = Vector3.zero;
|
|
Vector3 vector2 = Vector3.zero;
|
|
multiTargetCount = 0;
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (this.currentHand == i)
|
|
{
|
|
Library.Inventory inventory = null;
|
|
if (i == 0)
|
|
{
|
|
inventory = this.character.invRow1;
|
|
}
|
|
if (i == 1)
|
|
{
|
|
inventory = this.character.invRow2;
|
|
}
|
|
if (inventory._ID > 1 && inventory._Tag == "Weapon")
|
|
{
|
|
vector = this.character.GetSocketNum(i * 2);
|
|
vector2 = this.character.GetSocketNum(i * 2 + 1);
|
|
if (vector.x > 0f && this.character.stats.CanWearEnchantedItem(vector2.z))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (flag || flag2)
|
|
{
|
|
Library.Pagan paganRowByID = Links.x.library.GetPaganRowByID((float)((int)vector.x));
|
|
Library.Abilities abilityRow = Links.x.library.GetAbilityRow(paganRowByID._ID);
|
|
if (paganRowByID != null && abilityRow != null)
|
|
{
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
float num3 = 0f;
|
|
float num4 = 0f;
|
|
int number = paganRowByID._Number;
|
|
if (evt == abilityRow._Trigger)
|
|
{
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
string text = paganRowByID._Slider1;
|
|
float num5 = vector.y;
|
|
if (j == 1)
|
|
{
|
|
text = paganRowByID._Slider2;
|
|
num5 = vector.z;
|
|
}
|
|
if (j == 2)
|
|
{
|
|
text = paganRowByID._Slider3;
|
|
num5 = vector2.x;
|
|
}
|
|
if (text != "")
|
|
{
|
|
if (text == "Radius")
|
|
{
|
|
num3 = num5;
|
|
}
|
|
if (text.Contains("Duration") || text.Contains("Time"))
|
|
{
|
|
num2 = num5;
|
|
}
|
|
if (text.Contains("Potency"))
|
|
{
|
|
num = num5;
|
|
}
|
|
if (text.Contains("Time") && number == 17)
|
|
{
|
|
num = num5;
|
|
}
|
|
if (text.Contains("Debuff"))
|
|
{
|
|
num = num5;
|
|
}
|
|
if (text.Contains("Reduction"))
|
|
{
|
|
num = num5;
|
|
}
|
|
if (text == "Targets")
|
|
{
|
|
num4 = Mathf.Round(num5);
|
|
}
|
|
if (text == "Distance")
|
|
{
|
|
num = Mathf.Round(num5);
|
|
}
|
|
if (text == "Tile")
|
|
{
|
|
num = Mathf.Round(num5);
|
|
}
|
|
}
|
|
}
|
|
if (evt == "PreAttack")
|
|
{
|
|
multiTargetCount = abilityRow._MultiTarget;
|
|
if (multiTargetCount > 0)
|
|
{
|
|
multiTargetCount = (int)num4;
|
|
}
|
|
}
|
|
bool flag3 = true;
|
|
if ((number == 56 || number == 57) && !this.character.hasCircleBuff)
|
|
{
|
|
flag3 = false;
|
|
}
|
|
if (number == 58 && !target.stats.HasInstrumentEffect("Horn"))
|
|
{
|
|
flag3 = false;
|
|
}
|
|
if (Records.x.editor)
|
|
{
|
|
string[] array = new string[17];
|
|
int num6 = 0;
|
|
Character character = this.character;
|
|
array[num6] = ((character != null) ? character.ToString() : null);
|
|
array[1] = " using enchanted weapon ";
|
|
array[2] = multiTargetCount.ToString();
|
|
array[3] = " ";
|
|
array[4] = abilityRow._MultiTarget.ToString();
|
|
array[5] = " ";
|
|
array[6] = ((int)num4).ToString();
|
|
array[7] = " ";
|
|
int num7 = 8;
|
|
Vector3 vector3 = vector;
|
|
array[num7] = vector3.ToString();
|
|
array[9] = " ";
|
|
int num8 = 10;
|
|
vector3 = vector2;
|
|
array[num8] = vector3.ToString();
|
|
array[11] = " ";
|
|
array[12] = num.ToString();
|
|
array[13] = " ";
|
|
int num9 = 14;
|
|
Character character2 = target;
|
|
array[num9] = ((character2 != null) ? character2.ToString() : null);
|
|
array[15] = " ";
|
|
array[16] = flag3.ToString();
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
if (num3 == 0f && flag3)
|
|
{
|
|
if (abilityRow._MultiTarget == -1)
|
|
{
|
|
target = this.character;
|
|
}
|
|
if (target)
|
|
{
|
|
if (Links.x.library.GetEffectRow(paganRowByID._ID)._IsBuff)
|
|
{
|
|
target = this.character;
|
|
}
|
|
Effects effects = target.gameObject.AddComponent<Effects>();
|
|
Links.x.cellar.AddEffects(effects);
|
|
effects.gameObject.SetActive(true);
|
|
effects.source = this.character;
|
|
effects.target = target;
|
|
effects.fromLoad = false;
|
|
effects.effectName = paganRowByID._ID;
|
|
effects.sourceLevel = num;
|
|
if (num2 > 0f)
|
|
{
|
|
effects.overrideDuration = Records.x.RealSecondsToGameSeconds(num2);
|
|
}
|
|
effects.Inflicted(false);
|
|
return;
|
|
}
|
|
}
|
|
else if (flag3)
|
|
{
|
|
if (startNode == null && target && num3 > 0f)
|
|
{
|
|
target.FindCurrentNode(false);
|
|
startNode = target.node;
|
|
}
|
|
if (startNode != null)
|
|
{
|
|
TileEffects tileEffects = Links.x.tileEffects.AddComponent<TileEffects>();
|
|
tileEffects.gameObject.SetActive(true);
|
|
tileEffects.severity = 0f;
|
|
tileEffects.spellIndex = this.spellIndex;
|
|
tileEffects.paganRow = paganRowByID;
|
|
tileEffects.mainSkill = abilityRow._MainSkill;
|
|
tileEffects.tether = 0f;
|
|
tileEffects.spellScroll = null;
|
|
tileEffects.fromEnchantedItem = true;
|
|
tileEffects.timeToWait = num2;
|
|
tileEffects.spellDuration = num2;
|
|
tileEffects.radius = num3;
|
|
tileEffects.sourceLevel = (float)((int)num);
|
|
tileEffects.targetCount = (int)Mathf.Abs(num4);
|
|
tileEffects.startNode = startNode;
|
|
if (evt == "Attack" && (paganRowByID._Slider1.Contains("Target") || paganRowByID._Slider2.Contains("Target") || paganRowByID._Slider3.Contains("Target")))
|
|
{
|
|
tileEffects.singleTarget = target;
|
|
tileEffects.singleTargetInteractive = interactiveTarget;
|
|
}
|
|
tileEffects.Setup(abilityRow, null, null, null, null, this.character);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string[] array2 = new string[9];
|
|
int num10 = 0;
|
|
Character character3 = this.character;
|
|
array2[num10] = ((character3 != null) ? character3.ToString() : null);
|
|
array2[1] = " missing something from enchant ";
|
|
int num11 = 2;
|
|
Library.Pagan pagan = paganRowByID;
|
|
array2[num11] = ((pagan != null) ? pagan.ToString() : null);
|
|
array2[3] = " ";
|
|
int num12 = 4;
|
|
Library.Abilities abilities = abilityRow;
|
|
array2[num12] = ((abilities != null) ? abilities.ToString() : null);
|
|
array2[5] = " ";
|
|
int num13 = 6;
|
|
GraphNode graphNode = startNode;
|
|
array2[num13] = ((graphNode != null) ? graphNode.ToString() : null);
|
|
array2[7] = " ";
|
|
int num14 = 8;
|
|
Character character4 = target;
|
|
array2[num14] = ((character4 != null) ? character4.ToString() : null);
|
|
Debug.Log(string.Concat(array2));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600016B RID: 363 RVA: 0x0001E360 File Offset: 0x0001C560
|
|
public void SpellFromTrigger(string spellToCast, string unique, Character t)
|
|
{
|
|
this.StopAction();
|
|
this.RemoveAbility();
|
|
this.ClearTargetCharacters();
|
|
this.AddTarget(t);
|
|
this.spellNode = t.node;
|
|
this.spellIndex = this.character.stats.SpellIndex(spellToCast);
|
|
this.paganRow = Links.x.library.GetPaganRow(spellToCast);
|
|
this.Ability(spellToCast, unique, false, true);
|
|
this.CastSpell(t, true, t.node, Vector3.zero, true, true);
|
|
}
|
|
|
|
// Token: 0x0600016C RID: 364 RVA: 0x0001E3E0 File Offset: 0x0001C5E0
|
|
private void OnDisable()
|
|
{
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600016D RID: 365 RVA: 0x0001E434 File Offset: 0x0001C634
|
|
private void OnDestroy()
|
|
{
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600016E RID: 366 RVA: 0x0001E488 File Offset: 0x0001C688
|
|
public void EndActions()
|
|
{
|
|
if (this.channeling)
|
|
{
|
|
this.EndChanneling(false);
|
|
}
|
|
if (this.character.mainSelected && Records.x.pocketPause)
|
|
{
|
|
this.canEndAttackTime = true;
|
|
}
|
|
if (this.ai.busy || this.character.stats.pinning || (Links.x.combat.inPocketAttack && (this.character == Links.x.main || this.character == Links.x.pocketWheel.selectedRallyCharacter)))
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
return;
|
|
}
|
|
this.EndAttackTime(0f);
|
|
if (this.chargeUpFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(this.chargeUpNum, this.chargeUpFX);
|
|
this.chargeUpFX = null;
|
|
MasterAudio.StopSoundGroupOfTransform(this.character.tr, "SpecialAttacks");
|
|
}
|
|
if (!Records.x.combat && this.character.mainSelected)
|
|
{
|
|
Links.x.hudControl.timelineAnimator.Play("Timeline End");
|
|
}
|
|
if (this.spellCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.spellCoroutine);
|
|
this.spellCoroutine = null;
|
|
}
|
|
if (this.instrumentCoroutine != null)
|
|
{
|
|
this.EndPlayingInstrument();
|
|
if (this.instrumentCoroutine != null)
|
|
{
|
|
base.StopCoroutine(this.instrumentCoroutine);
|
|
}
|
|
this.instrumentCoroutine = null;
|
|
}
|
|
if (this.startAttackCoroutine != null)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
return;
|
|
}
|
|
if (this.actionCoroutine != null)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
return;
|
|
}
|
|
if (this.castCompleteCoroutine != null || this.instrumentCoroutine != null || this.wordCoroutine != null)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
return;
|
|
}
|
|
if (this.projectiles.Count > 0)
|
|
{
|
|
this.endActionsAfterTurn = true;
|
|
return;
|
|
}
|
|
if (this.pinTarget)
|
|
{
|
|
return;
|
|
}
|
|
if (this.spellCasterFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(69, this.spellCasterFX);
|
|
}
|
|
if (this.spellWaveFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(88, this.spellWaveFX);
|
|
this.spellWaveFX = null;
|
|
}
|
|
if (this.spellCasterTargetFX)
|
|
{
|
|
Links.x.cellar.ReturnPooledGameObject(70, this.spellCasterTargetFX);
|
|
}
|
|
if (Links.x.gameplay.actionCharacter == this.character)
|
|
{
|
|
Links.x.gameplay.actionCharacter = null;
|
|
Links.x.gameplay.currentAbility = "";
|
|
}
|
|
this.readyToAttack = false;
|
|
this.EndVine();
|
|
this.character.MoveBackEmpty();
|
|
this.character.body.EndBlink();
|
|
this.spellScroll = null;
|
|
this.character.hasActions = false;
|
|
this.character.inAction = false;
|
|
this.character.inRecovery = false;
|
|
if (this.character.stats.pinning)
|
|
{
|
|
this.character.stats.HealEffect("Pinning");
|
|
this.character.stats.pinning = false;
|
|
}
|
|
if (this.character.sailing)
|
|
{
|
|
this.character.NeedToUpdateSailingAnimator(false);
|
|
}
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.overridePause = false;
|
|
}
|
|
this.character.inQueuedAbility = false;
|
|
this.character.stats.lastActionModifier = 1f;
|
|
if (Records.x.combatConsoleDebugging)
|
|
{
|
|
string[] array = new string[10];
|
|
array[0] = "Leaving combat ";
|
|
int num = 1;
|
|
Character character = this.character;
|
|
array[num] = ((character != null) ? character.ToString() : null);
|
|
array[2] = " ";
|
|
int num2 = 3;
|
|
IEnumerator enumerator = this.castCompleteCoroutine;
|
|
array[num2] = ((enumerator != null) ? enumerator.ToString() : null);
|
|
array[4] = " ";
|
|
int num3 = 5;
|
|
IEnumerator enumerator2 = this.startAttackCoroutine;
|
|
array[num3] = ((enumerator2 != null) ? enumerator2.ToString() : null);
|
|
array[6] = " ";
|
|
int num4 = 7;
|
|
IEnumerator enumerator3 = this.actionCoroutine;
|
|
array[num4] = ((enumerator3 != null) ? enumerator3.ToString() : null);
|
|
array[8] = " ";
|
|
int num5 = 9;
|
|
IEnumerator enumerator4 = this.instrumentCoroutine;
|
|
array[num5] = ((enumerator4 != null) ? enumerator4.ToString() : null);
|
|
Debug.Log(string.Concat(array));
|
|
}
|
|
this.ai.ClearCoroutines();
|
|
if (this.ai)
|
|
{
|
|
Object.Destroy(this.ai);
|
|
}
|
|
if (this.character.timelineIcon)
|
|
{
|
|
this.character.timelineIcon.End();
|
|
this.character.timelineIcon = null;
|
|
}
|
|
if (this.character.heard)
|
|
{
|
|
this.character.heard.SetActive(false);
|
|
Links.x.cellar.ReturnPooledGameObject(22, this.character.heard);
|
|
this.character.heard = null;
|
|
}
|
|
this.QueueIcon(false);
|
|
Links.x.combat.RemoveFromNeedsTurn(this.character);
|
|
if (this.character)
|
|
{
|
|
this.character.body.animationHold = false;
|
|
this.character.body.SetSeeThroughAmount();
|
|
if (this.character.mainSelected || this.character == Links.x.combat.rallyCharacter)
|
|
{
|
|
this.character.body.CombatSheen(0);
|
|
Links.x.cameraEffects.RemoveCombatCharacters();
|
|
}
|
|
if (this.character.npc && this.character.creatures.creatures.temperament == Creatures.temperamentState.FightsIfAttacked && (this.character.stats.characterRow._Quest == "" || (this.character.hostility < 2 && !Links.x.sensory.CheckProof(this.character))) && Records.x.BribeBadgeCount() == 0)
|
|
{
|
|
Links.x.combat.AddHostilityReduceCharacter(this.character);
|
|
}
|
|
Links.x.combat.RemoveTimelineIcon(this.character);
|
|
this.character.searching = false;
|
|
this.character.inCombat = false;
|
|
this.character.actions = null;
|
|
this.character.EndCombat();
|
|
this.character.hasLKP = false;
|
|
this.character.ClearLKP();
|
|
if (this.character.boatNavigator && this.character.sailing)
|
|
{
|
|
this.character.boat.EndCombat();
|
|
}
|
|
}
|
|
Object.Destroy(this);
|
|
}
|
|
|
|
// Token: 0x0600016F RID: 367 RVA: 0x0001EAF0 File Offset: 0x0001CCF0
|
|
public Character AttackInBound(out bool dodgeSideways)
|
|
{
|
|
dodgeSideways = false;
|
|
Character character = this.ai.NearbyAttackingEnemy();
|
|
Character character2 = null;
|
|
if (!character)
|
|
{
|
|
character2 = this.ai.NearbyAttackingProjectileCharacter();
|
|
dodgeSideways = true;
|
|
}
|
|
if (character)
|
|
{
|
|
return character;
|
|
}
|
|
if (character2)
|
|
{
|
|
return character2;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000170 RID: 368 RVA: 0x0001EB3C File Offset: 0x0001CD3C
|
|
public bool InAttackDirection(Character target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return false;
|
|
}
|
|
if (!this.character)
|
|
{
|
|
return false;
|
|
}
|
|
if (target.dead)
|
|
{
|
|
return true;
|
|
}
|
|
Vector3 forward = this.character.body.tr.forward;
|
|
Vector3 currentPosition = target.currentPosition;
|
|
Vector3 currentPosition2 = this.character.currentPosition;
|
|
currentPosition.y = currentPosition2.y;
|
|
Vector3 vector = Vector3.Normalize(currentPosition - currentPosition2);
|
|
return Vector3.Dot(forward, vector) >= 0.5f;
|
|
}
|
|
|
|
// Token: 0x06000171 RID: 369 RVA: 0x0001EBC0 File Offset: 0x0001CDC0
|
|
public bool AboveMinDistance(Character target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return false;
|
|
}
|
|
if (!this.character)
|
|
{
|
|
return false;
|
|
}
|
|
if (target.dead)
|
|
{
|
|
return true;
|
|
}
|
|
this.invRow = this.character.invRow1;
|
|
if (this.invRow == null)
|
|
{
|
|
return false;
|
|
}
|
|
float num = 0.1f;
|
|
float num2 = (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num) * (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num);
|
|
return this.character.SubtractVectors(this.GetPosition(this.character), this.GetPosition(target)).sqrMagnitude >= num2;
|
|
}
|
|
|
|
// Token: 0x06000172 RID: 370 RVA: 0x0001EC98 File Offset: 0x0001CE98
|
|
public bool InAttackRange(Character target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return false;
|
|
}
|
|
if (!this.character)
|
|
{
|
|
return false;
|
|
}
|
|
if (target.dead)
|
|
{
|
|
return true;
|
|
}
|
|
this.invRow = this.character.invRow1;
|
|
if (this.invRow == null)
|
|
{
|
|
return false;
|
|
}
|
|
float num = 0.1f;
|
|
float num2 = this.invRow._MeleeRangeEnd;
|
|
if (this.hasPowerDraw)
|
|
{
|
|
num2 += 30f;
|
|
}
|
|
float num3 = (num2 * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num) * (num2 * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num);
|
|
float num4 = (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num) * (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num);
|
|
if (num4 == num3 || this.invRow._MeleeRangeStart == 0f)
|
|
{
|
|
num4 = 0f;
|
|
}
|
|
float sqrMagnitude = this.character.SubtractVectors(this.GetPosition(this.character), this.GetPosition(target)).sqrMagnitude;
|
|
return !this.TargetOutOfSight(target) && (sqrMagnitude <= num3 && sqrMagnitude >= num4);
|
|
}
|
|
|
|
// Token: 0x06000173 RID: 371 RVA: 0x0001EE00 File Offset: 0x0001D000
|
|
public bool InAttackRangeObject(GameObject target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return false;
|
|
}
|
|
this.invRow = this.character.invRow1;
|
|
if (this.invRow == null)
|
|
{
|
|
return false;
|
|
}
|
|
float num = 0.1f;
|
|
float num2 = this.invRow._MeleeRangeEnd;
|
|
if (this.hasPowerDraw)
|
|
{
|
|
num2 += 30f;
|
|
}
|
|
Vector3 vector = target.transform.position;
|
|
DoorActions component = target.GetComponent<DoorActions>();
|
|
if (component)
|
|
{
|
|
vector = component.lockColliderPosition;
|
|
}
|
|
float num3 = (num2 * Records.x.nodeSize + this.character.attackRadius + 1f + num) * (num2 * Records.x.nodeSize + this.character.attackRadius + 1f + num);
|
|
float num4 = (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + 1f + num) * (this.invRow._MeleeRangeStart * Records.x.nodeSize + this.character.attackRadius + 1f + num);
|
|
if (num4 == num3 || this.invRow._MeleeRangeStart == 0f)
|
|
{
|
|
num4 = 0f;
|
|
}
|
|
float sqrMagnitude = this.character.SubtractVectors(this.GetPosition(this.character), vector).sqrMagnitude;
|
|
return !this.TargetOutOfSight(target) && (sqrMagnitude <= num3 && sqrMagnitude >= num4);
|
|
}
|
|
|
|
// Token: 0x06000174 RID: 372 RVA: 0x0001EF6C File Offset: 0x0001D16C
|
|
public bool TargetOutOfSight(GameObject target)
|
|
{
|
|
this.invRow = this.character.invRow1;
|
|
if (this.invRow._MainSkill != "Pole" && this.invRow._MainSkill != "Elixir" && !this.hasPowerDraw)
|
|
{
|
|
Vector3 vector = target.transform.position;
|
|
DoorActions component = target.GetComponent<DoorActions>();
|
|
if (component)
|
|
{
|
|
vector = component.lockColliderPosition;
|
|
}
|
|
RaycastHit raycastHit;
|
|
if (Physics.Linecast(this.character.raycastPosition, vector + new Vector3(0f, 4f, 0f), out raycastHit, Links.x.sightBlockers))
|
|
{
|
|
return !(raycastHit.collider.gameObject == target) && !(raycastHit.collider.gameObject == target.transform.parent.gameObject);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000175 RID: 373 RVA: 0x0001F064 File Offset: 0x0001D264
|
|
public bool TargetOutOfSight(Character target)
|
|
{
|
|
return this.invRow != null && (this.invRow._MainSkill != "Pole" && this.invRow._MainSkill != "Elixir" && !this.hasPowerDraw && Physics.Linecast(this.character.raycastPosition, target.AddVectorY(this.GetPosition(target), 2f), Links.x.sightBlockers));
|
|
}
|
|
|
|
// Token: 0x06000176 RID: 374 RVA: 0x0001F0E8 File Offset: 0x0001D2E8
|
|
public float AttackRange(Character target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return 10000f;
|
|
}
|
|
float num = 0.1f;
|
|
float num2 = this.invRow._MeleeRangeEnd;
|
|
if (this.hasPowerDraw)
|
|
{
|
|
num2 += 30f;
|
|
}
|
|
return (num2 * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num) * (num2 * Records.x.nodeSize + this.character.attackRadius + target.attackRadius + num);
|
|
}
|
|
|
|
// Token: 0x06000177 RID: 375 RVA: 0x0001F168 File Offset: 0x0001D368
|
|
public float AttackRangeObject(GameObject target)
|
|
{
|
|
if (!target)
|
|
{
|
|
return 10000f;
|
|
}
|
|
float num = 0.1f;
|
|
float num2 = this.invRow._MeleeRangeEnd;
|
|
if (this.hasPowerDraw)
|
|
{
|
|
num2 += 30f;
|
|
}
|
|
return (num2 * Records.x.nodeSize + this.character.attackRadius + 1f + num) * (num2 * Records.x.nodeSize + this.character.attackRadius + 1f + num);
|
|
}
|
|
|
|
// Token: 0x06000178 RID: 376 RVA: 0x0001F1E8 File Offset: 0x0001D3E8
|
|
public bool InItemRange(Character t, Character a)
|
|
{
|
|
float num = (1f * Records.x.nodeSize + a.attackRadius + t.attackRadius) * (1f * Records.x.nodeSize + a.attackRadius + a.attackRadius + t.attackRadius);
|
|
Vector3 position = this.GetPosition(a);
|
|
position.y = this.GetPosition(t).y;
|
|
return a.SubtractVectors(this.GetPosition(t), position).sqrMagnitude <= num;
|
|
}
|
|
|
|
// Token: 0x06000179 RID: 377 RVA: 0x0001F274 File Offset: 0x0001D474
|
|
public bool InSongRange(Character t, Character a)
|
|
{
|
|
float num = (this.songRange * Records.x.nodeSize + a.attackRadius + t.attackRadius) * (this.songRange * Records.x.nodeSize + a.attackRadius + a.attackRadius + t.attackRadius);
|
|
return a.SubtractVectors(this.GetPosition(t), this.GetPosition(a)).sqrMagnitude <= num;
|
|
}
|
|
|
|
// Token: 0x0600017A RID: 378 RVA: 0x0001F2EC File Offset: 0x0001D4EC
|
|
public bool InItemRange(Character a, Vector3 position)
|
|
{
|
|
float num = 1f;
|
|
float num2 = (num * Records.x.nodeSize + a.attackRadius) * (num * Records.x.nodeSize + a.attackRadius);
|
|
Vector3 position2 = this.GetPosition(a);
|
|
position2.y = position.y;
|
|
return a.SubtractVectors(position, position2).sqrMagnitude <= num2;
|
|
}
|
|
|
|
// Token: 0x0600017B RID: 379 RVA: 0x0001F352 File Offset: 0x0001D552
|
|
public Library.Abilities GetCurrentSpell()
|
|
{
|
|
return this.spell;
|
|
}
|
|
|
|
// Token: 0x0600017C RID: 380 RVA: 0x0001F35A File Offset: 0x0001D55A
|
|
public string GetCurrentSpellName()
|
|
{
|
|
return this.currentSpellName;
|
|
}
|
|
|
|
// Token: 0x0600017D RID: 381 RVA: 0x0001F362 File Offset: 0x0001D562
|
|
public Projectile GetFirstProjectile()
|
|
{
|
|
if (this.ProjectileCount() > 0)
|
|
{
|
|
return this.projectiles[0];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600017E RID: 382 RVA: 0x0001F37B File Offset: 0x0001D57B
|
|
public int ProjectileCount()
|
|
{
|
|
return this.projectiles.Count;
|
|
}
|
|
|
|
// Token: 0x0600017F RID: 383 RVA: 0x0001F388 File Offset: 0x0001D588
|
|
public Character GetTarget()
|
|
{
|
|
if (this.actionTargets.Count > 0)
|
|
{
|
|
return this.actionTargets[0];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000180 RID: 384 RVA: 0x0001F3A6 File Offset: 0x0001D5A6
|
|
public Vector3 GetPosition(Character target)
|
|
{
|
|
return target.tr.position;
|
|
}
|
|
|
|
// Token: 0x06000181 RID: 385 RVA: 0x0001F3B4 File Offset: 0x0001D5B4
|
|
public void QueueIcon(bool state)
|
|
{
|
|
if (this.character.party && this.character.portrait)
|
|
{
|
|
this.character.portrait.QueueIcon(state);
|
|
if (this.selectedTarget != null && this.character.selected && !Records.x.paused)
|
|
{
|
|
this.selectedTarget.isTarget = true;
|
|
this.selectedTarget.CircleAnimation("");
|
|
}
|
|
if (this.selectedTargetInteractive != null)
|
|
{
|
|
bool selected = this.character.selected;
|
|
}
|
|
if (this.actionTargets.Count > 0 && this.character.selected)
|
|
{
|
|
for (int i = 0; i < this.actionTargets.Count; i++)
|
|
{
|
|
if (this.actionTargets[i] && this.actionTargets[i].npc && !Records.x.paused)
|
|
{
|
|
this.actionTargets[i].isTarget = true;
|
|
this.actionTargets[i].CircleAnimation("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000182 RID: 386 RVA: 0x0001F4DF File Offset: 0x0001D6DF
|
|
public int TargetCount()
|
|
{
|
|
return this.actionTargets.Count;
|
|
}
|
|
|
|
// Token: 0x06000183 RID: 387 RVA: 0x0001F4EC File Offset: 0x0001D6EC
|
|
public bool HasTarget(Character t)
|
|
{
|
|
return this.character.selected && (this.selectedTarget == t || (this.selectedTarget == null && this.actionTargets.Contains(t)));
|
|
}
|
|
|
|
// Token: 0x06000184 RID: 388 RVA: 0x0001F52C File Offset: 0x0001D72C
|
|
public bool ActionTargetsContains(Character t)
|
|
{
|
|
return this.actionTargets.Contains(t);
|
|
}
|
|
|
|
// Token: 0x06000185 RID: 389 RVA: 0x0001F53F File Offset: 0x0001D73F
|
|
public bool DamageTargets(Character t)
|
|
{
|
|
return this.targets.Contains(t);
|
|
}
|
|
|
|
// Token: 0x06000186 RID: 390 RVA: 0x0001F554 File Offset: 0x0001D754
|
|
public bool HasMove()
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < this.current.Count; i++)
|
|
{
|
|
if (this.current[i].Contains("Move"))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000187 RID: 391 RVA: 0x0001F594 File Offset: 0x0001D794
|
|
public float GetActionSpeed(string type)
|
|
{
|
|
float num;
|
|
if (type != "Spell")
|
|
{
|
|
num = 0.1f;
|
|
}
|
|
else if (Records.x.banquetIsle || this.character.stats.semizenMagic)
|
|
{
|
|
num = 2f;
|
|
}
|
|
else
|
|
{
|
|
num = 0.001f;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000188 RID: 392 RVA: 0x0001F5EC File Offset: 0x0001D7EC
|
|
public void ClearMoves()
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < this.current.Count; i++)
|
|
{
|
|
if (this.current[i].Contains("Move"))
|
|
{
|
|
this.current[i] = "empty";
|
|
flag = true;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
this.current.RemoveAll((string item) => item == "empty");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000189 RID: 393 RVA: 0x0001F66A File Offset: 0x0001D86A
|
|
private bool IsInstrument(string type)
|
|
{
|
|
return type == "Flute" || type == "Pipe" || type == "Drum" || type == "Horn";
|
|
}
|
|
|
|
// Token: 0x0600018A RID: 394 RVA: 0x0001F6A9 File Offset: 0x0001D8A9
|
|
private bool IsWord(string type)
|
|
{
|
|
return type == "Melee" || type == "Range" || type == "Defense";
|
|
}
|
|
|
|
// Token: 0x0600018B RID: 395 RVA: 0x0001F6DC File Offset: 0x0001D8DC
|
|
public GraphNode GetInteractiveObjectNode(GameObject obj)
|
|
{
|
|
this.nodeConstraint.constrainWalkability = true;
|
|
this.nodeConstraint.walkable = true;
|
|
this.nodeConstraint.constrainTags = false;
|
|
this.nodeConstraint.checkCircleID = 0;
|
|
this.nodeConstraint.passID = 0;
|
|
this.nodeConstraint.passID2 = 0;
|
|
this.nodeConstraint.checkConnections = 0;
|
|
this.nodeConstraint.constrainPenalty = 0;
|
|
this.nodeConstraint.constrainToArea = -1;
|
|
return AstarPath.active.GetNearest(obj.transform.position, this.nodeConstraint).node;
|
|
}
|
|
|
|
// Token: 0x0400028B RID: 651
|
|
[Header("ACTIONS")]
|
|
public List<string> current = new List<string>();
|
|
|
|
// Token: 0x0400028C RID: 652
|
|
public Character character;
|
|
|
|
// Token: 0x0400028D RID: 653
|
|
private StringFast str = new StringFast(64);
|
|
|
|
// Token: 0x0400028E RID: 654
|
|
public AttackAI ai;
|
|
|
|
// Token: 0x0400028F RID: 655
|
|
public GraphNode targetMovePosition;
|
|
|
|
// Token: 0x04000290 RID: 656
|
|
public Character currentTarget;
|
|
|
|
// Token: 0x04000291 RID: 657
|
|
public List<int> hits = new List<int>();
|
|
|
|
// Token: 0x04000292 RID: 658
|
|
public List<Character> targets = new List<Character>();
|
|
|
|
// Token: 0x04000293 RID: 659
|
|
public List<GameObject> targetsInteractive = new List<GameObject>();
|
|
|
|
// Token: 0x04000294 RID: 660
|
|
public List<string> hitText = new List<string>();
|
|
|
|
// Token: 0x04000295 RID: 661
|
|
public List<string> attackTotal = new List<string>();
|
|
|
|
// Token: 0x04000296 RID: 662
|
|
public List<string> defenseTotal = new List<string>();
|
|
|
|
// Token: 0x04000297 RID: 663
|
|
public List<float> damages = new List<float>();
|
|
|
|
// Token: 0x04000298 RID: 664
|
|
public List<string> songsWordsQueued = new List<string>();
|
|
|
|
// Token: 0x04000299 RID: 665
|
|
public List<bool> songsWordsQueuedTrigger = new List<bool>();
|
|
|
|
// Token: 0x0400029A RID: 666
|
|
public List<GameObject[]> queuedSongWordsTargets = new List<GameObject[]>();
|
|
|
|
// Token: 0x0400029B RID: 667
|
|
private GameObject[] saveTargets;
|
|
|
|
// Token: 0x0400029C RID: 668
|
|
private GameObject[] doSaveTargets;
|
|
|
|
// Token: 0x0400029D RID: 669
|
|
public List<Projectile> projectiles = new List<Projectile>();
|
|
|
|
// Token: 0x0400029E RID: 670
|
|
public string currentAction;
|
|
|
|
// Token: 0x0400029F RID: 671
|
|
public bool pocketQueued;
|
|
|
|
// Token: 0x040002A0 RID: 672
|
|
public bool pocketAttack;
|
|
|
|
// Token: 0x040002A1 RID: 673
|
|
public bool heavyAttack;
|
|
|
|
// Token: 0x040002A2 RID: 674
|
|
public bool lightAttack;
|
|
|
|
// Token: 0x040002A3 RID: 675
|
|
public bool specialAttack1;
|
|
|
|
// Token: 0x040002A4 RID: 676
|
|
public bool specialAttack2;
|
|
|
|
// Token: 0x040002A5 RID: 677
|
|
public bool specialAttack3;
|
|
|
|
// Token: 0x040002A6 RID: 678
|
|
public bool charming;
|
|
|
|
// Token: 0x040002A7 RID: 679
|
|
public bool checkingMultiTarget;
|
|
|
|
// Token: 0x040002A8 RID: 680
|
|
private List<TimedBreakable> timedBreakables;
|
|
|
|
// Token: 0x040002A9 RID: 681
|
|
private List<BreakableActions> diaBreakables;
|
|
|
|
// Token: 0x040002AA RID: 682
|
|
private List<DoorActions> diaDoors;
|
|
|
|
// Token: 0x040002AB RID: 683
|
|
private List<ChestActions> diaChests;
|
|
|
|
// Token: 0x040002AC RID: 684
|
|
private List<TileEffects> currentTileEffects;
|
|
|
|
// Token: 0x040002AD RID: 685
|
|
public bool endActionsAfterTurn;
|
|
|
|
// Token: 0x040002AE RID: 686
|
|
public bool choosingTurn;
|
|
|
|
// Token: 0x040002AF RID: 687
|
|
public float useSpeed = 0.5f;
|
|
|
|
// Token: 0x040002B0 RID: 688
|
|
public bool queueInterrupt;
|
|
|
|
// Token: 0x040002B1 RID: 689
|
|
public bool readyToAttack;
|
|
|
|
// Token: 0x040002B2 RID: 690
|
|
public bool combatStartPassives;
|
|
|
|
// Token: 0x040002B3 RID: 691
|
|
public bool repathing;
|
|
|
|
// Token: 0x040002B4 RID: 692
|
|
public bool hasTarget;
|
|
|
|
// Token: 0x040002B5 RID: 693
|
|
public bool hasWaypoint;
|
|
|
|
// Token: 0x040002B6 RID: 694
|
|
public Character selectedTarget;
|
|
|
|
// Token: 0x040002B7 RID: 695
|
|
public Character currentlyTargeting;
|
|
|
|
// Token: 0x040002B8 RID: 696
|
|
public GameObject selectedTargetInteractive;
|
|
|
|
// Token: 0x040002B9 RID: 697
|
|
public GameObject selectedAITargetInteractive;
|
|
|
|
// Token: 0x040002BA RID: 698
|
|
public GameObject prevSelectedTargetInteractive;
|
|
|
|
// Token: 0x040002BB RID: 699
|
|
public GameObject rallyInteractiveTarget;
|
|
|
|
// Token: 0x040002BC RID: 700
|
|
public bool hasPowerDraw;
|
|
|
|
// Token: 0x040002BD RID: 701
|
|
private List<GraphNode> noUse;
|
|
|
|
// Token: 0x040002BE RID: 702
|
|
private List<Character> characters;
|
|
|
|
// Token: 0x040002BF RID: 703
|
|
public Library.Inventory invRow;
|
|
|
|
// Token: 0x040002C0 RID: 704
|
|
public string currentSpellName;
|
|
|
|
// Token: 0x040002C1 RID: 705
|
|
public string spellSkill;
|
|
|
|
// Token: 0x040002C2 RID: 706
|
|
public int currentHand;
|
|
|
|
// Token: 0x040002C3 RID: 707
|
|
public bool firstAttack;
|
|
|
|
// Token: 0x040002C4 RID: 708
|
|
public bool secondAttack;
|
|
|
|
// Token: 0x040002C5 RID: 709
|
|
public int secondAttackIndex;
|
|
|
|
// Token: 0x040002C6 RID: 710
|
|
public float effectSeverity;
|
|
|
|
// Token: 0x040002C7 RID: 711
|
|
public float songRange;
|
|
|
|
// Token: 0x040002C8 RID: 712
|
|
public bool selectedWeapon;
|
|
|
|
// Token: 0x040002C9 RID: 713
|
|
public bool selectedAmmo;
|
|
|
|
// Token: 0x040002CA RID: 714
|
|
public bool movingToPlaySong;
|
|
|
|
// Token: 0x040002CB RID: 715
|
|
public bool playingMusic;
|
|
|
|
// Token: 0x040002CC RID: 716
|
|
public Library.Abilities moveToPlaySongAbility;
|
|
|
|
// Token: 0x040002CD RID: 717
|
|
public bool cannotInterrupt;
|
|
|
|
// Token: 0x040002CE RID: 718
|
|
private List<string> words;
|
|
|
|
// Token: 0x040002CF RID: 719
|
|
private Library.Inventory ammoRow;
|
|
|
|
// Token: 0x040002D0 RID: 720
|
|
private Library.Inventory instrumentRow;
|
|
|
|
// Token: 0x040002D1 RID: 721
|
|
public bool canEndAttackTime;
|
|
|
|
// Token: 0x040002D2 RID: 722
|
|
private bool charging;
|
|
|
|
// Token: 0x040002D3 RID: 723
|
|
private bool pinning;
|
|
|
|
// Token: 0x040002D4 RID: 724
|
|
private bool doSlowTime;
|
|
|
|
// Token: 0x040002D5 RID: 725
|
|
private bool addDamageBonus;
|
|
|
|
// Token: 0x040002D6 RID: 726
|
|
private bool reroll;
|
|
|
|
// Token: 0x040002D7 RID: 727
|
|
private float damageBonus;
|
|
|
|
// Token: 0x040002D8 RID: 728
|
|
private float effectBonus;
|
|
|
|
// Token: 0x040002D9 RID: 729
|
|
private float evasionBonus;
|
|
|
|
// Token: 0x040002DA RID: 730
|
|
public bool doBubbleAttack;
|
|
|
|
// Token: 0x040002DB RID: 731
|
|
public bool bubbleAttackStopsGameplay;
|
|
|
|
// Token: 0x040002DC RID: 732
|
|
public Character bubbleTarget;
|
|
|
|
// Token: 0x040002DD RID: 733
|
|
[Header("ITEM ACTIONS")]
|
|
public bool givingItem;
|
|
|
|
// Token: 0x040002DE RID: 734
|
|
public int givingItemID;
|
|
|
|
// Token: 0x040002DF RID: 735
|
|
public Character giveCharacter;
|
|
|
|
// Token: 0x040002E0 RID: 736
|
|
public bool movingToPin;
|
|
|
|
// Token: 0x040002E1 RID: 737
|
|
public Character pinTarget;
|
|
|
|
// Token: 0x040002E2 RID: 738
|
|
public bool usingItem;
|
|
|
|
// Token: 0x040002E3 RID: 739
|
|
public int usingItemID;
|
|
|
|
// Token: 0x040002E4 RID: 740
|
|
public bool pickingUpItem;
|
|
|
|
// Token: 0x040002E5 RID: 741
|
|
public Item pickupItem;
|
|
|
|
// Token: 0x040002E6 RID: 742
|
|
public int spellScrollID;
|
|
|
|
// Token: 0x040002E7 RID: 743
|
|
public Library.Inventory spellScroll;
|
|
|
|
// Token: 0x040002E8 RID: 744
|
|
[Header("SPELLS")]
|
|
public bool channeling;
|
|
|
|
// Token: 0x040002E9 RID: 745
|
|
public TileEffects currentTileEffect;
|
|
|
|
// Token: 0x040002EA RID: 746
|
|
public bool vineComplete;
|
|
|
|
// Token: 0x040002EB RID: 747
|
|
public Library.Abilities spell;
|
|
|
|
// Token: 0x040002EC RID: 748
|
|
public Library.Abilities utility;
|
|
|
|
// Token: 0x040002ED RID: 749
|
|
public SpellVine vine;
|
|
|
|
// Token: 0x040002EE RID: 750
|
|
public float channelingSpeed = 4f;
|
|
|
|
// Token: 0x040002EF RID: 751
|
|
public int spellIndex;
|
|
|
|
// Token: 0x040002F0 RID: 752
|
|
public Library.Pagan paganRow;
|
|
|
|
// Token: 0x040002F1 RID: 753
|
|
public GameObject spellCasterFX;
|
|
|
|
// Token: 0x040002F2 RID: 754
|
|
public GameObject spellCasterTargetFX;
|
|
|
|
// Token: 0x040002F3 RID: 755
|
|
public GameObject spellCasterTargetFailFX;
|
|
|
|
// Token: 0x040002F4 RID: 756
|
|
public GameObject spellWaveFX;
|
|
|
|
// Token: 0x040002F5 RID: 757
|
|
public GameObject chargeUpFX;
|
|
|
|
// Token: 0x040002F6 RID: 758
|
|
public int chargeUpNum;
|
|
|
|
// Token: 0x040002F7 RID: 759
|
|
public bool castingSpell;
|
|
|
|
// Token: 0x040002F8 RID: 760
|
|
public GraphNode spellNode;
|
|
|
|
// Token: 0x040002F9 RID: 761
|
|
[Header("TARGETING")]
|
|
public List<Character> actionTargets = new List<Character>();
|
|
|
|
// Token: 0x040002FA RID: 762
|
|
public List<GameObject> actionInteractives = new List<GameObject>();
|
|
|
|
// Token: 0x040002FB RID: 763
|
|
public int rangeIndex;
|
|
|
|
// Token: 0x040002FC RID: 764
|
|
public Character savedEnemy;
|
|
|
|
// Token: 0x040002FD RID: 765
|
|
[Header("TACTICS")]
|
|
public float startSearchTime;
|
|
|
|
// Token: 0x040002FE RID: 766
|
|
private List<Character> allCharacters;
|
|
|
|
// Token: 0x040002FF RID: 767
|
|
private List<Character> combatCharacters;
|
|
|
|
// Token: 0x04000300 RID: 768
|
|
private List<Character> multiHitCharacters = new List<Character>();
|
|
|
|
// Token: 0x04000301 RID: 769
|
|
public int moveAttempts;
|
|
|
|
// Token: 0x04000302 RID: 770
|
|
public List<Library.Abilities> abilities = new List<Library.Abilities>();
|
|
|
|
// Token: 0x04000303 RID: 771
|
|
[Header("PATHFINDING")]
|
|
public bool closingGap;
|
|
|
|
// Token: 0x04000304 RID: 772
|
|
[Header("PATHFINDING")]
|
|
public bool closingGapInteract;
|
|
|
|
// Token: 0x04000305 RID: 773
|
|
public IEnumerator pathToCharacterCoroutine;
|
|
|
|
// Token: 0x04000306 RID: 774
|
|
public IEnumerator instrumentCoroutine;
|
|
|
|
// Token: 0x04000307 RID: 775
|
|
public IEnumerator wordCoroutine;
|
|
|
|
// Token: 0x04000308 RID: 776
|
|
public IEnumerator startAttackCoroutine;
|
|
|
|
// Token: 0x04000309 RID: 777
|
|
public IEnumerator actionCoroutine;
|
|
|
|
// Token: 0x0400030A RID: 778
|
|
public IEnumerator spellCoroutine;
|
|
|
|
// Token: 0x0400030B RID: 779
|
|
public IEnumerator checkAbilityQueues;
|
|
|
|
// Token: 0x0400030C RID: 780
|
|
public IEnumerator miniCoroutine;
|
|
|
|
// Token: 0x0400030D RID: 781
|
|
private NNConstraint nodeConstraint = new NNConstraint();
|
|
|
|
// Token: 0x0400030E RID: 782
|
|
private List<GraphNode> tempPath;
|
|
|
|
// Token: 0x0400030F RID: 783
|
|
[Header("MISC")]
|
|
public Animator blood;
|
|
|
|
// Token: 0x04000310 RID: 784
|
|
private IEnumerator castCompleteCoroutine;
|
|
|
|
// Token: 0x04000311 RID: 785
|
|
private IEnumerator pocketAttackRoutine;
|
|
|
|
// Token: 0x04000312 RID: 786
|
|
private List<Character> party;
|
|
|
|
// Token: 0x04000313 RID: 787
|
|
private WaitForSeconds delayShort = new WaitForSeconds(0.001f);
|
|
|
|
// Token: 0x04000314 RID: 788
|
|
private WaitForSeconds delayHalfSecond = new WaitForSeconds(0.5f);
|
|
|
|
// Token: 0x04000315 RID: 789
|
|
private WaitForSeconds delaySecond = new WaitForSeconds(1f);
|
|
|
|
// Token: 0x04000316 RID: 790
|
|
public bool rolling;
|
|
|
|
// Token: 0x04000317 RID: 791
|
|
public bool quickAttack;
|
|
|
|
// Token: 0x04000318 RID: 792
|
|
private float lastMainActionTime;
|
|
|
|
// Token: 0x04000319 RID: 793
|
|
private AnimatorClipInfo[] m_CurrentClipInfo;
|
|
|
|
// Token: 0x0400031A RID: 794
|
|
private AnimationEvent[] events;
|
|
|
|
// Token: 0x0400031B RID: 795
|
|
private bool blocked;
|
|
}
|