Unity зависает в Application.EnterPlayMode() после использования сенсорного ввода ⇐ C#

[Anonymous]

У меня есть сложный мобильный проект на Unity под названием Cake Sort 3D, это была моя первая внештатная работа. Думаю, я допустил несколько ошибок.
Все работало идеально, пока я не перевел код движения пластины для обработки сенсорного ввода на экране. Я не осознавал этой проблемы, пока не начал создавать проект. Система отслеживания проблем Unity сообщила, что движок не может войти в режим воспроизведения, и я подумал: «Как это возможно? Раньше он работал нормально».
Когда я тестировал его самостоятельно, я обнаружил что если класс PlateManager запускается в начале, код застревает в бесконечном цикле и режим воспроизведения не запускается. Последние два дня я пытался выяснить источник бесконечного цикла, но пока не смог его точно определить.
Вот PlateManager и входные данные. классы, а также другие классы, которые могут вызывать бесконечный цикл.
Скрипт перемещения плиты
using System.Collections;
using UnityEngine;

public class DragAndDropMouse : MonoBehaviour
{
private bool _isDragging;
public GameObject[] plateHolders;
private GameObject draggingObj;
private GameObject holderToSnap;
[SerializeField] public bool isMoveable = true;
[SerializeField] private Plate plate;
[SerializeField] private GameObject plane;
[SerializeField] private PlateManager Manager;
private ScoreManager scm;
private SoundPlayer soundPlayer;
SkillManager sm;
SwitchController switchController;
private bool isThereUnused = false;
Vector3 StartPosition;
private bool canCreate = true;

private void Start()
{
plate = GetComponent
();
sm = GameObject.FindGameObjectWithTag("SkillManager").GetComponent();
soundPlayer = GameObject.FindGameObjectWithTag("SoundPlayer").GetComponent();
plateHolders = GameObject.FindGameObjectsWithTag("PlateHolder");
scm = GameObject.FindGameObjectWithTag("ScoreManager").GetComponent();
Manager = GameObject.FindGameObjectWithTag("PlateManager").GetComponent();
plane = GameObject.FindGameObjectWithTag("Plane");
if (Manager != null)
{
switchController = Manager.GetComponent();
Debug.Log(switchController);
}
plate.snappedHolder = null;
}

private void Update()
{
if (Input.touchCount > 0)
{
Touch touch = Input.GetTouch(0);

switch (touch.phase)
{
case TouchPhase.Began:
OnTouchDown(touch);
break;

case TouchPhase.Moved:
OnTouchDrag(touch);
break;

case TouchPhase.Ended:
OnTouchUp();
break;
}
}
}

private void OnTouchDown(Touch touch)
{
if (switchController == null)
{
switchController = Manager?.GetComponent();
Debug.Log(switchController != null ? "SwitchController bulundu." : "SwitchController hala null.");
}

if (switchController != null && switchController.SwitchSkillActive)
{
Ray ray2 = Camera.main.ScreenPointToRay(touch.position);
if (Physics.Raycast(ray2, out RaycastHit hit2) && hit2.collider.tag.StartsWith("Cake"))
{
draggingObj = hit2.collider.gameObject;
}
Manager.GetComponent().MouseDownSwitchSkill(hit2.collider.gameObject);
return;
}
if (Manager == null)
{
Manager = GetComponent().manager;
}
Ray ray = Camera.main.ScreenPointToRay(touch.position);
if (Physics.Raycast(ray, out RaycastHit hit) && hit.collider.tag.StartsWith("Cake") && isMoveable)
{
draggingObj = hit.collider.gameObject;
StartPosition = draggingObj.transform.position;
draggingObj.GetComponent().enabled = false;
_isDragging = true;
}
else if (sm.handSkill && plate.snappedHolder != null)
{
draggingObj = hit.collider.gameObject;
draggingObj.GetComponent().enabled = false;
_isDragging = true;
}
else if (sm.hammerSkill && plate.snappedHolder != null)
{
hit.collider.gameObject.GetComponent().snappedHolder.GetComponent().isUsed = false;
Destroy(hit.collider.gameObject);
sm.hammerSkill = false;
sm.ExecuteSkill();
}
}

private void OnTouchDrag(Touch touch)
{
if (_isDragging && draggingObj != null)
{
Ray ray = Camera.main.ScreenPointToRay(touch.position);
if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, LayerMask.GetMask("Ignore Raycast")) && hit.collider.gameObject == plane)
{
Vector3 newPos = hit.point;
draggingObj.transform.position = new Vector3(newPos.x, transform.position.y, newPos.z);
}
}
}

