601 lines
14 KiB
C#
601 lines
14 KiB
C#
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.Events;
|
|
|
|
using System.Reflection;
|
|
|
|
[Serializable]
|
|
public class hackTerminal : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool resetAfterIncorrectHack;
|
|
|
|
public float timerSpeed = 10;
|
|
public float typeTime;
|
|
public float minSwipeDist = 50;
|
|
|
|
public string hackingAnimation;
|
|
public GameObject electronicDeviceGameObject;
|
|
|
|
public float hackTerminalMovementSpeed = 2;
|
|
public Transform hackTerminalTargetTransform;
|
|
|
|
public Texture[] icons;
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public UnityEvent correctHackedlyFunction = new UnityEvent ();
|
|
public UnityEvent incorrectlyHackedFunction = new UnityEvent ();
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool usingPanel;
|
|
|
|
public bool showGizmo;
|
|
|
|
[Space]
|
|
[Header ("Components and UI Elements")]
|
|
[Space]
|
|
|
|
public GameObject hackHud;
|
|
public GameObject hackText;
|
|
public GameObject content;
|
|
public GameObject objectToHack;
|
|
|
|
public Image backGround;
|
|
public Text currentPasswordText;
|
|
public Color hackedColor;
|
|
public Slider timeSlider;
|
|
|
|
Vector3 originalHackTerminalPosition;
|
|
Quaternion originalHackTerminalRotation;
|
|
Coroutine hackTerminalMovementCoroutine;
|
|
bool hackTerminalMoving;
|
|
Vector3 hackTerminalTargetPosition;
|
|
Quaternion hackTerminaTargetRotation;
|
|
|
|
List<int> order = new List<int> ();
|
|
List<RawImage> iconsImage = new List<RawImage> ();
|
|
int currentButtonIndex = 0;
|
|
int i;
|
|
int j;
|
|
float hackTimer;
|
|
float typeRate;
|
|
float time;
|
|
float characterChangeRate = 0.1f;
|
|
float characterTime;
|
|
bool checkHackState;
|
|
bool disableHud;
|
|
bool swiping;
|
|
bool touchPlatform;
|
|
bool hackTerminalOpened;
|
|
bool hackTextComplete;
|
|
bool setSliderToZero;
|
|
bool changeColor;
|
|
bool hacked;
|
|
bool panelClosed;
|
|
|
|
String finalText;
|
|
string randomCharacter;
|
|
Color alpha;
|
|
RaycastHit hit;
|
|
Vector3 swipeStartPos;
|
|
Vector3 swipeFinalPos;
|
|
Touch currentTouch;
|
|
Animation hackHudAnimation;
|
|
moveCameraToDevice cameraMovementManager;
|
|
|
|
playerInputManager playerInput;
|
|
|
|
bool keyPressed;
|
|
|
|
//the hack system has been changed from the player to an independent script, so like this, can be used in any type of device to hack it.
|
|
void Start ()
|
|
{
|
|
alpha = Color.white;
|
|
alpha.a = 0.5f;
|
|
|
|
getElements ();
|
|
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
|
|
if (currentPasswordText != null) {
|
|
currentPasswordText.text = "";
|
|
|
|
int length = objectToHack.GetComponent<accessTerminal> ().code.Length;
|
|
|
|
for (int i = 0; i < length; i++) {
|
|
currentPasswordText.text += "#";
|
|
}
|
|
|
|
}
|
|
|
|
content.SetActive (false);
|
|
|
|
hackHudAnimation = hackHud.GetComponent<Animation> ();
|
|
|
|
getCameraMovementManager ();
|
|
|
|
originalHackTerminalPosition = content.transform.localPosition;
|
|
originalHackTerminalRotation = content.transform.localRotation;
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
//if the player is hacking a device, check if the WASD keys are pressed, to compare if the current key direction to press matches with the arrow direction
|
|
if (checkHackState && !hackHudAnimation.IsPlaying (hackingAnimation)) {
|
|
//in PC, the control use the key directions to hack the turret
|
|
Vector2 movementInput = playerInput.getPlayerRawMovementAxis ();
|
|
|
|
if (keyPressed) {
|
|
if (movementInput == Vector2.zero) {
|
|
keyPressed = false;
|
|
}
|
|
}
|
|
|
|
if (!keyPressed) {
|
|
if (movementInput.x < 0 || Input.GetKeyDown (KeyCode.LeftArrow)) {
|
|
checkButton (0);
|
|
|
|
keyPressed = true;
|
|
|
|
return;
|
|
}
|
|
|
|
if (movementInput.x > 0 || Input.GetKeyDown (KeyCode.RightArrow)) {
|
|
checkButton (1);
|
|
|
|
keyPressed = true;
|
|
|
|
return;
|
|
}
|
|
|
|
if (movementInput.y > 0 || Input.GetKeyDown (KeyCode.UpArrow)) {
|
|
checkButton (2);
|
|
|
|
keyPressed = true;
|
|
|
|
return;
|
|
}
|
|
|
|
if (movementInput.y < 0 || Input.GetKeyDown (KeyCode.DownArrow)) {
|
|
checkButton (3);
|
|
|
|
keyPressed = true;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
//also, if the touch controls are enabled, check any swipe in the screen, and check the direction
|
|
int touchCount = Input.touchCount;
|
|
|
|
if (!touchPlatform) {
|
|
touchCount++;
|
|
}
|
|
|
|
for (int i = 0; i < touchCount; i++) {
|
|
if (!touchPlatform) {
|
|
currentTouch = touchJoystick.convertMouseIntoFinger ();
|
|
} else {
|
|
currentTouch = Input.GetTouch (i);
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Began && !swiping) {
|
|
swipeStartPos = currentTouch.position;
|
|
swiping = true;
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Ended && swiping) {
|
|
//get the start and the final position of the swipe to get the direction, left, right, vertical or horizontal
|
|
swipeFinalPos = currentTouch.position;
|
|
swiping = false;
|
|
|
|
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) {
|
|
//print("up swipe");
|
|
checkButton (2);
|
|
|
|
return;
|
|
}
|
|
|
|
if (Vector2.Dot (currentSwipe, GKC_Utils.swipeDirections.down) > 0.906f) {
|
|
//print("down swipe");
|
|
checkButton (3);
|
|
|
|
return;
|
|
}
|
|
|
|
if (Vector2.Dot (currentSwipe, GKC_Utils.swipeDirections.left) > 0.906f) {
|
|
//print("left swipe");
|
|
checkButton (0);
|
|
|
|
return;
|
|
}
|
|
|
|
if (Vector2.Dot (currentSwipe, GKC_Utils.swipeDirections.right) > 0.906f) {
|
|
//print("right swipe");
|
|
checkButton (1);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//the player has a limit of time, if the time reachs the limit, the kack will fail
|
|
hackTimer += Time.deltaTime * timerSpeed;
|
|
|
|
timeSlider.value = hackTimer;
|
|
|
|
if (hackTimer >= timeSlider.maxValue) {
|
|
checkButton (-1);
|
|
}
|
|
}
|
|
|
|
//active the animation to close the hack HUD
|
|
if (setSliderToZero) {
|
|
|
|
timeSlider.value -= Time.deltaTime * 15;
|
|
|
|
if (timeSlider.value == 0) {
|
|
|
|
setSliderToZero = false;
|
|
|
|
disableHud = true;
|
|
|
|
hackHudAnimation [hackingAnimation].speed = 1;
|
|
hackHudAnimation.Play (hackingAnimation);
|
|
}
|
|
}
|
|
|
|
//disable all the components of the hack interface
|
|
if (disableHud && !hackHudAnimation.IsPlaying (hackingAnimation)) {
|
|
disableHud = false;
|
|
usingPanel = false;
|
|
}
|
|
|
|
//if the player ends the hacking, set a text in the HUD to show if he has successed or failed
|
|
//also the text is displayed letter by letter with a random symbol before the real letter is set
|
|
//for a hacking looking
|
|
if (!hackTextComplete && hackHud.activeSelf) {
|
|
if (Time.time - characterTime >= characterChangeRate) {
|
|
randomCharacter = randomChar ();
|
|
|
|
characterTime = Time.time;
|
|
}
|
|
|
|
hackText.GetComponent<Text> ().text = finalText.Substring (0, j) + randomCharacter;
|
|
|
|
if (Time.time - time >= typeRate) {
|
|
j++;
|
|
time = Time.time;
|
|
}
|
|
|
|
bool isChar = false;
|
|
|
|
while (!isChar) {
|
|
if ((j + 1) < finalText.Length) {
|
|
if (finalText.Substring (j, 1) == " ") {
|
|
j++;
|
|
} else {
|
|
isChar = true;
|
|
}
|
|
} else {
|
|
isChar = true;
|
|
}
|
|
}
|
|
|
|
if (hackText.GetComponent<Text> ().text.Length == finalText.Length + 1) {
|
|
|
|
hackText.GetComponent<Text> ().text = finalText;
|
|
|
|
j = 0;
|
|
time = 0;
|
|
|
|
hackTextComplete = true;
|
|
}
|
|
}
|
|
|
|
if (changeColor) {
|
|
backGround.color = Vector4.MoveTowards (backGround.color, hackedColor, Time.deltaTime * 3);
|
|
|
|
if (backGround.color == hackedColor) {
|
|
changeColor = false;
|
|
}
|
|
}
|
|
|
|
if (hacked && panelClosed && !hackTerminalMoving) {
|
|
gameObject.SetActive (false);
|
|
}
|
|
}
|
|
|
|
//enable the hack system
|
|
public void activeHack ()
|
|
{
|
|
if (!usingPanel && !hacked) {
|
|
content.SetActive (true);
|
|
|
|
moveHackTerminal (true);
|
|
|
|
setCurrentPlayer ();
|
|
|
|
cameraMovementManager.moveCamera (true);
|
|
|
|
order.Clear ();
|
|
|
|
currentButtonIndex = 0;
|
|
|
|
hackHud.SetActive (true);
|
|
|
|
//play the hack interface animation to "open" it
|
|
hackHudAnimation [hackingAnimation].speed = -1;
|
|
hackHudAnimation [hackingAnimation].time = hackHudAnimation [hackingAnimation].length;
|
|
hackHudAnimation.Play (hackingAnimation);
|
|
|
|
hackTimer = 0;
|
|
setHackText ("Hacking...");
|
|
hackTextComplete = false;
|
|
timeSlider.value = 0;
|
|
|
|
//get a random value to every button. There are four arrow Rawimage, stored in a gameObject array, so the random number is the index in the array
|
|
//the right order is an integer array, that will be compared to the pressed keys
|
|
for (int k = 0; k < icons.Length; k++) {
|
|
int randomNumber = UnityEngine.Random.Range (0, icons.Length - 1);
|
|
|
|
iconsImage [k].texture = icons [randomNumber];
|
|
iconsImage [k].color = alpha;
|
|
|
|
order.Add (randomNumber);
|
|
}
|
|
|
|
checkHackState = true;
|
|
|
|
usingPanel = true;
|
|
}
|
|
}
|
|
|
|
//disable hacking
|
|
public void disableHack (bool state)
|
|
{
|
|
setSliderToZero = true;
|
|
hackTextComplete = false;
|
|
|
|
if (state) {
|
|
StartCoroutine (resetCameraPos ());
|
|
} else {
|
|
cameraMovementManager.moveCamera (false);
|
|
}
|
|
|
|
currentButtonIndex = 0;
|
|
checkHackState = false;
|
|
}
|
|
|
|
//if the hack has failed or not, the camera is reset to its regular position in the camera player
|
|
IEnumerator resetCameraPos ()
|
|
{
|
|
yield return new WaitForSeconds (1);
|
|
|
|
cameraMovementManager.moveCamera (false);
|
|
}
|
|
|
|
//open or close the hack terminal in the object that uses it
|
|
public void moveHackTerminal (bool state)
|
|
{
|
|
if (state) {
|
|
if (!hackTerminalOpened) {
|
|
hackTerminalTargetPosition = hackTerminalTargetTransform.localPosition;
|
|
hackTerminaTargetRotation = hackTerminalTargetTransform.localRotation;
|
|
|
|
if (hackTerminalMovementCoroutine != null) {
|
|
StopCoroutine (hackTerminalMovementCoroutine);
|
|
}
|
|
|
|
hackTerminalMovementCoroutine = StartCoroutine (moveHackTerminalCoroutine ());
|
|
|
|
hackTerminalOpened = state;
|
|
}
|
|
} else {
|
|
if (hackTerminalOpened) {
|
|
hackTerminalTargetPosition = originalHackTerminalPosition;
|
|
hackTerminaTargetRotation = originalHackTerminalRotation;
|
|
|
|
if (hackTerminalMovementCoroutine != null) {
|
|
StopCoroutine (hackTerminalMovementCoroutine);
|
|
}
|
|
|
|
hackTerminalMovementCoroutine = StartCoroutine (moveHackTerminalCoroutine ());
|
|
|
|
panelClosed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator moveHackTerminalCoroutine ()
|
|
{
|
|
hackTerminalMoving = true;
|
|
|
|
float t = 0;
|
|
|
|
while (t < 1) {
|
|
//content.transform.position != hackTerminalTargetPosition && content.transform.rotation != hackTerminaTargetRotation) {
|
|
t += Time.deltaTime;
|
|
|
|
content.transform.localPosition = Vector3.Lerp (content.transform.localPosition, hackTerminalTargetPosition, t);
|
|
content.transform.localRotation = Quaternion.Slerp (content.transform.localRotation, hackTerminaTargetRotation, t);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
hackTerminalMoving = false;
|
|
}
|
|
|
|
//get a random character
|
|
string randomChar ()
|
|
{
|
|
byte value = (byte)UnityEngine.Random.Range (41f, 128f);
|
|
string c = System.Text.Encoding.ASCII.GetString (new byte[]{ value });
|
|
|
|
return c;
|
|
}
|
|
|
|
//a button is pressed, so check if the button direction matches with the direction of the arrow
|
|
void checkButton (int pressedButton)
|
|
{
|
|
if (order [currentButtonIndex] == pressedButton) {
|
|
currentButtonIndex++;
|
|
|
|
iconsImage [currentButtonIndex - 1].color = Color.white;
|
|
|
|
//the buttons have been pressed in the correct order, so the device is hacked
|
|
if (currentButtonIndex == icons.Length) {
|
|
setHackText ("Hacked Successfully!");
|
|
|
|
if (correctHackedlyFunction.GetPersistentEventCount () > 0) {
|
|
correctHackedlyFunction.Invoke ();
|
|
}
|
|
|
|
disableHack (true);
|
|
changeColor = true;
|
|
hacked = true;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//incorrect order, activate alarm
|
|
if (pressedButton == -1 || order [currentButtonIndex] != pressedButton) {
|
|
incorretlyHacked ();
|
|
}
|
|
}
|
|
|
|
public void incorretlyHacked ()
|
|
{
|
|
setHackText ("Hack failed!");
|
|
|
|
if (incorrectlyHackedFunction.GetPersistentEventCount () > 0) {
|
|
incorrectlyHackedFunction.Invoke ();
|
|
}
|
|
|
|
if (resetAfterIncorrectHack) {
|
|
disableHack (false);
|
|
} else {
|
|
disableHack (true);
|
|
}
|
|
}
|
|
|
|
public void stopHacking ()
|
|
{
|
|
setHackText ("Hack failed!");
|
|
|
|
if (incorrectlyHackedFunction.GetPersistentEventCount () > 0) {
|
|
incorrectlyHackedFunction.Invoke ();
|
|
}
|
|
|
|
setSliderToZero = true;
|
|
hackTextComplete = false;
|
|
currentButtonIndex = 0;
|
|
checkHackState = false;
|
|
|
|
if (cameraMovementManager != null) {
|
|
cameraMovementManager.stopMovement ();
|
|
}
|
|
}
|
|
|
|
void setHackText (string text)
|
|
{
|
|
finalText = text;
|
|
hackText.GetComponent<Text> ().text = "";
|
|
typeRate = typeTime / (float)finalText.Length;
|
|
}
|
|
|
|
//get the rawimages inside the hack HUD
|
|
void getElements ()
|
|
{
|
|
hackHud.gameObject.SetActive (true);
|
|
|
|
Component[] components = hackHud.transform.GetComponentsInChildren (typeof(RawImage));
|
|
foreach (RawImage child in components) {
|
|
iconsImage.Add (child);
|
|
}
|
|
|
|
hackHud.gameObject.SetActive (false);
|
|
}
|
|
|
|
public void hasMoveCameraToDevice ()
|
|
{
|
|
getCameraMovementManager ();
|
|
|
|
cameraMovementManager.hasSecondMoveCameraToDevice ();
|
|
}
|
|
|
|
public void setCurrentPlayer ()
|
|
{
|
|
GameObject currentPlayer = electronicDeviceGameObject.GetComponent<electronicDevice> ().getCurrentPlayer ();
|
|
|
|
if (currentPlayer != null) {
|
|
|
|
playerInput = currentPlayer.GetComponent<playerInputManager> ();
|
|
|
|
cameraMovementManager.setCurrentPlayer (currentPlayer);
|
|
}
|
|
}
|
|
|
|
public void getCameraMovementManager ()
|
|
{
|
|
if (cameraMovementManager == null) {
|
|
cameraMovementManager = GetComponent<moveCameraToDevice> ();
|
|
}
|
|
}
|
|
|
|
public void setTextContent (string textContent)
|
|
{
|
|
if (currentPasswordText != null) {
|
|
currentPasswordText.text = textContent;
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
if (content != null && hackTerminalTargetTransform != null) {
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawSphere (content.transform.position, 0.03f);
|
|
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawSphere (hackTerminalTargetTransform.position, 0.03f);
|
|
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawLine (content.transform.position, hackTerminalTargetTransform.position);
|
|
}
|
|
}
|
|
}
|
|
} |