2082 lines
64 KiB
C#
2082 lines
64 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.UI;
|
|
using System.IO;
|
|
using System;
|
|
using GameKitController.Audio;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
|
|
public class playerAbilitiesUISystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool openMenuEnabled = true;
|
|
|
|
public bool abilityListManagerEnabled;
|
|
|
|
public int numberOfAbilitySlots = 8;
|
|
|
|
public bool selectAbilityOnMenuClose;
|
|
|
|
public bool useDpadPanel = true;
|
|
|
|
public float timeToShowAbilitySlotsWheel = 1;
|
|
|
|
public bool useBlurUIPanel = true;
|
|
|
|
public bool slowDownTimeWhenMenuActive;
|
|
public float timeScaleWhenMenuActive;
|
|
|
|
public Vector2 abilityWheelMenuRotationRange = new Vector2 (5f, 3f);
|
|
public float rotationHUDSpeed = 20;
|
|
|
|
public bool showOnlyEnabledAbilitySlots;
|
|
|
|
[Space]
|
|
[Header ("Ability Slot Settings")]
|
|
[Space]
|
|
|
|
public bool changeCurrentSlotSize;
|
|
public float changeCurrentSlotSpeed;
|
|
public float changeCurrentSlotMultiplier;
|
|
public float distanceFromCenterToSelectAbility = 10;
|
|
|
|
[Space]
|
|
[Header ("Slot Position And Size Settings")]
|
|
[Space]
|
|
|
|
public bool useSlotsChangeScale;
|
|
public int numberOfSlotsToChangeScale;
|
|
public float slotScale;
|
|
public float minSlotScale = 0.3f;
|
|
public float slotHeightOffset;
|
|
|
|
public float wheelRadius = 880;
|
|
|
|
[Space]
|
|
[Header ("Wheel And Scroll Rect Settings")]
|
|
[Space]
|
|
|
|
public bool useWheelMenu = true;
|
|
|
|
[Space]
|
|
[Header ("Sound Settings")]
|
|
[Space]
|
|
|
|
public bool useSoundOnSlot;
|
|
public AudioClip soundEffect;
|
|
public AudioElement soundEffectAudioElement;
|
|
public AudioSource mainAudioSource;
|
|
|
|
[Space]
|
|
[Header ("Dpad Icon Info List Settings")]
|
|
[Space]
|
|
|
|
public List<dpadIconInfo> dpadIconInfoList = new List<dpadIconInfo> ();
|
|
|
|
public bool useCurrentAbilityIcon;
|
|
|
|
public dpadIconInfo currentAbilityIcon;
|
|
|
|
public Text currentAbilityInputText;
|
|
|
|
public string abilityInputName;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool selectingAbility;
|
|
public int currentAbilityPressedIndex = -1;
|
|
|
|
public bool pauseCheckUsingDeviceOnAbilityInput;
|
|
|
|
public bool inputPaused;
|
|
|
|
public List<abilitySlotInfo> abilitySlotInfoList = new List<abilitySlotInfo> ();
|
|
|
|
public abilitySlotInfo closestSlot;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool playerCanMoveStatePausedOnMenuOpened = true;
|
|
|
|
public bool usedByAI;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public UnityEvent eventOnAbilitiesAssignedOnDpad;
|
|
public UnityEvent eventOnAbilitiesNotAssignedOnDpad;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnOpenAbilitiesWheel;
|
|
public UnityEvent eventOnCloseAbilitiesWheel;
|
|
|
|
[Space]
|
|
[Header ("UI Elements")]
|
|
[Space]
|
|
|
|
public GameObject abilitySlotsMenu;
|
|
public GameObject wheelAbilityListElement;
|
|
|
|
|
|
public GameObject dpadPanel;
|
|
public Slider mainEnerySlider;
|
|
public Slider abilitiesEnergySlider;
|
|
|
|
public Transform abilitySlotsWheel;
|
|
|
|
public Text currentAbilityNameText;
|
|
public GameObject completeAbilityWheel;
|
|
public RectTransform completeAbilityWheelRectTransform;
|
|
public Transform slotArrow;
|
|
public Transform slotArrowIcon;
|
|
public RectTransform slotArrowRectTransform;
|
|
|
|
public GameObject wheelBackground;
|
|
|
|
[Space]
|
|
|
|
public Transform slotsGridTransformParent;
|
|
public GameObject slotsGridPanelGameObject;
|
|
public GameObject gridAbilityListElement;
|
|
|
|
public GameObject slotsGridBackground;
|
|
|
|
public GameObject abilityDescriptionTextGameObject;
|
|
public Text abilityDescriptionText;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public menuPause pauseManager;
|
|
public playerAbilitiesSystem mainPlayerAbilitiesSystem;
|
|
public playerController playerControllerManager;
|
|
public timeBullet timeBulletManager;
|
|
|
|
public playerInputManager playerInput;
|
|
|
|
|
|
bool ignoreUpdateAbilityInfoOnMainPlayerAbilitiesSystemActive;
|
|
|
|
abilitySlotInfo previousClosestSlot;
|
|
|
|
float screenWidth;
|
|
float screenHeight;
|
|
bool touchPlatform;
|
|
bool touching;
|
|
Vector2 mRot = Vector2.zero;
|
|
Quaternion mStart;
|
|
|
|
int numberOfCurrentAbilities;
|
|
|
|
Touch currentTouch;
|
|
|
|
float anglePerSlot;
|
|
float currentAngle;
|
|
float lastTimeTouching;
|
|
bool isFirstAbilitySelected;
|
|
|
|
Vector3 initialTouchPosition;
|
|
|
|
float currentArrowAngle;
|
|
|
|
Vector2 currentTouchPosition;
|
|
|
|
float currentDistance;
|
|
|
|
bool dpadDirectionsAssigned;
|
|
|
|
bool touchPressHoldActive;
|
|
|
|
bool fingerPressingTouchPanel;
|
|
|
|
bool currentAbilityIconChecked;
|
|
|
|
public enum dpadDirection
|
|
{
|
|
up,
|
|
down,
|
|
left,
|
|
right
|
|
}
|
|
|
|
bool dpadInitialized;
|
|
|
|
bool dpadEventsChecked;
|
|
|
|
bool dpadEventsInitialized;
|
|
|
|
private void InitializeAudioElements ()
|
|
{
|
|
if (soundEffect != null) {
|
|
soundEffectAudioElement.clip = soundEffect;
|
|
}
|
|
|
|
if (mainAudioSource != null) {
|
|
soundEffectAudioElement.audioSource = mainAudioSource;
|
|
}
|
|
}
|
|
|
|
void Start ()
|
|
{
|
|
InitializeAudioElements ();
|
|
|
|
if (!mainPlayerAbilitiesSystem.isAbilitiesSystemEnabled ()) {
|
|
abilityListManagerEnabled = false;
|
|
}
|
|
|
|
if (!abilityListManagerEnabled) {
|
|
enableOrDisableDpadPanel (false);
|
|
|
|
return;
|
|
}
|
|
|
|
if (usedByAI) {
|
|
return;
|
|
}
|
|
|
|
Transform slotsParent = abilitySlotsWheel;
|
|
|
|
GameObject currentSlotPrefab = wheelAbilityListElement;
|
|
|
|
if (useWheelMenu) {
|
|
if (slotsGridPanelGameObject.activeSelf) {
|
|
slotsGridPanelGameObject.SetActive (false);
|
|
}
|
|
|
|
if (!slotArrow.gameObject.activeSelf) {
|
|
slotArrow.gameObject.SetActive (true);
|
|
}
|
|
|
|
if (!abilitySlotsWheel.gameObject.activeSelf) {
|
|
abilitySlotsWheel.gameObject.SetActive (true);
|
|
}
|
|
|
|
if (!wheelBackground.gameObject.activeSelf) {
|
|
wheelBackground.gameObject.SetActive (true);
|
|
}
|
|
|
|
if (slotsGridBackground.gameObject.activeSelf) {
|
|
slotsGridBackground.gameObject.SetActive (false);
|
|
}
|
|
} else {
|
|
slotsParent = slotsGridTransformParent;
|
|
|
|
if (!slotsGridPanelGameObject.activeSelf) {
|
|
slotsGridPanelGameObject.SetActive (true);
|
|
}
|
|
|
|
if (slotArrow.gameObject.activeSelf) {
|
|
slotArrow.gameObject.SetActive (false);
|
|
}
|
|
|
|
if (abilitySlotsWheel.gameObject.activeSelf) {
|
|
abilitySlotsWheel.gameObject.SetActive (false);
|
|
}
|
|
|
|
if (wheelBackground.gameObject.activeSelf) {
|
|
wheelBackground.gameObject.SetActive (false);
|
|
}
|
|
|
|
if (!slotsGridBackground.gameObject.activeSelf) {
|
|
slotsGridBackground.gameObject.SetActive (true);
|
|
}
|
|
|
|
currentSlotPrefab = gridAbilityListElement;
|
|
}
|
|
|
|
int abilityInfoListCount = mainPlayerAbilitiesSystem.abilityInfoList.Count;
|
|
|
|
//for every ability created in the player abilities manager inspector, add to the list of the ability manager
|
|
for (int i = 0; i < abilityInfoListCount; i++) {
|
|
GameObject newAbilityListElement = (GameObject)Instantiate (currentSlotPrefab, Vector3.zero, Quaternion.identity, slotsParent);
|
|
|
|
newAbilityListElement.name = "Ability Slot " + (i + 1);
|
|
|
|
newAbilityListElement.transform.localScale = Vector3.one;
|
|
newAbilityListElement.transform.position = currentSlotPrefab.transform.position;
|
|
|
|
abilitySlotInfo newAbilitySlotInfo = newAbilityListElement.GetComponent<abilitySlotElement> ().slotInfo;
|
|
|
|
abilityInfo currentAbilityInfo = mainPlayerAbilitiesSystem.abilityInfoList [i];
|
|
|
|
newAbilitySlotInfo.Name = currentAbilityInfo.Name;
|
|
|
|
newAbilitySlotInfo.abilityDescription = currentAbilityInfo.abilityDescription;
|
|
|
|
newAbilitySlotInfo.abilityIcon.transform.rotation = Quaternion.identity;
|
|
|
|
newAbilitySlotInfo.abilityIcon.texture = currentAbilityInfo.abilityTexture;
|
|
|
|
newAbilitySlotInfo.abilityIndex = i;
|
|
|
|
abilitySlotInfoList.Add (newAbilitySlotInfo);
|
|
}
|
|
|
|
currentSlotPrefab.SetActive (false);
|
|
|
|
//get the rotation of the ability wheel
|
|
mStart = completeAbilityWheel.transform.localRotation;
|
|
|
|
//check if the platform is a touch device or not
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
|
|
if (!useDpadPanel) {
|
|
enableOrDisableDpadPanel (false);
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableDpadPanel (bool state)
|
|
{
|
|
if (!useDpadPanel) {
|
|
state = false;
|
|
}
|
|
|
|
if (dpadPanel != null) {
|
|
if (dpadPanel.activeSelf != state) {
|
|
dpadPanel.SetActive (state);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableExtraElementsOnAbilitiesUI (bool state)
|
|
{
|
|
if (useWheelMenu) {
|
|
if (slotArrow.gameObject.activeSelf != state) {
|
|
slotArrow.gameObject.SetActive (state);
|
|
}
|
|
} else {
|
|
if (slotsGridBackground.activeSelf != state) {
|
|
slotsGridBackground.SetActive (state);
|
|
}
|
|
}
|
|
|
|
if (currentAbilityNameText.gameObject.activeSelf != state) {
|
|
currentAbilityNameText.gameObject.SetActive (state);
|
|
}
|
|
}
|
|
|
|
public bool isUseWheelMenuActive ()
|
|
{
|
|
return useWheelMenu;
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
if (usedByAI) {
|
|
return;
|
|
}
|
|
|
|
if (!dpadInitialized) {
|
|
setDpadIconsInfo ();
|
|
|
|
dpadInitialized = true;
|
|
}
|
|
|
|
if (useDpadPanel) {
|
|
if (!currentAbilityIconChecked) {
|
|
if (useCurrentAbilityIcon && currentAbilityIcon != null) {
|
|
|
|
int currentAbilityIndexToCheck = mainPlayerAbilitiesSystem.getCurrentAbilityIndex ();
|
|
|
|
bool anyAbilityAssignedOnDpad = false;
|
|
|
|
if (currentAbilityIndexToCheck > -1) {
|
|
|
|
abilityInfo currentAbilityInfo = mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIndexToCheck];
|
|
|
|
if (currentAbilityInfo.abilityVisibleOnWheelSelection && currentAbilityInfo.abilityCanBeShownOnWheelSelection) {
|
|
setDpadIconInfo (currentAbilityIcon, currentAbilityIndexToCheck);
|
|
|
|
updateCurrentAbilityInputText ();
|
|
|
|
anyAbilityAssignedOnDpad = true;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [i];
|
|
|
|
if (currentDpadIconInfo.dpadAbilityIndex > -1) {
|
|
anyAbilityAssignedOnDpad = true;
|
|
}
|
|
}
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (anyAbilityAssignedOnDpad);
|
|
|
|
if (!anyAbilityAssignedOnDpad) {
|
|
mainPlayerAbilitiesSystem.removeCurrentAbilityInfo ();
|
|
}
|
|
}
|
|
|
|
currentAbilityIconChecked = true;
|
|
}
|
|
}
|
|
|
|
//if the player is selecting or the touch controls are enabled, then
|
|
if ((selectingAbility || pauseManager.isUsingTouchControls ()) && !pauseManager.isGamePaused ()) {
|
|
//check the mouse position in the screen if we are in the editor, or the finger position in a touch device
|
|
int touchCount = Input.touchCount;
|
|
if (!touchPlatform) {
|
|
touchCount++;
|
|
}
|
|
|
|
for (int i = 0; i < touchCount; i++) {
|
|
if (!touchPlatform) {
|
|
currentTouch = touchJoystick.convertMouseIntoFinger ();
|
|
} else {
|
|
currentTouch = Input.GetTouch (i);
|
|
}
|
|
|
|
currentTouchPosition = currentTouch.position;
|
|
|
|
if (fingerPressingTouchPanel && !touching) {
|
|
touching = true;
|
|
|
|
initialTouchPosition = currentTouchPosition;
|
|
|
|
lastTimeTouching = Time.time;
|
|
}
|
|
|
|
if (touching && (currentTouch.phase == TouchPhase.Stationary || currentTouch.phase == TouchPhase.Moved)) {
|
|
if (!selectingAbility) {
|
|
if (Time.time > lastTimeTouching + timeToShowAbilitySlotsWheel) {
|
|
selectAbilitySlots (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Ended) {
|
|
if (touching && selectingAbility) {
|
|
selectAbilitySlots (false);
|
|
}
|
|
|
|
touching = false;
|
|
|
|
fingerPressingTouchPanel = false;
|
|
|
|
return;
|
|
}
|
|
|
|
if (selectingAbility) {
|
|
if (useWheelMenu) {
|
|
//get the current screen size
|
|
screenWidth = Screen.width;
|
|
screenHeight = Screen.height;
|
|
|
|
//get the arrow rotates toward the mouse, selecting the closest ability to it
|
|
Vector2 slotDirection = new Vector2 (currentTouchPosition.x, currentTouchPosition.y) - slotArrowRectTransform.anchoredPosition;
|
|
Vector2 screenCenter = new Vector2 (screenWidth, screenHeight) / 2;
|
|
|
|
slotDirection -= screenCenter;
|
|
|
|
currentArrowAngle = Mathf.Atan2 (slotDirection.y, slotDirection.x);
|
|
currentArrowAngle -= 90 * Mathf.Deg2Rad;
|
|
|
|
slotArrow.localRotation = Quaternion.Euler (0, 0, currentArrowAngle * Mathf.Rad2Deg);
|
|
|
|
if (GKC_Utils.distance (initialTouchPosition, currentTouchPosition) > distanceFromCenterToSelectAbility) {
|
|
if (!slotArrow.gameObject.activeSelf) {
|
|
slotArrow.gameObject.SetActive (true);
|
|
}
|
|
|
|
//make the slots wheel looks toward the mouse
|
|
float halfWidth = screenWidth * 0.5f;
|
|
float halfHeight = screenHeight * 0.5f;
|
|
|
|
float x = Mathf.Clamp ((currentTouchPosition.x - halfWidth) / halfWidth, -1f, 1f);
|
|
float y = Mathf.Clamp ((currentTouchPosition.y - halfHeight) / halfHeight, -1f, 1f);
|
|
|
|
mRot = Vector2.Lerp (mRot, new Vector2 (x, y), Time.deltaTime * rotationHUDSpeed);
|
|
|
|
completeAbilityWheel.transform.localRotation = mStart * Quaternion.Euler (mRot.y * abilityWheelMenuRotationRange.y, -mRot.x * abilityWheelMenuRotationRange.x, 0f);
|
|
|
|
//get the ability inside the wheel closest to the mouse
|
|
float distance = Mathf.Infinity;
|
|
|
|
for (int k = 0; k < abilitySlotInfoList.Count; k++) {
|
|
if (abilitySlotInfoList [k].slotActive) {
|
|
currentDistance = GKC_Utils.distance (slotArrowIcon.position, abilitySlotInfoList [k].abilityIcon.transform.position);
|
|
|
|
if (currentDistance < distance) {
|
|
distance = currentDistance;
|
|
closestSlot = abilitySlotInfoList [k];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (previousClosestSlot != closestSlot) {
|
|
if (changeCurrentSlotSize) {
|
|
if (previousClosestSlot != null) {
|
|
changeSlotSize (previousClosestSlot, true, changeCurrentSlotMultiplier, true);
|
|
}
|
|
}
|
|
|
|
previousClosestSlot = closestSlot;
|
|
|
|
if (changeCurrentSlotSize) {
|
|
changeSlotSize (closestSlot, false, changeCurrentSlotMultiplier, true);
|
|
}
|
|
|
|
updateAbilityText (closestSlot.Name, closestSlot.abilityDescription);
|
|
|
|
if (useSoundOnSlot) {
|
|
playSound (soundEffectAudioElement);
|
|
}
|
|
}
|
|
|
|
//set the name of the closest ability in the center of the ability wheel
|
|
if (mainPlayerAbilitiesSystem.getCurrentAbilityIndex () != closestSlot.abilityIndex || !isFirstAbilitySelected) {
|
|
isFirstAbilitySelected = true;
|
|
|
|
if (!selectAbilityOnMenuClose) {
|
|
selectAbility (closestSlot);
|
|
}
|
|
}
|
|
} else {
|
|
if (slotArrow.gameObject.activeSelf) {
|
|
slotArrow.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
touchPressHoldActive = false;
|
|
} else {
|
|
|
|
if (GKC_Utils.distance (initialTouchPosition, currentTouchPosition) > distanceFromCenterToSelectAbility) {
|
|
|
|
float distance = Mathf.Infinity;
|
|
|
|
for (int k = 0; k < abilitySlotInfoList.Count; k++) {
|
|
if (abilitySlotInfoList [k].slotActive) {
|
|
Vector2 slotPosition = abilitySlotInfoList [k].slotRectTransform.position;
|
|
|
|
currentDistance = GKC_Utils.distance (currentTouchPosition, slotPosition);
|
|
|
|
if (currentDistance < distance) {
|
|
distance = currentDistance;
|
|
closestSlot = abilitySlotInfoList [k];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (previousClosestSlot != closestSlot) {
|
|
if (changeCurrentSlotSize) {
|
|
if (previousClosestSlot != null) {
|
|
changeSlotSize (previousClosestSlot, true, changeCurrentSlotMultiplier, true);
|
|
}
|
|
}
|
|
|
|
previousClosestSlot = closestSlot;
|
|
|
|
if (changeCurrentSlotSize) {
|
|
changeSlotSize (closestSlot, false, changeCurrentSlotMultiplier, true);
|
|
}
|
|
|
|
updateAbilityText (closestSlot.Name, closestSlot.abilityDescription);
|
|
|
|
if (useSoundOnSlot) {
|
|
playSound (soundEffectAudioElement);
|
|
}
|
|
}
|
|
|
|
//set the name of the closest ability in the center of the ability wheel
|
|
if (mainPlayerAbilitiesSystem.getCurrentAbilityIndex () != closestSlot.abilityIndex || !isFirstAbilitySelected) {
|
|
isFirstAbilitySelected = true;
|
|
|
|
if (!selectAbilityOnMenuClose) {
|
|
selectAbility (closestSlot);
|
|
}
|
|
}
|
|
}
|
|
|
|
touchPressHoldActive = false;
|
|
}
|
|
} else {
|
|
if (touchPressHoldActive) {
|
|
inputUseDpadDirectionPressHold ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateAbilityText (string abilityName, string abilityDescription)
|
|
{
|
|
if (abilityName != "") {
|
|
currentAbilityNameText.text = abilityName;
|
|
}
|
|
|
|
if (currentAbilityNameText != null) {
|
|
if (abilityDescription != "") {
|
|
abilityDescriptionText.text = abilityDescription;
|
|
} else {
|
|
abilityDescriptionText.text = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateCurrentAbilityInputText ()
|
|
{
|
|
if (useCurrentAbilityIcon) {
|
|
currentAbilityInputText.text = playerInput.getButtonKey (abilityInputName);
|
|
}
|
|
}
|
|
|
|
public void setTouchingMenuPanelState (bool state)
|
|
{
|
|
fingerPressingTouchPanel = state;
|
|
|
|
pauseManager.setIgnoreDisableTouchZoneListState (fingerPressingTouchPanel);
|
|
}
|
|
|
|
public void updateCurrentSelectedAbilityUIByName (string abilityName)
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (!useDpadPanel) {
|
|
return;
|
|
}
|
|
|
|
if (abilityName == null || abilityName == "") {
|
|
return;
|
|
}
|
|
|
|
ignoreUpdateAbilityInfoOnMainPlayerAbilitiesSystemActive = true;
|
|
|
|
selectAbilityByName (abilityName);
|
|
|
|
ignoreUpdateAbilityInfoOnMainPlayerAbilitiesSystemActive = false;
|
|
}
|
|
|
|
public void selectAbilityByName (string abilityName)
|
|
{
|
|
for (int k = 0; k < abilitySlotInfoList.Count; k++) {
|
|
if (abilitySlotInfoList [k].Name.Equals (abilityName)) {
|
|
selectAbility (abilitySlotInfoList [k]);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void selectAbility (abilitySlotInfo slotInfo)
|
|
{
|
|
if (!ignoreUpdateAbilityInfoOnMainPlayerAbilitiesSystemActive) {
|
|
mainPlayerAbilitiesSystem.setCurrentAbilityByName (slotInfo.Name);
|
|
}
|
|
|
|
for (int k = 0; k < abilitySlotInfoList.Count; k++) {
|
|
if (slotInfo.abilityIndex == abilitySlotInfoList [k].abilityIndex) {
|
|
if (!abilitySlotInfoList [k].currentAbilitySelectedIcon.activeSelf) {
|
|
abilitySlotInfoList [k].currentAbilitySelectedIcon.SetActive (true);
|
|
}
|
|
} else {
|
|
if (abilitySlotInfoList [k].currentAbilitySelectedIcon.activeSelf) {
|
|
abilitySlotInfoList [k].currentAbilitySelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
setDpadIconInfo (currentAbilityIcon, slotInfo.abilityIndex);
|
|
|
|
updateCurrentAbilityInputText ();
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (true);
|
|
}
|
|
}
|
|
|
|
public void changeSlotSize (abilitySlotInfo slotInfo, bool setRegularSize, float sizeMultiplier, bool smoothSizeChange)
|
|
{
|
|
if (slotInfo.sizeCoroutine != null) {
|
|
StopCoroutine (slotInfo.sizeCoroutine);
|
|
}
|
|
|
|
slotInfo.sizeCoroutine = StartCoroutine (changeSlotSizeCoroutine (slotInfo, setRegularSize, sizeMultiplier, smoothSizeChange));
|
|
}
|
|
|
|
IEnumerator changeSlotSizeCoroutine (abilitySlotInfo slotInfo, bool setRegularSize, float sizeMultiplier, bool smoothSizeChange)
|
|
{
|
|
Vector3 targetValue = Vector3.one;
|
|
|
|
if (!setRegularSize) {
|
|
targetValue *= sizeMultiplier;
|
|
}
|
|
|
|
bool innerSlotLocated = slotInfo.innerSlot != null;
|
|
|
|
if (innerSlotLocated) {
|
|
if (smoothSizeChange) {
|
|
while (slotInfo.innerSlot.localScale != targetValue) {
|
|
slotInfo.innerSlot.localScale = Vector3.MoveTowards (slotInfo.innerSlot.localScale, targetValue, Time.deltaTime * changeCurrentSlotMultiplier);
|
|
|
|
yield return null;
|
|
}
|
|
} else {
|
|
slotInfo.innerSlot.localScale = targetValue;
|
|
}
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
//enable the ability wheel to select the current ability to use
|
|
public void selectAbilitySlots (bool state)
|
|
{
|
|
if (currentAbilityPressedIndex != -1) {
|
|
if (showDebugPrint) {
|
|
print ("Wheel menu can't be opened due current Ability Pressed Index != -1, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//check that the game is not paused, that the player is not editing the ability, using a device and that the ability manager can be enabled
|
|
if ((canBeOpened () || selectingAbility)) {
|
|
|
|
if (!mainPlayerAbilitiesSystem.checkIfAbilitiesAvailable ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
print ("ability input in use, cancelling ");
|
|
|
|
return;
|
|
}
|
|
|
|
selectingAbility = state;
|
|
|
|
mainPlayerAbilitiesSystem.setSelectingAbilityActiveState (selectingAbility);
|
|
|
|
if (!selectingAbility) {
|
|
if (changeCurrentSlotSize && closestSlot != null) {
|
|
changeSlotSize (closestSlot, true, changeCurrentSlotMultiplier, false);
|
|
}
|
|
}
|
|
|
|
pauseManager.openOrClosePlayerMenu (selectingAbility, abilitySlotsMenu.transform, useBlurUIPanel);
|
|
|
|
//enable the ability wheel
|
|
completeAbilityWheel.SetActive (selectingAbility);
|
|
|
|
pauseManager.setIngameMenuOpenedState ("Ability List Manager", selectingAbility, true);
|
|
|
|
pauseManager.enableOrDisablePlayerMenu (selectingAbility, playerCanMoveStatePausedOnMenuOpened, false);
|
|
|
|
//reset the arrow and the wheel rotation
|
|
completeAbilityWheel.transform.localRotation = Quaternion.identity;
|
|
|
|
slotArrow.localRotation = Quaternion.identity;
|
|
|
|
if (selectingAbility) {
|
|
|
|
updateSlotsInfo ();
|
|
|
|
if (!touchPlatform) {
|
|
initialTouchPosition = touchJoystick.convertMouseIntoFinger ().position;
|
|
} else {
|
|
initialTouchPosition = Input.GetTouch (1).position;
|
|
}
|
|
|
|
if (slowDownTimeWhenMenuActive) {
|
|
timeBulletManager.setBulletTimeState (true, timeScaleWhenMenuActive);
|
|
}
|
|
|
|
completeAbilityWheelRectTransform.anchoredPosition = Vector3.zero;
|
|
} else {
|
|
isFirstAbilitySelected = false;
|
|
|
|
if (slowDownTimeWhenMenuActive) {
|
|
timeBulletManager.setBulletTimeState (false, 1);
|
|
}
|
|
|
|
if (selectAbilityOnMenuClose && closestSlot != null) {
|
|
selectAbility (closestSlot);
|
|
}
|
|
}
|
|
|
|
if (state) {
|
|
eventOnOpenAbilitiesWheel.Invoke ();
|
|
} else {
|
|
eventOnCloseAbilitiesWheel.Invoke ();
|
|
}
|
|
|
|
closestSlot = null;
|
|
previousClosestSlot = null;
|
|
}
|
|
}
|
|
|
|
public void setPauseCheckUsingDeviceOnAbilityInputState (bool state)
|
|
{
|
|
pauseCheckUsingDeviceOnAbilityInput = state;
|
|
}
|
|
|
|
public void togglePauseCheckUsingDeviceOnAbilityInputState ()
|
|
{
|
|
setPauseCheckUsingDeviceOnAbilityInputState (!pauseCheckUsingDeviceOnAbilityInput);
|
|
}
|
|
|
|
public bool canBeOpened ()
|
|
{
|
|
if (pauseManager.isGamePaused ()) {
|
|
if (showDebugPrint) {
|
|
print ("game paused, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!pauseCheckUsingDeviceOnAbilityInput && playerControllerManager.isUsingDevice ()) {
|
|
if (showDebugPrint) {
|
|
print ("using device, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!abilityListManagerEnabled) {
|
|
if (showDebugPrint) {
|
|
print ("ability list manager not enabled, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!mainPlayerAbilitiesSystem.isAbilitiesModeActive ()) {
|
|
if (showDebugPrint) {
|
|
print ("abilities mode not active, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (playerControllerManager.isPlayerMenuActive ()) {
|
|
if (showDebugPrint) {
|
|
print ("player menu active, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.disableAbilitySystemOnFirstPerson && playerControllerManager.isPlayerOnFirstPerson ()) {
|
|
if (showDebugPrint) {
|
|
print ("first person without abilities, cancelling opening menu");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void udpateSlotsInfo ()
|
|
{
|
|
updateSlotsInfo ();
|
|
}
|
|
|
|
public void updateSlotsInfo ()
|
|
{
|
|
if (showOnlyEnabledAbilitySlots) {
|
|
numberOfCurrentAbilities = mainPlayerAbilitiesSystem.getNumberOfAbilitiesAvailable ();
|
|
} else {
|
|
numberOfCurrentAbilities = mainPlayerAbilitiesSystem.getNumberOfAbilitiesCanBeShownOnWheelSelection ();
|
|
}
|
|
|
|
anglePerSlot = 360 / (float)numberOfCurrentAbilities;
|
|
currentAngle = 0;
|
|
|
|
for (int j = 0; j < abilitySlotInfoList.Count; j++) {
|
|
abilitySlotInfoList [j].slotActive = false;
|
|
|
|
if (abilitySlotInfoList [j].slot.activeSelf) {
|
|
abilitySlotInfoList [j].slot.SetActive (false);
|
|
}
|
|
}
|
|
|
|
bool anySlotAviable = false;
|
|
|
|
int numberSlotsActive = 0;
|
|
|
|
int abilityInfoListCount = mainPlayerAbilitiesSystem.abilityInfoList.Count;
|
|
|
|
for (int i = 0; i < abilityInfoListCount; i++) {
|
|
|
|
abilityInfo currentAbilityInfo = mainPlayerAbilitiesSystem.abilityInfoList [i];
|
|
|
|
if (currentAbilityInfo.isAbilityEnabled () && currentAbilityInfo.addAbilityToUIWheelActive && i <= numberOfAbilitySlots) {
|
|
|
|
abilitySlotInfo newAbilitySlotInfo = abilitySlotInfoList [i];
|
|
|
|
if (!newAbilitySlotInfo.slotActive &&
|
|
currentAbilityInfo.abilityVisibleOnWheelSelection &&
|
|
currentAbilityInfo.abilityCanBeShownOnWheelSelection) {
|
|
|
|
if (useWheelMenu) {
|
|
newAbilitySlotInfo.slotRectTransform.rotation = Quaternion.Euler (new Vector3 (0, 0, currentAngle));
|
|
|
|
currentAngle += anglePerSlot;
|
|
}
|
|
|
|
newAbilitySlotInfo.abilityIcon.transform.rotation = Quaternion.identity;
|
|
|
|
if (mainPlayerAbilitiesSystem.getCurrentAbilityIndex () == i) {
|
|
if (!newAbilitySlotInfo.currentAbilitySelectedIcon.activeSelf) {
|
|
newAbilitySlotInfo.currentAbilitySelectedIcon.SetActive (true);
|
|
}
|
|
|
|
updateAbilityText (newAbilitySlotInfo.Name, newAbilitySlotInfo.abilityDescription);
|
|
} else {
|
|
if (newAbilitySlotInfo.currentAbilitySelectedIcon.activeSelf) {
|
|
newAbilitySlotInfo.currentAbilitySelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
|
|
newAbilitySlotInfo.slotActive = true;
|
|
|
|
if (!newAbilitySlotInfo.slot.activeSelf) {
|
|
newAbilitySlotInfo.slot.SetActive (true);
|
|
}
|
|
|
|
anySlotAviable = true;
|
|
|
|
numberSlotsActive++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (useWheelMenu) {
|
|
if (useSlotsChangeScale) {
|
|
Vector3 newScale = Vector3.one;
|
|
|
|
Vector2 newAnchoredPosition = Vector2.zero;
|
|
|
|
if (numberSlotsActive >= numberOfSlotsToChangeScale) {
|
|
newScale = Vector3.one - (Vector3.one * (numberSlotsActive / slotScale));
|
|
|
|
if (newScale.x < minSlotScale) {
|
|
newScale = minSlotScale * Vector3.one;
|
|
}
|
|
|
|
float slotHeight = (wheelRadius / slotHeightOffset) * numberSlotsActive;
|
|
|
|
slotHeight = Mathf.Clamp (slotHeight, 0, wheelRadius);
|
|
|
|
newAnchoredPosition = new Vector2 (0, slotHeight);
|
|
}
|
|
|
|
for (int j = 0; j < abilitySlotInfoList.Count; j++) {
|
|
abilitySlotInfoList [j].slotCenter.transform.localScale = newScale;
|
|
|
|
abilitySlotInfoList [j].slotCenter.anchoredPosition = newAnchoredPosition;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
}
|
|
|
|
if (!anySlotAviable) {
|
|
selectAbilitySlots (false);
|
|
}
|
|
|
|
updateDpadIconsOnWheelMenu ();
|
|
}
|
|
|
|
public void checkIfAssignActivatedAbilitiesToFreeDpadSlots (string currentAbilityName, int abilityIndexToCheck, bool addingAbilityToWheel)
|
|
{
|
|
bool abilityAssignedOnDpad = false;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [i];
|
|
|
|
if (currentDpadIconInfo.dpadAbilityIndex == abilityIndexToCheck) {
|
|
abilityAssignedOnDpad = true;
|
|
}
|
|
}
|
|
|
|
if (abilityAssignedOnDpad) {
|
|
if (addingAbilityToWheel) {
|
|
if (showDebugPrint) {
|
|
print ("ability already on dpad, not doing anything");
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("ability already on dpad, removing from it");
|
|
}
|
|
|
|
int dpadIndex = getDpadIconInfoListIndexByAbilityIndex (abilityIndexToCheck);
|
|
|
|
if (dpadIndex > -1) {
|
|
setDpadIconInfo (dpadIconInfoList [dpadIndex], -1);
|
|
}
|
|
}
|
|
} else {
|
|
if (addingAbilityToWheel) {
|
|
if (showDebugPrint) {
|
|
print ("ability not on dpad, adding to it");
|
|
}
|
|
|
|
bool dpadFound = false;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
if (!dpadFound) {
|
|
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [i];
|
|
|
|
if (currentDpadIconInfo.dpadAbilityIndex == -1) {
|
|
setDpadIconInfo (currentDpadIconInfo, abilityIndexToCheck);
|
|
|
|
dpadFound = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("ability not on dpad, not doing anything");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool anyAbilityAssignedOnDpad = false;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [i];
|
|
|
|
if (currentDpadIconInfo.dpadAbilityIndex > -1) {
|
|
anyAbilityAssignedOnDpad = true;
|
|
}
|
|
}
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (anyAbilityAssignedOnDpad);
|
|
|
|
if (showDebugPrint) {
|
|
print (anyAbilityAssignedOnDpad + " " + abilityAssignedOnDpad + " " + addingAbilityToWheel + " " + abilityIndexToCheck + " " + currentAbilityName);
|
|
}
|
|
|
|
if (anyAbilityAssignedOnDpad) {
|
|
|
|
if (!abilityAssignedOnDpad && addingAbilityToWheel) {
|
|
if (currentAbilityIcon.dpadAbilityIndex == -1) {
|
|
if (showDebugPrint) {
|
|
print ("assigning ability on main dpad icon");
|
|
}
|
|
|
|
setDpadIconInfo (currentAbilityIcon, abilityIndexToCheck);
|
|
|
|
if (mainPlayerAbilitiesSystem.currentAbilityInfo == null) {
|
|
mainPlayerAbilitiesSystem.setCurrentAbilityByName (currentAbilityName);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (abilityAssignedOnDpad && !addingAbilityToWheel) {
|
|
if (showDebugPrint) {
|
|
print ("here " + currentAbilityIcon.abilityName + " " + currentAbilityName);
|
|
}
|
|
|
|
if (currentAbilityIcon.abilityName == currentAbilityName) {
|
|
if (showDebugPrint) {
|
|
print ("current ability icon contained the ability removed, assigning new one");
|
|
}
|
|
|
|
bool newAbilityToAssignOnCurrentDpadIconInfoConfigured = false;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
if (!newAbilityToAssignOnCurrentDpadIconInfoConfigured) {
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [i];
|
|
|
|
if (currentDpadIconInfo.dpadAbilityIndex > -1) {
|
|
if (showDebugPrint) {
|
|
print ("new ability configured on the current ability icon");
|
|
}
|
|
|
|
newAbilityToAssignOnCurrentDpadIconInfoConfigured = true;
|
|
|
|
setDpadIconInfo (currentAbilityIcon, currentDpadIconInfo.dpadAbilityIndex);
|
|
|
|
if (mainPlayerAbilitiesSystem.currentAbilityInfo != null && mainPlayerAbilitiesSystem.currentAbilityInfo.Name == currentAbilityName) {
|
|
mainPlayerAbilitiesSystem.setCurrentAbilityByName (currentDpadIconInfo.abilityName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("check to rmeove the ability assigned on current dpad icon");
|
|
}
|
|
|
|
setDpadIconInfo (currentAbilityIcon, -1);
|
|
|
|
mainPlayerAbilitiesSystem.removeCurrentAbilityInfo ();
|
|
}
|
|
}
|
|
|
|
public void updateDpadIconsOnWheelMenu ()
|
|
{
|
|
for (int j = 0; j < abilitySlotInfoList.Count; j++) {
|
|
|
|
abilitySlotInfo newAbilitySlotInfo = abilitySlotInfoList [j];
|
|
|
|
if (newAbilitySlotInfo.slotActive) {
|
|
|
|
int abilityIndex = getDpadIconInfoListIndexByAbilityIndex (newAbilitySlotInfo.abilityIndex);
|
|
|
|
if (abilityIndex > -1) {
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [abilityIndex];
|
|
|
|
currentDpadIconInfo.abilitySlotIndex = j;
|
|
|
|
newAbilitySlotInfo.currentDpadDirection = currentDpadIconInfo.currentDpadDirection;
|
|
|
|
if (!newAbilitySlotInfo.dpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.dpadIcon.SetActive (true);
|
|
}
|
|
|
|
newAbilitySlotInfo.dpadIcon.transform.rotation = Quaternion.identity;
|
|
|
|
if (newAbilitySlotInfo.upDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.upDpadIcon.SetActive (false);
|
|
}
|
|
|
|
if (newAbilitySlotInfo.downDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.downDpadIcon.SetActive (false);
|
|
}
|
|
|
|
if (newAbilitySlotInfo.leftDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.leftDpadIcon.SetActive (false);
|
|
}
|
|
|
|
if (newAbilitySlotInfo.rightDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.rightDpadIcon.SetActive (false);
|
|
}
|
|
|
|
switch (newAbilitySlotInfo.currentDpadDirection) {
|
|
case dpadDirection.up:
|
|
if (!newAbilitySlotInfo.upDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.upDpadIcon.SetActive (true);
|
|
}
|
|
|
|
break;
|
|
case dpadDirection.down:
|
|
if (!newAbilitySlotInfo.downDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.downDpadIcon.SetActive (true);
|
|
}
|
|
|
|
break;
|
|
case dpadDirection.left:
|
|
if (!newAbilitySlotInfo.leftDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.leftDpadIcon.SetActive (true);
|
|
}
|
|
|
|
break;
|
|
case dpadDirection.right:
|
|
if (!newAbilitySlotInfo.rightDpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.rightDpadIcon.SetActive (true);
|
|
}
|
|
|
|
break;
|
|
}
|
|
} else {
|
|
if (newAbilitySlotInfo.dpadIcon.activeSelf) {
|
|
newAbilitySlotInfo.dpadIcon.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getDpadIconInfoListIndexByAbilityIndex (int abilityIndex)
|
|
{
|
|
for (int j = 0; j < dpadIconInfoList.Count; j++) {
|
|
if (dpadIconInfoList [j].dpadAbilityIndex == abilityIndex) {
|
|
return j;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public int getDpadIconInfoListIndexByAbilityName (string abilityName)
|
|
{
|
|
for (int j = 0; j < dpadIconInfoList.Count; j++) {
|
|
if (dpadIconInfoList [j].abilityName == abilityName) {
|
|
return j;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void setDpadIconsInfo ()
|
|
{
|
|
if (!dpadDirectionsAssigned) {
|
|
|
|
bool anyAbilityAssignedOnDpad = false;
|
|
|
|
int currentAbilityIndex = 0;
|
|
|
|
int abilityInfoListCount = mainPlayerAbilitiesSystem.abilityInfoList.Count;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
|
|
bool abilityFound = false;
|
|
|
|
while (!abilityFound) {
|
|
if (dpadIconInfoList [i].setInitialAbilityIndex) {
|
|
currentAbilityIndex = dpadIconInfoList [i].initialAbilityIndex;
|
|
}
|
|
|
|
if (currentAbilityIndex < abilityInfoListCount) {
|
|
|
|
if (mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIndex].isAbilityEnabled () &&
|
|
mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIndex].abilityVisibleOnWheelSelection &&
|
|
mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIndex].abilityCanBeShownOnWheelSelection) {
|
|
|
|
abilityFound = true;
|
|
|
|
anyAbilityAssignedOnDpad = true;
|
|
} else {
|
|
currentAbilityIndex++;
|
|
}
|
|
} else {
|
|
abilityFound = true;
|
|
}
|
|
}
|
|
|
|
if (currentAbilityIndex < abilitySlotInfoList.Count) {
|
|
setDpadIconInfo (dpadIconInfoList [i], currentAbilityIndex);
|
|
|
|
currentAbilityIndex++;
|
|
}
|
|
}
|
|
|
|
dpadDirectionsAssigned = true;
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (anyAbilityAssignedOnDpad);
|
|
|
|
if (anyAbilityAssignedOnDpad) {
|
|
if (showDebugPrint) {
|
|
print ("abilities assigned");
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("abilities not assigned");
|
|
}
|
|
|
|
for (int j = 0; j < dpadIconInfoList.Count; j++) {
|
|
|
|
dpadIconInfo newDpadIconInfo = dpadIconInfoList [j];
|
|
|
|
if (!newDpadIconInfo.dpadIconAssigned && newDpadIconInfo.dpadIconGameObject.activeSelf) {
|
|
newDpadIconInfo.dpadIconGameObject.SetActive (false);
|
|
|
|
newDpadIconInfo.dpadAbilityIndex = -1;
|
|
}
|
|
}
|
|
|
|
mainPlayerAbilitiesSystem.removeCurrentAbilityInfo ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkEventsOnAbilitiesAssignedOnDpad (bool state)
|
|
{
|
|
if (dpadEventsChecked != state || !dpadEventsInitialized) {
|
|
|
|
dpadEventsChecked = state;
|
|
|
|
if (state) {
|
|
eventOnAbilitiesAssignedOnDpad.Invoke ();
|
|
} else {
|
|
eventOnAbilitiesNotAssignedOnDpad.Invoke ();
|
|
}
|
|
}
|
|
|
|
dpadEventsInitialized = true;
|
|
}
|
|
|
|
public List<abilitySlotInfo> getAbilitySlotInfoList ()
|
|
{
|
|
return abilitySlotInfoList;
|
|
}
|
|
|
|
public int getAbilityIndexByName (string abilityName)
|
|
{
|
|
for (int i = 0; i < mainPlayerAbilitiesSystem.abilityInfoList.Count; i++) {
|
|
|
|
abilityInfo currentAbilityInfo = mainPlayerAbilitiesSystem.abilityInfoList [i];
|
|
|
|
if (currentAbilityInfo.Name == abilityName) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void setCurrentAbilityIconAssignedByName (string abilityName)
|
|
{
|
|
if (useCurrentAbilityIcon) {
|
|
int abilityIndex = getAbilityIndexByName (abilityName);
|
|
|
|
if (abilityIndex != -1) {
|
|
setDpadIconInfo (currentAbilityIcon, abilityIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setDpadIconInfo (dpadIconInfo newDpadIconInfo, int currentAbilityIndex)
|
|
{
|
|
if (currentAbilityIndex > -1) {
|
|
abilityInfo newAbilitySlotInfo = mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIndex];
|
|
|
|
newDpadIconInfo.abilityName = newAbilitySlotInfo.Name;
|
|
newDpadIconInfo.dpadAbilityIndex = currentAbilityIndex;
|
|
newDpadIconInfo.iconActive = true;
|
|
newDpadIconInfo.backgroundIcon.texture = newAbilitySlotInfo.abilityTexture;
|
|
newDpadIconInfo.icon.sprite = newAbilitySlotInfo.abilitySprite;
|
|
|
|
if (!newDpadIconInfo.iconActiveGameObject.activeSelf) {
|
|
newDpadIconInfo.iconActiveGameObject.SetActive (true);
|
|
}
|
|
|
|
newDpadIconInfo.dpadIconAssigned = true;
|
|
|
|
if (!newDpadIconInfo.dpadIconGameObject.activeSelf) {
|
|
newDpadIconInfo.dpadIconGameObject.SetActive (true);
|
|
}
|
|
} else {
|
|
newDpadIconInfo.abilityName = "";
|
|
newDpadIconInfo.dpadAbilityIndex = -1;
|
|
newDpadIconInfo.iconActive = false;
|
|
|
|
if (!newDpadIconInfo.iconActiveGameObject.activeSelf) {
|
|
newDpadIconInfo.iconActiveGameObject.SetActive (false);
|
|
}
|
|
|
|
newDpadIconInfo.dpadIconAssigned = false;
|
|
}
|
|
|
|
for (int j = 0; j < dpadIconInfoList.Count; j++) {
|
|
if (!dpadIconInfoList [j].dpadIconAssigned && dpadIconInfoList [j].dpadIconGameObject.activeSelf) {
|
|
dpadIconInfoList [j].dpadIconGameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
if (currentAbilityIcon == newDpadIconInfo) {
|
|
if (!currentAbilityIcon.dpadIconAssigned && currentAbilityIcon.dpadIconGameObject.activeSelf) {
|
|
currentAbilityIcon.dpadIconGameObject.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateDpadIconsOnAbilitiesDeactivated ()
|
|
{
|
|
if (useDpadPanel) {
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
if (dpadIconInfoList [i].dpadAbilityIndex > -1) {
|
|
if (!mainPlayerAbilitiesSystem.abilityInfoList [dpadIconInfoList [i].dpadAbilityIndex].isAbilityEnabled ()) {
|
|
setDpadIconInfo (dpadIconInfoList [i], -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
if (currentAbilityIcon.dpadAbilityIndex > -1) {
|
|
if (!mainPlayerAbilitiesSystem.abilityInfoList [currentAbilityIcon.dpadAbilityIndex].isAbilityEnabled ()) {
|
|
setDpadIconInfo (currentAbilityIcon, -1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void playSound (AudioElement sound)
|
|
{
|
|
if (sound != null) {
|
|
AudioPlayer.PlayOneShot (sound, gameObject);
|
|
}
|
|
}
|
|
|
|
public void setUsedByAIState (bool state)
|
|
{
|
|
usedByAI = state;
|
|
}
|
|
|
|
public void setUseDpadPanelState (bool state)
|
|
{
|
|
useDpadPanel = state;
|
|
}
|
|
|
|
public void updateEnergySlider ()
|
|
{
|
|
if (useDpadPanel && Application.isPlaying) {
|
|
abilitiesEnergySlider.maxValue = mainEnerySlider.maxValue;
|
|
abilitiesEnergySlider.value = mainEnerySlider.value;
|
|
}
|
|
}
|
|
|
|
public void activateAbilityCoolDown (string abilityName)
|
|
{
|
|
int dpadAbilityIndex = getDpadIconInfoListIndexByAbilityName (abilityName);
|
|
|
|
if (dpadAbilityIndex > -1) {
|
|
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [dpadAbilityIndex];
|
|
|
|
if (currentDpadIconInfo.limitTextGameObject.activeSelf) {
|
|
currentDpadIconInfo.limitTextGameObject.SetActive (false);
|
|
}
|
|
|
|
if (currentDpadIconInfo.coolDownCoroutine != null) {
|
|
StopCoroutine (currentDpadIconInfo.coolDownCoroutine);
|
|
}
|
|
|
|
currentDpadIconInfo.coolDownCoroutine = StartCoroutine (activateAbilityCoolDownCoroutine (currentDpadIconInfo));
|
|
}
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
if (currentAbilityIcon.abilityName.Equals (abilityName)) {
|
|
if (currentAbilityIcon.limitTextGameObject.activeSelf) {
|
|
currentAbilityIcon.limitTextGameObject.SetActive (false);
|
|
}
|
|
|
|
if (currentAbilityIcon.coolDownCoroutine != null) {
|
|
StopCoroutine (currentAbilityIcon.coolDownCoroutine);
|
|
}
|
|
|
|
currentAbilityIcon.coolDownCoroutine = StartCoroutine (activateAbilityCoolDownCoroutine (currentAbilityIcon));
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator activateAbilityCoolDownCoroutine (dpadIconInfo currentDpadIconInfo)
|
|
{
|
|
if (showDebugPrint) {
|
|
print (currentDpadIconInfo.abilityName);
|
|
}
|
|
|
|
float t = mainPlayerAbilitiesSystem.abilityInfoList [currentDpadIconInfo.dpadAbilityIndex].getCoolDownDurationValue ();
|
|
|
|
currentDpadIconInfo.icon.fillAmount = 0;
|
|
|
|
float timer = 0;
|
|
|
|
float fillamount = 0;
|
|
|
|
while (timer < t) {
|
|
timer += Time.deltaTime;
|
|
|
|
fillamount = timer / t;
|
|
|
|
currentDpadIconInfo.icon.fillAmount = Mathf.MoveTowards (currentDpadIconInfo.icon.fillAmount, fillamount, fillamount);
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public void activateAbilityLimit (string abilityName)
|
|
{
|
|
int dpadAbilityIndex = getDpadIconInfoListIndexByAbilityName (abilityName);
|
|
|
|
if (dpadAbilityIndex > -1) {
|
|
dpadIconInfo currentDpadIconInfo = dpadIconInfoList [dpadAbilityIndex];
|
|
|
|
stopActivateAbilityLimit (currentDpadIconInfo);
|
|
|
|
currentDpadIconInfo.limitCoroutine = StartCoroutine (activateAbilityLimitCoroutine (currentDpadIconInfo));
|
|
}
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
if (currentAbilityIcon.abilityName.Equals (abilityName)) {
|
|
stopActivateAbilityLimit (currentAbilityIcon);
|
|
|
|
currentAbilityIcon.limitCoroutine = StartCoroutine (activateAbilityLimitCoroutine (currentAbilityIcon));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopActivateAbilityLimit (dpadIconInfo currentDpadIconInfo)
|
|
{
|
|
if (currentDpadIconInfo != null) {
|
|
if (currentDpadIconInfo.limitCoroutine != null) {
|
|
StopCoroutine (currentDpadIconInfo.limitCoroutine);
|
|
}
|
|
|
|
if (currentDpadIconInfo.limitTextGameObject.activeSelf) {
|
|
currentDpadIconInfo.limitTextGameObject.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator activateAbilityLimitCoroutine (dpadIconInfo currentDpadIconInfo)
|
|
{
|
|
if (showDebugPrint) {
|
|
print (currentDpadIconInfo.abilityName);
|
|
}
|
|
|
|
float t = mainPlayerAbilitiesSystem.abilityInfoList [currentDpadIconInfo.dpadAbilityIndex].getTimeLimitValue ();
|
|
|
|
float timer = 0;
|
|
|
|
if (!currentDpadIconInfo.limitTextGameObject.activeSelf) {
|
|
currentDpadIconInfo.limitTextGameObject.SetActive (true);
|
|
}
|
|
|
|
while (timer < t) {
|
|
timer += Time.deltaTime;
|
|
|
|
currentDpadIconInfo.limitText.text = (t - timer).ToString ("##.0");
|
|
|
|
yield return null;
|
|
}
|
|
|
|
currentDpadIconInfo.limitTextGameObject.SetActive (false);
|
|
}
|
|
|
|
public void setInputPausedState (bool state)
|
|
{
|
|
inputPaused = state;
|
|
}
|
|
|
|
public void toggleInputPausedState ()
|
|
{
|
|
setInputPausedState (!inputPaused);
|
|
}
|
|
|
|
bool canUseInput ()
|
|
{
|
|
if (playerControllerManager.iscloseCombatAttackInProcess ()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void setNumberOfAbilitySlotsValue (int newAmount)
|
|
{
|
|
numberOfAbilitySlots = newAmount;
|
|
}
|
|
|
|
public void updateNumberOfAbilitySlotsWithAbilitiesAmount ()
|
|
{
|
|
setNumberOfAbilitySlotsValue (mainPlayerAbilitiesSystem.getNumberOfAbilitiesAvailable ());
|
|
}
|
|
|
|
bool playerIsBusy ()
|
|
{
|
|
if (mainPlayerAbilitiesSystem.isActionActive ()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//INPUT FUNCTIONS
|
|
public void inputOpenOrCloseAbilityWheel (bool openAbilityWheel)
|
|
{
|
|
if (!openMenuEnabled) {
|
|
if (showDebugPrint) {
|
|
print ("open Menu not Enabled, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!abilityListManagerEnabled) {
|
|
if (showDebugPrint) {
|
|
print ("ability list manager not Enabled, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
if (showDebugPrint) {
|
|
print ("Wheel menu can't be opened due to input paused, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
if (showDebugPrint) {
|
|
print ("Wheel menu can't be opened due to can't use input, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (playerIsBusy ()) {
|
|
if (showDebugPrint) {
|
|
print ("Wheel menu can't be opened due to player busy, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (pauseManager.isOpenOrClosePlayerOpenMenuByNamePaused ()) {
|
|
if (showDebugPrint) {
|
|
print ("player open menu by name paused, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//if the select Ability button is holding, enable the Ability wheel to select Ability
|
|
if (openAbilityWheel) {
|
|
selectAbilitySlots (true);
|
|
} else {
|
|
selectAbilitySlots (false);
|
|
}
|
|
}
|
|
|
|
public void inputStartToPressAbilityWheelPanel ()
|
|
{
|
|
//if (!abilityListManagerEnabled) {
|
|
// return;
|
|
//}
|
|
|
|
//if (inputPaused) {
|
|
// return;
|
|
//}
|
|
|
|
//if (playerIsBusy ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (pauseManager.isOpenOrClosePlayerOpenMenuByNamePaused ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (!canUseInput ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (abilityListManagerEnabled) {
|
|
// selectAbilitySlots (true);
|
|
//}
|
|
|
|
inputOpenOrCloseAbilityWheel (true);
|
|
}
|
|
|
|
public void inputStopToPressAbilityWheelPanel ()
|
|
{
|
|
//if (!abilityListManagerEnabled) {
|
|
// return;
|
|
//}
|
|
|
|
//if (inputPaused) {
|
|
// return;
|
|
//}
|
|
|
|
//if (playerIsBusy ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (pauseManager.isOpenOrClosePlayerOpenMenuByNamePaused ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (!canUseInput ()) {
|
|
// return;
|
|
//}
|
|
|
|
//if (selectingAbility) {
|
|
// selectAbilitySlots (false);
|
|
//}
|
|
|
|
inputOpenOrCloseAbilityWheel (false);
|
|
}
|
|
|
|
public void inputUseDpadDirectionPressDown (int dpadIndex)
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to input paused, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to can't use input, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (playerIsBusy ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to player busy, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to ability input in use, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (playerControllerManager.isGamePaused ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to game paused, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (playerControllerManager.isPlayerMenuActive ()) {
|
|
if (!selectingAbility) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press down can't be used due to player menu active, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (selectingAbility) {
|
|
|
|
if (showDebugPrint) {
|
|
print ("Trying to assign quick access slot to ability ");
|
|
}
|
|
|
|
if (closestSlot != null) {
|
|
|
|
bool abilityFound = false;
|
|
|
|
for (int i = 0; i < dpadIconInfoList.Count; i++) {
|
|
if (!abilityFound && dpadIconInfoList [i].dpadAbilityIndex == closestSlot.abilityIndex) {
|
|
setDpadIconInfo (dpadIconInfoList [i], -1);
|
|
|
|
abilityFound = true;
|
|
}
|
|
}
|
|
|
|
setDpadIconInfo (dpadIconInfoList [dpadIndex], closestSlot.abilityIndex);
|
|
|
|
updateDpadIconsOnWheelMenu ();
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (true);
|
|
|
|
if (showDebugPrint) {
|
|
print ("Selecting quick access slot to ability " + closestSlot.Name + " on index " + dpadIndex);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentAbilityPressedIndex == -1) {
|
|
if (dpadIconInfoList [dpadIndex].iconActive) {
|
|
|
|
currentAbilityPressedIndex = dpadIndex;
|
|
|
|
if (showDebugPrint) {
|
|
print (dpadIconInfoList [dpadIndex].abilityName + " " + dpadIndex);
|
|
}
|
|
|
|
mainPlayerAbilitiesSystem.setCurrentAbilityByName (dpadIconInfoList [dpadIndex].abilityName);
|
|
|
|
mainPlayerAbilitiesSystem.pressDownUseCurrentAbility ();
|
|
|
|
if (useCurrentAbilityIcon) {
|
|
setDpadIconInfo (currentAbilityIcon, dpadIconInfoList [dpadIndex].dpadAbilityIndex);
|
|
|
|
updateCurrentAbilityInputText ();
|
|
|
|
checkEventsOnAbilitiesAssignedOnDpad (true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputUseDpadDirectionPressHold ()
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
return;
|
|
}
|
|
|
|
if (selectingAbility) {
|
|
return;
|
|
}
|
|
|
|
if (currentAbilityPressedIndex != -1) {
|
|
mainPlayerAbilitiesSystem.pressHoldUseCurrentAbility ();
|
|
}
|
|
}
|
|
|
|
public void inputUseDpadDirectionPressUp ()
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press up can't be used due to input paused, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press up can't be used due to can't use input, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press up can't be used due to ability input in used, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (selectingAbility) {
|
|
if (showDebugPrint) {
|
|
print ("input dpad press up can't be used due to selecting ability, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (currentAbilityPressedIndex != -1) {
|
|
mainPlayerAbilitiesSystem.pressUpUseCurrentAbility ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("pressing up ability " + dpadIconInfoList [currentAbilityPressedIndex].abilityName + " " + currentAbilityPressedIndex);
|
|
}
|
|
|
|
currentAbilityPressedIndex = -1;
|
|
}
|
|
}
|
|
|
|
public void resetCurrentAbilityPressedIndexByName (string abilityName)
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (currentAbilityPressedIndex != -1) {
|
|
if (currentAbilityPressedIndex < dpadIconInfoList.Count &&
|
|
dpadIconInfoList [currentAbilityPressedIndex].abilityName.Equals (abilityName)) {
|
|
|
|
currentAbilityPressedIndex = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputTouchPressDown (int dpadIndex)
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (playerIsBusy ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
return;
|
|
}
|
|
|
|
if (touchPlatform || pauseManager.isUsingTouchControls ()) {
|
|
inputUseDpadDirectionPressDown (dpadIndex);
|
|
|
|
touchPressHoldActive = true;
|
|
}
|
|
}
|
|
|
|
public void inputTouchPressUp ()
|
|
{
|
|
if (!abilityListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (inputPaused) {
|
|
return;
|
|
}
|
|
|
|
if (!canUseInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isAbilityInputInUse ()) {
|
|
return;
|
|
}
|
|
|
|
if (touchPlatform || pauseManager.isUsingTouchControls ()) {
|
|
touchPressHoldActive = false;
|
|
|
|
inputUseDpadDirectionPressUp ();
|
|
}
|
|
}
|
|
|
|
public bool isSelectingAbilityActive ()
|
|
{
|
|
return selectingAbility;
|
|
}
|
|
|
|
public void setOpenMenuEnabled (bool state)
|
|
{
|
|
openMenuEnabled = state;
|
|
}
|
|
|
|
//EDITOR FUNCTIONS
|
|
public void setUseDpadPanelStateFromEditor (bool state)
|
|
{
|
|
setUseDpadPanelState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void setOpenMenuEnabledFromEditor (bool state)
|
|
{
|
|
setOpenMenuEnabled (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Abilities UI System", gameObject);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class abilitySlotInfo
|
|
{
|
|
public string Name;
|
|
|
|
public string abilityDescription;
|
|
|
|
public bool slotActive;
|
|
|
|
public GameObject slot;
|
|
public RectTransform slotRectTransform;
|
|
|
|
public int abilityIndex;
|
|
|
|
public bool slotVisible = true;
|
|
|
|
public RawImage abilityIcon;
|
|
public Texture abilityTexture;
|
|
public GameObject currentAbilitySelectedIcon;
|
|
|
|
public RectTransform slotPivot;
|
|
public RectTransform slotCenter;
|
|
|
|
public RectTransform innerSlot;
|
|
|
|
public Coroutine sizeCoroutine;
|
|
|
|
public dpadDirection currentDpadDirection;
|
|
|
|
public GameObject dpadIcon;
|
|
public GameObject upDpadIcon;
|
|
public GameObject downDpadIcon;
|
|
public GameObject leftDpadIcon;
|
|
public GameObject rightDpadIcon;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class dpadIconInfo
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string Name;
|
|
public string abilityName;
|
|
|
|
[Space]
|
|
[Header ("UI Components")]
|
|
[Space]
|
|
|
|
public Image icon;
|
|
public RawImage backgroundIcon;
|
|
public GameObject iconActiveGameObject;
|
|
|
|
public GameObject limitTextGameObject;
|
|
public Text limitText;
|
|
|
|
public GameObject dpadIconGameObject;
|
|
|
|
public dpadDirection currentDpadDirection;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool iconActive;
|
|
|
|
public int abilitySlotIndex;
|
|
|
|
public bool dpadIconAssigned;
|
|
|
|
public int dpadAbilityIndex;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool setInitialAbilityIndex;
|
|
public int initialAbilityIndex;
|
|
|
|
public Coroutine coolDownCoroutine;
|
|
public Coroutine limitCoroutine;
|
|
}
|
|
} |