406 lines
9.6 KiB
C#
406 lines
9.6 KiB
C#
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.IO;
|
|
using System;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.EventSystems;
|
|
|
|
|
|
[System.Serializable]
|
|
//this script allows to edit the touch buttons to set their positions in run time with the mouse or finger in a touch screen, save those positions in a file,
|
|
//and reload in the next execution, in case you want to load it
|
|
public class editControlPosition : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool loadButtonsPositionEnabled = false;
|
|
|
|
public bool initializeTouchButtonsPositionEnabled = false;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public List<RectTransform> buttons = new List<RectTransform> ();
|
|
|
|
public bool mainGameManagerLocated;
|
|
|
|
[Space]
|
|
[Header ("Button Info Debug")]
|
|
[Space]
|
|
|
|
public List<Vector2> buttonsPos = new List<Vector2> ();
|
|
public List<Vector2> buttonPosDefault = new List<Vector2> ();
|
|
public List<touchButtonListener> touchButtonList = new List<touchButtonListener> ();
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public inputManager input;
|
|
public gameManager mainGameManager;
|
|
|
|
|
|
RectTransform buttonToMove;
|
|
|
|
bool enableButtonEdit = false;
|
|
bool touching;
|
|
bool grab;
|
|
|
|
int i = 0;
|
|
readonly List<RaycastResult> captureRaycastResults = new List<RaycastResult> ();
|
|
Touch currentTouch;
|
|
bool touchPlatform;
|
|
string currentSaveDataPath;
|
|
bool checkSettingsInitialized;
|
|
|
|
bool useRelativePath;
|
|
|
|
string touchControlsPositionFolderName;
|
|
string touchControlsPositionFileName;
|
|
|
|
Coroutine mainUpdateCoroutine;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
touchPlatform = touchJoystick.checkTouchPlatform ();
|
|
|
|
checkMainManager ();
|
|
|
|
if (mainGameManagerLocated) {
|
|
touchControlsPositionFolderName = mainGameManager.getTouchControlsPositionFolderName ();
|
|
|
|
touchControlsPositionFileName = mainGameManager.getTouchControlsPositionFileName ();
|
|
}
|
|
}
|
|
|
|
void checkMainManager ()
|
|
{
|
|
mainGameManagerLocated = mainGameManager != null;
|
|
|
|
if (!mainGameManagerLocated) {
|
|
mainGameManager = gameManager.Instance;
|
|
|
|
mainGameManagerLocated = mainGameManager != null;
|
|
}
|
|
|
|
if (!mainGameManagerLocated) {
|
|
mainGameManager = FindObjectOfType<gameManager> ();
|
|
|
|
mainGameManager.getComponentInstanceOnApplicationPlaying ();
|
|
|
|
mainGameManagerLocated = mainGameManager != null;
|
|
}
|
|
}
|
|
|
|
public void stopUpdateCoroutine ()
|
|
{
|
|
if (mainUpdateCoroutine != null) {
|
|
StopCoroutine (mainUpdateCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator updateCoroutine ()
|
|
{
|
|
var waitTime = new WaitForSecondsRealtime (0.00001f);
|
|
|
|
while (true) {
|
|
if (enableButtonEdit) {
|
|
//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);
|
|
}
|
|
|
|
if (currentTouch.phase == TouchPhase.Began) {
|
|
//if the finger/mouse position is above a button, it is selected to translate
|
|
captureRaycastResults.Clear ();
|
|
PointerEventData p = new PointerEventData (EventSystem.current);
|
|
p.position = currentTouch.position;
|
|
p.clickCount = i;
|
|
p.dragging = false;
|
|
EventSystem.current.RaycastAll (p, captureRaycastResults);
|
|
foreach (RaycastResult r in captureRaycastResults) {
|
|
if (buttons.Contains (r.gameObject.GetComponent<RectTransform> ())) {
|
|
grab = true;
|
|
buttonToMove = r.gameObject.GetComponent<RectTransform> ();
|
|
touching = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//the button follows the mouse/finger position
|
|
if ((currentTouch.phase == TouchPhase.Stationary || currentTouch.phase == TouchPhase.Moved) && grab) {
|
|
if (grab && buttonToMove != null) {
|
|
buttonToMove.position = new Vector2 (currentTouch.position.x, currentTouch.position.y);
|
|
}
|
|
}
|
|
|
|
//release the button
|
|
if (currentTouch.phase == TouchPhase.Ended && touching) {
|
|
touching = false;
|
|
|
|
if (grab) {
|
|
grab = false;
|
|
|
|
buttonToMove = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
yield return waitTime;
|
|
}
|
|
}
|
|
|
|
public void checkSettings ()
|
|
{
|
|
checkMainManager ();
|
|
|
|
if (!checkSettingsInitialized && mainGameManagerLocated) {
|
|
|
|
useRelativePath = mainGameManager.useRelativePath;
|
|
|
|
currentSaveDataPath = getDataPath ();
|
|
|
|
checkSettingsInitialized = true;
|
|
}
|
|
}
|
|
|
|
public string getDataPath ()
|
|
{
|
|
string dataPath = "";
|
|
|
|
if (useRelativePath) {
|
|
dataPath = touchControlsPositionFolderName;
|
|
} else {
|
|
dataPath = Application.persistentDataPath + "/" + touchControlsPositionFolderName;
|
|
}
|
|
|
|
if (!Directory.Exists (dataPath)) {
|
|
Directory.CreateDirectory (dataPath);
|
|
}
|
|
|
|
dataPath += "/";
|
|
|
|
return dataPath;
|
|
}
|
|
|
|
public void getTouchButtons ()
|
|
{
|
|
checkMainManager ();
|
|
|
|
if (mainGameManagerLocated) {
|
|
//load or not the previous positions of the buttons, saved in another execution
|
|
if (mainGameManager.loadEnabled) {
|
|
if (loadButtonsPositionEnabled) {
|
|
Load ();
|
|
|
|
loadButtonsPositionEnabled = false;
|
|
}
|
|
|
|
if (initializeTouchButtonsPositionEnabled) {
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
buttonsPos.Add (buttons [i].position);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void getTouchButtonsComponents ()
|
|
{
|
|
buttons.Clear ();
|
|
|
|
buttonPosDefault.Clear ();
|
|
|
|
touchButtonList.Clear ();
|
|
|
|
bool inputManagerLocated = input != null;
|
|
|
|
if (!inputManagerLocated) {
|
|
input = inputManager.Instance;
|
|
|
|
inputManagerLocated = input != null;
|
|
}
|
|
|
|
if (!inputManagerLocated) {
|
|
input = FindObjectOfType<inputManager> ();
|
|
|
|
input.getComponentInstanceOnApplicationPlaying ();
|
|
|
|
inputManagerLocated = input != null;
|
|
}
|
|
|
|
if (!inputManagerLocated) {
|
|
return;
|
|
}
|
|
|
|
//save all touch buttons in a list and their positions
|
|
for (i = 0; i < input.touchButtonList.Count; i++) {
|
|
if (input.touchButtonList [i] != null) {
|
|
RectTransform currentRectTransform = input.touchButtonList [i].GetComponent<RectTransform> ();
|
|
|
|
if (currentRectTransform != null) {
|
|
buttons.Add (currentRectTransform);
|
|
|
|
buttonPosDefault.Add (currentRectTransform.anchoredPosition);
|
|
|
|
touchButtonList.Add (input.touchButtonList [i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
print ("Touch Buttons Components stored");
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
//after edit the buttons, their positions are saved
|
|
public void activateEdit ()
|
|
{
|
|
enableButtonEdit = !enableButtonEdit;
|
|
|
|
stopUpdateCoroutine ();
|
|
|
|
if (enableButtonEdit) {
|
|
changeButtonsState (false);
|
|
|
|
mainUpdateCoroutine = StartCoroutine (updateCoroutine ());
|
|
|
|
} else {
|
|
buttonsPos.Clear ();
|
|
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
buttonsPos.Add (buttons [i].anchoredPosition);
|
|
}
|
|
}
|
|
|
|
Save ();
|
|
}
|
|
}
|
|
|
|
//if we cancel the edition, the buttons back to their previous position, if any of them has been moved
|
|
public void disableEdit ()
|
|
{
|
|
if (enableButtonEdit) {
|
|
enableButtonEdit = false;
|
|
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
buttons [i].anchoredPosition = buttonsPos [i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//set the buttons with their default position
|
|
public void changeToDefault ()
|
|
{
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
buttons [i].anchoredPosition = buttonPosDefault [i];
|
|
}
|
|
}
|
|
|
|
Save ();
|
|
}
|
|
|
|
//disable and enable the pointer click components in the buttons, to avoid activate them while the game is paused
|
|
public void changeButtonsState (bool state)
|
|
{
|
|
for (i = 0; i < touchButtonList.Count; i++) {
|
|
if (touchButtonList [i] != null && touchButtonList [i].enabled != state) {
|
|
touchButtonList [i].enabled = state;
|
|
}
|
|
}
|
|
}
|
|
|
|
//save in a file the positions of the button, vector2 are not serializable if I am not wrong, so every axis is save in a list of float
|
|
public void Save ()
|
|
{
|
|
checkSettings ();
|
|
|
|
savedButtons sB = new savedButtons ();
|
|
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
sB.saveButtonsPosX.Add (buttons [i].position.x);
|
|
sB.saveButtonsPosY.Add (buttons [i].position.y);
|
|
}
|
|
}
|
|
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
|
|
FileStream file = File.Create (currentSaveDataPath + touchControlsPositionFileName + ".txt");
|
|
|
|
bf.Serialize (file, sB.saveButtonsPosX);
|
|
|
|
bf.Serialize (file, sB.saveButtonsPosY);
|
|
|
|
file.Close ();
|
|
|
|
buttonsPos.Clear ();
|
|
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
buttonsPos.Add (new Vector2 (sB.saveButtonsPosX [i], sB.saveButtonsPosY [i]));
|
|
}
|
|
}
|
|
|
|
//load the positions of the buttons reading the file if it exists
|
|
public void Load ()
|
|
{
|
|
checkSettings ();
|
|
|
|
savedButtons sB = new savedButtons ();
|
|
|
|
if (File.Exists (currentSaveDataPath + touchControlsPositionFileName + ".txt")) {
|
|
BinaryFormatter bf = new BinaryFormatter ();
|
|
FileStream file = File.Open (currentSaveDataPath + touchControlsPositionFileName + ".txt", FileMode.Open);
|
|
|
|
sB.saveButtonsPosX = (List<float>)bf.Deserialize (file);
|
|
sB.saveButtonsPosY = (List<float>)bf.Deserialize (file);
|
|
|
|
file.Close ();
|
|
}
|
|
|
|
//also check the lenght are equal in both list, to avoid exceptions
|
|
if (sB.saveButtonsPosX.Count == buttons.Count) {
|
|
for (i = 0; i < buttons.Count; i++) {
|
|
if (buttons [i] != null) {
|
|
buttons [i].position = new Vector2 (sB.saveButtonsPosX [i], sB.saveButtonsPosY [i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Touch Control Positions", gameObject);
|
|
}
|
|
}
|
|
|
|
//the positions of the buttons need to be serializable to save them in a file
|
|
[Serializable]
|
|
class savedButtons
|
|
{
|
|
public List<float> saveButtonsPosX = new List<float> ();
|
|
public List<float> saveButtonsPosY = new List<float> ();
|
|
} |