private void ClickFocus(BaseEventData data)
{
PointerEventData pData = data as PointerEventData;
if (pData == null)
{
return;
}
UIAddBaseAttribute uiFocus = pData.rawPointerPress.GetComponent <UIFocus>() as UIAddBaseAttribute;
if (uiFocus != null)
{
if (nowUIFocus)
{
nowUIFocus.LostForcus();
}
if (uiFocus != nowUIFocus)
{
nowUIFocus = uiFocus;
}
else
{
nowUIFocus = null;
}
if (nowUIFocus)
{
nowUIFocus.SetForcus();
}
}
}
/// <summary>
/// 获取焦点
/// </summary>
/// <param name="moveType"></param>
public void GetKeyDown(UIFocusPath.MoveType moveType)
{
Action <UIFocusPath.MoveType> MoveNextAction = (_moveType) =>
{
if (!nowUIFocus)
{
nowUIFocus = uiFocusPath.GetFirstFocus();
}
if (nowUIFocus)
{
UIFocus nextUIFocus = uiFocusPath.GetNewNextFocus(nowUIFocus, _moveType);
if (nextUIFocus != null)
{
nowUIFocus = nextUIFocus;
}
nowUIFocus.SetForcus();
}
};
switch (moveType)
{
case UIFocusPath.MoveType.LEFT:
case UIFocusPath.MoveType.RIGHT:
MoveNextAction(moveType);
break;
case UIFocusPath.MoveType.OK:
UIFocusButton uiFocusButton = nowUIFocus as UIFocusButton;
if (uiFocusButton)
{
uiFocusButton.ClickThisButton(); //激活事件
}
break;
}
}
private void OnEnable()
{
UIManager.Instance.KeyUpHandle += Instance_KeyUpHandle;
if (uiFocusPath)
{
nowTabPageFocus = uiFocusPath.GetFirstFocus() as UIFocusTabPage;
if (nowTabPageFocus)
{
nowTabPageFocus.SetForcus();
}
if (nowTabPageFocus != null && nowTabPageFocus.panel)
{
nowTabPageFocus.panel.gameObject.SetActive(true);
}
if (nowTabPageFocus != null && nowTabPageFocus.panelFocusPath)
{
tabPanelFocus = nowTabPageFocus.panelFocusPath.GetFirstFocus();
if (tabPanelFocus != null)
{
tabPanelFocus.SetForcus();
}
}
}
//重新载入数据
//throw new NotImplementedException();
}
/// <summary>
/// 检索
/// </summary>
/// <param name="target"></param>
/// <param name="moveType"></param>
/// <returns></returns>
public UIFocus GetNewNextFocus(UIFocus target, MoveType moveType)
{
FocusRelaship focusRelaship = UIFocusArrayRelaships.FirstOrDefault(temp => temp.This == target);
if (focusRelaship != null)
{
Func <UIFocus, MoveType, UIFocus> CheckThisFocus = (innerTarget, innerMoveType) =>
{
if (innerTarget == null)
{
return(null);
}
if (innerTarget.gameObject.activeSelf)
{
return(innerTarget);
}
return(GetNewNextFocus(innerTarget, innerMoveType));
};
switch (moveType)
{
case MoveType.LEFT:
return(CheckThisFocus(focusRelaship.Left, moveType));
case MoveType.RIGHT:
return(CheckThisFocus(focusRelaship.Right, moveType));
case MoveType.UP:
return(CheckThisFocus(focusRelaship.Up, moveType));
case MoveType.DOWN:
return(CheckThisFocus(focusRelaship.Down, moveType));
}
}
return(null);
}
///// <summary>
///// 切换到指定场景
///// </summary>
///// <param name="sceneName">场景名</param>
//private void ChangeScene(string sceneName)
//{
// StartCoroutine(CrossoverMaskImageAlpha(0, () => { }));
//}
#region 功能类
/// <summary>
/// 继续按钮按下事件
/// </summary>
public void ContinueButtonClick()
{
if (isLoadedScene || entranceType != EnumEntranceType.Start)
{
return;
}
//切换场景
nowStartFocus = EventSystem.current.currentSelectedGameObject.GetComponent <UIFocus>();
List <Archive> archiveList = DataCenter.Instance.GetAllArchive();//获取所有存档名
Archive defaultArchive = archiveList.FirstOrDefault(temp => temp.ID == 1);
if (defaultArchive != null)
{
DataCenter.Instance.LoadArchive(1);//加载第一个存档
//隐藏该面板显示进入面板
entranceType = EnumEntranceType.Transition;
StartCoroutine(CrossoverMaskImageAlpha(1, () =>
{
startRect.gameObject.SetActive(false);
enterRect.gameObject.SetActive(true);
InitEnterRect();
StartCoroutine(CrossoverMaskImageAlpha(0, () =>
{
entranceType = EnumEntranceType.Enter;
}));
}));
#region 老版的加载
//DataCenter.Instance.LoadArchive(1);//加载第一个存档
//GetArchiveData();
#endregion
}
}
/// <summary>
/// 按键检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void Instance_KeyUpHandle(UIManager.KeyType keyType, Vector2 rockValue)
{
if (isSaving)
{
return;
}
if (uiFocusPath && CanChangeTab)//切换标签页
{
UIFocus nextTabPageFocus = null;
switch (keyType)
{
case UIManager.KeyType.R1:
//nextTabPageFocus = uiFocusPath.GetNewNextFocus(nowTabPageFocus, UIFocusPath.MoveType.RIGHT);// uiFocusPath.GetNextFocus(nowTabPageFocus, UIFocusPath.MoveType.RIGHT, true);
nextTabPageFocus = GetNextEnableTabPage(UIFocusPath.MoveType.RIGHT);
break;
case UIManager.KeyType.L1:
//nextTabPageFocus = uiFocusPath.GetNewNextFocus(nowTabPageFocus, UIFocusPath.MoveType.LEFT);//uiFocusPath.GetNextFocus(nowTabPageFocus, UIFocusPath.MoveType.LEFT, true);
nextTabPageFocus = GetNextEnableTabPage(UIFocusPath.MoveType.LEFT);
break;
}
TabPageClick(nextTabPageFocus as UIFocusTabPage);
}
switch (keyType)
{
case UIManager.KeyType.START: //返回
CloseActionClick();
break;
}
}
/// <summary>
/// 创建时输入名字状态的手柄输入检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void CreateNameInputType_HandleUpdate(UIManager.KeyType keyType, Vector2 rockValue)
{
if (nowNameInputFocus == null && nameInputUIFocusPath)
{
nowNameInputFocus = nameInputUIFocusPath.GetFirstFocus();
if (nowNameInputFocus)
{
nowNameInputFocus.SetForcus();
}
}
if (nowNameInputFocus)
{
//判断键位
Action <UIFocusPath.MoveType> MoveFocusAction = (moveType) =>
{
UIFocus next = nameInputUIFocusPath.GetNewNextFocus(nowNameInputFocus, moveType);// uiFocusPath.GetNextFocus(nowFocus, moveType, true);
if (next)
{
nowNameInputFocus.LostForcus();
nowNameInputFocus = next;
nowNameInputFocus.SetForcus();
}
};
switch (keyType)
{
case UIManager.KeyType.A:
if (nowNameInputFocus)
{
UIFocusButton uiFocusButton = nowNameInputFocus as UIFocusButton;
UIFocusInputField uiFocusInputField = nowNameInputFocus as UIFocusInputField;
if (uiFocusButton)
{
uiFocusButton.ClickThisButton();
}
else if (uiFocusInputField)
{
uiFocusInputField.EnterInputField();
}
}
break;
case UIManager.KeyType.LEFT:
MoveFocusAction(UIFocusPath.MoveType.LEFT);
break;
case UIManager.KeyType.RIGHT:
MoveFocusAction(UIFocusPath.MoveType.RIGHT);
break;
case UIManager.KeyType.UP:
MoveFocusAction(UIFocusPath.MoveType.UP);
break;
case UIManager.KeyType.DOWN:
MoveFocusAction(UIFocusPath.MoveType.DOWN);
break;
}
}
}
private void OnEnable()
{
fisrtKeyUP = false;
uiFocusPath = GetComponent <UIFocusPath>();
nowUIFocus = uiFocusPath.GetFirstFocus();
saveingImage.gameObject.SetActive(false);
UIManager.Instance.KeyUpHandle += Instance_KeyUpHandle;
}
private void OnEnable()
{
nowUIFocus = uiFocusPath.GetFirstFocus();
if (nowUIFocus)
{
nowUIFocus.SetForcus();
}
}
private void OnMouseDown()
{
Operating = true;
StartCoroutine(UIFocus.ControlListener());
_ScreenPos = Input.mousePosition;
_Origin = Cam.ScreenToWorldPoint(new Vector3(_ScreenPos.x, _ScreenPos.y, Cam.nearClipPlane));
_Origin.y = 0;
_Anchor = Opposite.transform.position;
}
static public void SetOwner(GameObject go, UIFocus ownerFocus)
{
UIFocusHelper helper = go.GetComponent <UIFocusHelper>();
if (helper == null)
{
helper = go.AddComponent <UIFocusHelper>();
}
helper.mOwnerFocus = ownerFocus;
}
void Awake()
{
reference = this;
if (defaultFocus == null)
{
try { defaultFocus = FindObjectOfType <Text>().GetComponent <RectTransform>(); } catch { defaultFocus = FindObjectOfType <RectTransform>(); }
}
EventSystem.current.SetSelectedGameObject((initialFocus != null) ? initialFocus.gameObject : null);
}
private void OnMouseDown()
{
if (Editable && Selected == this)
{
StartCoroutine(UIFocus.ControlListener());
_ScreenPos = Input.mousePosition;
_Origin = Cam.ScreenToWorldPoint(new Vector3(_ScreenPos.x, _ScreenPos.y, Cam.nearClipPlane));
_Origin.y = 0;
}
}
/// <summary>
/// 新建时选择种族中的种族按钮被点击
/// </summary>
/// <param name="uiFocus"></param>
public void CreateSelectRoleOfRaceButtonClick(UIFocus uiFocus)
{
if (nowRoleOfRaceFocus == uiFocus && uiFocus != null)
{
CreateSelectRoleOfRaceSelect(uiFocus.Tag);
}
else
{
nowRoleOfRaceFocus = uiFocus;
CreateSelectRoleOfRaceUpdateNowFocus();
}
}
/// <summary>
/// 创建时选择种族状态的手柄输入检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void CreateSelectRoleOfRaceType_HandleUpdate(UIManager.KeyType keyType, Vector2 rockValue)
{
if (nowRoleOfRaceFocus == null && roleOfRaceUIFocusPath)
{
nowRoleOfRaceFocus = roleOfRaceUIFocusPath.GetFirstFocus();
if (nowRoleOfRaceFocus)
{
nowRoleOfRaceFocus.SetForcus();
}
}
if (nowRoleOfRaceFocus)
{
//判断键位
Action <UIFocusPath.MoveType> MoveFocusAction = (moveType) =>
{
UIFocus next = roleOfRaceUIFocusPath.GetNewNextFocus(nowRoleOfRaceFocus, moveType);// uiFocusPath.GetNextFocus(nowFocus, moveType, true);
if (next)
{
nowRoleOfRaceFocus = next;
CreateSelectRoleOfRaceUpdateNowFocus();
}
};
switch (keyType)
{
case UIManager.KeyType.A:
if (nowRoleOfRaceFocus)
{
UIFocusButton uiFocusButton = nowRoleOfRaceFocus as UIFocusButton;
if (uiFocusButton)
{
uiFocusButton.ClickThisButton();
}
}
break;
case UIManager.KeyType.LEFT:
MoveFocusAction(UIFocusPath.MoveType.LEFT);
break;
case UIManager.KeyType.RIGHT:
MoveFocusAction(UIFocusPath.MoveType.RIGHT);
break;
case UIManager.KeyType.UP:
MoveFocusAction(UIFocusPath.MoveType.UP);
break;
case UIManager.KeyType.DOWN:
MoveFocusAction(UIFocusPath.MoveType.DOWN);
break;
}
}
}
void Start()
{
entranceType = EnumEntranceType.Start;
playerCreateTrans = GameObject.Find("PlayerInit").transform;
if (settingCanvasPrefab)
{
GameObject settingGameObject = Instantiate(settingCanvasPrefab);
settingCanvas = settingGameObject.GetComponent <Canvas>();
settingGameObject.SetActive(false);
}
UIManager.Instance.KeyUpHandle += Instance_KeyUpHandle;
StartCoroutine(CrossoverMaskImageAlpha(0));
//判断现在是否有默认存档,如果有则显示继续,如果没有则显示新建
List <Archive> archiveList = DataCenter.Instance.GetAllArchive();//获取所有存档名
Archive defaultArchive = archiveList.FirstOrDefault(temp => temp.ID == 1);
UIFocus continueFoucs = startUIFocusPath.NewUIFocusArray.FirstOrDefault(temp => string.Equals(temp.Tag, "Continue"));
UIFocus newFocus = startUIFocusPath.NewUIFocusArray.FirstOrDefault(temp => string.Equals(temp.Tag, "New"));
if (defaultArchive == null)
{
if (continueFoucs)
{
continueFoucs.gameObject.SetActive(false);
}
if (newFocus)
{
newFocus.gameObject.SetActive(true);
}
}
else
{
if (continueFoucs)
{
continueFoucs.gameObject.SetActive(true);
}
if (newFocus)
{
newFocus.gameObject.SetActive(false);
}
}
//设置当前选中
if (nowStartFocus == null && startUIFocusPath)
{
nowStartFocus = startUIFocusPath.GetFirstFocus();
if (nowStartFocus)
{
nowStartFocus.SetForcus();
}
}
}
/// <summary>
/// 设置按钮按下事件
/// </summary>
public void SettingButtonClick()
{
if (isLoadedScene)
{
return;
}
nowStartFocus = EventSystem.current.currentSelectedGameObject.GetComponent <UIFocus>();
//显示设置面板
if (settingCanvas)
{
settingCanvas.gameObject.SetActive(true);
}
}
/// <summary>
/// 按键检测(抬起)
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void Instance_KeyUpHandle(UIManager.KeyType keyType, Vector2 rockValue)
{
Func <UIFocusPath.MoveType, UIFocus> GetNext = (key) =>
{
UIFocus nextFocus = uiFocusPath.GetNewNextFocus(nowUIFocus, key);
return(nextFocus);
};
switch (keyType)
{
case UIManager.KeyType.A:
if (nowUIFocus)
{
nowUIFocus.MoveChild(UIFocusPath.MoveType.OK);
}
break;
case UIManager.KeyType.LEFT:
if (nowUIFocus)
{
nowUIFocus.MoveChild(UIFocusPath.MoveType.LEFT);
}
break;
case UIManager.KeyType.RIGHT:
if (nowUIFocus)
{
nowUIFocus.MoveChild(UIFocusPath.MoveType.RIGHT);
}
break;
case UIManager.KeyType.UP:
case UIManager.KeyType.DOWN:
if (!nowUIFocus)
{
nowUIFocus = uiFocusPath.GetFirstFocus();
}
else
{
UIFocus nextFocus = GetNext(keyType == UIManager.KeyType.UP ? UIFocusPath.MoveType.UP : UIFocusPath.MoveType.DOWN);
nowUIFocus.LostForcus();
nowUIFocus = nextFocus;
}
if (nowUIFocus)
{
nowUIFocus.SetForcus();
}
break;
}
}
/// <summary>
/// 按键检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void Instance_KeyUpHandle(UIManager.KeyType keyType, Vector2 rockValue)
{
if (!fisrtKeyUP)
{
fisrtKeyUP = true;
return;
}
if (UIAction.isSaving)
{
return;
}
Action <UIFocusPath.MoveType> MoveNextEndAction = (moveType) =>
{
if (nowUIFocus)
{
UIFocus uiFocus = uiFocusPath.GetNewNextFocus(nowUIFocus, moveType);
if (uiFocus)
{
nowUIFocus.LostForcus();
nowUIFocus = uiFocus;
nowUIFocus.SetForcus();
}
}
else
{
nowUIFocus = uiFocusPath.GetFirstFocus();
nowUIFocus.SetForcus();
}
};
switch (keyType)
{
case UIManager.KeyType.A:
UIFocusButton uiFocusButton = nowUIFocus as UIFocusButton;
if (uiFocusButton)
{
uiFocusButton.ClickThisButton();
}
break;
case UIManager.KeyType.UP:
MoveNextEndAction(UIFocusPath.MoveType.UP);
break;
case UIManager.KeyType.DOWN:
MoveNextEndAction(UIFocusPath.MoveType.DOWN);
break;
}
}
/// <summary>
/// 输入名字的按钮点击时
/// </summary>
/// <param name="uiFocus"></param>
public void CreateNameInputButtonClick(UIFocus uiFocus)
{
if (uiFocus)
{
switch (uiFocus.Tag)
{
case "OK":
{
UIFocusInputField uiFocusInputField = nameInputUIFocusPath.GetFirstFocus <UIFocusInputField>();
if (uiFocusInputField)
{
InputField inputField = uiFocusInputField.GetComponent <InputField>();
if (inputField)
{
if (!string.IsNullOrEmpty(inputField.text))
{
PlayerState playerState = DataCenter.Instance.GetEntity <PlayerState>();
playerState.PlayerName = inputField.text;
//再次保存
DataCenter.Instance.Save(1, "存档", "默认存档");
//隐藏该面板显示进入面板
entranceType = EnumEntranceType.Transition;
nameInputRect.gameObject.SetActive(false);
StartCoroutine(CrossoverMaskImageAlpha(1, () =>
{
createRect.gameObject.SetActive(false);
enterRect.gameObject.SetActive(true);
InitEnterRect();
StartCoroutine(CrossoverMaskImageAlpha(0, () =>
{
entranceType = EnumEntranceType.Enter;
}));
}));
}
}
}
}
break;
case "Cancel":
roleOfRaceRect.gameObject.SetActive(true);
nameInputRect.gameObject.SetActive(false);
entranceType = EnumEntranceType.Create_SelectRoleOfRace;
InitCreateSelectRoleOfRace();
break;
}
}
}
private void OnEnable()
{
UIManager.Instance.KeyUpHandle += Instance_KeyUpHandle;
if (uiFocusPath)
{
nowUIFocus = uiFocusPath.GetFirstFocus();
if (nowUIFocus)
{
nowUIFocus.SetForcus();
}
}
//给任务系统填入状态
INowTaskState iNowTaskState = GameState.Instance.GetEntity <INowTaskState>();
iNowTaskState.CheckNowTask(EnumCheckTaskType.Special, (int)TaskMap.Enums.EnumTaskSpecialCheck.OpenItemUI);
}
/// <summary>
/// 点击按钮
/// </summary>
/// <param name="uiFocus"></param>
public void ClickButtong(UIFocus uiFocus)
{
if (UIAction.isSaving)
{
return;
}
if (nowUIFocus != uiFocus)
{
if (nowUIFocus != null)
{
nowUIFocus.LostForcus();
}
nowUIFocus = uiFocus;
nowUIFocus.SetForcus();
}
ButtonAction();
}
/// <summary>
/// 按键检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void Instance_KeyUpHandle(UIManager.KeyType keyType, Vector2 rockValue)
{
//输入
if (uiFocusPath)
{
Action <UIFocusPath.MoveType> MoveFocusAction = (moveType) =>
{
if (nowUIFocus)
{
if (nowUIFocus.CanMoveNext(moveType))
{
UIFocus nextUIFocus = uiFocusPath.GetNewNextFocus(nowUIFocus, moveType);//uiFocusPath.GetNextFocus(nowUIFocus, moveType);
if (nextUIFocus)
{
nowUIFocus = nextUIFocus;
nowUIFocus.SetForcus();
}
}
else//移动控件内的控件
{
nowUIFocus.MoveChild(moveType);
}
}
};
switch (keyType)
{
case UIManager.KeyType.LEFT:
MoveFocusAction(UIFocusPath.MoveType.LEFT);
break;
case UIManager.KeyType.RIGHT:
MoveFocusAction(UIFocusPath.MoveType.RIGHT);
break;
case UIManager.KeyType.UP:
MoveFocusAction(UIFocusPath.MoveType.UP);
break;
case UIManager.KeyType.DOWN:
MoveFocusAction(UIFocusPath.MoveType.DOWN);
break;
}
}
}
/// <summary>
/// 依照当前的焦点获取下一个可以移动的焦点
/// </summary>
/// <param name="moveType"></param>
/// <returns></returns>
private UIFocus GetNextEnableTabPage(UIFocusPath.MoveType moveType)
{
UIFocus tempStartFocus = nowTabPageFocus;
ReGo:
tempStartFocus = uiFocusPath.GetNewNextFocus(tempStartFocus, moveType);
if (tempStartFocus != null)
{
//查看是否可以使用
if (tempStartFocus.Tag == "BigMap")//如果是大地图则查看是是否可以使用大地图
{
GameRunningStateData gameRunningStateData = DataCenter.Instance.GetEntity <GameRunningStateData>();
if (!gameRunningStateData.CanBigMap)//如果不可以使用则调到上面重新获取该节点的下一个位置
{
goto ReGo;
}
}
}
return(tempStartFocus);
}
/// <summary>
/// 点击标签页
/// </summary>
/// <param name="nextTabPageFocus"></param>
public void TabPageClick(UIFocusTabPage nextTabPageFocus)
{
if (nextTabPageFocus != null)
{
nowTabPageFocus.LostForcus();
nowTabPageFocus.panel.gameObject.SetActive(false);
nowTabPageFocus = nextTabPageFocus;
nowTabPageFocus.panel.gameObject.SetActive(true);
nowTabPageFocus.SetForcus();
if (nowTabPageFocus.panelFocusPath)
{
if (tabPanelFocus)
{
tabPanelFocus.LostForcus();
}
tabPanelFocus = nowTabPageFocus.panelFocusPath.GetFirstFocus();
if (tabPanelFocus)
{
tabPanelFocus.SetForcus();
}
}
}
}
/// <summary>
/// 按键检测
/// </summary>
/// <param name="keyType"></param>
/// <param name="rockValue"></param>
private void Instance_KeyUpHandle(UIManager.KeyType keyType, Vector2 rockValue)
{
if (uiFocusPath)//切换标签页
{
UIFocus nextTabPageFocus = null;
switch (keyType)
{
case UIManager.KeyType.R1:
nextTabPageFocus = uiFocusPath.GetNewNextFocus(nowTabPageFocus, UIFocusPath.MoveType.RIGHT);
break;
case UIManager.KeyType.L1:
nextTabPageFocus = uiFocusPath.GetNewNextFocus(nowTabPageFocus, UIFocusPath.MoveType.LEFT);
break;
}
TabPageClick(nextTabPageFocus as UIFocusTabPage);
}
switch (keyType)
{
case UIManager.KeyType.B: //返回
CloseActionClick();
break;
}
}
private void OnGUI()
{
if (uiFocusPath == null)
{
return;
}
//提取所有焦点
uiFocusToLocaionDic = uiFocusPath.NewUIFocusArray.Where(temp => temp != null).ToDictionary(temp => temp, temp => temp.transform.position);
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("缩放比例:", GUILayout.Width(50));
scale = GUILayout.HorizontalSlider(scale, 0.2f, 5f, GUILayout.Width(100));
EditorGUILayout.LabelField("显示全部", GUILayout.Width(50));
showAll = EditorGUILayout.Toggle(showAll, GUILayout.Width(15));
EditorGUILayout.LabelField("点击选择对象", GUILayout.Width(75));
clickButtonToSelect = EditorGUILayout.Toggle(clickButtonToSelect, GUILayout.Width(15));
EditorGUILayout.EndHorizontal();
if (uiFocusToLocaionDic.Count <= 0)
{
EditorGUILayout.EndVertical();
return;
}
//计算出一个范围
float minX = uiFocusToLocaionDic.Min(temp => temp.Value.x) - 30;
float minY = uiFocusToLocaionDic.Min(temp => temp.Value.y) - 30;
float maxX = uiFocusToLocaionDic.Max(temp => temp.Value.x) + 30;
float maxY = uiFocusToLocaionDic.Max(temp => temp.Value.y) + 30;
Vector2 baseOffset = new Vector2(minX, minY); //基础的偏差值
Vector2 baseSize = new Vector2(maxX - minX, maxY - minY); //基础的大小
Rect baseRect = new Rect(baseOffset, baseSize); //基础的位置
Dictionary <UIFocus, Rect> uiFocusToShowRectDic = new Dictionary <UIFocus, Rect>(); //本次运行时的显示区域
scroll = GUI.BeginScrollView(new Rect(0, 40, position.width, position.height - 40), scroll, new Rect(0, 0, baseRect.width * scale, baseRect.height * scale));
foreach (KeyValuePair <UIFocus, Vector3> item in uiFocusToLocaionDic)//遍历绘制
{
Vector2 nowPos = item.Value;
nowPos = nowPos - baseOffset;
nowPos.y = baseSize.y - nowPos.y;
nowPos *= scale;
Rect tempRect = new Rect(nowPos.x, nowPos.y, 70, 15);
GUIStyle buttonStyle = buttonNotSelectStyle;
if (selectUIFcous == item.Key)
{
buttonStyle = buttonSelectStyle;
}
if (GUI.Button(tempRect, item.Key.name, buttonStyle))
{
selectUIFcous = item.Key;
if (clickButtonToSelect)
{
Selection.activeGameObject = selectUIFcous.gameObject;
}
}
uiFocusToShowRectDic.Add(item.Key, new Rect(nowPos.x - scroll.x, nowPos.y + 40 - scroll.y, 70, 15));
}
GUI.EndScrollView();
EditorGUILayout.EndVertical();
Dictionary <Vector3[], UIFocus[]> lineToFocusDic = new Dictionary <Vector3[], UIFocus[]>();//线对应焦点字典
//绘制线
Action <Vector3, Vector3, UIFocus, UIFocus> DrawLineAction = (startVec, endVec, startFocus, endFocus) =>
{
Handles.color = Color.red;
Handles.DrawLine(startVec, endVec);
lineToFocusDic.Add(new Vector3[] { startVec, endVec }, new UIFocus[] { startFocus, endFocus });
};
foreach (UIFocusPath.FocusRelaship item in uiFocusPath.UIFocusArrayRelaships)
{
if (showAll || item.This == selectUIFcous)
{
if (!uiFocusToShowRectDic.ContainsKey(item.This))
{
continue;
}
Rect thisRect = uiFocusToShowRectDic[item.This];
if (item.Up)
{
Vector3 thisVec = new Vector3(thisRect.xMin + thisRect.width / 2, thisRect.yMin);
if (uiFocusToShowRectDic.ContainsKey(item.Up))
{
Rect upRect = uiFocusToShowRectDic[item.Up];
Vector3 target = upRect.center;
DrawLineAction(thisVec, target, item.This, item.Up);
}
}
if (item.Down)
{
Vector3 thisVec = new Vector3(thisRect.xMin + thisRect.width / 2, thisRect.yMax);
if (uiFocusToShowRectDic.ContainsKey(item.Down))
{
Rect downRect = uiFocusToShowRectDic[item.Down];
Vector3 target = downRect.center;
DrawLineAction(thisVec, target, item.This, item.Down);
}
}
if (item.Left)
{
Vector3 thisVec = new Vector3(thisRect.xMin, thisRect.yMin + thisRect.height / 2);
if (uiFocusToShowRectDic.ContainsKey(item.Left))
{
Rect leftRect = uiFocusToShowRectDic[item.Left];
Vector3 target = leftRect.center;
DrawLineAction(thisVec, target, item.This, item.Left);
}
}
if (item.Right)
{
Vector3 thisVec = new Vector3(thisRect.xMax, thisRect.yMin + thisRect.height / 2);
if (uiFocusToShowRectDic.ContainsKey(item.Right))
{
Rect rightRect = uiFocusToShowRectDic[item.Right];
Vector3 target = rightRect.center;
DrawLineAction(thisVec, target, item.This, item.Right);
}
}
}
}
Event e = Event.current;
//绘制选择对象的四个游标
if (selectUIFcous)
{
Rect thisRect = uiFocusToShowRectDic[selectUIFcous];
Rect upRect = new Rect(thisRect.xMin + thisRect.width / 2 - 5, thisRect.yMin - 10, 10, 10);
Rect downRect = new Rect(thisRect.xMin + thisRect.width / 2 - 5, thisRect.yMax, 10, 10);
Rect leftRect = new Rect(thisRect.xMin - 10, thisRect.yMin + thisRect.height / 2 - 5, 10, 10);
Rect rightRect = new Rect(thisRect.xMax, thisRect.yMin + thisRect.height / 2 - 5, 10, 10);
GUI.DrawTexture(upRect, relashipButtonTexture);
GUI.DrawTexture(downRect, relashipButtonTexture);
GUI.DrawTexture(leftRect, relashipButtonTexture);
GUI.DrawTexture(rightRect, relashipButtonTexture);
if (e.button == 1 && e.rawType == EventType.mouseDown)
{
if (upRect.Contains(e.mousePosition))
{
forwardType = EnumEditorGUIFocusPathForward.Up;
}
else if (downRect.Contains(e.mousePosition))
{
forwardType = EnumEditorGUIFocusPathForward.Down;
}
else if (leftRect.Contains(e.mousePosition))
{
forwardType = EnumEditorGUIFocusPathForward.Left;
}
else if (rightRect.Contains(e.mousePosition))
{
forwardType = EnumEditorGUIFocusPathForward.Right;
}
}
}
if (e.button == 1)
{
if (forwardType != null)
{
if (selectUIFcous)
{
Rect thisRect = uiFocusToShowRectDic[selectUIFcous];
Rect upRect = new Rect(thisRect.xMin + thisRect.width / 2 - 5, thisRect.yMin - 10, 10, 10);
Rect downRect = new Rect(thisRect.xMin + thisRect.width / 2 - 5, thisRect.yMax, 10, 10);
Rect leftRect = new Rect(thisRect.xMin - 10, thisRect.yMin + thisRect.height / 2 - 5, 10, 10);
Rect rightRect = new Rect(thisRect.xMax, thisRect.yMin + thisRect.height / 2 - 5, 10, 10);
Handles.color = Color.gray;
switch (forwardType.Value)
{
case EnumEditorGUIFocusPathForward.Left:
Handles.DrawLine(leftRect.center, e.mousePosition);
break;
case EnumEditorGUIFocusPathForward.Right:
Handles.DrawLine(rightRect.center, e.mousePosition);
break;
case EnumEditorGUIFocusPathForward.Up:
Handles.DrawLine(upRect.center, e.mousePosition);
break;
case EnumEditorGUIFocusPathForward.Down:
Handles.DrawLine(downRect.center, e.mousePosition);
break;
}
}
}
}
if (e.button == 1 && e.rawType == EventType.mouseUp)
{
if (forwardType != null)
{
KeyValuePair <UIFocus, Rect>[] mouseUpResultArray = uiFocusToShowRectDic.Where(temp => temp.Value.Contains(e.mousePosition)).ToArray();
KeyValuePair <UIFocus, Rect> mouseUpResult = mouseUpResultArray.FirstOrDefault();
UIFocusPath.FocusRelaship focusRelaship = uiFocusPath.UIFocusArrayRelaships.FirstOrDefault(temp => temp.This == selectUIFcous);
if (focusRelaship != null)
{
switch (forwardType.Value)
{
case EnumEditorGUIFocusPathForward.Left:
focusRelaship.Left = mouseUpResult.Key;
break;
case EnumEditorGUIFocusPathForward.Right:
focusRelaship.Right = mouseUpResult.Key;
break;
case EnumEditorGUIFocusPathForward.Up:
focusRelaship.Up = mouseUpResult.Key;
break;
case EnumEditorGUIFocusPathForward.Down:
focusRelaship.Down = mouseUpResult.Key;
break;
}
}
forwardType = null;
}
}
}
/// <summary>
/// 初始化新建时的输入姓名
/// </summary>
private void InitCreateNameInput()
{
nowNameInputFocus = nameInputUIFocusPath.GetFirstFocus();
nowNameInputFocus = nameInputUIFocusPath.GetFirstFocus();
nowNameInputFocus.SetForcus();
}
public UIFocus GetNextFocus(UIFocus target, MoveType moveType, bool cycle = false)
{
if (target == null)
{
return(null);
}
int index = UIFocuesArray.ToList().FindIndex(temp => target.Equals(temp));
if (index < 0)
{
return(null);
}
int _row = (index) / column;
int _column = index % column;
switch (moveType)
{
case MoveType.LEFT:
_column -= 1;
break;
case MoveType.RIGHT:
_column += 1;
break;
case MoveType.UP:
_row -= 1;
break;
case MoveType.DOWN:
_row += 1;
break;
}
if (_row >= row && cycle)
{
_row = 0;
}
if (_row < 0 && cycle)
{
_row = row - 1;
}
if (_column >= column && cycle)
{
_column = 0;
}
if (_column < 0 && cycle)
{
_column = column - 1;
}
if (_row >= 0 && _row < row && _column >= 0 && _column < column)
{
Func <int, int, int, int, UIFocus> CheckUIFocus = null;
CheckUIFocus = (__row, __column, _add_row, _add_column) =>
{
if (__row >= 0 && __column >= 0 && __row < row && __column < column)
{
__row += _add_row;
__column += _add_column;
UIFocus _tempUIFocus = GetFocus(__row, __column);
if (!_tempUIFocus)
{
return(CheckUIFocus(__row, __column, _add_row, _add_column));
}
else
{
return(_tempUIFocus);
}
}
return(null);
};
UIFocus nextUIFocus = GetFocus(_row, _column); // UIFocuesArray[_row * column + _column];
if (!nextUIFocus) //如果为空，则根据方向确定
{
UIFocus tempUIFocus = null;
switch (moveType)
{
case MoveType.RIGHT:
case MoveType.LEFT:
tempUIFocus = CheckUIFocus(_row, _column, -1, 0);
if (!tempUIFocus)
{
tempUIFocus = CheckUIFocus(_row, _column, 1, 0);
}
break;
case MoveType.UP:
case MoveType.DOWN:
tempUIFocus = CheckUIFocus(_row, _column, 0, -1);
if (!tempUIFocus)
{
tempUIFocus = CheckUIFocus(_row, _column, 0, 1);
}
break;
}
if (tempUIFocus)
{
nextUIFocus = tempUIFocus;
}
}
if (nextUIFocus == null || nextUIFocus.gameObject.activeSelf)//如果没有隐藏则直接返回
{
return(nextUIFocus);
}
return(GetNextFocus(nextUIFocus, moveType, cycle));//如果隐藏了则以当前点为坐标继续向下查找
}
else
{
return(null);
}
}
public UIFocus GetNextFocus(UIFocus target, MoveType moveType, EnumFocusCheckModel focusCheckModel, bool cycle = false)
{
int index = UIFocuesArray.ToList().FindIndex(temp => target.Equals(temp));
if (index < 0)
{
return(null);
}
int this_BaseRowIndex = (index) / column;
int this_BaseColumnIndex = index % column;
//构建检索用的数组
CheckFocusStruct[,] _CheckFocusStructArray = CheckFocusStructArray;
CheckFocusStruct[,] useCheckFocusStructArray = null; //本次使用的数组对象
if (cycle) //如果循环(默认方向向右向下)
{
useCheckFocusStructArray = new CheckFocusStruct[row, column];
foreach (CheckFocusStruct checkFocusStruct in _CheckFocusStructArray)
{
int baseX = checkFocusStruct.BaseX;
int baseY = checkFocusStruct.BaseY;
switch (moveType)
{
case MoveType.LEFT: //左下方向延伸 x--,y++
//列
baseX = this_BaseColumnIndex >= baseX ?
(column - (this_BaseColumnIndex - baseX) - 1) //如果当前下标大于等于遍历对象的下标
: (baseX - this_BaseColumnIndex - 1); //如果当前下标小于遍历对象的下标
//行
baseY = this_BaseRowIndex > baseY ?
(row - this_BaseRowIndex + baseY) //如果当前下标大于遍历对象的下标
: (baseY - this_BaseRowIndex); //如果当前下标小于等于遍历对象的下标
break;
case MoveType.UP: //右上方向延伸 x++,y--
//列
baseX = this_BaseColumnIndex > baseX ?
(column - this_BaseColumnIndex + baseX) //如果当前下标大于便利对象的下标
: (baseX - this_BaseColumnIndex); //如果当前下标小于等于遍历对象的下标
//行
baseY = this_BaseRowIndex >= baseY ?
(row - (this_BaseRowIndex - baseY) - 1) //如果当前下标大于等于遍历对象的下标
: (baseY - this_BaseRowIndex - 1); //如果当前下标小于遍历对象的下标
break;
case MoveType.DOWN: //右下方向延伸 x++,y++
case MoveType.RIGHT:
//列
baseX = this_BaseColumnIndex > baseX ?
(column - this_BaseColumnIndex + baseX) //如果当前下标大于便利对象的下标
: (baseX - this_BaseColumnIndex); //如果当前下标小于等于遍历对象的下标
//行
baseY = this_BaseRowIndex > baseY ?
(row - this_BaseRowIndex + baseY) //如果当前下标大于遍历对象的下标
: (baseY - this_BaseRowIndex); //如果当前下标小于等于遍历对象的下标
break;
}
useCheckFocusStructArray[baseY, baseX] = checkFocusStruct;
}
}
else
{
int thisRowCount = 0;
int thisColumnCount = 0;
//建立数组
switch (moveType)
{
case MoveType.LEFT: //左下方向延伸 x--,y++
thisColumnCount = this_BaseColumnIndex + 1;
thisRowCount = row - this_BaseRowIndex;
break;
case MoveType.UP: //右上方向延伸 x++,y--
thisColumnCount = column - this_BaseColumnIndex;
thisRowCount = this_BaseRowIndex + 1;
break;
case MoveType.RIGHT: //右下方向延伸 x++,y++
case MoveType.DOWN:
thisColumnCount = column - this_BaseColumnIndex;
thisRowCount = row - this_BaseRowIndex;
break;
}
useCheckFocusStructArray = new CheckFocusStruct[thisRowCount, thisColumnCount];
//存放数据
for (int i = 0; i < useCheckFocusStructArray.GetLength(0); i++) //行
{
for (int j = 0; j < useCheckFocusStructArray.GetLength(1); j++) //列
{
int thisX = -1;
int thisY = -1;
switch (moveType)
{
case MoveType.LEFT: //左下方向延伸 x--,y++
thisX = j; //列
thisY = i + this_BaseRowIndex; //行
break;
case MoveType.UP: //右上方向延伸 x++,y--
thisX = j + this_BaseColumnIndex; //列
thisY = i; //行
break;
case MoveType.RIGHT: //右下方向延伸 x++,y++
case MoveType.DOWN:
thisX = j + this_BaseColumnIndex; //列
thisY = i + this_BaseRowIndex; //行
break;
}
if (thisX > -1 && thisX < _CheckFocusStructArray.GetLength(1) && thisY > -1 && thisY < _CheckFocusStructArray.GetLength(0))
{
useCheckFocusStructArray[i, j] = _CheckFocusStructArray[thisY, thisX];
}
}
}
}
//设置起始坐标与增加量
int startX = -1;
int startY = -1;
int addX = 0;
int addY = 0;
switch (moveType)
{
case MoveType.LEFT:
startX = useCheckFocusStructArray.GetLength(1) - 1;
startY = 0;
addX = -1;
break;
case MoveType.UP:
startX = 0;
startY = useCheckFocusStructArray.GetLength(0) - 1;
addY = -1;
break;
case MoveType.RIGHT:
startX = 0;
startY = 0;
addX = 1;
break;
case MoveType.DOWN:
startX = 0;
startY = 0;
addY = 1;
break;
}
if (startX < 0 || startY < 0)
{
return(null);
}
if (addX == 0 && addY == 0)
{
return(null);
}
//开始检索
UIFocus checkedFocus = null;
//寻找指定坐标开始的最近位置
Action BothCheckFunc = () =>
{
int dis = int.MaxValue;
CheckFocusStruct checkFocusStruct = null;
for (int i = 0; i < useCheckFocusStructArray.GetLength(0); i++) //行y
{
for (int j = 0; j < useCheckFocusStructArray.GetLength(1); j++) //列x
{
if (i == startY && j == startX)
{
continue;
}
CheckFocusStruct tempObj = useCheckFocusStructArray[i, j];
if (tempObj.Target != null)
{
//计算距离
int x = startX - j;
int y = startY - i;
int tempDis = (int)Mathf.Pow(x, 2) + (int)Mathf.Pow(y, 2);
if (tempDis < dis)
{
dis = tempDis;
checkFocusStruct = tempObj;
}
else if (tempDis == dis)//如果相等,则根据移动方向判断,在移动方向上的差距越小约好
{
int oldInterval = 0, nowInterval = 0;
if (addX != 0)//判断列的差距
{
oldInterval = Mathf.Abs(checkFocusStruct.BaseX - this_BaseColumnIndex);
nowInterval = Mathf.Abs(tempObj.BaseX - this_BaseColumnIndex);
}
else if (addY != 0)//判断行的差距
{
oldInterval = Mathf.Abs(checkFocusStruct.BaseY - this_BaseRowIndex);
nowInterval = Mathf.Abs(tempObj.BaseY - this_BaseRowIndex);
}
if (nowInterval < oldInterval)
{
checkFocusStruct = tempObj;
}
}
}
}
}
if (checkFocusStruct != null)
{
checkedFocus = checkFocusStruct.Target;
}
};
//垂直方向检测(检测的是行i(y))
Func <bool> VertiacalCheckFunc = () =>
{
if (addY == 0)
{
return(false);
}
int rowCount = useCheckFocusStructArray.GetLength(0);//总行数
for (int i = 1; i < rowCount; i++)
{
CheckFocusStruct checkFocusStruct = useCheckFocusStructArray[startY + i * addY, startX];
if (checkFocusStruct.Target != null)
{
checkedFocus = checkFocusStruct.Target;
return(true);
}
}
return(false);
};
//水平方向检测(检测的是列j(x))
Func <bool> HorizontalCheckFunc = () =>
{
if (addX == 0)
{
return(false);
}
int columnCount = useCheckFocusStructArray.GetLength(1);//纵列数
for (int i = 1; i < columnCount; i++)
{
CheckFocusStruct checkFocusStruct = useCheckFocusStructArray[startY, startX + i * addX];
if (checkFocusStruct.Target != null)
{
checkedFocus = checkFocusStruct.Target;
return(true);
}
}
return(false);
};
switch (focusCheckModel)
{
case EnumFocusCheckModel.Vertical:
if (!VertiacalCheckFunc())
{
BothCheckFunc();
}
break;
case EnumFocusCheckModel.Horizontal:
if (!HorizontalCheckFunc())
{
BothCheckFunc();
}
break;
case EnumFocusCheckModel.Both:
BothCheckFunc();
break;
}
return(checkedFocus);
}