private void OnTouchUp()
{
if (switchController.SwitchSkillActive) return;
MouseUp(draggingObj);
}

public void SnapPlateToHolder(GameObject plateObj, GameObject targetHolder)
{
var plateComponent = plateObj.GetComponent();
var targetHolderComponent = targetHolder.GetComponent();

if (plateComponent.snappedHolder != null)
{
plateComponent.snappedHolder.GetComponent().isUsed = false;
}

plateObj.transform.position = new Vector3(targetHolder.transform.position.x, plateObj.transform.position.y, targetHolder.transform.position.z);

plateComponent.snappedHolder = targetHolder;
targetHolderComponent.isUsed = true;
plateComponent.GetComponent().isMoveable = false;
holderToSnap = targetHolder;

if (sm.remainingSkills == 0)
{
StartCoroutine(finishController(plateHolders));
}
StartCoroutine(plateComponent.CheckSurroundingPlates(plateObj));
}

public void MouseUp(GameObject draggingObj)
{
if ((draggingObj != null && isMoveable) || sm.handSkill)
{
draggingObj.GetComponent().enabled = true;
_isDragging = false;
GameObject closestHolder = SnapToClosestHolder();

if (closestHolder != null)
{
soundPlayer.PlaySound("Plate");
SnapPlateToHolder(draggingObj, closestHolder);
}
else
{
canCreate = false;
draggingObj.transform.position = StartPosition;
Debug.Log("No unused plateholder found.");
}

draggingObj = null;
sm.ExecuteSkill();
sm.handSkill = false;
}
}

private GameObject SnapToClosestHolder()
{
GameObject closestHolder = null;
float closestDistance = Mathf.Infinity;

foreach (GameObject holder in plateHolders)
{
if (!holder.GetComponent().isUsed)
{
float distance = Vector3.Distance(transform.position, holder.transform.position);
if (distance < closestDistance)
{
closestDistance = distance;
closestHolder = holder;
}
}
}

return closestHolder;
}

private IEnumerator finishController(GameObject[] holders) // controls if game has no moves left
{
int counter = 0;

while (counter 0.1f)
{
plate.transform.position = Vector3.Lerp(plate.transform.position, lerpPositions[index].position, Time.deltaTime * moveSpeed);

yield return null;

safetyCounter++;
if (safetyCounter > maxIterations)
{
Debug.LogError($"Plate {index} hedef pozisyona taşınamıyor. Emniyet sınırına ulaşıldı!");
yield break;
}
}

// Ensure the plate is exactly at the target position
plate.transform.position = lerpPositions[index].position;
plate.GetComponent().enabled = true;
}

