738 lines
28 KiB
C#
738 lines
28 KiB
C#
using System.Text.RegularExpressions;
|
|
using System;
|
|
using System.Linq.Expressions;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using System.IO;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
|
|
namespace BFEditor
|
|
{
|
|
public class BoardEditorWindow : EditorWindow {
|
|
|
|
// private static void ShowWindow() {
|
|
// var window = GetWindow<BoardEditorWindow>();
|
|
// window.titleContent = new GUIContent("BoardWindow");
|
|
// window.Show();
|
|
// }
|
|
const string BOARD_EXCEL_KEY = "bf_board_excel_key";
|
|
const string BOARD_GRID_TYPE_KEY = "bf_board_grid_type_key";
|
|
const string BOARD_GRID_EDGE_KEY = "bf_board_grid_edge_key";
|
|
int gridCount = 49;
|
|
string battleImgDirectory = "Assets/arts/textures/ui/battle/";
|
|
string boardFilepath;
|
|
string boardGridTypePath;
|
|
string boardGridEdgePath;
|
|
string boardFiledName = "board";
|
|
string boardEdgeFiledName = "grid_edge";
|
|
string randomTypeStr = "";
|
|
string boardEdgeStr = "";
|
|
int curIndex = 1;
|
|
int maxRow = 7;
|
|
Dictionary<int, Dictionary<string, string>> boardGridTypeDict = new Dictionary<int, Dictionary<string, string>>();
|
|
Dictionary<int, JArray> boardDict = new Dictionary<int, JArray>();
|
|
Dictionary<int, JArray> outPutBoardDict = new Dictionary<int, JArray>();
|
|
Dictionary<string, Texture> imgDict = new Dictionary<string, Texture>();
|
|
Dictionary<int, Dictionary<string, string>> boardGridEdgeDict = new Dictionary<int, Dictionary<string, string>>();
|
|
Dictionary<int, JArray> edgeDict = new Dictionary<int, JArray>();
|
|
Dictionary<int, JArray> outPutBoardEdgeDict = new Dictionary<int, JArray>();
|
|
bool loadExcelOver = false;
|
|
Dictionary<int, string> elementTypeImgDict = new Dictionary<int, string>(){
|
|
[1] = "red_1",
|
|
[2] = "yellow_1",
|
|
[3] = "green_1",
|
|
[4] = "blue_1",
|
|
[5] = "purple_1"
|
|
};
|
|
Texture boardImg;
|
|
private void OnEnable()
|
|
{
|
|
loadExcelOver = false;
|
|
boardFilepath = GetBoardExcelPath();
|
|
if (boardFilepath.Equals(""))
|
|
{
|
|
boardFilepath = "选择配置表路径";
|
|
}
|
|
|
|
boardGridTypePath = GetBoardGridTypePath();
|
|
if (boardGridTypePath.Equals(""))
|
|
{
|
|
boardGridTypePath = "选择grid_type配置表路径";
|
|
}
|
|
|
|
boardGridEdgePath = GetBoardGridEdgePath();
|
|
if (boardGridEdgePath.Equals(""))
|
|
{
|
|
boardGridEdgePath = "选择grid_edge_type配置表路径";
|
|
}
|
|
string[] paths = Directory.GetFiles(battleImgDirectory);
|
|
foreach(var path in paths)
|
|
{
|
|
if(!path.EndsWith(".meta"))
|
|
{
|
|
string formatPath = Path.GetFileNameWithoutExtension(path);
|
|
imgDict[formatPath] = AssetDatabase.LoadAssetAtPath<Texture>(path);
|
|
}
|
|
}
|
|
boardImg = AssetDatabase.LoadAssetAtPath<Texture>("Assets/arts/textures/background/battle_common/chessboard_1.png");
|
|
}
|
|
string GetBoardExcelPath()
|
|
{
|
|
return PlayerPrefs.GetString(BOARD_EXCEL_KEY, "");
|
|
}
|
|
|
|
void SetBoardExcelPath(string path)
|
|
{
|
|
PlayerPrefs.SetString(BOARD_EXCEL_KEY, path);
|
|
}
|
|
|
|
string GetBoardGridTypePath()
|
|
{
|
|
return PlayerPrefs.GetString(BOARD_GRID_TYPE_KEY, "");
|
|
}
|
|
|
|
void SetBoardGridTypePath(string path)
|
|
{
|
|
PlayerPrefs.SetString(BOARD_GRID_TYPE_KEY, path);
|
|
}
|
|
|
|
string GetBoardGridEdgePath()
|
|
{
|
|
return PlayerPrefs.GetString(BOARD_GRID_EDGE_KEY, "");
|
|
}
|
|
|
|
void SetBoardGridEdgePath(string path)
|
|
{
|
|
PlayerPrefs.SetString(BOARD_GRID_EDGE_KEY, path);
|
|
}
|
|
|
|
BoardEditorWindow()
|
|
{
|
|
this.titleContent = new GUIContent("棋盘编辑器");
|
|
}
|
|
|
|
private void OnGUI() {
|
|
DrawBaseInfo();
|
|
DragBoard();
|
|
}
|
|
|
|
void DrawBaseInfo()
|
|
{
|
|
GUILayout.BeginVertical();
|
|
GUILayout.Space(10);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("grid_type 路径", GUILayout.Width(100));
|
|
GUILayout.Space(10);
|
|
GUILayout.TextField(boardGridTypePath, GUILayout.Width(300));
|
|
if (GUILayout.Button("选择", GUILayout.Width(80)))
|
|
{
|
|
string openPath = EditorUtility.OpenFilePanel("选择配置表", GetBoardGridTypePath(), "");
|
|
if (openPath.CompareTo("") != 0)
|
|
{
|
|
boardGridTypePath = openPath;
|
|
SetBoardGridTypePath(openPath);
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("grid_edge 路径", GUILayout.Width(100));
|
|
GUILayout.Space(10);
|
|
GUILayout.TextField(boardGridEdgePath, GUILayout.Width(300));
|
|
if (GUILayout.Button("选择", GUILayout.Width(80)))
|
|
{
|
|
string openPath = EditorUtility.OpenFilePanel("选择配置表", GetBoardGridEdgePath(), "");
|
|
if (openPath.CompareTo("") != 0)
|
|
{
|
|
boardGridEdgePath = openPath;
|
|
SetBoardGridEdgePath(openPath);
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("配置表路径", GUILayout.Width(100));
|
|
GUILayout.Space(10);
|
|
GUILayout.TextField(boardFilepath, GUILayout.Width(300));
|
|
if (GUILayout.Button("选择", GUILayout.Width(80)))
|
|
{
|
|
string openPath = EditorUtility.OpenFilePanel("选择配置表", GetBoardExcelPath(), "");
|
|
if (openPath.CompareTo("") != 0)
|
|
{
|
|
boardFilepath = openPath;
|
|
SetBoardExcelPath(openPath);
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("字段名称", GUILayout.Width(100));
|
|
GUILayout.Space(10);
|
|
boardFiledName = GUILayout.TextField(boardFiledName, GUILayout.Width(200));
|
|
GUILayout.EndHorizontal();
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.BeginHorizontal();
|
|
if (GUILayout.Button("加载棋盘", GUILayout.Width(80)))
|
|
{
|
|
LoadBoardExcel();
|
|
}
|
|
|
|
GUILayout.Label("棋盘数量", GUILayout.Width(100));
|
|
gridCount = int.Parse(GUILayout.TextField(gridCount.ToString(), GUILayout.Width(200)));
|
|
maxRow = (int)(gridCount / 7);
|
|
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.BeginHorizontal();
|
|
if (!IsInNewBoard())
|
|
{
|
|
if (GUILayout.Button("上一张", GUILayout.Width(80)))
|
|
{
|
|
showSwitchBoardSaveDialog(Math.Max(curIndex - 1, 1));
|
|
}
|
|
}
|
|
|
|
GUILayout.BeginHorizontal(GUILayout.Width(80));
|
|
GUIStyle style = new GUIStyle(GUI.skin.label);
|
|
style.alignment = TextAnchor.MiddleCenter;
|
|
GUILayout.Label("当前编号id = ", style);
|
|
showSwitchBoardSaveDialog(int.Parse(GUILayout.TextField(curIndex.ToString(), GUILayout.Width(40))));
|
|
GUILayout.EndHorizontal();
|
|
if (!IsInNewBoard())
|
|
{
|
|
if (GUILayout.Button("下一张", GUILayout.Width(80)))
|
|
{
|
|
showSwitchBoardSaveDialog(Math.Min(curIndex + 1, boardDict.Count));
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button("复制当前棋盘", GUILayout.Width(80)))
|
|
{
|
|
if (!boardDict.ContainsKey(curIndex))
|
|
{
|
|
return;
|
|
}
|
|
JArray jo = boardDict[curIndex];
|
|
GUIUtility.systemCopyBuffer = JsonConvert.SerializeObject(jo);
|
|
}
|
|
|
|
if (GUILayout.Button("粘贴棋盘", GUILayout.Width(80)))
|
|
{
|
|
JArray jo = (JArray)JsonConvert.DeserializeObject(GUIUtility.systemCopyBuffer);
|
|
if (jo == null)
|
|
{
|
|
return;
|
|
}
|
|
boardDict[curIndex] = jo;
|
|
}
|
|
|
|
if (!IsInNewBoard())
|
|
{
|
|
if (GUILayout.Button("新建棋盘", GUILayout.Width(80)))
|
|
{
|
|
curIndex = outPutBoardDict.Count + 1;
|
|
boardDict[curIndex] = new JArray();
|
|
for (int i = 0; i < gridCount; i++)
|
|
{
|
|
JArray unit = (JArray)JsonConvert.DeserializeObject("[0, 0]");
|
|
boardDict[curIndex].Add(unit);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GUILayout.Button("退出新建棋盘", GUILayout.Width(80)))
|
|
{
|
|
boardDict.Remove(curIndex);
|
|
curIndex = outPutBoardDict.Count;
|
|
}
|
|
if (GUILayout.Button("保存当前棋盘", GUILayout.Width(80)))
|
|
{
|
|
SaveBoard(curIndex);
|
|
}
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.EndVertical();
|
|
|
|
GUILayout.BeginArea(new Rect(730, 500, 500, 100));
|
|
GUILayout.BeginVertical();
|
|
GUILayout.Label("随机类型和数量[类型,数量] 空格 [类型,数量]");
|
|
randomTypeStr = GUILayout.TextField(randomTypeStr, GUILayout.Width(500));
|
|
GUILayout.BeginHorizontal();
|
|
if(GUILayout.Button("生成随机棋盘", GUILayout.Width(80)))
|
|
{
|
|
string[] units = randomTypeStr.Split('[');
|
|
Dictionary<int, int> dict = new Dictionary<int, int>();
|
|
for (int i = 0; i < units.Length; i++)
|
|
{
|
|
string formatStr = units[i].Replace("[", "").Replace("]", "").Replace(" ", "");
|
|
string[] unitList = formatStr.Split(',');
|
|
if (unitList.Length >= 2)
|
|
{
|
|
dict[int.Parse(unitList[0])] = int.Parse(unitList[1]);
|
|
}
|
|
}
|
|
List<int> list = new List<int>();
|
|
for (int i = 0; i < gridCount; i++)
|
|
{
|
|
list.Add(i);
|
|
}
|
|
JArray ja = new JArray();
|
|
for (int i = 0; i < gridCount; i++)
|
|
{
|
|
JArray unit = (JArray)JsonConvert.DeserializeObject("[0, 0]");
|
|
ja.Add(unit);
|
|
}
|
|
foreach (int gridType in dict.Keys)
|
|
{
|
|
for(int i = 0; i < dict[gridType]; i++)
|
|
{
|
|
int index = UnityEngine.Random.Range(0, list.Count);
|
|
ja[list[index]][0] = gridType;
|
|
list.RemoveAt(index);
|
|
}
|
|
}
|
|
boardDict[curIndex] = ja;
|
|
}
|
|
if(GUILayout.Button("生成随机棋盘+元素", GUILayout.Width(110)))
|
|
{
|
|
string[] units = randomTypeStr.Split('[');
|
|
Dictionary<int, int> dict = new Dictionary<int, int>();
|
|
for (int i = 0; i < units.Length; i++)
|
|
{
|
|
string formatStr = units[i].Replace("[", "").Replace("]", "").Replace(" ", "");
|
|
string[] unitList = formatStr.Split(',');
|
|
if (unitList.Length >= 2)
|
|
{
|
|
dict[int.Parse(unitList[0])] = int.Parse(unitList[1]);
|
|
}
|
|
}
|
|
List<int> list = new List<int>();
|
|
for (int i = 0; i < gridCount; i++)
|
|
{
|
|
list.Add(i);
|
|
}
|
|
JArray ja = new JArray();
|
|
for (int i = 0; i < gridCount; i++)
|
|
{
|
|
ja.Add(getNewGridUnitInfo());
|
|
}
|
|
foreach (int gridType in dict.Keys)
|
|
{
|
|
for(int i = 0; i < dict[gridType]; i++)
|
|
{
|
|
int index = UnityEngine.Random.Range(0, list.Count);
|
|
ja[list[index]][0] = gridType;
|
|
list.RemoveAt(index);
|
|
}
|
|
}
|
|
for (int i = 0; i < ja.Count; i++)
|
|
{
|
|
int gridType = (int)(ja[i][0]);
|
|
Dictionary<string, string> gridTypeDict = boardGridTypeDict[gridType];
|
|
if (gridTypeDict.ContainsKey("break_stay_element") || !gridTypeDict.ContainsKey("element_invalid"))
|
|
{
|
|
ja[i][1] = UnityEngine.Random.Range(1, 6);
|
|
}
|
|
}
|
|
boardDict[curIndex] = ja;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.EndVertical();
|
|
GUILayout.EndArea();
|
|
GUILayout.BeginArea(new Rect(730, 650, 500, 100));
|
|
GUILayout.BeginVertical();
|
|
GUILayout.Label("棋盘边缘元素");
|
|
boardEdgeStr = GUILayout.TextField(boardEdgeStr, GUILayout.Width(500), GUILayout.Height(300));
|
|
if(GUILayout.Button("重新加载边缘元素"))
|
|
{
|
|
string[] units = boardEdgeStr.Split('{');
|
|
List<string> edgeList = new List<string>();
|
|
for (int i = 0; i < units.Length; i++)
|
|
{
|
|
string formatStr = units[i].Replace("[", "").Replace("]", "").Replace(" ", "").Replace("}", "");
|
|
string[] unitList = formatStr.Split(',');
|
|
if (unitList.Length >= 3)
|
|
{
|
|
string str = "[";
|
|
for(int j = 0; j < 3; j++)
|
|
{
|
|
str = str + unitList[j];
|
|
if (j != 2)
|
|
{
|
|
str = str + ",";
|
|
}
|
|
}
|
|
str = str + "]";
|
|
edgeList.Add(str);
|
|
}
|
|
}
|
|
|
|
JArray ja = new JArray();
|
|
for (int i = 0; i < edgeList.Count; i++)
|
|
{
|
|
JArray unit = (JArray)JsonConvert.DeserializeObject(edgeList[i]);
|
|
ja.Add(unit);
|
|
}
|
|
edgeDict[curIndex] = ja;
|
|
}
|
|
GUILayout.EndVertical();
|
|
GUILayout.EndArea();
|
|
if(GUI.Button(new Rect(1050, 10, 100, 30), "导出到Excel"))
|
|
{
|
|
if (CheckBoardChanged(curIndex))
|
|
{
|
|
switch (EditorUtility.DisplayDialogComplex("提示", "当前棋盘已经改变，是否保存", "确定", "放弃", "再次确认"))
|
|
{
|
|
case 0:
|
|
SaveBoard(curIndex);
|
|
SaveBoardExcel();
|
|
break;
|
|
case 1:
|
|
AbortBoard(curIndex);
|
|
SaveBoardExcel();
|
|
break;
|
|
case 2:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SaveBoardExcel();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LoadBoardExcel()
|
|
{
|
|
var desktopDir = System.Environment.GetFolderPath(System.Environment.SpecialFolder.DesktopDirectory);
|
|
var tempPath = System.IO.Path.Combine(desktopDir, "BoardEditorTemp.txt");
|
|
|
|
string relitivePath = Application.dataPath;
|
|
relitivePath = relitivePath.Remove(relitivePath.Length - 6, 6);
|
|
string pythonToolPath = relitivePath + "Tools/tranexcel_new";
|
|
|
|
// 读取grid_type配置表
|
|
BFEditorUtils.RunCommond("python", "load_board.py " + tempPath + " " + boardGridTypePath, pythonToolPath);
|
|
string boardGridTypeJson = File.ReadAllText(tempPath);
|
|
JObject jsonObj = (JObject)JsonConvert.DeserializeObject(boardGridTypeJson);
|
|
foreach (var item in jsonObj)
|
|
{
|
|
int key = int.Parse(item.Key);
|
|
Dictionary<string, string> dict = new Dictionary<string, string>();
|
|
foreach (var item2 in (JObject)item.Value)
|
|
{
|
|
dict[item2.Key] = item2.Value.ToString();
|
|
}
|
|
boardGridTypeDict[key] = dict;
|
|
}
|
|
|
|
// 读取grid_edge_type配置表
|
|
BFEditorUtils.RunCommond("python", "load_board.py " + tempPath + " " + boardGridEdgePath, pythonToolPath);
|
|
string boardGridEdgeJson = File.ReadAllText(tempPath);
|
|
jsonObj = (JObject)JsonConvert.DeserializeObject(boardGridEdgeJson);
|
|
foreach (var item in jsonObj)
|
|
{
|
|
int key = int.Parse(item.Key);
|
|
Dictionary<string, string> dict = new Dictionary<string, string>();
|
|
foreach (var item2 in (JObject)item.Value)
|
|
{
|
|
dict[item2.Key] = item2.Value.ToString();
|
|
}
|
|
boardGridEdgeDict[key] = dict;
|
|
}
|
|
|
|
// 读取boardFile配置表
|
|
BFEditorUtils.RunCommond("python", "load_board.py " + tempPath + " " + boardFilepath, pythonToolPath);
|
|
string boardFileJson = File.ReadAllText(tempPath);
|
|
|
|
jsonObj = (JObject)JsonConvert.DeserializeObject(boardFileJson);
|
|
foreach (var item in jsonObj){
|
|
if (item.Value[boardFiledName] != null)
|
|
{
|
|
int key = int.Parse(item.Key);
|
|
boardDict[key] = copyBoard((JArray)item.Value[boardFiledName]);
|
|
outPutBoardDict[key] = copyBoard((JArray)item.Value[boardFiledName]);
|
|
}
|
|
if (item.Value[boardEdgeFiledName] != null)
|
|
{
|
|
int key = int.Parse(item.Key);
|
|
edgeDict[key] = copyBoard((JArray)item.Value[boardEdgeFiledName]);
|
|
outPutBoardEdgeDict[key] = copyBoard((JArray)item.Value[boardEdgeFiledName]);
|
|
}
|
|
}
|
|
|
|
loadExcelOver = true;
|
|
}
|
|
|
|
void SaveBoardExcel()
|
|
{
|
|
var desktopDir = System.Environment.GetFolderPath(System.Environment.SpecialFolder.DesktopDirectory);
|
|
var tempPath = System.IO.Path.Combine(desktopDir, "BoardEditorTemp.txt");
|
|
Dictionary<int, Dictionary<string, JArray>> output = new Dictionary<int, Dictionary<string, JArray>>();
|
|
foreach(int key in outPutBoardDict.Keys)
|
|
{
|
|
output[key] = new Dictionary<string, JArray>();
|
|
output[key][boardFiledName] = copyBoard(outPutBoardDict[key]);
|
|
}
|
|
string relitivePath = Application.dataPath;
|
|
relitivePath = relitivePath.Remove(relitivePath.Length - 6, 6);
|
|
string pythonToolPath = relitivePath + "Tools/tranexcel_new";
|
|
File.WriteAllText(tempPath, JsonConvert.SerializeObject(output));
|
|
BFEditorUtils.RunCommond("python", "save_board.py " + tempPath + " " + boardFilepath, pythonToolPath);
|
|
}
|
|
|
|
void DragBoard()
|
|
{
|
|
Texture img;
|
|
GUI.DrawTexture(new Rect(0, 200, 702, 702), boardImg);
|
|
if(!loadExcelOver)
|
|
{
|
|
return;
|
|
}
|
|
int startOffset = 22 * 7 / maxRow;
|
|
int textureWidth = 94 * 7 / maxRow;
|
|
if (!boardDict.ContainsKey(curIndex))
|
|
{
|
|
return;
|
|
}
|
|
|
|
GUILayout.BeginArea(new Rect(0, 200, 702, 702));
|
|
GUILayout.BeginVertical();
|
|
JArray jo = boardDict[curIndex];
|
|
int posIndex = 0;
|
|
for (int row = 1; row <= maxRow; row++) {
|
|
GUILayout.BeginHorizontal();
|
|
for (int col = 1; col <= 7; col++) {
|
|
if (jo.Count == posIndex)
|
|
{
|
|
jo.Add(getNewGridUnitInfo());
|
|
}
|
|
JArray gridInfo = (JArray)jo[posIndex];
|
|
if(gridInfo.Count < 2)
|
|
{
|
|
continue;
|
|
}
|
|
int gridType = (int)gridInfo[0];
|
|
int gridElementType = (int)gridInfo[1];
|
|
if(!boardGridTypeDict.ContainsKey(gridType))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// 绘制元素
|
|
if (elementTypeImgDict.ContainsKey(gridElementType))
|
|
{
|
|
img = imgDict[elementTypeImgDict[gridElementType]];
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth, startOffset + (row - 1) * textureWidth, textureWidth, textureWidth), img);
|
|
}
|
|
|
|
// 绘制类型
|
|
if(boardGridTypeDict[gridType].ContainsKey("icon"))
|
|
{
|
|
string icon = boardGridTypeDict[gridType]["icon"];
|
|
if (imgDict.ContainsKey(icon))
|
|
{
|
|
img = imgDict[icon];
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth, startOffset + (row - 1) * textureWidth, textureWidth, textureWidth), img);
|
|
}
|
|
}
|
|
|
|
posIndex++;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
GUILayout.EndVertical();
|
|
if (edgeDict.ContainsKey(curIndex))
|
|
{
|
|
JArray edgeJo = edgeDict[curIndex];
|
|
for (int i = 0; i < edgeJo.Count; i++)
|
|
{
|
|
JArray gridInfo = (JArray)edgeJo[i];
|
|
if(gridInfo.Count < 3)
|
|
{
|
|
continue;
|
|
}
|
|
int posId = (int)gridInfo[0];
|
|
int edgeType = (int)gridInfo[1];
|
|
int dir = (int)gridInfo[2];
|
|
// 绘制类型
|
|
if(boardGridEdgeDict[edgeType].ContainsKey("icon"))
|
|
{
|
|
string icon = boardGridEdgeDict[edgeType]["icon"];
|
|
if (imgDict.ContainsKey(icon))
|
|
{
|
|
int row = posId / 10;
|
|
int col = posId % 10;
|
|
img = imgDict[icon];
|
|
if (dir == 1)
|
|
{
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth, startOffset + (row - 1) * textureWidth - 16, 92, 32), img);
|
|
}
|
|
else if (dir == 2)
|
|
{
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth, startOffset + (row - 1) * textureWidth - 16 + textureWidth, 92, 32), img);
|
|
}
|
|
else if (dir == 3)
|
|
{
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth - 16, startOffset + (row - 1) * textureWidth - 16, 32, 92), img);
|
|
}
|
|
else if (dir == 4)
|
|
{
|
|
GUI.DrawTexture(new Rect(startOffset + (col - 1) * textureWidth - 16 + textureWidth, startOffset + (row - 1) * textureWidth - 16, 32, 92), img);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
GUILayout.EndArea();
|
|
|
|
GUILayout.BeginArea(new Rect(730, 200, 510 * 7, 550 / 7 * maxRow));
|
|
GUILayout.BeginVertical();
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.Label("棋盘配置信息", GUILayout.Width(100), GUILayout.Height(30));
|
|
GUILayout.EndHorizontal();
|
|
|
|
posIndex = 0;
|
|
for (int row = 1; row <= maxRow; row++) {
|
|
GUILayout.BeginHorizontal();
|
|
for (int col = 1; col <= 7; col++) {
|
|
JArray gridInfo = (JArray)jo[posIndex];
|
|
if(gridInfo.Count < 2)
|
|
{
|
|
continue;
|
|
}
|
|
gridInfo[0] = int.Parse(GUILayout.TextField(gridInfo[0].ToString(), GUILayout.Width(25)));
|
|
gridInfo[1] = int.Parse(GUILayout.TextField(gridInfo[1].ToString(), GUILayout.Width(25)));
|
|
GUILayout.Space(10);
|
|
posIndex++;
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
GUILayout.Space(10);
|
|
}
|
|
GUILayout.EndVertical();
|
|
GUILayout.EndArea();
|
|
}
|
|
|
|
bool CheckBoardChanged(int index)
|
|
{
|
|
if(boardDict.ContainsKey(index) && outPutBoardDict.ContainsKey(index))
|
|
{
|
|
if(outPutBoardDict[index].Count != boardDict[index].Count)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
for (int i = 0; i < boardDict[index].Count; i++)
|
|
{
|
|
JArray tArray = (JArray)boardDict[index][i];
|
|
JArray tArray2 = (JArray)outPutBoardDict[index][i];
|
|
if (tArray.Count != tArray2.Count)
|
|
{
|
|
return true;
|
|
}
|
|
for (int j = 0; j < tArray.Count; j++)
|
|
{
|
|
if (tArray[j].ToString() != tArray2[j].ToString())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SaveBoard(int index)
|
|
{
|
|
if(!boardDict.ContainsKey(index))
|
|
{
|
|
return;
|
|
}
|
|
outPutBoardDict[index] = copyBoard(boardDict[index]);
|
|
}
|
|
|
|
void AbortBoard(int index)
|
|
{
|
|
if(!outPutBoardDict.ContainsKey(index))
|
|
{
|
|
boardDict.Remove(index);
|
|
return;
|
|
}
|
|
boardDict[index] = copyBoard(outPutBoardDict[index]);
|
|
}
|
|
|
|
void showSwitchBoardSaveDialog(int targetIndex)
|
|
{
|
|
if (IsInNewBoard())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (targetIndex == curIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CheckBoardChanged(curIndex))
|
|
{
|
|
switch (EditorUtility.DisplayDialogComplex("提示", "当前棋盘已经改变，是否保存", "确定", "放弃", "再次确认"))
|
|
{
|
|
case 0:
|
|
SaveBoard(curIndex);
|
|
curIndex = targetIndex;
|
|
break;
|
|
case 1:
|
|
AbortBoard(curIndex);
|
|
curIndex = targetIndex;
|
|
break;
|
|
case 2:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
curIndex = targetIndex;
|
|
}
|
|
}
|
|
|
|
JArray copyBoard(JArray targetArray)
|
|
{
|
|
JArray resultArray = new JArray();
|
|
for (int i = 0; i < targetArray.Count; i++)
|
|
{
|
|
JArray unit = new JArray();
|
|
resultArray.Add(unit);
|
|
JArray temp = (JArray)targetArray[i];
|
|
for (int j = 0; j < temp.Count; j++)
|
|
{
|
|
unit.Add(int.Parse(temp[j].ToString()));
|
|
}
|
|
}
|
|
return resultArray;
|
|
}
|
|
|
|
bool IsInNewBoard()
|
|
{
|
|
if(!boardDict.ContainsKey(curIndex) && !outPutBoardDict.ContainsKey(curIndex))
|
|
{
|
|
return false;
|
|
}
|
|
return !outPutBoardDict.ContainsKey(curIndex);
|
|
}
|
|
|
|
JArray getNewGridUnitInfo()
|
|
{
|
|
return (JArray)JsonConvert.DeserializeObject("[0, 0]");
|
|
}
|
|
}
|
|
} |