731 lines
20 KiB
C#
731 lines
20 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 weaponListManager : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool weaponListManagerEnabled;
|
|
|
|
public Vector2 range = new Vector2 (5f, 3f);
|
|
public float rotationHUDSpeed = 20;
|
|
|
|
public float timeToShowWeaponSlotsWheel = 1;
|
|
|
|
public int numberOfWeaponSlots = 8;
|
|
|
|
public bool useBlurUIPanel = true;
|
|
|
|
public bool drawSelectedWeapon;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool slowDownTimeWhenMenuActive;
|
|
public float timeScaleWhenMenuActive;
|
|
|
|
public bool selectWeaponOnMenuClose;
|
|
|
|
public bool useSoundOnSlot;
|
|
public AudioClip soundEffect;
|
|
public AudioElement soundEffectAudioElement;
|
|
public AudioSource mainAudioSource;
|
|
|
|
public bool changeCurrentSlotSize;
|
|
public float changeCurrentSlotSpeed;
|
|
public float changeCurrentSlotMultiplier;
|
|
public float distanceFromCenterToSelectWeapon = 10;
|
|
|
|
public bool playerCanMoveStatePausedOnMenuOpened = true;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool selectingWeapon;
|
|
|
|
public bool usingDualWepaon;
|
|
|
|
public bool selectingRightWeapon;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool usedByAI;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public GameObject weaponSlotsMenu;
|
|
public GameObject weaponsListElement;
|
|
public Transform weaponsSlotsWheel;
|
|
public Text currentWeaponNameText;
|
|
public GameObject completeWeaponsWheel;
|
|
public Transform slotArrow;
|
|
public Transform slotArrowIcon;
|
|
|
|
public RectTransform rightHandWheelPosition;
|
|
public RectTransform leftHandWheelPosition;
|
|
|
|
public RectTransform dualHandIcon;
|
|
|
|
public Camera mainCamera;
|
|
|
|
public menuPause pauseManager;
|
|
public playerWeaponsManager weaponsManager;
|
|
public playerController playerControllerManager;
|
|
public timeBullet timeBulletManager;
|
|
|
|
List<weaponSlotInfo> weaponSlotInfoList = new List<weaponSlotInfo> ();
|
|
|
|
weaponSlotInfo closestSlot;
|
|
weaponSlotInfo previousClosestSlot;
|
|
|
|
weaponSlotInfo closestRightSlot;
|
|
weaponSlotInfo closestLeftSlot;
|
|
|
|
float screenWidth;
|
|
float screenHeight;
|
|
bool touchPlatform;
|
|
bool touching;
|
|
Vector2 mRot = Vector2.zero;
|
|
Quaternion mStart;
|
|
|
|
int numberOfCurrentWeapons;
|
|
|
|
Touch currentTouch;
|
|
|
|
float anglePerSlot;
|
|
float currentAngle;
|
|
float lastTimeTouching;
|
|
bool isFirstWeaponSelected;
|
|
|
|
Vector3 initialTouchPosition;
|
|
|
|
float currentArrowAngle;
|
|
|
|
Vector2 currentTouchPosition;
|
|
|
|
float currentDistance;
|
|
|
|
bool fingerPressingTouchPanel;
|
|
|
|
int weaponSlotInfoListCount;
|
|
|
|
private void InitializeAudioElements ()
|
|
{
|
|
if (mainAudioSource != null) {
|
|
soundEffectAudioElement.audioSource = mainAudioSource;
|
|
}
|
|
|
|
if (soundEffect != null) {
|
|
soundEffectAudioElement.clip = soundEffect;
|
|
}
|
|
}
|
|
|
|
void Start ()
|
|
{
|
|
InitializeAudioElements ();
|
|
|
|
if (usedByAI) {
|
|
return;
|
|
}
|
|
|
|
if (!weaponListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
//for every weapon created in the player weapons manager inspector, add to the list of the weapon manager
|
|
for (int i = 0; i < numberOfWeaponSlots; i++) {
|
|
GameObject newWeaponsListElement = (GameObject)Instantiate (weaponsListElement, Vector3.zero, Quaternion.identity, weaponsSlotsWheel);
|
|
newWeaponsListElement.name = "Weapon Slot " + (i + 1);
|
|
|
|
newWeaponsListElement.transform.localScale = Vector3.one;
|
|
newWeaponsListElement.transform.position = weaponsListElement.transform.position;
|
|
|
|
weaponSlotInfo newWeaponSlotInfo = newWeaponsListElement.GetComponent<weaponSlotElement> ().slotInfo;
|
|
|
|
//add this element to the list
|
|
weaponSlotInfoList.Add (newWeaponSlotInfo);
|
|
}
|
|
|
|
weaponSlotInfoListCount = weaponSlotInfoList.Count;
|
|
|
|
weaponsListElement.SetActive (false);
|
|
|
|
//get the rotation of the weapon wheel
|
|
mStart = completeWeaponsWheel.transform.localRotation;
|
|
|
|
//check if the platform is a touch device or not
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
if (usedByAI) {
|
|
return;
|
|
}
|
|
|
|
if (!weaponListManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
//if the player is selecting or the touch controls are enabled, then
|
|
if (weaponsManager.isWeaponsModeActive () && (selectingWeapon || 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 (!selectingWeapon) {
|
|
if (Time.time > lastTimeTouching + timeToShowWeaponSlotsWheel) {
|
|
selectWeaponsSlots (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Ended) {
|
|
if (touching && selectingWeapon) {
|
|
selectWeaponsSlots (false);
|
|
}
|
|
|
|
touching = false;
|
|
|
|
fingerPressingTouchPanel = false;
|
|
|
|
return;
|
|
}
|
|
|
|
if (selectingWeapon) {
|
|
//get the current screen size
|
|
screenWidth = Screen.width;
|
|
screenHeight = Screen.height;
|
|
|
|
//get the arrow rotates toward the mouse, selecting the closest weapon to it
|
|
Vector2 slotDirection = new Vector2 (currentTouchPosition.x, currentTouchPosition.y) - slotArrow.GetComponent<RectTransform> ().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) > distanceFromCenterToSelectWeapon) {
|
|
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);
|
|
|
|
completeWeaponsWheel.transform.localRotation = mStart * Quaternion.Euler (mRot.y * range.y, -mRot.x * range.x, 0f);
|
|
|
|
//get the weapon inside the wheel closest to the mouse
|
|
float distance = Mathf.Infinity;
|
|
|
|
for (int k = 0; k < weaponSlotInfoListCount; k++) {
|
|
if (weaponSlotInfoList [k].slotActive) {
|
|
currentDistance = GKC_Utils.distance (slotArrowIcon.position, weaponSlotInfoList [k].weaponIcon.transform.position);
|
|
|
|
if (currentDistance < distance) {
|
|
distance = currentDistance;
|
|
closestSlot = weaponSlotInfoList [k];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (previousClosestSlot != closestSlot) {
|
|
if (changeCurrentSlotSize) {
|
|
if (previousClosestSlot != null) {
|
|
changeSlotSize (previousClosestSlot, true, changeCurrentSlotMultiplier, true);
|
|
}
|
|
}
|
|
|
|
previousClosestSlot = closestSlot;
|
|
|
|
if (usingDualWepaon) {
|
|
if (selectingRightWeapon) {
|
|
closestRightSlot = closestSlot;
|
|
} else {
|
|
closestLeftSlot = closestSlot;
|
|
}
|
|
}
|
|
|
|
if (changeCurrentSlotSize) {
|
|
changeSlotSize (closestSlot, false, changeCurrentSlotMultiplier, true);
|
|
}
|
|
|
|
if (closestSlot.Name != "") {
|
|
currentWeaponNameText.text = closestSlot.Name;
|
|
}
|
|
|
|
if (useSoundOnSlot) {
|
|
playSound (soundEffectAudioElement);
|
|
}
|
|
}
|
|
|
|
//set the name of the closest weapon in the center of the weapon wheel
|
|
if (weaponsManager.getCurrentWeaponSystem () != closestSlot.weaponSystem || !isFirstWeaponSelected || usingDualWepaon) {
|
|
isFirstWeaponSelected = true;
|
|
|
|
if (!selectWeaponOnMenuClose && !selectingRightWeapon) {
|
|
selectWeapon (closestSlot);
|
|
}
|
|
}
|
|
} else {
|
|
if (slotArrow.gameObject.activeSelf) {
|
|
slotArrow.gameObject.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setTouchingMenuPanelState (bool state)
|
|
{
|
|
fingerPressingTouchPanel = state;
|
|
|
|
pauseManager.setIgnoreDisableTouchZoneListState (fingerPressingTouchPanel);
|
|
}
|
|
|
|
public void selectWeapon (weaponSlotInfo slotInfo)
|
|
{
|
|
bool dualWeaponsCanBeUsed = false;
|
|
|
|
if (usingDualWepaon) {
|
|
|
|
string rightWeaponName = "";
|
|
string leftWeaponName = "";
|
|
|
|
if (closestRightSlot != null) {
|
|
rightWeaponName = closestRightSlot.Name;
|
|
}
|
|
|
|
if (closestLeftSlot != null) {
|
|
leftWeaponName = closestLeftSlot.Name;
|
|
}
|
|
|
|
if (weaponsManager.checkIfWeaponsAvailable ()) {
|
|
dualWeaponsCanBeUsed = true;
|
|
|
|
if (rightWeaponName.Equals ("") || leftWeaponName.Equals ("")) {
|
|
if (rightWeaponName.Equals ("")) {
|
|
rightWeaponName = weaponsManager.getCurrentWeaponSystem ().getWeaponSystemName ();
|
|
} else {
|
|
leftWeaponName = weaponsManager.getCurrentWeaponSystem ().getWeaponSystemName ();
|
|
}
|
|
|
|
if (rightWeaponName.Equals (leftWeaponName)) {
|
|
if (showDebugPrint) {
|
|
print ("the player is trying to use the same weapon on both slots or hasn't selected two weapons in the weapons wheel menu");
|
|
}
|
|
|
|
dualWeaponsCanBeUsed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dualWeaponsCanBeUsed) {
|
|
|
|
int rightWeaponNumberKey = -1;
|
|
int leftWeaponNumberKey = -1;
|
|
|
|
playerWeaponSystem rightWeaponSystem = weaponsManager.getWeaponSystemByName (rightWeaponName);
|
|
|
|
if (rightWeaponSystem != null) {
|
|
rightWeaponNumberKey = rightWeaponSystem.getWeaponNumberKey ();
|
|
}
|
|
|
|
if (rightWeaponNumberKey > -1) {
|
|
weaponsManager.removeWeaponConfiguredAsDualWeaponState (rightWeaponNumberKey);
|
|
}
|
|
|
|
playerWeaponSystem leftWeaponSystem = weaponsManager.getWeaponSystemByName (leftWeaponName);
|
|
|
|
if (leftWeaponSystem != null) {
|
|
leftWeaponNumberKey = leftWeaponSystem.getWeaponNumberKey ();
|
|
}
|
|
|
|
if (leftWeaponNumberKey > -1) {
|
|
weaponsManager.removeWeaponConfiguredAsDualWeaponState (leftWeaponNumberKey);
|
|
}
|
|
|
|
if (rightWeaponNumberKey > -1 && leftWeaponNumberKey > -1) {
|
|
weaponsManager.changeDualWeapons (rightWeaponName, leftWeaponName);
|
|
|
|
weaponsManager.updateWeaponSlotInfo ();
|
|
|
|
for (int k = 0; k < weaponSlotInfoListCount; k++) {
|
|
if (weaponSlotInfoList [k].currentWeaponSelectedIcon.activeSelf) {
|
|
weaponSlotInfoList [k].currentWeaponSelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!dualWeaponsCanBeUsed) {
|
|
weaponsManager.selectWeaponByName (slotInfo.Name, drawSelectedWeapon);
|
|
|
|
for (int k = 0; k < weaponSlotInfoListCount; k++) {
|
|
if (slotInfo.weaponSystem == weaponSlotInfoList [k].weaponSystem) {
|
|
if (!weaponSlotInfoList [k].currentWeaponSelectedIcon.activeSelf) {
|
|
weaponSlotInfoList [k].currentWeaponSelectedIcon.SetActive (true);
|
|
}
|
|
} else {
|
|
if (weaponSlotInfoList [k].currentWeaponSelectedIcon.activeSelf) {
|
|
weaponSlotInfoList [k].currentWeaponSelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void changeSlotSize (weaponSlotInfo slotInfo, bool setRegularSize, float sizeMultiplier, bool smoothSizeChange)
|
|
{
|
|
if (slotInfo.sizeCoroutine != null) {
|
|
StopCoroutine (slotInfo.sizeCoroutine);
|
|
}
|
|
|
|
slotInfo.sizeCoroutine = StartCoroutine (changeSlotSizeCoroutine (slotInfo, setRegularSize, sizeMultiplier, smoothSizeChange));
|
|
}
|
|
|
|
IEnumerator changeSlotSizeCoroutine (weaponSlotInfo slotInfo, bool setRegularSize, float sizeMultiplier, bool smoothSizeChange)
|
|
{
|
|
Vector3 targetValue = Vector3.one;
|
|
|
|
if (!setRegularSize) {
|
|
targetValue *= sizeMultiplier;
|
|
}
|
|
|
|
if (smoothSizeChange) {
|
|
while (slotInfo.slotCenter.localScale != targetValue) {
|
|
slotInfo.slotCenter.localScale = Vector3.MoveTowards (slotInfo.slotCenter.localScale, targetValue, Time.deltaTime * changeCurrentSlotMultiplier);
|
|
yield return null;
|
|
}
|
|
} else {
|
|
slotInfo.slotCenter.localScale = targetValue;
|
|
}
|
|
}
|
|
|
|
//enable the weapon wheel to select the current weapon to use
|
|
public void selectWeaponsSlots (bool state)
|
|
{
|
|
//check that the game is not paused, that the player is not editing the weapon, using a device and that the weapon manager can be enabled
|
|
if ((canBeOpened () || selectingWeapon)) {
|
|
|
|
if (!weaponsManager.checkIfWeaponsAvailable ()) {
|
|
return;
|
|
}
|
|
|
|
selectingWeapon = state;
|
|
|
|
if (!selectingWeapon) {
|
|
if (changeCurrentSlotSize && closestSlot != null) {
|
|
changeSlotSize (closestSlot, true, changeCurrentSlotMultiplier, false);
|
|
}
|
|
}
|
|
|
|
pauseManager.openOrClosePlayerMenu (selectingWeapon, weaponSlotsMenu.transform, useBlurUIPanel);
|
|
|
|
//enable the weapon wheel
|
|
completeWeaponsWheel.SetActive (selectingWeapon);
|
|
|
|
pauseManager.setIngameMenuOpenedState ("Weapon List Manager", selectingWeapon, true);
|
|
|
|
pauseManager.enableOrDisablePlayerMenu (selectingWeapon, playerCanMoveStatePausedOnMenuOpened, false);
|
|
|
|
//reset the arrow and the wheel rotation
|
|
completeWeaponsWheel.transform.localRotation = Quaternion.identity;
|
|
|
|
slotArrow.localRotation = Quaternion.identity;
|
|
|
|
if (selectingWeapon) {
|
|
|
|
updateSlotsInfo ();
|
|
|
|
if (!touchPlatform) {
|
|
initialTouchPosition = touchJoystick.convertMouseIntoFinger ().position;
|
|
} else {
|
|
initialTouchPosition = Input.GetTouch (1).position;
|
|
}
|
|
|
|
if (slowDownTimeWhenMenuActive) {
|
|
timeBulletManager.setBulletTimeState (true, timeScaleWhenMenuActive);
|
|
}
|
|
|
|
if (usingDualWepaon) {
|
|
dualHandIcon.gameObject.SetActive (true);
|
|
|
|
setRightOrLeftWeapon (true);
|
|
} else {
|
|
dualHandIcon.gameObject.SetActive (false);
|
|
|
|
completeWeaponsWheel.GetComponent<RectTransform> ().anchoredPosition = Vector3.zero;
|
|
}
|
|
} else {
|
|
isFirstWeaponSelected = false;
|
|
|
|
if (slowDownTimeWhenMenuActive) {
|
|
timeBulletManager.setBulletTimeState (false, 1);
|
|
}
|
|
|
|
if ((selectWeaponOnMenuClose || selectingRightWeapon) && closestSlot != null) {
|
|
selectWeapon (closestSlot);
|
|
}
|
|
}
|
|
|
|
closestSlot = null;
|
|
previousClosestSlot = null;
|
|
|
|
closestRightSlot = null;
|
|
closestLeftSlot = null;
|
|
}
|
|
}
|
|
|
|
public bool canBeOpened ()
|
|
{
|
|
if (pauseManager.isGamePaused ()) {
|
|
return false;
|
|
}
|
|
|
|
if (playerControllerManager.isUsingDevice ()) {
|
|
return false;
|
|
}
|
|
|
|
if (!weaponListManagerEnabled) {
|
|
return false;
|
|
}
|
|
|
|
if (!weaponsManager.isWeaponsModeActive ()) {
|
|
return false;
|
|
}
|
|
|
|
if (playerControllerManager.isPlayerMenuActive ()) {
|
|
return false;
|
|
}
|
|
|
|
if (playerControllerManager.iscloseCombatAttackInProcess ()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void udpateSlotsInfo ()
|
|
{
|
|
updateSlotsInfo ();
|
|
}
|
|
|
|
public void updateSlotsInfo ()
|
|
{
|
|
numberOfCurrentWeapons = weaponsManager.getNumberOfWeaponsAvailable ();
|
|
|
|
anglePerSlot = 360 / (float)numberOfCurrentWeapons;
|
|
currentAngle = 0;
|
|
|
|
for (int j = 0; j < weaponSlotInfoListCount; j++) {
|
|
weaponSlotInfoList [j].slotActive = false;
|
|
|
|
if (weaponSlotInfoList [j].slot.activeSelf) {
|
|
weaponSlotInfoList [j].slot.SetActive (false);
|
|
}
|
|
}
|
|
|
|
int currentSlotIndex = 0;
|
|
|
|
bool anySlotAviable = false;
|
|
|
|
int weaponsListCount = weaponsManager.weaponsList.Count;
|
|
|
|
for (int i = 0; i < weaponsListCount; i++) {
|
|
|
|
if (weaponsManager.weaponsList [i].weaponEnabled) {
|
|
if (currentSlotIndex < weaponSlotInfoListCount) {
|
|
weaponSlotInfo newWeaponSlotInfo = weaponSlotInfoList [currentSlotIndex];
|
|
|
|
if (!newWeaponSlotInfo.slotActive) {
|
|
newWeaponSlotInfo.slot.GetComponent<RectTransform> ().rotation = Quaternion.Euler (new Vector3 (0, 0, currentAngle));
|
|
|
|
currentAngle += anglePerSlot;
|
|
|
|
playerWeaponSystem newPlayerWeaponSystem = weaponsManager.weaponsList [i].getWeaponSystemManager ();
|
|
|
|
newWeaponSlotInfo.Name = newPlayerWeaponSystem.weaponSettings.Name;
|
|
newWeaponSlotInfo.weaponSystem = newPlayerWeaponSystem;
|
|
newWeaponSlotInfo.weaponAmmoText.text = newPlayerWeaponSystem.getCurrentAmmoText ();
|
|
//newWeaponSlotInfo.weaponAmmoText.transform.rotation = Quaternion.identity;
|
|
|
|
newWeaponSlotInfo.ammoAmountIcon.transform.rotation = Quaternion.identity;
|
|
|
|
newWeaponSlotInfo.weaponIcon.transform.rotation = Quaternion.identity;
|
|
|
|
Texture weaponIconTexture = newPlayerWeaponSystem.getWeaponIcon ();
|
|
|
|
if (weaponIconTexture != null) {
|
|
newWeaponSlotInfo.weaponIcon.texture = weaponIconTexture;
|
|
}
|
|
|
|
if (weaponsManager.getCurrentWeaponSystem () == newPlayerWeaponSystem) {
|
|
if (!newWeaponSlotInfo.currentWeaponSelectedIcon.activeSelf) {
|
|
newWeaponSlotInfo.currentWeaponSelectedIcon.SetActive (true);
|
|
}
|
|
|
|
currentWeaponNameText.text = newWeaponSlotInfo.Name;
|
|
} else {
|
|
if (newWeaponSlotInfo.currentWeaponSelectedIcon.activeSelf) {
|
|
newWeaponSlotInfo.currentWeaponSelectedIcon.SetActive (false);
|
|
}
|
|
}
|
|
|
|
newWeaponSlotInfo.slotActive = true;
|
|
|
|
if (!newWeaponSlotInfo.slot.activeSelf) {
|
|
newWeaponSlotInfo.slot.SetActive (true);
|
|
}
|
|
|
|
currentSlotIndex++;
|
|
|
|
anySlotAviable = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!anySlotAviable) {
|
|
selectWeaponsSlots (false);
|
|
}
|
|
}
|
|
|
|
public void playSound (AudioElement sound)
|
|
{
|
|
if (sound != null) {
|
|
AudioPlayer.PlayOneShot (sound, gameObject);
|
|
}
|
|
}
|
|
|
|
public void inputOpenOrCloseWeaponsWheel (bool openWeaponsWheel)
|
|
{
|
|
//if the select weapon button is holding, enable the weapon wheel to select weapon
|
|
if (openWeaponsWheel) {
|
|
selectWeaponsSlots (true);
|
|
} else {
|
|
selectWeaponsSlots (false);
|
|
}
|
|
}
|
|
|
|
public void setSelectingWeaponState (bool state)
|
|
{
|
|
usingDualWepaon = state;
|
|
}
|
|
|
|
public void setRightOrLeftWeapon (bool state)
|
|
{
|
|
if (!weaponsManager.isActivateDualWeaponsEnabled ()) {
|
|
return;
|
|
}
|
|
|
|
if (selectingWeapon) {
|
|
if (weaponsManager.storePickedWeaponsOnInventory) {
|
|
if (weaponsManager.getNumberOfWeaponsAvailable () >= 2) {
|
|
usingDualWepaon = true;
|
|
|
|
dualHandIcon.gameObject.SetActive (true);
|
|
|
|
selectingRightWeapon = state;
|
|
|
|
if (selectingRightWeapon) {
|
|
completeWeaponsWheel.GetComponent<RectTransform> ().anchoredPosition = rightHandWheelPosition.anchoredPosition;
|
|
|
|
dualHandIcon.localEulerAngles = new Vector3 (0, 0, 0);
|
|
} else {
|
|
completeWeaponsWheel.GetComponent<RectTransform> ().anchoredPosition = leftHandWheelPosition.anchoredPosition;
|
|
|
|
dualHandIcon.localEulerAngles = new Vector3 (0, 180, 0);
|
|
}
|
|
}
|
|
} else {
|
|
print ("WARNING: the weapons need to be managed with the inventory system to use the dual weapon system, make sure to active the option Store Picked Weapons On Inventory in both" +
|
|
"player weapons manager and inventory manager components in the player controller gameObject");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setUsedByAIState (bool state)
|
|
{
|
|
usedByAI = state;
|
|
}
|
|
|
|
public void setWeaponListManagerEnabledState (bool state)
|
|
{
|
|
weaponListManagerEnabled = state;
|
|
}
|
|
|
|
public void setWeaponListManagerEnabledStateFromEditor (bool state)
|
|
{
|
|
setWeaponListManagerEnabledState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Weapon List Manager", gameObject);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class weaponSlotInfo
|
|
{
|
|
public string Name;
|
|
public bool slotActive;
|
|
public GameObject slot;
|
|
public playerWeaponSystem weaponSystem;
|
|
public GameObject ammoAmountIcon;
|
|
public Text weaponAmmoText;
|
|
public RawImage weaponIcon;
|
|
public Texture weaponTexture;
|
|
public GameObject currentWeaponSelectedIcon;
|
|
public Transform slotCenter;
|
|
|
|
public Coroutine sizeCoroutine;
|
|
}
|
|
} |