523 lines
12 KiB
C#
523 lines
12 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
|
|
using System.Reflection;
|
|
using GameKitController.Audio;
|
|
|
|
public class padlockSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string currentCodeOnWheels;
|
|
public string correctCode;
|
|
public float rotateWheelSpeed;
|
|
public int numbersPerWheel;
|
|
|
|
public float waitDelayAfterUnlock;
|
|
|
|
[Space]
|
|
[Header ("Interaction Settings")]
|
|
[Space]
|
|
|
|
public bool allowToUseKeyboard;
|
|
public bool useSwipeToRotateWheels;
|
|
public float minSwipeDist;
|
|
public bool useSwipeAndClickForWheels;
|
|
|
|
public bool allowKeyboardControls;
|
|
|
|
public bool useMouseWheelToRotateActive = true;
|
|
|
|
[Space]
|
|
[Header ("Wheel Settings")]
|
|
[Space]
|
|
|
|
public List<wheelInfo> wheels = new List<wheelInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool usingDevice;
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnUnlock;
|
|
public UnityEvent eventOnUnlock;
|
|
|
|
public bool callEventsAfterActivateUnlock;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public GameObject resetButton;
|
|
|
|
public GameObject resolveButton;
|
|
|
|
public AudioClip corretPassSound;
|
|
public AudioElement corretPassAudioElement;
|
|
public AudioClip keyPressSound;
|
|
public AudioElement keyPressAudioElement;
|
|
|
|
public Transform currentWheelMark;
|
|
public Vector3 currentWheelMarkOffset;
|
|
|
|
public AudioSource audioSource;
|
|
public electronicDevice deviceManager;
|
|
public examineObjectSystem examineObjectManager;
|
|
|
|
readonly List<RaycastResult> captureRaycastResults = new List<RaycastResult> ();
|
|
int length;
|
|
bool unlocked;
|
|
|
|
bool touchPlatform;
|
|
RaycastHit hit;
|
|
GameObject currentCaptured;
|
|
Touch currentTouch;
|
|
|
|
float anglePerWheel;
|
|
|
|
bool touching;
|
|
|
|
wheelInfo currentWheelInfo;
|
|
int currentWheelIndex;
|
|
|
|
Vector3 swipeStartPos;
|
|
Vector3 swipeFinalPos;
|
|
|
|
int currentWheelRotationDirection = 1;
|
|
playerInputManager playerInput;
|
|
bool pressingHorizontalRight;
|
|
bool pressingHorizontalLeft;
|
|
bool resetingPadlock;
|
|
|
|
GameObject currentPlayer;
|
|
|
|
Vector2 axisValues;
|
|
|
|
padlockSystemPlayerManagement currentPadlockSystemPlayerManagement;
|
|
|
|
private void InitializeAudioElements ()
|
|
{
|
|
if (audioSource == null) {
|
|
audioSource = GetComponent<AudioSource> ();
|
|
}
|
|
|
|
if (audioSource != null) {
|
|
corretPassAudioElement.audioSource = audioSource;
|
|
keyPressAudioElement.audioSource = audioSource;
|
|
}
|
|
|
|
if (corretPassSound != null) {
|
|
corretPassAudioElement.clip = corretPassSound;
|
|
}
|
|
|
|
if (keyPressSound != null) {
|
|
keyPressAudioElement.clip = keyPressSound;
|
|
}
|
|
}
|
|
|
|
void Start ()
|
|
{
|
|
anglePerWheel = 360 / numbersPerWheel;
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
|
|
InitializeAudioElements ();
|
|
|
|
if (deviceManager == null) {
|
|
deviceManager = GetComponent<electronicDevice> ();
|
|
}
|
|
|
|
if (examineObjectManager == null) {
|
|
examineObjectManager = GetComponent<examineObjectSystem> ();
|
|
}
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
//if the terminal still locked, and the player is using it
|
|
if (!unlocked && usingDevice && !playerInput.isGameManagerPaused ()) {
|
|
// //use the center of the camera as mouse, checking also the touch input
|
|
int touchCount = Input.touchCount;
|
|
if (!touchPlatform) {
|
|
touchCount++;
|
|
}
|
|
|
|
for (int i = 0; i < touchCount; i++) {
|
|
if (!touchPlatform) {
|
|
currentTouch = touchJoystick.convertMouseIntoFinger ();
|
|
} else {
|
|
currentTouch = Input.GetTouch (i);
|
|
}
|
|
|
|
//get a list with all the objects under the center of the screen of the finger tap
|
|
captureRaycastResults.Clear ();
|
|
|
|
PointerEventData p = new PointerEventData (EventSystem.current);
|
|
p.position = currentTouch.position;
|
|
p.clickCount = i;
|
|
p.dragging = false;
|
|
|
|
EventSystem.current.RaycastAll (p, captureRaycastResults);
|
|
|
|
if (captureRaycastResults.Count > 0) {
|
|
currentCaptured = captureRaycastResults [0].gameObject;
|
|
//check the current number key pressed with the finger
|
|
if (currentTouch.phase == TouchPhase.Began) {
|
|
for (int k = 0; k < wheels.Count; k++) {
|
|
if (wheels [k].wheelTransform == currentCaptured.transform) {
|
|
|
|
touching = true;
|
|
changeExamineObjectState (false);
|
|
|
|
currentWheelInfo = wheels [k];
|
|
|
|
swipeStartPos = currentTouch.position;
|
|
}
|
|
}
|
|
|
|
if (resetButton) {
|
|
if (currentCaptured == resetButton) {
|
|
resetPadLock ();
|
|
}
|
|
}
|
|
|
|
if (resolveButton) {
|
|
if (currentCaptured == resolveButton) {
|
|
setCorrectCode ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Ended) {
|
|
if (touching && useSwipeToRotateWheels) {
|
|
|
|
swipeFinalPos = currentTouch.position;
|
|
|
|
Vector2 currentSwipe = new Vector2 (swipeFinalPos.x - swipeStartPos.x, swipeFinalPos.y - swipeStartPos.y);
|
|
|
|
if (currentSwipe.magnitude > minSwipeDist) {
|
|
currentSwipe.Normalize ();
|
|
if (Vector2.Dot (currentSwipe, GKC_Utils.swipeDirections.up) > 0.906f) {
|
|
//up swipe
|
|
setNextNumber ();
|
|
}
|
|
if (Vector2.Dot (currentSwipe, GKC_Utils.swipeDirections.down) > 0.906f) {
|
|
//down swipe
|
|
setPreviousNumber ();
|
|
}
|
|
}
|
|
|
|
if (useSwipeAndClickForWheels) {
|
|
checkNumber (currentWheelInfo, -1);
|
|
}
|
|
}
|
|
|
|
changeExamineObjectState (true);
|
|
|
|
touching = false;
|
|
|
|
currentWheelInfo = null;
|
|
}
|
|
|
|
if (touching && (currentTouch.phase == TouchPhase.Stationary || currentTouch.phase == TouchPhase.Moved)) {
|
|
if (!useSwipeToRotateWheels) {
|
|
checkNumber (currentWheelInfo, -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allowToUseKeyboard) {
|
|
for (int i = 0; i < 10; i++) {
|
|
if (Input.GetKeyDown ("" + i)) {
|
|
checkNumberByKeyboard (i);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allowKeyboardControls) {
|
|
axisValues = playerInput.getPlayerMovementAxis ();
|
|
|
|
if (axisValues.y < 0) {
|
|
currentWheelInfo = wheels [currentWheelIndex];
|
|
setNextNumber ();
|
|
}
|
|
|
|
if (axisValues.y > 0) {
|
|
currentWheelInfo = wheels [currentWheelIndex];
|
|
setPreviousNumber ();
|
|
}
|
|
|
|
if (!pressingHorizontalRight) {
|
|
if (axisValues.x > 0) {
|
|
setCurrentWheelIndex (1);
|
|
pressingHorizontalRight = true;
|
|
}
|
|
}
|
|
|
|
if (!pressingHorizontalLeft) {
|
|
if (axisValues.x < 0) {
|
|
setCurrentWheelIndex (-1);
|
|
pressingHorizontalLeft = true;
|
|
}
|
|
}
|
|
|
|
if (axisValues.x == 0) {
|
|
pressingHorizontalLeft = false;
|
|
pressingHorizontalRight = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setCurrentWheelIndex (int amount)
|
|
{
|
|
currentWheelIndex += amount;
|
|
|
|
if (currentWheelIndex >= wheels.Count) {
|
|
currentWheelIndex = 0;
|
|
}
|
|
|
|
if (currentWheelIndex < 0) {
|
|
currentWheelIndex = wheels.Count - 1;
|
|
}
|
|
|
|
if (currentWheelMark) {
|
|
currentWheelMark.localPosition = wheels [currentWheelIndex].wheelTransform.localPosition + currentWheelMarkOffset;
|
|
}
|
|
}
|
|
|
|
public void setPreviousNumber ()
|
|
{
|
|
currentWheelRotationDirection = 1;
|
|
|
|
checkNumber (currentWheelInfo, -1);
|
|
}
|
|
|
|
public void setNextNumber ()
|
|
{
|
|
currentWheelRotationDirection = -1;
|
|
|
|
checkNumber (currentWheelInfo, -1);
|
|
}
|
|
|
|
public void activatePadlock ()
|
|
{
|
|
usingDevice = !usingDevice;
|
|
|
|
if (usingDevice) {
|
|
currentPlayer = deviceManager.getCurrentPlayer ();
|
|
|
|
playerComponentsManager mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();
|
|
|
|
playerInput = mainPlayerComponentsManager.getPlayerInputManager ();
|
|
|
|
currentPadlockSystemPlayerManagement = mainPlayerComponentsManager.getPadlockSystemPlayerManagement ();
|
|
|
|
currentPadlockSystemPlayerManagement.setCurrentPadlockSystem (this);
|
|
}
|
|
|
|
currentPadlockSystemPlayerManagement.setUsingPadlockState (usingDevice);
|
|
}
|
|
|
|
public void checkNumberByKeyboard (int number)
|
|
{
|
|
if (wheels [currentWheelIndex].wheelRotating) {
|
|
return;
|
|
}
|
|
|
|
checkNumber (wheels [currentWheelIndex], number);
|
|
|
|
setCurrentWheelIndex (1);
|
|
}
|
|
|
|
public void checkNumber (wheelInfo wheel, int wheelNumber)
|
|
{
|
|
if (wheel.wheelRotating && !resetingPadlock) {
|
|
return;
|
|
}
|
|
|
|
AudioPlayer.PlayOneShot (keyPressAudioElement, gameObject);
|
|
|
|
if (wheelNumber > -1) {
|
|
if (wheelNumber <= numbersPerWheel) {
|
|
wheel.currentNumber = wheelNumber;
|
|
|
|
if (resetingPadlock) {
|
|
StartCoroutine (rotateCenter (currentWheelRotationDirection, wheel, wheelNumber));
|
|
} else {
|
|
checkRotateWheel (currentWheelRotationDirection, wheel, wheel.currentNumber);
|
|
}
|
|
}
|
|
} else {
|
|
wheel.currentNumber += currentWheelRotationDirection;
|
|
|
|
if (wheel.currentNumber >= numbersPerWheel) {
|
|
wheel.currentNumber = 0;
|
|
}
|
|
|
|
if (wheel.currentNumber < 0) {
|
|
wheel.currentNumber = numbersPerWheel - 1;
|
|
}
|
|
|
|
checkRotateWheel (currentWheelRotationDirection, wheel, wheel.currentNumber);
|
|
}
|
|
|
|
currentCodeOnWheels = getCurrentCodeOnWheels ();
|
|
|
|
if (currentCodeOnWheels == correctCode) {
|
|
setLockedState (true);
|
|
}
|
|
}
|
|
|
|
public string getCurrentCodeOnWheels ()
|
|
{
|
|
string code = "";
|
|
|
|
for (int i = 0; i < wheels.Count; i++) {
|
|
code += wheels [i].currentNumber.ToString ();
|
|
}
|
|
|
|
return code;
|
|
}
|
|
|
|
public void setLockedState (bool state)
|
|
{
|
|
if (state) {
|
|
AudioPlayer.PlayOneShot (corretPassAudioElement, gameObject);
|
|
unlocked = true;
|
|
|
|
GetComponent<Collider> ().enabled = false;
|
|
|
|
if (callEventsAfterActivateUnlock) {
|
|
checkStopUsingDevice ();
|
|
}
|
|
|
|
if (useEventsOnUnlock) {
|
|
eventOnUnlock.Invoke ();
|
|
}
|
|
|
|
deviceManager.unlockObject ();
|
|
|
|
if (!callEventsAfterActivateUnlock) {
|
|
checkStopUsingDevice ();
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkStopUsingDevice ()
|
|
{
|
|
if (waitDelayAfterUnlock > 0) {
|
|
StartCoroutine (waitingAfterUnlock ());
|
|
} else {
|
|
deviceManager.stopUsindDevice ();
|
|
}
|
|
}
|
|
|
|
IEnumerator waitingAfterUnlock ()
|
|
{
|
|
yield return new WaitForSeconds (waitDelayAfterUnlock);
|
|
|
|
deviceManager.stopUsindDevice ();
|
|
|
|
yield return null;
|
|
}
|
|
|
|
public void checkRotateWheel (int direction, wheelInfo wheel, int number)
|
|
{
|
|
StartCoroutine (rotateCenter (direction, wheel, number));
|
|
}
|
|
|
|
public IEnumerator rotateCenter (int direction, wheelInfo wheel, int number)
|
|
{
|
|
wheel.wheelRotating = true;
|
|
|
|
Quaternion orgRotCenter = wheel.wheelTransform.localRotation;
|
|
|
|
float rotationAmount = number * anglePerWheel * direction * (-currentWheelRotationDirection);
|
|
Quaternion dstRotCenter = Quaternion.Euler (new Vector3 (orgRotCenter.eulerAngles.x, orgRotCenter.eulerAngles.y, rotationAmount));
|
|
|
|
for (float t = 0; t < 1;) {
|
|
t += Time.deltaTime * rotateWheelSpeed;
|
|
wheel.wheelTransform.localRotation = Quaternion.Slerp (orgRotCenter, dstRotCenter, t);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
wheel.wheelRotating = false;
|
|
|
|
currentWheelRotationDirection = 1;
|
|
|
|
resetingPadlock = false;
|
|
}
|
|
|
|
public void resetPadLock ()
|
|
{
|
|
resetingPadlock = true;
|
|
|
|
for (int i = 0; i < wheels.Count; i++) {
|
|
currentWheelIndex = i;
|
|
|
|
checkNumberByKeyboard (0);
|
|
}
|
|
|
|
currentWheelIndex = 0;
|
|
|
|
setCurrentWheelIndex (0);
|
|
}
|
|
|
|
public void setCorrectCode ()
|
|
{
|
|
resetingPadlock = true;
|
|
|
|
for (int i = 0; i < wheels.Count; i++) {
|
|
currentWheelIndex = i;
|
|
|
|
checkNumberByKeyboard (int.Parse (correctCode [i].ToString ()));
|
|
}
|
|
|
|
currentWheelIndex = 0;
|
|
|
|
setCurrentWheelIndex (0);
|
|
}
|
|
|
|
public void changeExamineObjectState (bool state)
|
|
{
|
|
if (examineObjectManager != null) {
|
|
examineObjectManager.setExamineDeviceState (state);
|
|
}
|
|
}
|
|
|
|
public void inputRotateWheel (bool directionUp)
|
|
{
|
|
if (useMouseWheelToRotateActive) {
|
|
if (directionUp) {
|
|
currentWheelInfo = wheels [currentWheelIndex];
|
|
|
|
setNextNumber ();
|
|
} else {
|
|
currentWheelInfo = wheels [currentWheelIndex];
|
|
|
|
setPreviousNumber ();
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class wheelInfo
|
|
{
|
|
public string name;
|
|
public int currentNumber;
|
|
public Transform wheelTransform;
|
|
public bool wheelRotating;
|
|
}
|
|
} |