public void SaveGrid()
{
if (pCurrentLevel == null)
{
Debug.LogError("You need an active level to save!");
return;
}
pCurrentLevel.pListGrid.Clear();
for (int j = 0; j < mGrid.GetLength(1); j++)
{
for (int i = 0; i < mGrid.GetLength(0); i++)
{
if (i % 2 != j % 2)
{
continue;
}
TileStruct ts = new TileStruct()
{
pPosition = mGrid[i, j].pPosition,
pBlockType = mGrid[i, j].pBlockType,
pVisibilty = mGrid[i, j].eVisibility
};
pCurrentLevel.pListGrid.Add(ts);
}
}
}
void Update()
{
if (Oldposition != transform.position)
{
TileData = map.GetTileData(TileData.X, TileData.Y);
Type = TileData.Type;
x = TileData.X;
y = TileData.Y;
if (!ReferenceEquals(oldTileData, TileData))
{
if (TileData.Type == TileType.Dirt)
{
sr.sprite = SpriteHandler.GetTexture(TileData, map);
gameObject.tag = "Tile";
}
else if (TileData.Type == TileType.Rock)
{
sr.sprite = SpriteHandler.GetTexture(TileData, map);
gameObject.tag = "Wall";
}
else if (TileData.Type == TileType.Wood)
{
sr.sprite = rock;
}
else
{
sr.sprite = dirt;
}
}
}
oldTileData = TileData;
Oldposition = transform.position;
}
////////////////////////////////////////////////////////////////////////
// コンストラクタ
////////////////////////////////////////////////////////////////////////
public TileBlock(Vector2 coord, TileType type)
{
tile = new TileStruct();
tile.coordinate = coord;
tile.tileType = type;
tile.attributes = AnalyzeAttributes.INull;
tile.isAnalyzed = false;
}
public static TileStruct CreateTileStruct(ref FileStruct.TSAreaTile tsAreaTile)
{
TileStruct ss = new TileStruct();
ss.fullName = Utils.CharsToString(tsAreaTile.tileName);
ss.priSqStart = tsAreaTile.priSqStart;
ss.priSqCount = tsAreaTile.priSqCount;
ss.secSqStart = tsAreaTile.secSqStart;
ss.secSqCount = tsAreaTile.secSqCount;
return(ss);
}
public static TileStruct findAvailableTile(TileMap map, int Xoffset, int Yoffset)
{
TileStruct tile = new TileStruct(0,0,TileType.None);
while (tile.Type != TileType.Dirt)
{
tile = map.GetTileData(rand.Next(0, map.map[0].Length - 1) + Xoffset, rand.Next(0, map.map.Length - 1) + Yoffset);
}
return tile;
}
//direction zero vertical corridor
private static TileStruct[][] addCorridor(TileStruct[][] arr1, TileStruct[][] arr2, int corridorMin, int corridorMax, int direction)
{
var corridorSize = rand.Next(corridorMin, corridorMax);
if (direction == 0)
{
// addRoom(TileMap.CropMap2(arr1, arr1[0].Length/2, arr1.Length/2 - corridorSize, arr1[0].Length, arr1.Length/2 + corridorSize), corridorMin, corridorMax, 0, TileType.Dirt, TileType.Dirt);
}
//arr1[connectingIndexes] make corridor
//arr2[connectingIndexes] make corridor
// merge(arr1 = arr2);
return null;
}
private Tile CreateNewTile(Vector2 position)
{
GameObject tileInstance = Instantiate(tilePrefab, position, Quaternion.identity, transform);
Tile tile = tileInstance.GetComponent <Tile>();
int x = (int)position.x;
int y = (int)position.y;
tileInstance.name = x + " | " + y;
TileStruct newTile = new TileStruct(tile, position);
tiles.Add(newTile);
return(tile);
}
public static TileStruct[][] horizontalMerge(TileStruct[][] arr1, TileStruct[][] arr2)
{
//Use lists?
TileStruct[][] result;
result = new TileStruct[arr1.Length + arr2.Length][];
int count = 0;
for (int i = 0; i < arr1.Length; i++)
{
result[count] = arr1[i];
count++;
}
for (int i = 0; i < arr2.Length; i++)
{
result[count] = arr2[i];
count++;
}
return result;
}
public static TileStruct[][] GenMap(TileStruct[][] arr, int roomMin, int roomMax, int corridorMin, int corridorMax, int roomMargin, bool first) {
//TODO crops return wrong result
//Checks if the size of the inputted array is big enough to hold a room
if (arr[0].Length >= roomMax + (roomMargin * 2) && arr[0].Length <= (roomMax + (roomMargin * 2))*RoomMaxEmptySpaceMod)
{
return addRoom(arr, roomMin, roomMax, roomMargin, TileType.Rock, TileType.Dirt);
}
else
{
//var leftLeaf = rand.Next(45,55);
//var rightLeaf = 100-leftLeaf;
if (first) //(rand.Next(1, 2) == 1)
{
var leftLeafMap = TileMap.CropMap(arr, 0, 0, arr.Length, arr.Length / 2);
var leftLeaf = GenMap(leftLeafMap, roomMin, roomMax, corridorMin, corridorMax, roomMargin, !first);
var rightLeafMap = TileMap.CropMap(arr, arr.Length / 2, arr.Length, arr.Length, arr.Length);
var rightLeaf = GenMap(rightLeafMap, roomMin, roomMax, corridorMin, corridorMax,roomMargin, !first);
var mergedLeaves = horizontalMerge(leftLeaf, rightLeaf);
var corridorSize = rand.Next(corridorMin,corridorMax);
return TileMap.CropMap2(mergedLeaves, arr[0].Length/2 - corridorSize - roomMargin, arr.Length/2 - corridorSize - roomMargin,
arr[0].Length/2+corridorSize+roomMargin, arr.Length/2 + corridorSize + roomMargin,
TileType.Dirt);
// GenMap(), GenMap)
//return addCorridor(GenMap(cropmapHorizontal(leftLeaf)), (GenMap(cropmapHorizontal(rightLeaf)),
}
else
{
var lowerLeafMap = TileMap.CropMap(arr, 0, 0, arr.Length, arr.Length / 2);
var lowerLeaf = GenMap(lowerLeafMap, roomMin, roomMax, corridorMin, corridorMax, roomMargin, !first);
var upperLeafMap = TileMap.CropMap(arr, arr.Length / 2, arr.Length, arr.Length, arr.Length);
var upperLeaf = GenMap(upperLeafMap, roomMin, roomMax, corridorMin, corridorMax, roomMargin, !first);
//return addCorridor(GenMap(cropmapVertical(leftLeaf)), (GenMap(cropmapVertical(rightLeaf)),
}
}
return null;
}
/// <summary>
/// Work around constructor DO NOT USE
/// </summary>
public virtual void Start () {
map = new TileStruct[Height][];
for (int i = 0; i < map.Length; i++)
{
map[i] = new TileStruct[Width];
}
for (int i = 0; i < 1000; i++)
{
GameObject coll = (GameObject)Instantiate(collider, new Vector3(0, 0, 0), Quaternion.identity);
coll.transform.parent = colliderContainer.transform;
colliders.Add(coll);
}
}
public void CreateNewTiles()
{
Color[] colors = new Color[4];
colors[0] = Color.red;
colors[1] = Color.blue;
colors[2] = Color.black;
colors[3] = Color.yellow;
Color currColor = Color.red;
int nextColorIndex = 0;
int colorCount = colors.Length;
int numbAssign = 1;
for (int i = 0; i < 104; i++)
{
if (i % 13 == 0)
{
nextColorIndex++;
if (nextColorIndex >= colorCount)
{
nextColorIndex = 0;
}
numbAssign = 1;
}
TileStruct T = new TileStruct();
T.color = colors[nextColorIndex];
T.number = numbAssign++;
T.isUsed = false;
tiles.Add(T);
}
if (CreateTileCR != null)
{
StopCoroutine(CreateTileCR);
}
CreateTileCR = StartCoroutine(CreateTiles());
}
public void SpawnStartExitPoint(TileStruct location, bool exit)
{
if (!exit)
{
int count = -1;
TileStruct x = GetTileData(location.X, location.Y);
int distance = 0 - location.X;
for (int i = distance; i <= 0; i++)
{
x = GetTileData(location.X+i, location.Y);
x.SetBoth(TerrainType.BlackCave);
x.Type = TileType.Dirt;
var downWalls = GetTileData(location.X + i, location.Y-1);
downWalls.SetBoth(TerrainType.BlackCave);
downWalls.Type = TileType.Rock;
var upWalls = GetTileData(location.X + i, location.Y+1);
upWalls.SetBoth(TerrainType.BlackCave);
upWalls.Type = TileType.Rock;
if (i == 0)
{
var Wall = GetTileData(location.X + i + 1, location.Y);
Wall.SetBoth(TerrainType.BlackCave);
Wall.Type = TileType.Dirt;
Wall = GetTileData(location.X + i +1, location.Y-1);
Wall.SetBoth(TerrainType.BlackCave);
Wall.Type = TileType.Dirt;
Wall = GetTileData(location.X + i + 1, location.Y + 1);
Wall.SetBoth(TerrainType.BlackCave);
Wall.Type = TileType.Dirt;
Wall = GetTileData(location.X + i + 2, location.Y);
Wall.SetBoth(TerrainType.BlackCave);
Wall.Type = TileType.Dirt;
}
}
}
}
public void Copy(TileStruct[][] original, TileStruct[][] newCopy)
{
for (int y = 0; y < original.Length; y++)
{
for (int x = 0; x < original[0].Length; x++)
{
var tile = newCopy[y][x];
original[y][x].Type = tile.Type;
original[y][x].DecorType = tile.DecorType;
original[y][x].SetBoth(tile.terrainType);
}
}
}
/// <summary>
/// Draws the map.
/// </summary>
/// <param name="map">The map.</param>
public void DrawMap(TileStruct[][] map)
{
var prefab = Resources.Load("Tile");
foreach (var item in map)
{
foreach (var item2 in item)
{
var tile = (GameObject)Instantiate(prefab, new Vector3(((float)item2.X*3.2f),((float)item2.Y*3.2f)), Quaternion.identity);
tile.transform.parent = gameObject.transform;
var script = (Tile)tile.GetComponent<Tile>();
script.TileData = item2;
}
}
}
public static void FloodFill(TileStruct[][] map, int x, int y, TileType targetType, TileType replacementType)
{
/*
1: stuff the start pixel into a queue, note its color. note it as added.
2: begin picking a pixel off the queue. If it's similar to the start pixel:
2: put all its neighbours into the queue
for each added pixel, note it's added. if already noted for a pixel, don't
add it anymore.
3: color it with the destination color.
3: nonempty => jump back to 2
4: empty => we are finished
*/
List<string> list = new List<string>();
Queue<TileStruct> q = new Queue<TileStruct>();
q.Enqueue(map[y][x]);
while (q.Count != 0)
{
var tile = q.Dequeue();
if (tile.Type == targetType)
{
tile.Type = replacementType;
var west = MapGen.GetTileData(map, tile.X - 1, tile.Y);
if (!list.Contains(west.X + "," + west.Y)) { q.Enqueue(west); list.Add(west.X + "," + west.Y); }
//west.Type = replacementType;
var east = MapGen.GetTileData(map, tile.X + 1, tile.Y);
if (!list.Contains(east.X + "," + east.Y)) { q.Enqueue(east); list.Add(east.X + "," + east.Y); }
//east.Type = replacementType;
var north = MapGen.GetTileData(map, tile.X, tile.Y + 1);
if (!list.Contains(north.X + "," + north.Y)) { q.Enqueue(north); list.Add(north.X + "," + north.Y); }
//north.Type = replacementType;
var south = MapGen.GetTileData(map, tile.X, tile.Y - 1);
if (!list.Contains(south.X + "," + south.Y)) { q.Enqueue(north); list.Add(south.X + "," + south.Y); }
//south.Type = replacementType;
}
}
}
public void PlaceRoadsign(TileStruct[][] map, TileStruct start, string hash)
{
Queue<TileStruct> stack = new Queue<TileStruct>();
foreach (var item in map)
{
foreach (var item2 in item)
{
item2.Visited = false;
}
}
stack.Enqueue(start);
int sentinel = 0;
while (stack.Count != 0 || sentinel > 400)
{
sentinel++;
var tile = stack.Dequeue();
tile.Debug = true;
var west = MapGen.GetTileData(map, tile.X - 1, tile.Y);
var east = MapGen.GetTileData(map, tile.X + 1, tile.Y);
var north = MapGen.GetTileData(map, tile.X, tile.Y + 1);
var south = MapGen.GetTileData(map, tile.X, tile.Y - 1);
if (tile.X >= WestMap.Width-1)
{
west = MapGen.GetTileData(map, (tile.X - WestMap.Width) - 1, (tile.Y - SouthMap.Height));
east = MapGen.GetTileData(map, (tile.X - WestMap.Width) + 1, (tile.Y - SouthMap.Height));
north = MapGen.GetTileData(map, (tile.X - WestMap.Width), (tile.Y - SouthMap.Height) + 1);
south = MapGen.GetTileData(map, (tile.X - WestMap.Width), (tile.Y - SouthMap.Height) - 1);
}
List<TileStruct> dirts = new List<TileStruct>();
if (west.Type == TileType.Dirt) dirts.Add(west);
if (east.Type == TileType.Dirt) dirts.Add(east);
if (north.Type == TileType.Dirt) dirts.Add(north);
if (south.Type == TileType.Dirt) dirts.Add(south);
if (dirts.Count >= 3)
{
foreach (var dirt in dirts)
{
if (tile.X != start.X && tile.Y != start.Y)
{
if(tile.X >= WestMap.Width-1)
{
var obj = (GameObject)Instantiate(Resources.Load("RoadSign"), new Vector3((tile.X) * 3.2f, (tile.Y) * 3.2f, -0.5f), Quaternion.identity);
obj.transform.GetChild(0).GetComponent<RoadSignBehaviour>().text = hash;
return;
}
else
{
var obj = (GameObject)Instantiate(Resources.Load("RoadSign"), new Vector3((tile.X + WestMap.Width) * 3.2f, (tile.Y + SouthMap.Height) * 3.2f, -0.5f), Quaternion.identity);
obj.transform.GetChild(0).GetComponent<RoadSignBehaviour>().text = hash;
return;
}
}
}
}
if (west.Visited == false && west.Type == TileType.Dirt) stack.Enqueue(west);
if (east.Visited == false && east.Type == TileType.Dirt) stack.Enqueue(east);
if (north.Visited == false && north.Type == TileType.Dirt) stack.Enqueue(north);
if (south.Visited == false && south.Type == TileType.Dirt) stack.Enqueue(south);
}
}
public void DrawCorridorHVertical(TileStruct[][] map, int y1, int y2, int x, TileType wallType, TileType floorType, TerrainType wallTerrainType, TerrainType floorTerrainType)
{
int length = Mathf.Abs(y1 - y2) + 1;
int distanceA = y1 - y2;
int distanceB = y1 - y2;
for (int i = 0; i < length; i++)
{
TileStruct pointA;
if (distanceA <= 0)
{
pointA = GetTileData(map, x, y1 + i);
}
else
{
pointA = GetTileData(map, x, y1 - i);
}
pointA.Type = floorType;
pointA.SetBoth(wallTerrainType);
}
}
/// <summary>
/// 버튼을 생성하는 메소드
/// </summary>
/// <param name="ctrlNewTile">버튼 데이터 구조체</param>
private void ButtonMaker(TileStruct ctrlNewTile = null)
{
#region 현재 + 버튼의 위치를 가져옴
Point curPlusPos = tileAdd.Location;
Size curPlusSize = tileAdd.Size;
#endregion
#region 새롭게 추가할 버튼
bool bIsNextLined = false;
bool bIsNew = false;
if (ctrlNewTile == null)
{
ctrlNewTile = new TileStruct(mTileList.Count, "새로운 연결")
{
Text = "새로운 연결",
MainThemeType = mSettingStruct.ThemeType,
MainStyleType = mSettingStruct.StyleType,
Name = (mTileList.Count + 1).ToString()
};
bIsNew = true;
}
else
{
ctrlNewTile.MainThemeType = mSettingStruct.ThemeType;
ctrlNewTile.MainStyleType = mSettingStruct.StyleType;
ctrlNewTile.Name = ctrlNewTile.TileNo.ToString();
}
ctrlNewTile.SaveSerialDataEvent += SaveSerialData;
ctrlNewTile.RefreshEvent += RefreshData;
Point ptNewPoint = new Point(curPlusPos.X, curPlusPos.Y);
if (mMainPanelRight < ptNewPoint.X + Const.DEFAULT_BUTTON_WIDTH)
{
ptNewPoint.X = Const.DEFAULT_MARGIN;
ptNewPoint.Y = curPlusPos.Y + Const.DEFAULT_BUTTON_HEIGHT + Const.DEFAULT_MARGIN;
bIsNextLined = true;
}
ctrlNewTile.Location = ptNewPoint;
ctrlNewTile.Size = Const.DEFAULT_BUTTON_SIZE;
//ctrlNewTile.TileNo = ++mCurNewTileNum;
if (bIsNew)
{
mTileList.Add(ctrlNewTile);
}
#endregion
#region 버튼 패널에 붙임
if (bIsNew)
{
// 버튼에 현재 테마 적용
ThemeChangeEvent(mSettingStruct.ThemeType);
StyleChangeEvent(mSettingStruct.StyleType);
panMain.Controls.Add(mTileList[mTileList.Count - 1] as TileStruct);
}
else
{
panMain.Controls.Add(mTileList[ctrlNewTile.TileNo] as TileStruct);
}
#endregion
#region +버튼 옮기기
curPlusPos.X = ptNewPoint.X + Const.DEFAULT_BUTTON_WIDTH + Const.DEFAULT_MARGIN;
if (bIsNextLined == false)
{
if (mMainPanelRight < curPlusPos.X + Const.DEFAULT_PLUS_BUTTON_WIDTH)
{
curPlusPos.X = Const.DEFAULT_MARGIN;
curPlusPos.Y = ptNewPoint.Y + Const.DEFAULT_BUTTON_HEIGHT + Const.DEFAULT_MARGIN;
}
}
else
{
curPlusPos.Y = ptNewPoint.Y;
}
tileAdd.Location = curPlusPos;
#endregion
}
public void MergeAllMaps()
{
var outArr = new TileStruct[NorthMap.Height+CenterMap.Height+SouthMap.Height][];
for (int i = 0; i < outArr.Length; i++)
{
outArr[i] = new TileStruct[WestMap.Width + CenterMap.Width + SouthMap.Height];
for (int i2 = 0; i2 < outArr[i].Length; i2++)
{
outArr[i][i2] = new TileStruct(i2, i, TileType.None);
}
}
for (int y = 0; y < WestMap.Height; y++)
{
for (int x = 0; x < WestMap.Width; x++)
{
var tile = WestMap.map[y][x];
tile.Y = tile.Y + SouthMap.Height;
outArr[y + SouthMap.Height][x] = tile;
}
}
for (int y = 0; y < EastMap.Height; y++)
{
for (int x = 0; x < EastMap.Width; x++)
{
var tile = EastMap.map[y][x];
tile.Y = tile.Y + SouthMap.Height;
tile.X = tile.X + WestMap.Width + CenterMap.Width;
outArr[y + SouthMap.Height][x+WestMap.Width+CenterMap.Width] = tile;
}
}
for (int y = 0; y < CenterMap.Height; y++)
{
for (int x = 0; x < CenterMap.Width; x++)
{
var tile = CenterMap.map[y][x];
tile.Y = tile.Y + SouthMap.Height;
tile.X = tile.X + WestMap.Width;
outArr[y + SouthMap.Height][x + WestMap.Width] = tile;
}
}
for (int y = 0; y < SouthMap.Height; y++)
{
for (int x = 0; x < SouthMap.Width; x++)
{
var tile = SouthMap.map[y][x];
tile.X = tile.X + WestMap.Width;
outArr[y][x + WestMap.Width] = tile;
}
}
for (int y = 0; y < NorthMap.Height; y++)
{
for (int x = 0; x < NorthMap.Width; x++)
{
var tile = NorthMap.map[y][x];
tile.X = tile.X + WestMap.Width;
tile.Y = tile.Y + SouthMap.Height + CenterMap.Height;
outArr[y + SouthMap.Height + CenterMap.Height][x + WestMap.Width] = tile;
}
}
map = outArr;
Height = map.Length;
Width = map[0].Length;
}
public static TileStruct[][] CropMap(TileStruct[][] map,int x1, int y1, int x2, int y2)
{
int height = Mathf.Abs(y1 - y2);
IEnumerable<TileStruct> arr = map.Skip(x1)
.Take(x2 - x1)
.SelectMany(a => a.Skip(y1).Take(y2 - y1));
var array = arr.Select((x, i) => new { Index = i, Value = x })
.GroupBy(x => x.Index / height)
.Select(x => x.Select(v => v.Value).ToList().ToArray())
.ToArray();
TileStruct[][] outArray = new TileStruct[array.Length][];
for (int i = 0; i < array.Length; i++)
{
outArray[i] = new TileStruct[array[i].Length];
for (int y = 0; y < array[i].Length; y++)
{
var input = array[i][y];
outArray[i][y] = new TileStruct(input.X, input.Y, input.Type);
}
}
return outArray;
}
/// <summary>
/// 계정을 불러오는 메소드
/// (각 배열의 짝수구간에는 ID, 홀수구간에는 PW가 들어있음)
/// </summary>
/// <param name="listSerial">불러온 계정을 저장할 리스트(ref)</param>
/// <returns>로드 결과</returns>
public static LoadResult LoadSerialData(ref ArrayList mTileList)
{
LoadResult eResult = LoadResult.NoData;
string strPath = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + Const.PATH_SERIAL_FOLDER + Path.DirectorySeparatorChar + XML_FILE;
if (mTileList.Count > 0)
{
mTileList.Clear();
}
try
{
string strNodes = string.Format(@"/{0}/{1}", XML_ROOT, XML_SUB);
string strParity = string.Empty;
string strStopBit = string.Empty;
string strFlowControl = string.Empty;
XmlDocument xDoc = new XmlDocument();
xDoc.Load(strPath);
XmlNodeList nodeList = xDoc.SelectNodes(strNodes);
foreach (XmlNode xmlNode in nodeList)
{
int nTileNo = int.Parse(xmlNode.SelectSingleNode(XML_SUB_TILE).InnerText);
TileStruct tileStruct = new TileStruct(nTileNo, xmlNode.Attributes[XML_SUB_TITLE].Value);
tileStruct.SerialData.SerialName = xmlNode.Attributes[XML_SUB_TITLE].Value;
tileStruct.SerialData.PortNum = int.Parse(xmlNode.SelectSingleNode(XML_SUB_COM).InnerText);
tileStruct.SerialData.BaudRate = int.Parse(xmlNode.SelectSingleNode(XML_SUB_BAUD).InnerText);
tileStruct.SerialData.DataBit = int.Parse(xmlNode.SelectSingleNode(XML_SUB_DATABIT).InnerText);
tileStruct.SerialData.ParityCode = (Parity)int.Parse(xmlNode.SelectSingleNode(XML_SUB_PARITY).InnerText);
tileStruct.SerialData.StopBitCode = (StopBits)int.Parse(xmlNode.SelectSingleNode(XML_SUB_STOPBIT).InnerText);
tileStruct.SerialData.FlowControl = (SerialStruct.FlowC) int.Parse(xmlNode.SelectSingleNode(XML_SUB_FLOW).InnerText);
tileStruct.SerialData.MacroEnable = int.Parse(xmlNode.SelectSingleNode(XML_SUB_MACROENABLE).InnerText) == 1;
tileStruct.SerialData.RunDelay = int.Parse(xmlNode.SelectSingleNode(XML_SUB_DELAY).InnerText);
tileStruct.TileColor = (Const.StyleType) int.Parse(xmlNode.SelectSingleNode(XML_SUB_TILECOLOR).InnerText);
tileStruct.SerialName = tileStruct.SerialData.SerialName;
tileStruct.Text = tileStruct.SerialData.SerialName;
tileStruct.SerialData.LogSave = int.Parse(xmlNode.SelectSingleNode(XML_SUB_LOG_SAVE).InnerText) == 1;
tileStruct.SerialData.LogSaveType = (Const.LogSaveType) int.Parse(xmlNode.SelectSingleNode(XML_SUB_LOG_SAVE_TYPE).InnerText);
tileStruct.SerialData.LogToken = (Const.LogToken) int.Parse(xmlNode.SelectSingleNode(XML_SUB_LOG_SAVE_TOKEN).InnerText);
tileStruct.SerialData.LogSavePath = xmlNode.SelectSingleNode(XML_SUB_LOG_SAVE_PATH).InnerText;
XmlNodeList nodeMacroList = xmlNode.SelectSingleNode(XML_SUB_SUB).ChildNodes;
foreach (XmlNode xmlMacro in nodeMacroList)
{
MacroStruct macroStruct = new MacroStruct();
macroStruct.MacroName = xmlMacro.SelectSingleNode(XML_SUB_SUB_MACRO_NAME).InnerText;
macroStruct.Macro = xmlMacro.SelectSingleNode(XML_SUB_SUB_MACRO).InnerText;
macroStruct.Enable = int.Parse(xmlMacro.SelectSingleNode(XML_SUB_SUB_MACRO_ENABLE).InnerText) == 1 ? true : false;
tileStruct.SerialData.MacroList.Add(macroStruct);
}
mTileList.Add(tileStruct);
}
if (mTileList.Count > 0)
{
eResult = LoadResult.Success;
}
else
{
eResult = LoadResult.NoData;
}
}
catch
{
eResult = LoadResult.Fail_FileLoad;
}
return(eResult);
}
/// <summary>
/// Modify the index of the map at specified coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
/// <param name="type">Tile type</param>
public void SetTileStruct(int x, int y, TileType type)
{
Array values = Enum.GetValues(typeof(TileType));
TileType randomBar = (TileType)values.GetValue(rand.Next(values.Length-1));
map[x][y] = new TileStruct(x, y, randomBar);
}
public void BreadthFirst(TileStruct[][] map, TileStruct start)
{
stack.Push(start);
while (stack.Count != 0)
{
var tile = stack.Pop();
tile.Visited = true;
var west = MapGen.GetTileData(map, tile.X - 1, tile.Y);
var east = MapGen.GetTileData(map, tile.X + 1, tile.Y);
var north = MapGen.GetTileData(map, tile.X, tile.Y + 1);
var south = MapGen.GetTileData(map, tile.X, tile.Y - 1);
if (west.Visited == false && west.Type == TileType.Dirt) stack.Push(west);
if (east.Visited == false && east.Type == TileType.Dirt) stack.Push(east);
if (north.Visited == false && north.Type == TileType.Dirt) stack.Push(north);
if (south.Visited == false && south.Type == TileType.Dirt) stack.Push(south);
}
for (int y = 0; y < map.Length; y++)
{
for (int x = 0; x < map[0].Length; x++)
{
var tile = map[y][x];
if (tile.Type == TileType.Dirt && tile.Visited == false)
{
tile.Type = TileType.Rock;
}
}
}
}
public TileStruct ClosestToBorderYReverse(TileStruct[][] map, TileType type)
{
int bestValue = 0;
TileStruct bestMatch = null;
for (int y = map.Length - 1; y >= 0; y--)
{
for (int x = map[0].Length - 1; x >= 0; x--)
{
if (map[y][x].Type == type && y > bestValue)
{
bestValue = map[y][x].Y;
bestMatch = map[y][x];
}
}
}
List<TileStruct> bestMatches = new List<TileStruct>();
for (int i = 0; i < map[0].Length; i++)
{
if (map[bestValue][i].Type == TileType.Dirt)
{
bestMatches.Add(map[bestValue][i]);
}
}
return bestMatches[rand.Next(0, bestMatches.Count - 1)];
}
//Merge arr1 with arr2, arr1 is at top arr2 is at bottom
public static TileStruct[][] verticalMerge(TileStruct[][] arr1, TileStruct[][] arr2)
{
var xOdd = arr2.Length % 2;
//var yOdd = arr[0].Length % 2;
TileStruct[][] result;
result = new TileStruct[arr1.Length][];
for (int i = 0; i < result.Length; i++)
{
result[i] = new TileStruct[arr1[0].Length + arr2[0].Length];
int count = 0;//TODO fix off by one
for (int y = 0; y < (result[i].Length / 2); y++)
{
result[i][y] = arr1[i][count];
result[i][y].Y = y;
result[i][y].X = i;
//var originalX = r
result[i][y + arr1[0].Length] = arr2[i][y];
var arr = result[i][y + arr1[0].Length];
result[i][y + arr1[0].Length].Y += arr1.Length/2;
//result[i][y + arr1[0].Length].X = result[i][y].X + arr1[0].Length;
count++;
}
if (arr1[0].Length-arr2[0].Length == 1)
{
result[i][count] = arr2[i][arr2[i].Length - 1];
}
else if (arr1[0].Length-arr2[0].Length == -1)
{
result[i][count + arr1[0].Length + 1] = arr1[i][arr1[i].Length - 1];
}
}
return result;
}
//private static TileStruct[][] tileListToArr(List<List<TileStruct>> list)
//{
// TileStruct[][] outArr = new TileStruct[list.Count][];
// for (int i = 0; i < list.Count; i++)
// {
// outArr[i] = list[i].ToArray();
// }
// return outArr;
//}
public static TileStruct[][] addRoom(TileStruct[][] arr, int roomMin, int roomMax, int roomMargin, TileType wall, TileType floor)
{
int roomSize = rand.Next(roomMin, roomMax);
for (int i = 0; i < arr.Length; i++)
{
for (int y = 0; y < arr[i].Length; y++)
{
//Checks if the loop is in the position to add a floor tile
if ((i < (arr.Length-1) - roomMargin && i > roomMargin) && y < (arr[i].Length-1) - roomMargin && y > roomMargin)
{
arr[i][y].Type = floor;
//add to a room object
}
//Checks if the loop is in the position to add a Wall tile
else if ((i <= (arr.Length-1) - roomMargin && i >= roomMargin) && y <= (arr[i].Length-1) - roomMargin && y >= roomMargin)
{
arr[i][y].Type = wall;
//add to a room object
}
}
}
return arr;
}
private TileStruct findAvailableTile(bool EastOrNorth)
{
TileStruct tile = new TileStruct(0, 0, TileType.None);
while (tile.Type != TileType.Dirt)
{
if (!EastOrNorth)
{
tile = GetTileData(rand.Next(0, (map[0].Length - 1) - 20), rand.Next(0, (map.Length - 1) - 20));
}
else
{
tile = GetTileData(rand.Next(20, (map[0].Length - 1)), rand.Next(20, (map.Length - 1)));
}
}
return tile;
}
public TileStruct Clone()
{
var outTile = new TileStruct(X,Y,Type);
outTile.FloorTerrainType = FloorTerrainType;
outTile.WallTerrainType = FloorTerrainType;
return outTile;
}
/// <summary>
/// 계정 정보를 저장하는 메소드
/// (각 배열의 짝수구간에는 ID, 홀수구간에는 PW가 들어있음)
/// </summary>
/// <param name="listSerial"></param>
/// <returns></returns>
public static bool SaveSerialData(ArrayList mTileList)
{
bool bResult = false;
string strPath = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + Const.PATH_SERIAL_FOLDER + Path.DirectorySeparatorChar + XML_FILE;
try
{
XmlDocument xDoc = new XmlDocument();
// 루트 노드
XmlNode rootNode = xDoc.CreateElement(XML_ROOT); // Serials
xDoc.AppendChild(rootNode);
int nSize = mTileList.Count;
TileStruct tileStruct = null;
// 하위 노드
for (int i = 0; i < nSize; i++)
{
tileStruct = mTileList[i] as TileStruct;
if (tileStruct != null)
{
XmlNode xmlSubNode = xDoc.CreateElement(XML_SUB); // Serial
XmlAttribute xmlAttribute = xDoc.CreateAttribute(XML_SUB_TITLE); // Name
xmlAttribute.Value = tileStruct.SerialData.SerialName;
xmlSubNode.Attributes.Append(xmlAttribute);
XmlNode nodeTile = xDoc.CreateElement(XML_SUB_TILE); // TileNo
nodeTile.InnerText = tileStruct.TileNo.ToString();
xmlSubNode.AppendChild(nodeTile);
XmlNode nodePort = xDoc.CreateElement(XML_SUB_COM); // COM
nodePort.InnerText = tileStruct.SerialData.PortNum.ToString();
xmlSubNode.AppendChild(nodePort);
XmlNode nodeBaud = xDoc.CreateElement(XML_SUB_BAUD); // Baudrate
nodeBaud.InnerText = tileStruct.SerialData.BaudRate.ToString();
xmlSubNode.AppendChild(nodeBaud);
XmlNode nodeDataBit = xDoc.CreateElement(XML_SUB_DATABIT); // DataBit
nodeDataBit.InnerText = tileStruct.SerialData.DataBit.ToString();
xmlSubNode.AppendChild(nodeDataBit);
XmlNode nodeParity = xDoc.CreateElement(XML_SUB_PARITY); // Parity
nodeParity.InnerText = string.Format("{0}", (int)tileStruct.SerialData.ParityCode);
xmlSubNode.AppendChild(nodeParity);
XmlNode nodeStopBit = xDoc.CreateElement(XML_SUB_STOPBIT); // StopBit
nodeStopBit.InnerText = string.Format("{0}", (int)tileStruct.SerialData.StopBitCode);
xmlSubNode.AppendChild(nodeStopBit);
XmlNode nodeFlow = xDoc.CreateElement(XML_SUB_FLOW); // FlowControl
nodeFlow.InnerText = string.Format("{0}", (int)tileStruct.SerialData.FlowControl);
xmlSubNode.AppendChild(nodeFlow);
XmlNode nodeMacroEnable = xDoc.CreateElement(XML_SUB_MACROENABLE); // MacroEnable
nodeMacroEnable.InnerText = string.Format("{0}", tileStruct.SerialData.MacroEnable ? 1 : 0);
xmlSubNode.AppendChild(nodeMacroEnable);
XmlNode nodeDelay = xDoc.CreateElement(XML_SUB_DELAY); // Delay
nodeDelay.InnerText = string.Format("{0}", tileStruct.SerialData.RunDelay);
xmlSubNode.AppendChild(nodeDelay);
XmlNode nodeTileColor = xDoc.CreateElement(XML_SUB_TILECOLOR); // Tile Color
nodeTileColor.InnerText = string.Format("{0}", (int)tileStruct.TileColor);
xmlSubNode.AppendChild(nodeTileColor);
XmlNode nodeLogSave = xDoc.CreateElement(XML_SUB_LOG_SAVE); // Log Save
nodeLogSave.InnerText = string.Format("{0}", tileStruct.SerialData.LogSave ? 1 : 0);
xmlSubNode.AppendChild(nodeLogSave);
XmlNode nodeLogSaveType = xDoc.CreateElement(XML_SUB_LOG_SAVE_TYPE);// Log Save Type
nodeLogSaveType.InnerText = string.Format("{0}", (int)tileStruct.SerialData.LogSaveType);
xmlSubNode.AppendChild(nodeLogSaveType);
XmlNode nodeLogToken = xDoc.CreateElement(XML_SUB_LOG_SAVE_TOKEN); // Log Save Token
nodeLogToken.InnerText = string.Format("{0}", (int)tileStruct.SerialData.LogToken);
xmlSubNode.AppendChild(nodeLogToken);
XmlNode nodeLogSavePath = xDoc.CreateElement(XML_SUB_LOG_SAVE_PATH);// Log Save Path
nodeLogSavePath.InnerText = string.Format("{0}", tileStruct.SerialData.LogSavePath);
xmlSubNode.AppendChild(nodeLogSavePath);
XmlNode nodeMacroList = xDoc.CreateElement(XML_SUB_SUB); // MacroList
int nCount = 0;
string strNodeNo = string.Empty;
foreach (MacroStruct macro in tileStruct.SerialData.MacroList)
{
strNodeNo = string.Format("{0}{1}", XML_SUB_SUB_MACRO_NO, nCount++);
XmlNode nodeNo = xDoc.CreateElement(strNodeNo);
XmlNode nodeName = xDoc.CreateElement(XML_SUB_SUB_MACRO_NAME);
nodeName.InnerText = macro.MacroName;
nodeNo.AppendChild(nodeName);
XmlNode nodeMacro = xDoc.CreateElement(XML_SUB_SUB_MACRO);
nodeMacro.InnerText = macro.Macro;
nodeNo.AppendChild(nodeMacro);
XmlNode nodeEnable = xDoc.CreateElement(XML_SUB_SUB_MACRO_ENABLE);
nodeEnable.InnerText = string.Format("{0}", macro.Enable ? 1 : 0);
nodeNo.AppendChild(nodeEnable);
nodeMacroList.AppendChild(nodeNo);
}
xmlSubNode.AppendChild(nodeMacroList);
rootNode.AppendChild(xmlSubNode);
}
}
xDoc.Save(strPath);
bResult = true;
}
catch
{
bResult = false;
}
return(bResult);
}
public TileStruct ClosestToBorderXReverse(TileStruct[][] map, TileType type)
{
int bestValue = 0;
//List<TileStruct> bestMatches = new List<TileStruct>();
TileStruct bestMatch = null;
for (int y = map.Length - 1; y >= 0; y--)
{
for (int x = map[0].Length - 1; x >= 0; x--)
{
if (map[y][x].Type == type && x > bestValue)
{
bestValue = map[y][x].X;
bestMatch = map[y][x];
//if (bestMatches.Count == 0 || bestValue < bestMatches[bestMatches.Count - 1].X)
//{
// bestMatches = new List<TileStruct>();
// bestMatches.Add(bestMatch);
//}
//else if (bestValue == bestMatches[bestMatches.Count - 1].X)
//{
// bestMatches.Add(bestMatch);
//}
}
}
}
List<TileStruct> bestMatches = new List<TileStruct>();
for (int i = 0; i < map.Length; i++)
{
if (map[i][bestValue].Type == TileType.Dirt)
{
bestMatches.Add(map[i][bestValue]);
}
}
return bestMatches[rand.Next(0, bestMatches.Count-1)];
}
public static Sprite GetTexture(TileStruct tile, TileMap map)
{
var left = map.GetTileData(tile.X - 1, tile.Y);
var right = map.GetTileData(tile.X + 1, tile.Y);
var north = map.GetTileData(tile.X, tile.Y + 1);
var south = map.GetTileData(tile.X, tile.Y - 1);
var upLeft = map.GetTileData(tile.X - 1, tile.Y + 1);
var upRight = map.GetTileData(tile.X + 1, tile.Y + 1);
var downLeft = map.GetTileData(tile.X - 1, tile.Y - 1);
var downRight = map.GetTileData(tile.X + 1, tile.Y - 1);
if (left.Type == TileType.Rock || right.Type == TileType.Rock || north.Type == TileType.Rock || south.Type == TileType.Rock || upLeft.Type == TileType.Rock || upRight.Type == TileType.Rock || downLeft.Type == TileType.Rock || downRight.Type == TileType.Rock)
{
tile.DecorType = DecorType.None;
}
if (tile.Type == TileType.Rock)
{
return getSpriteWithName(tile.WallTerrainType + getNumber(
tile.WallTerrainType,
left.GetTerrainType(),
right.GetTerrainType(),
north.GetTerrainType(),
south.GetTerrainType(),
upLeft.GetTerrainType(),
upRight.GetTerrainType(),
downLeft.GetTerrainType(),
downRight.GetTerrainType()
),
tile.Type);
}
string decor = Enum.GetName(typeof(DecorType), tile.DecorType);
if (tile.Type == TileType.Dirt)
{
if (tile.DecorType == DecorType.None)
{
return getSpriteWithName(tile.GetTerrainType() + getNumberFloors(
tile.GetTerrainType(),
left.GetTerrainType(),
right.GetTerrainType(),
north.GetTerrainType(),
south.GetTerrainType(),
upLeft.GetTerrainType(),
upRight.GetTerrainType(),
downLeft.GetTerrainType(),
downRight.GetTerrainType()),
tile.Type);
}
else
{
return getSpriteWithName(tile.GetTerrainType() + decor + getNumberFloors(
tile.GetTerrainType() + tile.GetDecorType(),
left.GetTerrainType() + left.GetDecorType(),
right.GetTerrainType() + right.GetDecorType(),
north.GetTerrainType() + north.GetDecorType(),
south.GetTerrainType() + south.GetDecorType(),
upLeft.GetTerrainType() + upLeft.GetDecorType(),
upRight.GetTerrainType() + upRight.GetDecorType(),
downLeft.GetTerrainType() + downLeft.GetDecorType(),
downRight.GetTerrainType() + downRight.GetDecorType()
),
tile.Type);
}
}
return null;
}
public TileStruct ClosestToBorderX(TileStruct[][] map, TileType type)
{
int bestValue = map[0].Length;
TileStruct bestMatch = null;
for (int y = 0; y < map.Length; y++)
{
for (int x = 0; x < map[0].Length; x++)
{
if (map[y][x].Type == type && x < bestValue)
{
bestValue = x;
bestMatch = map[y][x];
}
if (map[y][x].Type == type && x < bestValue)
{
bestValue = x;
bestMatch = map[y][x];
}
}
}
List<TileStruct> bestMatches = new List<TileStruct>();
for (int i = 0; i < map.Length; i++)
{
if (map[i][bestValue].Type == TileType.Dirt)
{
bestMatches.Add(map[i][bestValue]);
}
}
return bestMatches[rand.Next(0, bestMatches.Count - 1)];
}
private TileStruct[][] clone(TileStruct[][] map)
{
var newMap = new TileStruct[map.Length][];
for (int y = 0; y < map.Length; y++)
{
newMap[y] = new TileStruct[map[0].Length];
for (int x = 0; x < map[0].Length; x++)
{
var currentTile = map[y][x];
newMap[y][x] = new TileStruct(currentTile.X, currentTile.Y, currentTile.Type, currentTile.terrainType, currentTile.DecorType);
}
}
return newMap;
}
/// <summary>
/// Gets the tile data at specified map coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
/// <returns>TileStruct.</returns>
public TileStruct GetTileData(int x, int y)
{
var outType = new TileStruct(x, y, TileType.None);
if (x < 0 || x >= map[0].Length)
{
outType.Type = TileType.None;
}
else if (y < 0 || y >= map.Length)
{
outType.Type = TileType.None;
}
else
{
return map[y][x];
}
return outType;
}
public void CopyWithStartPoints(TileMap target, TileStruct[][] template, int startX, int startY, int endX, int endY)
{
Copy(target.map, template);
target.StartPointX = startX;
target.StartPointY = startY;
target.EndPointX = endX;
target.EndPointY = endY;
}
public TileStruct GetTileData2(int x, int y)
{
var outType = new TileStruct(x, y, TileType.None);
if (x < 0 || x >= map[0].Length)
{
outType.Type = TileType.None;
}
else if (y < 0 || y >= map.Length)
{
outType.Type = TileType.None;
}
else
{
var oldTile = map[y][x];
oldTile.X = x;
oldTile.Y = y;
return oldTile;
}
return outType;
}
//no cloning
public static TileStruct[][] CropMap2(TileStruct[][] map, int x1, int y1, int x2, int y2, TileType corridor)
{
int height = Mathf.Abs(y1 - y2);
IEnumerable<TileStruct> arr = map.Skip(x1)
.Take(x2 - x1)
.SelectMany(a => a.Skip(y1).Take(y2 - y1));
var array = arr.Select((x, i) => new { Index = i, Value = x })
.GroupBy(x => x.Index / height)
.Select(x => x.Select(v => v.Value).ToList().ToArray())
.ToArray();
foreach (var item in array)
{
foreach (var item2 in item)
{
item2.Type = corridor;
}
}
return array;
}
public void DrawCorridorHorizontal(TileStruct[][] map, int x1, int x2, int y, TileType wallType, TileType floorType, TerrainType wallTerrainType, TerrainType floorTerrainType)
{
int length = Mathf.Abs(x1 - x2) + 1;
int distanceA = x1 - x2;
int distanceB = x1 - x2;
for (int i = 0; i < length; i++)
{
TileStruct pointA;
if (distanceA <= 0)
{
pointA = GetTileData(map, x1 + i, y);
}
else
{
pointA = GetTileData(map, x1 - i, y);
}
pointA.Type = floorType;
pointA.SetBoth(wallTerrainType);
}
}
