591 lines
15 KiB
C#
591 lines
15 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class magicSpellActionSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool magicSystemEnabled = true;
|
|
|
|
public bool resetIndexIfNotAttackAfterDelay;
|
|
|
|
public float delayToResetIndexAfterAttack;
|
|
|
|
public float generalEnergyUseMultiplier = 1;
|
|
|
|
[Space]
|
|
[Header ("Attack Selection Settings")]
|
|
[Space]
|
|
|
|
public bool useAttackTypes;
|
|
|
|
public bool useRandomAttackIndex;
|
|
|
|
public bool useEnergyOnMagic;
|
|
|
|
public bool useNextMagicSpellOnListForNextAttackEnabled = true;
|
|
|
|
[Space]
|
|
|
|
public bool avoidActivateAbilityIfAnotherInProcessEnabled = true;
|
|
|
|
[Space]
|
|
[Header ("Movement Settings")]
|
|
[Space]
|
|
|
|
public bool useStrafeMode;
|
|
public int strafeIDUsed;
|
|
public bool setPreviousStrafeModeOnDisableMagicSystem;
|
|
|
|
public bool activateStrafeModeOnLockOnTargetActive;
|
|
public bool deactivateStrafeModeOnLockOnTargetDeactivate;
|
|
|
|
public bool toggleStrafeModeIfRunningActive;
|
|
|
|
public bool setNewCrouchID;
|
|
public int crouchIDUsed;
|
|
|
|
|
|
[Space]
|
|
[Header ("Magic Action List Settings")]
|
|
[Space]
|
|
|
|
public List<magicSpellActionInfo> magicSpellActionInfoList = new List<magicSpellActionInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
[Space]
|
|
|
|
public bool previousStrafeMode;
|
|
public int previousStrafeID = -1;
|
|
|
|
public bool magicSystemActive;
|
|
|
|
[Space]
|
|
|
|
public int currentAttackIndex;
|
|
|
|
public bool attackInProcess;
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnAttack;
|
|
public UnityEvent eventOnAttackStart;
|
|
public UnityEvent eventOnAttackEnd;
|
|
|
|
public bool useEventsOnEnableDisableMagicSystem;
|
|
public UnityEvent eventOnEnableMagicSystem;
|
|
public UnityEvent eventOnDisableMagicSystem;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public otherPowers mainOtherPowers;
|
|
|
|
public playerController mainPlayerController;
|
|
|
|
public remoteEventSystem mainRemoteEventSystem;
|
|
|
|
|
|
magicSpellActionInfo currentMagicSpellActionInfo;
|
|
|
|
float lastTimeAttackActive;
|
|
|
|
float lastTimeAttackComplete;
|
|
|
|
Coroutine magicCoroutine;
|
|
|
|
Coroutine magicEventCoroutine;
|
|
|
|
|
|
public void enableOrDisableMagicSystem (bool state)
|
|
{
|
|
if (!magicSystemEnabled) {
|
|
return;
|
|
}
|
|
|
|
bool previouslyActive = magicSystemActive;
|
|
|
|
magicSystemActive = state;
|
|
|
|
checkEventsOnEnableDisableMagicSystem (magicSystemActive);
|
|
|
|
mainOtherPowers.enableOrDisablePowersInfoPanel (magicSystemActive);
|
|
|
|
if (magicSystemActive) {
|
|
checkMagicStateAtStart ();
|
|
|
|
} else {
|
|
if (previouslyActive) {
|
|
checkMagicStateAtEnd ();
|
|
|
|
resumeState ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void useMagicSpell (string magicTypeName)
|
|
{
|
|
if (showDebugPrint) {
|
|
print ("input activated");
|
|
}
|
|
|
|
if (!magicSystemActive) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (currentAttackIndex > 0 && currentMagicSpellActionInfo != null) {
|
|
// print (currentAttackInfo.minDelayBeforeNextAttack);
|
|
|
|
if (Time.time < lastTimeAttackActive + currentMagicSpellActionInfo.minDelayBeforeNextAttack) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (attackInProcess && avoidActivateAbilityIfAnotherInProcessEnabled) {
|
|
if (showDebugPrint) {
|
|
print ("attack in process, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (resetIndexIfNotAttackAfterDelay && !attackInProcess) {
|
|
if (Time.time > lastTimeAttackComplete + delayToResetIndexAfterAttack) {
|
|
// print ("reset attack index");
|
|
|
|
currentAttackIndex = 0;
|
|
}
|
|
}
|
|
|
|
if (useAttackTypes) {
|
|
if (showDebugPrint) {
|
|
print ("attack all conditions checked");
|
|
}
|
|
|
|
int numberOfAttacksSameType = 0;
|
|
|
|
int numberOfAttacksAvailable = magicSpellActionInfoList.Count;
|
|
|
|
for (int i = 0; i < numberOfAttacksAvailable; i++) {
|
|
if (magicSpellActionInfoList [i].magicTypeName.Equals (magicTypeName) &&
|
|
magicSpellActionInfoList [i].magicEnabled) {
|
|
numberOfAttacksSameType++;
|
|
}
|
|
}
|
|
|
|
if (numberOfAttacksSameType == 1) {
|
|
bool cancelAttack = false;
|
|
|
|
if (attackInProcess &&
|
|
currentMagicSpellActionInfo != null &&
|
|
currentMagicSpellActionInfo.magicTypeName.Equals (magicTypeName)) {
|
|
cancelAttack = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("same attack type already in process with just 1 type configured, so " +
|
|
"the system is trying to activate the same magic attack which is already in process");
|
|
}
|
|
}
|
|
|
|
if (Time.time < lastTimeAttackComplete + 0.4f) {
|
|
cancelAttack = true;
|
|
}
|
|
|
|
if (cancelAttack) {
|
|
if (showDebugPrint) {
|
|
print ("just one attack type available and it is in process, avoiding to play it again");
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool attackFound = false;
|
|
|
|
setNextAttackIndex ();
|
|
|
|
while (!attackFound) {
|
|
currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
|
|
|
|
// print (currentAttackInfo.magicTypeName + " " + magicTypeName);
|
|
|
|
if (currentMagicSpellActionInfo.magicTypeName.Equals (magicTypeName) &&
|
|
currentMagicSpellActionInfo.magicEnabled) {
|
|
|
|
attackFound = true;
|
|
} else {
|
|
setNextAttackIndex ();
|
|
|
|
numberOfAttacksAvailable--;
|
|
|
|
if (numberOfAttacksAvailable < 0) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
bool attackFound = false;
|
|
|
|
int numberOfAttacksAvailable = magicSpellActionInfoList.Count;
|
|
|
|
while (!attackFound) {
|
|
currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
|
|
|
|
// print (currentAttackInfo.magicTypeName + " " + magicTypeName);
|
|
|
|
if (currentMagicSpellActionInfo.magicEnabled) {
|
|
attackFound = true;
|
|
} else {
|
|
setNextAttackIndex ();
|
|
|
|
numberOfAttacksAvailable--;
|
|
|
|
if (numberOfAttacksAvailable < 0) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
currentMagicSpellActionInfo = magicSpellActionInfoList [currentAttackIndex];
|
|
}
|
|
|
|
if (useEnergyOnMagic) {
|
|
float energyUsed = currentMagicSpellActionInfo.energyAmountUsed * generalEnergyUseMultiplier;
|
|
|
|
if (energyUsed > 0) {
|
|
mainOtherPowers.usePowerBar ((energyUsed));
|
|
}
|
|
}
|
|
|
|
// print ("Magic used " + currentMagicSpellActionInfo.Name);
|
|
|
|
stopActivateMagicSpellAction ();
|
|
|
|
magicCoroutine = StartCoroutine (activateMagicSpellAction ());
|
|
|
|
stopActivateMagicSpellEvent ();
|
|
|
|
magicEventCoroutine = StartCoroutine (activateMagicSpellEvent ());
|
|
|
|
if (!useAttackTypes && useNextMagicSpellOnListForNextAttackEnabled) {
|
|
setNextAttackIndex ();
|
|
}
|
|
}
|
|
|
|
public void enableMagicByName (string magicName)
|
|
{
|
|
enableOrDisableMagicByName (magicName, true);
|
|
}
|
|
|
|
public void disableMagicByName (string magicName)
|
|
{
|
|
enableOrDisableMagicByName (magicName, false);
|
|
}
|
|
|
|
public void enableOrDisableMagicByName (string magicName, bool state)
|
|
{
|
|
int weaponIdex = magicSpellActionInfoList.FindIndex (s => s.Name.Equals (magicName));
|
|
|
|
if (weaponIdex > -1) {
|
|
magicSpellActionInfoList [weaponIdex].magicEnabled = state;
|
|
}
|
|
}
|
|
|
|
public void setNextAttackIndex ()
|
|
{
|
|
if (useRandomAttackIndex) {
|
|
currentAttackIndex = Random.Range (0, magicSpellActionInfoList.Count - 1);
|
|
} else {
|
|
currentAttackIndex++;
|
|
|
|
if (currentAttackIndex >= magicSpellActionInfoList.Count) {
|
|
currentAttackIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setPreviousAttackIndex ()
|
|
{
|
|
if (useRandomAttackIndex) {
|
|
currentAttackIndex = Random.Range (0, magicSpellActionInfoList.Count - 1);
|
|
} else {
|
|
currentAttackIndex--;
|
|
|
|
if (currentAttackIndex <= 0) {
|
|
currentAttackIndex = magicSpellActionInfoList.Count - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopActivateMagicSpellAction ()
|
|
{
|
|
if (magicCoroutine != null) {
|
|
StopCoroutine (magicCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator activateMagicSpellAction ()
|
|
{
|
|
checkEventsOnAttack (true);
|
|
|
|
lastTimeAttackActive = Time.time;
|
|
|
|
attackInProcess = true;
|
|
|
|
if (currentMagicSpellActionInfo.useRemoteEvent) {
|
|
for (int i = 0; i < currentMagicSpellActionInfo.remoteEventNameList.Count; i++) {
|
|
mainRemoteEventSystem.callRemoteEvent (currentMagicSpellActionInfo.remoteEventNameList [i]);
|
|
}
|
|
}
|
|
|
|
if (currentMagicSpellActionInfo.useCustomAction) {
|
|
mainPlayerController.activateCustomAction (currentMagicSpellActionInfo.customActionName);
|
|
|
|
if (showDebugPrint) {
|
|
print ("attack activated :" + mainPlayerController.getCurrentActionName ());
|
|
}
|
|
}
|
|
|
|
yield return new WaitForSeconds (currentMagicSpellActionInfo.attackDuration);
|
|
|
|
lastTimeAttackComplete = Time.time;
|
|
|
|
resumeState ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("end of attack");
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
public void stopActivateMagicSpellEvent ()
|
|
{
|
|
if (magicEventCoroutine != null) {
|
|
StopCoroutine (magicEventCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator activateMagicSpellEvent ()
|
|
{
|
|
yield return new WaitForSeconds (currentMagicSpellActionInfo.delayToActiveEvent);
|
|
|
|
currentMagicSpellActionInfo.eventOnMagicUsed.Invoke ();
|
|
}
|
|
|
|
public void resumeState ()
|
|
{
|
|
attackInProcess = false;
|
|
|
|
checkEventsOnAttack (false);
|
|
}
|
|
|
|
public void checkEventsOnAttack (bool state)
|
|
{
|
|
if (useEventsOnAttack) {
|
|
if (state) {
|
|
eventOnAttackStart.Invoke ();
|
|
} else {
|
|
eventOnAttackEnd.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkMagicStateAtStart ()
|
|
{
|
|
previousStrafeMode = mainPlayerController.isStrafeModeActive ();
|
|
|
|
if (previousStrafeID == -1) {
|
|
previousStrafeID = mainPlayerController.getCurrentStrafeIDValue ();
|
|
}
|
|
|
|
if (useStrafeMode) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (true);
|
|
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("checking strafe mode when returning thrown weapon");
|
|
}
|
|
|
|
previousStrafeMode = false;
|
|
|
|
previousStrafeID = -1;
|
|
|
|
mainPlayerController.activateOrDeactivateStrafeMode (false);
|
|
}
|
|
|
|
if (toggleStrafeModeIfRunningActive) {
|
|
mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (true);
|
|
}
|
|
|
|
mainPlayerController.setCurrentStrafeIDValue (strafeIDUsed);
|
|
|
|
if (setNewCrouchID) {
|
|
mainPlayerController.setCurrentCrouchIDValue (crouchIDUsed);
|
|
}
|
|
}
|
|
|
|
public void checkMagicStateAtEnd ()
|
|
{
|
|
if (setPreviousStrafeModeOnDisableMagicSystem) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (previousStrafeMode);
|
|
} else {
|
|
mainPlayerController.setOriginalLookAlwaysInCameraDirectionState ();
|
|
}
|
|
|
|
if (previousStrafeID != -1) {
|
|
mainPlayerController.setCurrentStrafeIDValue (previousStrafeID);
|
|
}
|
|
|
|
if (toggleStrafeModeIfRunningActive) {
|
|
mainPlayerController.setDisableStrafeModeExternallyIfIncreaseWalkSpeedActiveState (false);
|
|
}
|
|
|
|
previousStrafeMode = false;
|
|
|
|
previousStrafeID = -1;
|
|
|
|
if (setNewCrouchID) {
|
|
mainPlayerController.setCurrentCrouchIDValue (0);
|
|
}
|
|
}
|
|
|
|
public void checkLookAtTargetActiveState ()
|
|
{
|
|
if (magicSystemActive) {
|
|
bool lookingAtTarget = mainPlayerController.isPlayerLookingAtTarget ();
|
|
|
|
if (lookingAtTarget) {
|
|
if (activateStrafeModeOnLockOnTargetActive) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (true);
|
|
|
|
}
|
|
} else {
|
|
if (activateStrafeModeOnLockOnTargetActive) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (false);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkLookAtTargetDeactivateState ()
|
|
{
|
|
if (activateStrafeModeOnLockOnTargetActive) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (false);
|
|
}
|
|
}
|
|
|
|
public bool canUseInput ()
|
|
{
|
|
if (!playerIsBusy ()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool playerIsBusy ()
|
|
{
|
|
if (mainPlayerController.isUsingDevice ()) {
|
|
return true;
|
|
}
|
|
|
|
if (mainPlayerController.isTurnBasedCombatActionActive ()) {
|
|
return false;
|
|
}
|
|
|
|
if (mainPlayerController.isUsingSubMenu ()) {
|
|
return true;
|
|
}
|
|
|
|
if (mainPlayerController.isPlayerMenuActive ()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void checkEventsOnEnableDisableMagicSystem (bool state)
|
|
{
|
|
if (useEventsOnEnableDisableMagicSystem) {
|
|
if (state) {
|
|
eventOnEnableMagicSystem.Invoke ();
|
|
} else {
|
|
eventOnDisableMagicSystem.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputSetNextOrPreviousAttackIndex (bool useNextAttack)
|
|
{
|
|
if (!magicSystemActive) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (useNextAttack) {
|
|
setNextAttackIndex ();
|
|
} else {
|
|
setPreviousAttackIndex ();
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class magicSpellActionInfo
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string Name;
|
|
|
|
public bool magicEnabled = true;
|
|
|
|
public float energyAmountUsed;
|
|
|
|
public string magicTypeName;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public float attackDuration;
|
|
|
|
public float minDelayBeforeNextAttack;
|
|
|
|
public bool useCustomAction;
|
|
|
|
public string customActionName;
|
|
|
|
[Space]
|
|
[Header ("Remote Events Settings")]
|
|
[Space]
|
|
|
|
public bool useRemoteEvent;
|
|
|
|
public List<string> remoteEventNameList = new List<string> ();
|
|
|
|
public float delayToActiveEvent;
|
|
|
|
public UnityEvent eventOnMagicUsed;
|
|
}
|
|
}
|