public GameObject[] getCakePrefab(string[] types)
{
GameObject[] typesToReturn = new GameObject[types.Length];

for (int i = 0; i < types.Length; i++)
{
string type = types;

if (type.StartsWith("Cake") && int.TryParse(type.Substring(4), out int cakeNumber))
{

if (cakeNumber >= 1 && cakeNumber = 1 && cakeNumber CakeIndex + CakeIndex2;
public bool isEvenTyped;
public bool isSwapped = false;
public string[] cakeTypes;
public string cakeType;
private GameObject[] prefabs;
private GameObject prefab;
[SerializeField] public int maxCakeTypeIndex;
[SerializeField] public float[] rotations;
[SerializeField] public PlateManager manager;
public bool isWorking = false;
private CakeTransferRemastered cakeTransfer;
public bool canInstantiateCakes = true;
private void Start()
{
maxCakeTypeIndex = GameObject.FindGameObjectWithTag("ScoreManager").GetComponent().maxIndexOfCakes;
cakeTransfer = GetComponent();
manager = GameObject.FindGameObjectWithTag("PlateManager").GetComponent();
if (canInstantiateCakes)
{
InitializePlate();
InstantiateCakeObjects();
}
else
{
GetComponent().MouseUp(gameObject);
}
}

private void InitializePlate()
{
cakeTypes = new string[2];
gameObject.tag = "Cake" + Random.Range(1, 10);
}

private void InstantiateCakeObjects()
{
if (Random.Range(1, 3) == 2)
{
isEvenTyped = false;
CakeIndex = (byte)Random.Range(1, 4);
cakeType = "Cake" + Random.Range(1, maxCakeTypeIndex+1);
prefab = manager?.getCakePrefab(cakeType);
InstantiateCakeLayers(prefab, CakeIndex,0);
}
else
{
isEvenTyped = true;
CakeIndex = 1;
CakeIndex2 = 3;
cakeTypes[0] = "Cake" + Random.Range(1, maxCakeTypeIndex+1);
cakeTypes[1] = "Cake" + Random.Range(1, maxCakeTypeIndex+1);
while (cakeTypes[0] == cakeTypes[1])
{
cakeTypes[1] = "Cake" + Random.Range(1, maxCakeTypeIndex+1);
}
prefabs = manager?.getCakePrefab(cakeTypes);

if (prefabs != null)
{
InstantiateCakeLayers(prefabs[0], CakeIndex, 0);
InstantiateCakeLayers(prefabs[1], CakeIndex2, CakeIndex);
if (cakeTransfer.isContainsSingleType(gameObject))
{
cakeTypes[1] = string.Empty;
}
}
else
{
Debug.LogWarning("Prefab bulunamadı veya PlateManager atanmamış.");
}
}
}

private void InstantiateCakeLayers(GameObject cakePrefab, int layers, int startRotationIndex)
{
for (int i = startRotationIndex; i < layers; i++)
{
GameObject cakeLayer = Instantiate(cakePrefab, transform);
cakeLayer.transform.localScale = new Vector3(60f, 2500f, 60f);
cakeLayer.transform.localPosition = Vector3.zero;
cakeLayer.transform.eulerAngles = new Vector3(0, rotations, 0);
}
}

public IEnumerator CheckSurroundingPlates(GameObject thisPlate)
{
isWorking = true;
List controlledIds = new List();
int processCount = 0;
Vector3[] directions = { Vector3.forward, Vector3.back, Vector3.left, Vector3.right };
Dictionary detectedPlates = new Dictionary();

ControlDirections(directions, ref detectedPlates);
bool isCommon = CheckForCommonCakes(thisPlate, detectedPlates);

while (detectedPlates.Count > 0 && isCommon && processCount x.Value).First();

foreach (GameObject detected in detectedPlates.Keys)
{
if (controlledIds.Contains(detected.GetInstanceID().ToString()))
{
processCount++;
}
else
{
controlledIds.Add(detected.GetInstanceID().ToString());
yield return StartCoroutine(cakeTransfer.StartTransfer(thisPlate, detected, isEvenTyped, detected.GetComponent().isEvenTyped));
}
}

detectedPlates.Clear();
ControlDirections(directions, ref detectedPlates);
isCommon = CheckForCommonCakes(thisPlate, detectedPlates);
}

yield return new WaitForEndOfFrame();
isWorking = false;
}

private bool CheckForCommonCakes(GameObject thisPlate, Dictionary detectedPlates)
{
foreach (GameObject detectedPlate in detectedPlates.Keys)
{
if (cakeTransfer.ControlCommonCakes(thisPlate, detectedPlate) >= 1)
{
return true;
}
}
return false;
}

private void ControlDirections(Vector3[] directions, ref Dictionary detectedPlates)
{
detectedPlates = new Dictionary();

foreach (Vector3 direction in directions)
{
if (Physics.Raycast(transform.position, direction, out RaycastHit hit, 4.0f) && hit.collider.gameObject != gameObject)
{
Plate hitPlate = hit.collider.GetComponent();
if (hitPlate != null)
{
detectedPlates.Add(hit.collider.gameObject, hitPlate.TotalCakeIndex);
}
}
}
}

private void OnDestroy()
{
manager.decreaseNumber();
}
private void OnDrawGizmosSelected()
{
Gizmos.color = Color.red;
Gizmos.DrawRay(transform.position, Vector3.forward * 4);
Gizmos.DrawRay(transform.position, Vector3.back * 4);
Gizmos.DrawRay(transform.position, Vector3.left * 4);
Gizmos.DrawRay(transform.position, Vector3.right * 4);
}
}



Подробнее здесь: https://stackoverflow.com/questions/791 ... uch-inputs