2025-02-12 08:43:33 +08:00

1561 lines
61 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using DG.Tweening;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using ZXK.Framework;
using ZXK.UTility;
/*******************************************************************************
*Create By CG
*Function 场景中端子连线
*******************************************************************************/
namespace ZXK.BYSS
{
public class ConnectLineCtrl : MonoBehaviour
{
//线路连接数据
[SerializeField]
public LineConnectModel _lineConnectData = null;
[SerializeField]
private GameObject _chatouPrefab = null;
[SerializeField]//所有插头父物体
private Transform _chatouContain = null;
public TerminalCtrl _terminalStart = null;//插入的第一个端子..不是null说明插完一个接头等待插入另一个的状态
public GameObject _chaTouTemp = null;//插入第一个时生成的动态线段
public Transform _chatou0 = null;//插入后需要脱离父物体寻找位置,暂时先提取出来
//计分时查看每个线段应该接多少个小线段
public Dictionary<string, int> _connectLineDic = new Dictionary<string, int>();
//智能运动系统内提前预知好的接线线段
public Dictionary<string, GameObject> _ZNYDLines = new Dictionary<string, GameObject>();
//每个线段有几个控制板,保证控制板之间只有一个线段连接
public Dictionary<string, List<string>> _lineCtrlDic = new Dictionary<string, List<string>>();
[Range(0.0f, 1.0f)]
private float posx = 0.825f;
[Range(0.0f, 1.0f)]
private float posy = 0.851f;
[Range(0.0f, 1.0f)]
private float posz = 0.615f;
//[Range(0.0f, 1.0f)]
//private float rotx = 0.3f;
//[Range(0.0f, 1.0f)]
//private float roty = 0.3f;
//[Range(0.0f, 1.0f)]
//private float rotz = 0.3f;
private void Awake()
{
if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
{
EventCenterManager.Instance.AddEventListener(EventEnum.AutoConnect, AutoLineCall);
}
}
private void OnDestroy()
{
if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
{
EventCenterManager.Instance.RemoveListener(EventEnum.AutoConnect, AutoLineCall);
}
}
private void Start()
{
if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
{
_lineConnectData = new LineConnectModel();
StartCoroutine(_lineConnectData.ReadLineConnectDataWeb(transform, GetCtrlTerminals));
AppManagement.Instance._ConnectScore = 0;
if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
{
//Transform[] lines = .GetComponentsInChildren<Transform>(true);
Transform lines = transform.Find("Aim_ZhiNengYunDongKongZhi/SM_LJDX");
foreach (Transform item in lines)
{
_ZNYDLines.Add(item.name, item.gameObject);
}
//for (int i = 1; i < lines.Length; i++)
//{
// _ZNYDLines.Add(lines[i].name, lines[i].gameObject);
//}
}
}
}
GameObject temp;
private void Update()
{
if (AppManagement.Instance._TrainExam==EnumCtrl.Model.Exam)
{
if (Input.GetMouseButton(2) && _terminalStart)
{
Debug.Log("可以清除");
DestoryChaTou();
}
}
else
{
}
}
public void InteractionInScene(RaycastHit rayHit)
{
if (!EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name)) return;
Debug.Log("进入连线模式!!!!");
TerminalCtrl terminalCtrl = rayHit.transform.GetComponent<TerminalCtrl>();
if (!TerminalInData(rayHit.transform.name))
{
//判空判断
if (terminalCtrl != null)
{
terminalCtrl.InsertLightState(false);
}
//if (_terminalStart && AppManagement.Instance._TrainExam == EnumCtrl.Model.Train)
//{
// Debug.Log("练习模式!!!接线模块");
// //如果练习模式不在数据内,不计次数,只弹窗
// PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", null);
//}
//if (_terminalStart && AppManagement.Instance._TrainExam == EnumCtrl.Model.Teach)
//{
// Debug.Log("教学模式!!!接线模块");
// //如果练习模式不在数据内,不计次数,只弹窗
// PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", null);
//}
//考核模式点击错误端子直接弹出提示
PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", () => {
DestoryChaTou();
});
return;
}
if (_terminalStart == null)
{
if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
AppManagement.Instance._CurType == EnumCtrl.Type.QDCY ||
AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD )
{
_chaTouTemp = Instantiate(_chatouPrefab, _chatouContain);
_chatou0 = _chaTouTemp.transform.Find("ChaTou0");
terminalCtrl.SetChaTouPos(_chatou0);
_chaTouTemp.transform.position = _chatou0.position;
_chaTouTemp.transform.rotation = _chatou0.rotation;
_terminalStart = terminalCtrl;
// Debug.Log("生成接头!!!!!!!");
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
Debug.Log("考核模式调用这个");
}
else
{
Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
SetCurrentTerminalCtrl();
}
}
//材料分拣特殊模式设置
else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ &&
terminalCtrl._CurTerminalData._ConnectGeos.Count < 1)
{
if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.3") ||
terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.4") ||
terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.5"))
{//材料分拣中的特殊情况
terminalCtrl.StraightSetChaTouPos();
terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.3"))
{
AddScore("12");
}
if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.4"))
{
AddScore("13");
}
if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.5"))
{
AddScore("14");
}
CheckAllTerminalConnect();
}
else
{
terminalCtrl.StraightSetChaTouPos();
_terminalStart = terminalCtrl;
}
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
Debug.Log("考核模式调用这个");
}
else
{
Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
SetCurrentTerminalCtrl();
}
}
#region
////搬运输送特殊模式设置
else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
{
#region 线
//if (terminalCtrl._CurTerminalData._ConnectGeos.Count < 1)
//{
// if (terminalCtrl._CurTerminalData._TerminalName.Contains("SM-X"))
// {
// terminalCtrl.StraightSetChaTouPos();
// terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
// if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-XA"))
// {
// AddScore("50");
// }
// if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-XB"))
// {
// AddScore("51");
// }
// if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-X4"))
// {
// AddScore("52");
// }
// if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-X6"))
// {
// AddScore("53");
// }
// CheckAllTerminalConnect();
// }
// else
// {
// terminalCtrl.InsertLightState(true);
// terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
// _terminalStart = terminalCtrl;
// }
//}
#endregion
//设置接线端子脚本
terminalCtrl.InsertLightState(false);
_terminalStart = terminalCtrl;
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
// Debug.Log("考核模式调用这个");
}
else
{
// Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
SetCurrentTerminalCtrl();
}
}
#endregion
}
else
{
string sameLineID = _terminalStart._CurTerminalData._LinesID[0];
if (TwoTerminalConnectable(_terminalStart, terminalCtrl, ref sameLineID))
{
_terminalStart._ConnectErrorNumber = 0;
}
else
{
_terminalStart._ConnectErrorNumber++;
}
terminalCtrl.InsertLightState(_terminalStart._ConnectErrorNumber == 0);
if (_terminalStart._ConnectErrorNumber == 0)
{
//手动连接成功
TerminalsConnect(_terminalStart, terminalCtrl, sameLineID);
AddScore(sameLineID);
_terminalStart = null;
_chaTouTemp = null;
CheckAllTerminalConnect();
//增加索引,调用闪烁UI和和闪烁端子
//智能运动
if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
{
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
Debug.Log("考核模式调用这个");
}
else
{
Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
SetCurrentTerminalCtrl();
}
}
//增加索引,调用闪烁UI和和闪烁端子
//搬运输送
if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
{
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
//Debug.Log("考核模式调用这个");
}
else
{
// Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
//增加提示索引,步骤提示
var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
v.AddByssIndex();
v.SetByssLineTip();
SetCurrentTerminalCtrl();
//配音播放
var a = UI_Manage.Instance.GetPanel("PracticeAndExamPanel").GetComponent<PracticeAndExamPanel>();
if (a._CurTrainExamSceneCtrl.speakManager != null)
{
a._CurTrainExamSceneCtrl.speakManager.AddAudioCilp();
a._CurTrainExamSceneCtrl.speakManager.PlayAudioCilp();
}
}
}
//剩下三个模式
if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ||
AppManagement.Instance._CurType == EnumCtrl.Type.QDCY||
AppManagement.Instance._CurType == EnumCtrl.Type.XHBY
) {
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam) {
Debug.Log("考核调用这个");
}
else
{
Debug.Log("练习,教学模式调用这个");
SetCurrentIndexAdd();
SetCurrentTerminalCtrl();
}
}
}
else
{//手动连接成功
PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", () =>
{
//练习模式
if (_terminalStart && _terminalStart._ConnectErrorNumber >= 3 && AppManagement.Instance._TrainExam == EnumCtrl.Model.Train)
{
//将正确接线
if (AutoInsertChaTou(_terminalStart))
{
_terminalStart._ConnectErrorNumber = 0;
_terminalStart = null;
_chaTouTemp = null;
CheckAllTerminalConnect();
}
else
{
DestoryChaTou();
}
}
//教学模式
if (_terminalStart && _terminalStart._ConnectErrorNumber >= 3 && AppManagement.Instance._TrainExam == EnumCtrl.Model.Teach)
{
//将正确接线
if (AutoInsertChaTou(_terminalStart))
{
_terminalStart._ConnectErrorNumber = 0;
_terminalStart = null;
_chaTouTemp = null;
CheckAllTerminalConnect();
}
else
{
DestoryChaTou();
}
} //考核模式
if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
{
DestoryChaTou();
}
});
}
}
}
/// <summary>
/// 自动接线
/// </summary>
private void AutoLineCall(object sender, System.EventArgs e)
{
AutoLine();
CheckAllTerminalConnect();
}
[SerializeField, Header("接线表所需要的端子脚本")]
List<TerminalCtrl> terminalCtrls = new List<TerminalCtrl>();
[SerializeField, Header("本次实验所有的端子脚本")]
List<TerminalCtrl> AllterminalCtrls = new List<TerminalCtrl>();
[Header("当前可以操作的端子")]
public int CurrentIndex = 0;
[SerializeField, Header("UI闪烁和相机位置组")]
public List<string> CameraOrUIStrs = new List<string>() { };
[SerializeField, Header("连线事件组")]
public List<LineEvent> AlllineEvents;
[Header("智能运动相机侧视角")]
public GameObject ZNYD_Ce_View;
[Header("搬运输送相机视角")]
public GameObject Byss_Camera1;
public GameObject Byss_Camera2;
/// <summary>
/// 获取本次接线要用到的端子
/// 获取这个预制体要用到的端子
/// </summary>
public void GetAllTerminalCtrl()
{
///这个循环是找到表中连接的端子
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
for (int j = 0; j < terminals.Length; j++)
{
if (terminals[j] != null)
{
for (int k = 0; k < terminals[j].Length; k++)
{
TerminalCtrl terminal1 = terminals[j][k]._TerminalGeo.GetComponent<TerminalCtrl>();
terminalCtrls.Add(terminal1);
}
}
}
}
///这个循环是找到预制体下所有的端子
var Scene_terminalCtrls = transform.GetComponentsInChildren<TerminalCtrl>();
for (int i = 0; i < Scene_terminalCtrls.Length; i++)
{
AllterminalCtrls.Add(Scene_terminalCtrls[i]);
}
if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
{
//生成对应表中连接端子的相机或者UI 事件
CameraOrUIStrs = new List<string>() {
//0-9
"前","后",
"前","后",
"前","后",
"前","后",
"前","后",
//10-19
"前","后",
"前","前",
"前","后",
"前","后",
"前","后",
//20-29
"前","后",
"前","前",
"前","后1",
"前1","侧",
"前1","侧",
//30-39
"前1","侧",
"前1","后1",
"前1","后1",
"前","无",
"无","无",
//40-51
"无","无",
"无","无",
"前","后",
"前","无",
"无","后",
"后1","前"
};
}
if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
{
CameraOrUIStrs = new List<string>() {
//0-9
"Camera1","Camera1",
"Camera1","Camera1",
"Camera1","Camera1",
"Camera1","Camera1",
"Camera1","Camera1",
//10-15
"Camera1","Camera1",
"Camera2","Camera2",
"Camera2","Camera2",
//16-20
"Camera2","Camera2",
"Camera2","Camera2",
"Camera2","Camera2",
"Camera2","Camera2",
};
}
if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ) {
//材料分拣 45个
CameraOrUIStrs = new List<string>()
{
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无"
};
}
if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ) {
//循环搬运机械手 66个
CameraOrUIStrs = new List<string>()
{
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无",
};
}
if (AppManagement.Instance._CurType == EnumCtrl.Type.QDCY )
{
// 气动冲压 30个
CameraOrUIStrs = new List<string>() {
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无",
"无","无","无","无","无", "无","无","无","无","无"
};
}
///添加进对应的事件组
for (int j = 0; j < terminalCtrls.Count; j++)
{
int num = j;
LineEvent _lineEvent = new LineEvent();
_lineEvent.terminalCtrl = terminalCtrls[num];
_lineEvent.CameraOrUI = CameraOrUIStrs[num];
AlllineEvents.Add(_lineEvent);
}
}
/// <summary>
///获取当前要显示的端子
///关掉除了当前端子的其他端子碰撞体
/// 关掉当前场景所有端子的端子碰撞体
/// /// <summary>
public void SetCurrentTerminalCtrl()
{
//关掉其他端子碰撞体,和泛光
//for (int i = 0; i < AlllineEvents.Count; i++)
//{
// var colliders = AlllineEvents[i].terminalCtrl.transform.GetComponents<Collider>();
// for (int h = 0; h < colliders.Length; h++)
// {
// colliders[h].enabled = false;
// }
// AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
//}
//关掉场景中所有接线端子碰撞器
for (int i = 0; i < AllterminalCtrls.Count; i++)
{
AllterminalCtrls[i].HideHighlightOutLine();
var colliders = AllterminalCtrls[i].transform.GetComponents<Collider>();
for (int h = 0; h < colliders.Length; h++)
{
colliders[h].enabled = false;
}
}
//获取ConnetPanel然后进行设置
var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
//结束
if (CurrentIndex == AlllineEvents.Count)
{
for (int i = 0; i < AlllineEvents.Count; i++)
{
//关闭所有闪光,碰撞体
var colliders = AlllineEvents[i].terminalCtrl.GetComponents<Collider>();
for (int h = 0; h < colliders.Length; h++)
{
colliders[h].enabled = false;
}
AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
}
//关闭闪烁UI
v.HideRedImage();
}
else
{
//继续增加
switch (AlllineEvents[CurrentIndex].CameraOrUI)
{
case "前":
v.ShowRedImage(0);
break;
case "后":
v.ShowRedImage(2);
break;
case "前1":
v.ShowRedImage(1);
break;
case "后1":
v.ShowRedImage(3);
break;
case "侧":
//相机右侧视角
Camera.main.GetComponent<CameraControl>().enabled = false;
Camera.main.transform.position = ZNYD_Ce_View.transform.position;
Camera.main.transform.localEulerAngles = ZNYD_Ce_View.transform.localEulerAngles;
Camera.main.GetComponent<CameraControl>().enabled = true;
//当前要点击的端子碰撞体打开
var colliders = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
for (int i = 0; i < colliders.Length; i++)
{
colliders[i].enabled = true;
}
AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
break;
case "无":
//当前端子设置碰撞体
AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
var col = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
for (int i = 0; i < col.Length; i++)
{
col[i].enabled = true;
}
break;
//相机1
case "Camera1":
//搬运输送相机视角1
Camera.main.GetComponent<CameraControl>().enabled = false;
Camera.main.transform.position = Byss_Camera1.transform.position;
Camera.main.transform.rotation = Byss_Camera1.transform.rotation;
Camera.main.GetComponent<CameraControl>().enabled = true;
//当前端子设置碰撞体
var colliders2 = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
for (int i = 0; i < colliders2.Length; i++)
{
colliders2[i].enabled = true;
}
AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
break;
//相机2
case "Camera2":
//搬运输送相机视角2
Camera.main.GetComponent<CameraControl>().enabled = false;
Camera.main.transform.position = Byss_Camera2.transform.position;
Camera.main.transform.rotation = Byss_Camera2.transform.rotation;
Camera.main.GetComponent<CameraControl>().enabled = true;
//当前端子设置碰撞体
var colliders1 = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
for (int i = 0; i < colliders1.Length; i++)
{
colliders1[i].enabled = true;
}
AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
break;
}
}
}
/// <summary>
/// 当前索引增加
/// </summary>
public void SetCurrentIndexAdd()
{
if (CurrentIndex < AlllineEvents.Count)
{
CurrentIndex++;
}
else
{
Debug.Log("结束。不再增加");
// CurrentIndex = AlllineEvents.Count;
}
}
/// <summary>
/// 设置当前索引的UI是否点击完成
/// </summary>
public void SetCurrentUIorCameraBool()
{
var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
//当前要点击的端子闪烁
AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
//当前要点击的端子碰撞体打开
var col = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
for (int i = 0; i < col.Length; i++)
{
col[i].enabled = true;
}
v.HideRedImage();
}
/// <summary>
///点击按钮结束接线
/// </summary>
public void FinishTerminalCtrl() {
//关闭所有端子的碰撞体,与闪光识别
for (int i = 0; i < AlllineEvents.Count; i++)
{
var colliders = AlllineEvents[i].terminalCtrl.GetComponents<Collider>();
for (int h = 0; h < colliders.Length; h++)
{
colliders[h].enabled = false;
}
AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
}
//关闭闪烁UI
bool isHave = UI_Manage.Instance.GetPanel("ConnectPanel");
if (isHave)
{
var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
v.HideRedImage();
}
else
{
}
}
/// <summary>
/// 导航栏直接调用接线
/// </summary>
public void AutoLine()
{
DestoryChaTou();
AutoInsertChaTou(null);
FinishTerminalCtrl();
}
/// <summary>
/// 销毁连接错误的线
/// </summary>
private void DestoryChaTou()
{
if (_terminalStart)
{
if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
AppManagement.Instance._CurType == EnumCtrl.Type.QDCY ||
AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD )
{
Destroy(_chaTouTemp);
DestroyImmediate(_chatou0.gameObject);
_terminalStart._ConnectErrorNumber = 0;
_terminalStart.ChaTouNumber(false);
_terminalStart = null;
_chatou0 = null;
_chaTouTemp = null;
}
else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ )
{
_terminalStart.RecallStraightChaTouPos();
_terminalStart = null;
}
else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS) {
_terminalStart = null;
}
}
}
/// <summary>
/// 自动将插头插入端子
/// 如果不是全部插入,则直插入当前所持有第一个端子对应的线路的关联端子
/// 如果全部插入,则将剩余的全部插入
/// </summary>
/// <param name="terminal">如果全部自动插入此处为null</param>
/// <returns>返回一次自动生成时是否成功</returns>
private bool AutoInsertChaTou(TerminalCtrl terminal)
{
bool isInsert = false;
if (terminal)
{
List<string> linesIndex = new List<string>(terminal._CurTerminalData._LinesID);
//筛选出所有与已持有的开始端子相关的线路
List<TerminalModel[][]> linesTemp = new List<TerminalModel[][]>();
List<TerminalModel[][]> linesSrc = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)];
for (int i = 0; i < linesIndex.Count; i++)
{
linesTemp.Add(linesSrc[int.Parse(linesIndex[i]) - 1]);
}
for (int i = 0; i < linesTemp.Count; i++)
{
TerminalModel[][] terminals = linesTemp[i];
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
for (int b = 0; b < terminals[a].Length; b++)
{
if (AutoItemCon(terminal, terminals)) return true;
}
}
}
}
}
else
{
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
//_lineConnectData.
//foreach (var item in _lineConnectData._TerminalDic["循环搬运机械手虚拟仿真系统"])
//{
//}
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
for (int b = 0; b < terminals[a].Length; b++)
{
Debug.Log("!!!!!!!!!!!!" + terminals[a][b]._TerminalGeo.name);
TerminalCtrl terminal1 = terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>();
//如果是材料分拣,有几个特殊端子
if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ && (
terminal1._CurTerminalData._TerminalName.Equals("DLB0.3") ||
terminal1._CurTerminalData._TerminalName.Equals("DLB0.4") ||
terminal1._CurTerminalData._TerminalName.Equals("DLB0.5")))
{
if (terminal1._CurTerminalData._ConnectGeos.Count < 1)
{
terminal1.StraightSetChaTouPos();
terminal1._CurTerminalData._ConnectGeos.Add(terminal1.gameObject);
}
}
//如果是搬运输送,有几个特殊端子
else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
{
if (terminal1._CurTerminalData._ConnectGeos.Count < 1)
{
terminal1.StraightSetChaTouPos_Rightaway();
terminal1._CurTerminalData._ConnectGeos.Add(terminal1.gameObject);
}
}
else
{
AutoItemCon(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>(), terminals);
}
}
}
}
}
}
return isInsert;
}
/// <summary>
/// 寻找可自动相连的端子,并连接
/// </summary>
/// <param name="terminal"></param>
/// <param name="terminals"></param>
/// <returns></returns>
private bool AutoItemCon(TerminalCtrl terminal, TerminalModel[][] terminals)
{
for (int c = 0; c < terminals.GetLength(0); c++)
{
if (terminals[c] != null)
{
for (int d = 0; d < terminals[c].Length; d++)
{
string sameLineID = terminal._CurTerminalData._LinesID[0];
if (TwoTerminalConnectable(terminal, terminals[c][d]._TerminalGeo.GetComponent<TerminalCtrl>(), ref sameLineID))
{
TerminalsConnect(terminal._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(),
terminals[c][d]._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
return true;
}
}
}
}
return false;
}
/// <summary>
/// 两个端子相连
/// _terminalStart不为null,则只能进行几次否则需要每次为_terminalStart赋值
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private bool TerminalsConnect(TerminalCtrl a, TerminalCtrl b, string sameLineID)
{
Debug.Log("线段:" + sameLineID + "——" + a.name + "_连_" + b.name);
if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
AppManagement.Instance._CurType == EnumCtrl.Type.QDCY)
{
if (_terminalStart == null)
{
_chaTouTemp = Instantiate(_chatouPrefab, _chatouContain);
_chatou0 = _chaTouTemp.transform.Find("ChaTou0");
a.SetChaTouPos(_chatou0);
}
a._CurTerminalData._ConnectGeos.Add(b.gameObject);
b._CurTerminalData._ConnectGeos.Add(a.gameObject);
Transform chatou1 = _chaTouTemp.transform.Find("ChaTou1");
b.SetChaTouPos(chatou1);
temp = _chaTouTemp;
//生成线段柔化
Transform line = temp.transform.Find("Line");
Transform line2 = temp.transform.Find("Line2");
Transform midPoint = temp.transform.Find("MidPoint");
Transform startPoint = line.GetComponent<BezierPipe>().point1;
Transform endPoint = line2.GetComponent<BezierPipe>().point2;
Vector3 lowPoint;
Vector3 highPoint;
if (startPoint.position.y > endPoint.position.y)
{
lowPoint = endPoint.position;
highPoint = startPoint.position;
}
else
{
lowPoint = startPoint.position;
highPoint = endPoint.position;
}
Debug.Log(Vector3.Distance(lowPoint, highPoint));
if (Vector3.Distance(lowPoint, highPoint) < 1.0f)
{
midPoint.position = new Vector3(
0.5f * lowPoint.x + (1 - 0.5f) * highPoint.x,
0.5f * lowPoint.y + (1 - 0.5f) * highPoint.y,
0.5f * lowPoint.z + (1 - 0.5f) * highPoint.z
);
}
else
{
//位置比例
//小部分在低处
midPoint.position = new Vector3(
posx * lowPoint.x + (1 - posx) * highPoint.x,
posy * lowPoint.y + (1 - posy) * highPoint.y,
posz * lowPoint.z + (1 - posz) * highPoint.z
);
//旋转比例
//小部分在高处
//Vector3 rotTargPoint = new Vector3(
// rotx * highPoint.x + (1 - rotx) * highPoint.x,
// roty * lowPoint.y + (1 - roty) * highPoint.y,
// rotz * highPoint.z + (1 - rotz) * highPoint.z
// );
}
midPoint.LookAt(startPoint, Vector3.up);
line.GetComponent<HighlightingSystem.Highlighter>().tween = true;
line2.GetComponent<HighlightingSystem.Highlighter>().tween = true;
line.GetComponent<BezierPipe>().update = true;
line2.GetComponent<BezierPipe>().update = true;
float formTime = 0.0f;
DOTween.To(() => formTime, x => x = formTime, 0.5f, 0.5f).OnComplete(() =>
{
line.GetComponent<BezierPipe>().update = false;
line2.GetComponent<BezierPipe>().update = false;
});
//line.SetParent(_chatouContain);
//line.GetComponent<HighlightingSystem.Highlighter>().tween = true;
//line.GetComponent<BezierPipe>().update = true;
//float formTime = 0.0f;
//DOTween.To(() => formTime, x => x = formTime, 0.5f, 0.5f).OnComplete(() =>
//{
// line.GetComponent<BezierPipe>().update = false;
//});
//Destroy(_chaTouTemp);
}
else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
{
if (a != _terminalStart)
{
a.StraightSetChaTouPos();
}
if (b != _terminalStart)
{
b.StraightSetChaTouPos();
}
a._CurTerminalData._ConnectGeos.Add(b.gameObject);
b._CurTerminalData._ConnectGeos.Add(a.gameObject);
}
else if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
{
string lineName = sameLineID;
if (sameLineID.Equals("22") || sameLineID.Equals("23"))
{
string terminalStart = a._CurTerminalData._TerminalName;
string terminalEnd = b._CurTerminalData._TerminalName;
string[] temp = new string[] { "ET2", "ET3", "WLSSQ", "CXKG" };
for (int i = 0; i < temp.Length; i++)
{
if (terminalStart.Contains(temp[i]))
{
lineName = $"{sameLineID}({terminalStart},{terminalEnd})";
break;
}
if (terminalEnd.Contains(temp[i]))
{
lineName = $"{sameLineID}({terminalEnd},{terminalStart})";
break;
}
}
}
if (!string.IsNullOrEmpty(lineName))
{
_ZNYDLines[lineName].SetActive(true);
}
if (_terminalStart)
{
DestroyImmediate(_chatou0.gameObject);
Destroy(_chaTouTemp);
}
a._CurTerminalData._ConnectGeos.Add(b.gameObject);
b._CurTerminalData._ConnectGeos.Add(a.gameObject);
}
//搬运输送设置插头模式
else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
{
Debug.Log(a.gameObject.name + "!!!!!!!!!!!!!!!!!!");
Debug.Log(b.gameObject.name + "!!!!!!!!!!!!!!!!!!");
a.StraightSetChaTouPos();
b.StraightSetChaTouPos();
a._CurTerminalData._ConnectGeos.Add(b.gameObject);
b._CurTerminalData._ConnectGeos.Add(a.gameObject);
}
SyncTerminalInfo(a);
SyncTerminalInfo(b);
return true;
}
/// <summary>
/// 判断此端子是否在当前系统数据中
/// </summary>
/// <param name="TerminalName"></param>
/// <returns></returns>
private bool TerminalInData(string TerminalName)
{
bool isInclude = false;
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
for (int b = 0; b < terminals[a].Length; b++)
{
if (terminals[a][b]._TerminalGeo.name.Equals(TerminalName))
{
isInclude = true;
break;
}
}
}
}
}
return isInclude;
}
/// <summary>
/// 两个端子必须满足所有条件,才可以相连
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="sameLineID"></param>
/// <returns></returns>
private bool TwoTerminalConnectable(TerminalCtrl a, TerminalCtrl b, ref string sameLineID)
{
if (!b._CurTerminalData._TerminalName.Equals(a._CurTerminalData._TerminalName) &&//不能连自身
!b._CurTerminalData._ConnectGeos.Contains(a._CurTerminalData._TerminalGeo))//连过的不连
{
//是否有相同LineID
bool sameline = TerminalsSameLine(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), out List<string> sameLines);
if (sameline)
{
sameLineID = sameLines[0];//同一模块端子之间和不同模块之间不存在并联,所以只会有一个相同的
////不要链接为一个环
//bool isLoop = CheckTerminalLoop(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
//if (!isLoop)
//{
////两个控制面板只允许有一条线
//bool ctrlTwo = CtrlConnect(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
//if (ctrlTwo)
//{
//一个控制板内必须串联
bool bunchInCtrl = BunchInCtrl(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
if (bunchInCtrl)
{
return true;
}
// }
// }
}
}
return false;
}
/// <summary>
/// 两个端子是否属于同一条线
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private bool TerminalsSameLine(TerminalCtrl a, TerminalCtrl b, out List<string> sameLinesID)
{
bool sameLine = false;
sameLinesID = new List<string>();
for (int i = 0; i < a._CurTerminalData._LinesID.Count; i++)
{
for (int j = 0; j < b._CurTerminalData._LinesID.Count; j++)
{
if (a._CurTerminalData._LinesID[i].Equals(b._CurTerminalData._LinesID[j]))
{//判断是否有相同的LineID
sameLine = true;
sameLinesID.Add(a._CurTerminalData._LinesID[i]);
}
}
}
return sameLine;
}
/// <summary>
/// 是否形成环
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>形成环</returns>
private bool CheckTerminalLoop(TerminalCtrl a, TerminalCtrl b, string sameLineID)
{
bool isLoop = TerminalConnectChildren(a, null, b, sameLineID);
return isLoop;
}
/// <summary>
/// DFS遍历某个端子的所有子物体,查看是否形成环形
/// </summary>
/// <param name="a">需要遍历的端子</param>
/// <param name="previous">遍历当前端子时的上一个端子,防止出现重复遍历</param>
/// <param name="target">需要匹配的目标端子</param>
/// <param name="lineID">需要查询的线段ID</param>
/// <returns>遍历到和目标相同端子说明会形成环形则返回false,</returns>
private bool TerminalConnectChildren(TerminalCtrl a, TerminalCtrl previous, TerminalCtrl target, string lineID)
{
bool loop = false;
if (a == target)
{
return true;
}
if (a._CurTerminalData._ConnectGeos.Count > 0)
{
foreach (GameObject item in a._CurTerminalData._ConnectGeos)
{
if (item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(lineID))
{
if (previous == null || (previous != null && item != previous.gameObject))
{
loop = TerminalConnectChildren(item.GetComponent<TerminalCtrl>(), a, target, lineID);
if (loop) return true;
}
}
}
}
return loop;
}
/// <summary>
/// 两个端子相连,查看是否属于两个控制板,
/// 两个控制板的只允许有一条连接线
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>两个点可连接</returns>
private bool CtrlConnect(TerminalCtrl a, TerminalCtrl b, string sameLineID)
{
bool isConnect = false;
string aCtrlName = a._CurTerminalData._CtrlBoard;
string bCtrlName = b._CurTerminalData._CtrlBoard;
if (aCtrlName.Equals(bCtrlName)) return true;//同一控制板可以直接通过此处
//不同控制板时候,需要有一个控制板没连过线
if (_lineCtrlDic[sameLineID].Contains(aCtrlName) || _lineCtrlDic[sameLineID].Contains(bCtrlName))
{
for (int i = 0; i < _lineCtrlDic[sameLineID].Count; i++)
{
if (aCtrlName.Equals(_lineCtrlDic[sameLineID][i]))
{
_lineCtrlDic[sameLineID].RemoveAt(i);
isConnect = true;
i--;
}
if (i >= 0 && bCtrlName.Equals(_lineCtrlDic[sameLineID][i]))
{
_lineCtrlDic[sameLineID].RemoveAt(i);
isConnect = true;
i--;
}
}
}
return isConnect;
}
/// <summary>
/// 每个线段有多少控制板数据存储起来
/// </summary>
private void GetCtrlTerminals()
{
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
List<string> ctrls = new List<string>();
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
ctrls.Add(terminals[a][0]._CtrlBoard);
}
}
if (!_lineCtrlDic.ContainsKey((i + 1).ToString()))
{
_lineCtrlDic.Add((i + 1).ToString(), ctrls);
}
}
}
/// <summary>
/// 保证一个控制板内所有端子是串联
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns>两个端子可连</returns>
private bool BunchInCtrl(TerminalCtrl aTerminal, TerminalCtrl bTerminal, string sameLineID)
{
int terminalConNumber = 0;//两个端子都需要验证
foreach (GameObject item in aTerminal._CurTerminalData._ConnectGeos)
{
if (aTerminal._CurTerminalData._CtrlBoard.Equals(bTerminal._CurTerminalData._CtrlBoard) &&//准备相连的两个属于同一个控制器
aTerminal._CurTerminalData._CtrlBoard.Equals(item.GetComponent<TerminalCtrl>()._CurTerminalData._CtrlBoard) &&//验证端子所连接的为同一个控制板的才计入其中
item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(sameLineID))//验证端子所连接的同时也是同一条线段的才计入其中
{
terminalConNumber++;
}
}
if (terminalConNumber < 2)
{
terminalConNumber = 0;
foreach (GameObject item in bTerminal._CurTerminalData._ConnectGeos)
{
if (bTerminal._CurTerminalData._CtrlBoard.Equals(aTerminal._CurTerminalData._CtrlBoard) &&//准备相连的两个属于同一个控制器
bTerminal._CurTerminalData._CtrlBoard.Equals(item.GetComponent<TerminalCtrl>()._CurTerminalData._CtrlBoard) &&//验证端子所连接的为同一个控制板的才计入其中
item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(sameLineID))//验证端子所连接的同时也是同一条线段的才计入其中
{
terminalConNumber++;
}
}
}
if (terminalConNumber < 2)
{//如果存在相同线路端子数量都小于2的就可以连接多余2的端子说明存在串联
return true;
}
return false;
}
/// <summary>
/// 同步端子信息,防止有的端子在不同线段中,信息无法同步问题
/// </summary>
private void SyncTerminalInfo(TerminalCtrl terminal)
{
Dictionary<TerminalCtrl, int> terminalLineDic = new Dictionary<TerminalCtrl, int>();
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
for (int b = 0; b < terminals[a].Length; b++)
{
if (terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>() == terminal)
{
terminals[a][b] = terminal._CurTerminalData;
}
}
}
}
}
}
/// <summary>
/// 检查所有端子是否都连接完毕
/// </summary>
private void CheckAllTerminalConnect()
{
//判断每个端子有多少线段
Dictionary<TerminalCtrl, int> terminalLineDic = new Dictionary<TerminalCtrl, int>();
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
for (int b = 0; b < terminals[a].Length; b++)
{
//考虑到一个端子可能涉及多条线路
if (terminalLineDic.ContainsKey(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>()))
{
terminalLineDic[terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>()]++;
}
else
{
terminalLineDic.Add(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>(), 0);
}
}
}
}
}
//连接后判断是否所有线路都链接完成
bool allConnect = true;
foreach (var item in terminalLineDic)
{
if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
{
if (item.Key._CurTerminalData._ConnectGeos.Count <= 0)
{
allConnect = false;
break;
}
}
else
{
if (item.Key._CurTerminalData._ConnectGeos.Count <= item.Value)
{
allConnect = false;
break;
}
}
}
if (allConnect)
{
PopUpMng.PopCustomSucToast("提示", "恭喜您成功完成设备所有接线", "程序调试", () =>
{
CalculateScore();
AppManagement.Instance.ChangeModel(EnumCtrl.Model.Debug);
//音频设置
PracticeAndExamInSceneCtrl _practiceAndExamCtrl = UI_Manage.Instance.GetPanel("PracticeAndExamPanel")
.GetComponent<PracticeAndExamPanel>()._CurTrainExamSceneCtrl;
//关闭声音组件
_practiceAndExamCtrl.speakManager.ChangeModelAudio("程序调试");
_practiceAndExamCtrl.speakManager.Init();
});
}
}
/// <summary>
/// 计算得分
/// 根据此线段总累计单位数是否等于此线段端子数量减一
/// </summary>
private void CalculateScore()
{
//计算得分
for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
{
int terminalInLine = 0;
TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
for (int a = 0; a < terminals.GetLength(0); a++)
{
if (terminals[a] != null)
{
if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
{
if (terminals[a][0]._TerminalName.Equals("DLB0.3") ||
terminals[a][0]._TerminalName.Equals("DLB0.4") ||
terminals[a][0]._TerminalName.Equals("DLB0.5"))
{
terminalInLine += 2;
}
else
{
terminalInLine += terminals[a].Length;
}
}
else
{
terminalInLine += terminals[a].Length;
}
}
}
if (_connectLineDic.ContainsKey((i + 1).ToString()))
{
if (_connectLineDic[(i + 1).ToString()] == terminalInLine - 1)
{//得分=此线段端子数量-1
AppManagement.Instance._ConnectScore += 3;
}
}
}
}
/// <summary>
/// 此线段每次接通一个小线段,累加一个单位
/// </summary>
/// <param name="lineID"></param>
private void AddScore(string lineID)
{
if (!string.IsNullOrEmpty(lineID))
{
if (_connectLineDic.ContainsKey(lineID))
{
_connectLineDic[lineID]++;
}
else
{
_connectLineDic.Add(lineID, 1);
}
}
}
}
}