public void Fill(GameBoardTile tileType)
{
for (int i = 0; i < tiles.Count; i++)
{
tiles[i] = tileType;
}
}
public void FillRow(int y, GameBoardTile tileType)
{
for (int x = 0; x < SizeX; x++)
{
SetTileValue(x, y, tileType);
}
}
public void ResizeTilesArray(int oldX, int oldY)
{
if (tiles != null && oldX == SizeX && oldY == SizeY)
{
return;
}
List <GameBoardTile> oldTiles = tiles;
tiles = new List <GameBoardTile>();
for (int x = 0; x < SizeX; x++)
{
for (int y = 0; y < SizeY; y++)
{
GameBoardTile tileValue = GameBoardTile.EMPTY;
if (oldTiles != null && x < oldX && y < oldY)
{
tileValue = GetTileValue(oldTiles, x, y, oldX, oldY);
}
tiles.Add(tileValue);
}
}
GenerateBoard();
}
internal void QueryTileFocus(GameBoardTile tile)
{
if (m_CurrentlySelectedTiles.Contains(tile) &&
m_SelectionType == SelectionType.Movement)
{
if (m_CurrentFocusTile != null)
{
m_CurrentFocusTile.RemoveFocus();
}
m_CurrentFocusTile = tile;
m_CurrentFocusTile.FocusTile();
}
else if (m_CurrentlySelectedTiles.Contains(tile) &&
m_SelectionType == SelectionType.Target)
{
if (GamePieceHandler.CurrentFocusPiece != null)
{
GamePieceHandler.CurrentFocusPiece.HandleAttackSelection(tile);
}
}
else
if (!m_CurrentlySelectedTiles.Contains(tile))
{
ClearCurrentSelections();
}
}
internal GameBoardTile[] GetRowFromHorizontalSelection(GameBoardTile relative, GameBoardTile targetTile, int range)
{
GameBoardTile[] tiles = m_CurrentlySelectedTiles.ToArray();
//North Row
if (targetTile.BoardVector.x >= relative.BoardVector.x && targetTile.BoardVector.y > relative.BoardVector.y)
{
tiles = tiles.Where
(t => t.BoardVector.x >= relative.BoardVector.x && t.BoardVector.y > relative.BoardVector.y).ToArray();
}
//West Row
else if (targetTile.BoardVector.x < relative.BoardVector.x && targetTile.BoardVector.y <= relative.BoardVector.y)
{
tiles = tiles.Where
(t => t.BoardVector.x < relative.BoardVector.x && t.BoardVector.y <= relative.BoardVector.y).ToArray();
}
//South Row
else if (targetTile.BoardVector.x >= relative.BoardVector.x && targetTile.BoardVector.y < relative.BoardVector.y)
{
tiles = tiles.Where
(t => t.BoardVector.x >= relative.BoardVector.x && t.BoardVector.y < relative.BoardVector.y).ToArray();
}
//East Row
else if (targetTile.BoardVector.x > relative.BoardVector.x && targetTile.BoardVector.y >= relative.BoardVector.y)
{
tiles = tiles.Where
(t => t.BoardVector.x > relative.BoardVector.x && t.BoardVector.y >= relative.BoardVector.y).ToArray();
}
return(tiles);
}
internal void HandleAttackSelection(GameBoardTile tile)
{
switch (m_AttackState.TargetType)
{
case TargetType.Single:
{
SelectAttackTargetTiles_SingleTarget(tile);
break;
}
case TargetType.Area:
{
SelectAttackTargetTiles_AreaTarget(tile);
break;
}
case TargetType.Linear:
{
SelectAttackTargetTiles_LinearTarget(tile);
break;
}
default:
{
Debug.LogWarning("Game Piece Attempting To Attack Without Attack Type.");
break;
}
}
}
internal static GameBoardTile[] DeterminePath
(GameBoardInstance gameBoard, Vector2 origin, GameBoardTile endTile)
{
m_Tiles.Clear();
GameBoardTile currentTile = gameBoard.GetTileByVector(origin);
int i = 0;
while (currentTile.BoardVector != endTile.BoardVector && i < 32)
{
i++;
currentTile = GetNextTileInPath
(gameBoard, currentTile, endTile.BoardVector);
if (currentTile == null)
{
Debug.LogWarning("Pathing Error: Next Tile In Path Returned Null!");
return(null);
}
if (!m_Tiles.Contains(currentTile))
{
m_Tiles.Add(currentTile);
}
}
m_Tiles.Add(endTile); return(m_Tiles.ToArray());
}
public GameLogic()
{
HostShipsLeft = new Ships.ShipsLeft(Settings.Default.Carriers, Settings.Default.Battleships, Settings.Default.Cruisers, Settings.Default.Destroyers, Settings.Default.Submarines);
PostTurnDelay = Settings.Default.PostTurnDelay;
ClientShipsLeft = HostShipsLeft;
//Generate the game boards
int x = 61;
int rowx = 0;
int rowy = 0;
int y = 0;
for (int i = 0; i <= 80; i++)
{
HostGameBoard[rowx, rowy] = new GameBoardTile(new Rectangle(x, y, 61, 61), TileType.Water);
ClientGameBoard[rowx, rowy] = new GameBoardTile(new Rectangle(x, y, 61, 61), TileType.Water);
x += 61;
if (rowx == 8)
{
y += 61;
x = 61;
rowx = 0;
rowy++;
}
else
{
rowx++;
}
}
}
public void Fill(GameBoardTile tileType)
{
for (int i = 0; i < tiles.Count; i++)
{
tiles[i] = tileType;
}
}
public void FillColumn(int x, GameBoardTile tileType)
{
for (int y = 0; y < SizeY; y++)
{
SetTileValue(x, y, tileType);
}
}
internal void SelectHorizontalTiles(GameBoardTile tile, int length, SelectionType selectionType, bool queryPassable)
{
ClearCurrentSelections();
m_SelectionType = selectionType;
SelectTiles(GetHorizontalTiles(tile, length, queryPassable), selectionType);
}
internal void SelectTile(GameBoardTile tile, SelectionType selectionType)
{
if (!m_CurrentlySelectedTiles.Contains(tile))
{
tile.Select(selectionType);
m_CurrentlySelectedTiles.Add(tile);
}
}
internal void DeselectTile(GameBoardTile tile)
{
if (m_CurrentlySelectedTiles.Contains(tile))
{
tile.Deselect();
m_CurrentlySelectedTiles.Remove(tile);
}
}
public void OnDrag()
{
GameBoardTile closest = board.FindClosestTileTo(tile.transform.position);
if (prevClosest != null && prevClosest != closest)
{
MeshRenderer[] renderers = prevClosest.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
try
{
Material material = renderer.material;
material.SetInt("_Marked", 0);
}
catch (Exception) { continue; }
}
}
prevClosest = closest;
Vector3 v = closest.transform.position - tile.transform.position;
v.y = 0.0f;
if (v.magnitude < 2.0f)
{
MeshRenderer[] renderers = closest.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
try
{
Material material = renderer.material;
if (board.IsTileBlocked(closest.x, closest.y))
{
material.SetColor("_MarkedCol", new Color(1, 0, 0));
material.SetInt("_Marked", 1);
}
else
{
material.SetColor("_MarkedCol", new Color(0, 1, 0));
material.SetInt("_Marked", 1);
}
}
catch (Exception) { continue; }
}
}
else
{
MeshRenderer[] renderers = closest.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer renderer in renderers)
{
try
{
Material material = renderer.material;
material.SetInt("_Marked", 0);
}
catch (Exception) { continue; }
}
}
}
internal void SelectRowFromHorizontalSelection(Vector2 relativeVector, GameBoardTile tile, int range, SelectionType selectionType)
{
GameBoardTile relative = GetTileByVector(relativeVector);
if (relative != null)
{
SelectRowFromHorizontalSelection(relative, tile, range, selectionType);
}
}
internal void SelectHorizontalTiles(Vector2 vector, int length, SelectionType selectionType, bool queryPassable)
{
GameBoardTile tile = GetTileByVector(vector);
if (tile != null)
{
SelectHorizontalTiles(tile, length, selectionType, queryPassable);
}
}
public void PleaseDontForgetToInitMe(int boardX, int boardY, Recipes.eIngredients ingredientType)
{
this.boardX = boardX;
this.boardY = boardY;
this.ingredientType = ingredientType;
wait = false;
tile = Game.BOARD.GetTile(boardX, boardY);
}
// Start is called before the first frame update
void Start()
{
tile = GetComponent <GameBoardTile>();
try
{
sounds = GameObject.Find("Audio").GetComponents <AudioSource>();
}
catch (Exception) { }
}
public GameBoardTileBehavior(GameBoard board, GameBoardTile tile)
{
this.board = board;
this.tile = tile;
try
{
this.sounds = GameObject.Find("Audio").GetComponents <AudioSource>();
}
catch (Exception) { }
}
internal void SelectRowFromHorizontalSelection(GameBoardTile relative, GameBoardTile tile, int range, SelectionType selectionType)
{
var tiles = GetRowFromHorizontalSelection(relative, tile, range);
ClearCurrentSelections();
m_SelectionType = selectionType;
SelectTile(tile, selectionType);
SelectTiles(tiles, selectionType);
}
public void AddTile(GameBoardTile tile, uint x, uint y)
{
if (blockedTiles.Get(x, y))
{
return;
}
//tile.GetComponent<Collider>().enabled = false;
tileMatrix.Set(x, y, tile);
tile.x = x;
tile.y = y;
}
internal GameBoardTile[] GetHorizontalTiles(GameBoardTile tile, int length, bool queryPassable)
{
List <GameBoardTile> horizontalTiles = new List <GameBoardTile>();
for (int i = 1; i <= length; i++)
{
PopulateHorizontalTiles(horizontalTiles, tile, i, queryPassable);
}
return(horizontalTiles.ToArray());
}
internal void HandleDoubleClick()
{
if (m_ParentBoard.SelectionType == SelectionType.Attack)
{
GameBoardTile tile = m_ParentBoard.GetTileByVector(BoardVector);
if (m_ParentBoard.CurrentlySelectedTiles.Contains(tile))
{
EventSink.InvokeUnitAttackEvent
(new UnitAttackEventArgs(tile));
}
}
}
public void Fill(GameBoardTile prefab)
{
for (uint i = 0; i < x; i++)
{
for (uint j = 0; j < y; j++)
{
GameBoardTile tile = Instantiate(prefab);
tile.name = "Tile" + i + "_" + j;
AddTile(tile, i, j);
}
}
}
public void Build()
{
for (uint i = 0; i < x; i++)
{
for (uint j = 0; j < y; j++)
{
GameBoardTile tile = tileMatrix.Get(i, j);
tile.transform.parent = tileRoot;
tile.transform.localPosition = new Vector3(botleftPos.x + i * tileDim.x, 0, botleftPos.y + j * tileDim.y);
tile.InitMovementPattern();
}
}
}
void TurnToFaceTarget(GameBoardTile targetTile)
{
m_DeltaRotation = Quaternion.LookRotation
(targetTile.transform.position - transform.position);
m_DeltaRotation.z = 0;
transform.rotation = Quaternion.Euler
(Utility.GetRotationToNearestRightAngle(m_DeltaRotation.eulerAngles));
GamePieceHandler.RelayPieceSyncToClientManager
(ControllingPlayerId, ControllingPlayerPosition, this);
}
private void HandleNetworkGamePieceMoveEvent(NetworkGamePieceMoveEventArgs args)
{
if (m_ActiveGamePieces.ContainsKey(args.PieceNetworkId))
{
GamePiece piece = m_ActiveGamePieces[args.PieceNetworkId];
GameBoardTile destinationTile = m_GameBoardRelative
.GetTileByVector(new Vector2(args.DestinationX, args.DestinationY));
piece.InitializePathTravel
(PathHandler.DeterminePath(m_GameBoardRelative, piece.BoardVector, destinationTile));
}
}
public void SpawnRollableOnTile(GameBoardTile tile)
{
GameObject obj = Instantiate(rollablePrefab, transform.Find("AllDice").transform);
obj.transform.position = tile.transform.position;
Rollable rollableComponent = obj.GetComponent <Rollable>();
rollableComponent.RandomiseRotation();
rollableComponent.BeginRiseing();
dice.Add(rollableComponent);
}
public bool Contains(GameBoardTile tile)
{
for (uint i = 0; i < x; i++)
{
for (uint j = 0; j < y; j++)
{
if (tileMatrix.Get(i, j) == tile)
{
return(true);
}
}
}
return(false);
}
public Vector2 GetTilePos(GameBoardTile tile)
{
for (uint i = 0; i < x; i++)
{
for (uint j = 0; j < y; j++)
{
if (tileMatrix.Get(i, j) == tile)
{
return(new Vector2(i, j));
}
}
}
return(new Vector2(-1, -1));
}
internal void SelectTilesInRange(GameBoardTile tile, int range, SelectionType selectionType, bool queryPassable, bool selectOrigin = true)
{
ClearCurrentSelections();
m_SelectionType = selectionType;
if (selectOrigin)
{
SelectTile(tile, selectionType);
}
SelectTiles
(GetTilesInRange(tile, range, queryPassable), selectionType);
}
void OnGUI()
{
GameBoard selectedObjectBoard = null;
if (Selection.activeGameObject != null)
{
selectedObjectBoard = Selection.activeGameObject.GetComponent<GameBoard>();
}
EditorGUILayout.BeginHorizontal(); //BEGIN Whole Window
//Sidebar
EditorGUILayout.BeginVertical(GUILayout.Width(200)); // BEGIN Sidebar
EditorGUILayout.BeginHorizontal(); // BEGIN Board Size
currentData.SizeX = EditorGUILayout.IntField("Size X", currentData.SizeX);
currentData.SizeY = EditorGUILayout.IntField("Size Y", currentData.SizeY);
EditorGUILayout.EndHorizontal(); // END Board Size
EditorGUILayout.Space();
if (GUILayout.Button("Fill"))
{
currentData.Fill(selectedTile);
}
if (GUILayout.Button("Clear"))
{
currentData.Clear();
}
bool guiEnabled = GUI.enabled;
GUI.enabled = selectedObjectBoard != null;
if (GUILayout.Button("Save to Object"))
{
selectedObjectBoard.Load(currentData);
}
if (GUILayout.Button("Load From Object"))
{
currentData.Load(selectedObjectBoard);
}
GUI.enabled = guiEnabled;
GUILayout.Space(30f);
fileName = EditorGUILayout.TextField("File:", fileName);
if (GUILayout.Button("Save to File"))
{
FileHelper.writeObjectFile(filePrefix + fileName, currentData, FileHelper.SerializeXML);
}
GUI.enabled = FileHelper.fileExists(filePrefix + fileName);
if (GUILayout.Button("Load from File"))
{
currentData = FileHelper.readObjectFile<GameBoardData>(filePrefix + fileName, FileHelper.DeserializeXML<GameBoardData>);
}
GUI.enabled = guiEnabled;
EditorGUILayout.EndVertical(); // END Sidebar
//Board Editor
EditorGUILayout.BeginVertical(); // BEGIN Board Editor
EditorGUILayout.BeginHorizontal(); // BEGIN selectedTile Menu
foreach (GameBoardTile tile in Enum.GetValues(typeof(GameBoardTile)))
{
if (GUILayout.Button(tile.ToString(), (tile == selectedTile ? selectedButton : GUI.skin.button)))
{
selectedTile = tile;
}
}
EditorGUILayout.EndHorizontal(); // END selectedTile Menu
EditorGUILayout.BeginHorizontal(); // BEGIN Board Layout
#region V2 Code
/*
EditorGUILayout.BeginVertical(); // BEGIN Row Fill Column
GUILayout.Space(20);
for (int y = 0; y < currentData.SizeY; y++)
{
if (GUILayout.Button(">", GUILayout.Width(20), GUILayout.Height(50)))
{
currentData.FillRow(y, selectedTile);
}
}
EditorGUILayout.EndVertical(); // END Row Fill Column
*/
#endregion
for (int x = 0; x < currentData.SizeX; x++)
{
EditorGUILayout.BeginVertical(); // BEGIN Sub-Board Layout
#region V2 Code
/*
if (GUILayout.Button("v", GUILayout.Width(50), GUILayout.Height(20)))
{
currentData.FillColumn(x, selectedTile);
}
*/
#endregion
for (int y = 0; y < currentData.SizeY; y++)
{
if (GUILayout.Button(currentData.GetTileValue(x, y).ToString(), GUILayout.Width(50), GUILayout.Height(50)))
{
currentData.SetTileValue(x, y, selectedTile);
}
}
EditorGUILayout.EndVertical(); // END Sub-Board Layout
}
EditorGUILayout.EndHorizontal(); // END Board Layout
EditorGUILayout.EndVertical(); //END Board Editor
EditorGUILayout.EndHorizontal(); //END Whole Window
}
void SetTileValue(List<GameBoardTile> list, int x, int y, GameBoardTile value, int lengthX, int lengthY)
{
int index = x*lengthY + y;
list[index] = value;
}
public void SetTileValue(int x, int y, GameBoardTile value)
{
SetTileValue(tiles, x, y, value, SizeX, SizeY);
GenerateBoard();
}
public override void OnInspectorGUI()
{
GameBoard boardTarget = (GameBoard) target;
#region Target Initialization
if (boardTarget.tiles == null)
{
boardTarget.ResizeTilesArray(0, 0);
}
if (boardTarget.tilePrefabs == null)
{
boardTarget.tilePrefabs = new List<TilePrefab>();
}
List<GameBoardTile> addTiles = new List<GameBoardTile>();
foreach (GameBoardTile tile in Enum.GetValues(typeof (GameBoardTile)))
{
bool addTile = !boardTarget.tilePrefabs.Exists(o => o.Key == tile);
if (addTile)
{
boardTarget.tilePrefabs.Add(new TilePrefab(tile, null));
}
}
#endregion
boardTarget.playerObject = EditorGUILayout.ObjectField("Player", boardTarget.playerObject, typeof(GameObject), true) as GameObject;
#region Board Parameters
EditorGUILayout.BeginHorizontal();
boardTarget.SizeX = EditorGUILayout.IntField("Size X", boardTarget.SizeX);
boardTarget.SizeY = EditorGUILayout.IntField("Size Y", boardTarget.SizeY);
EditorGUILayout.EndHorizontal();
boardTarget.tileSize = EditorGUILayout.Vector2Field("Tile Size", boardTarget.tileSize);
//Prefab List
foreach (TilePrefab pair in boardTarget.tilePrefabs)
{
pair.Value = EditorGUILayout.ObjectField(pair.Key.ToString(), pair.Value, typeof (GameObject)) as GameObject;
}
#endregion
#region Board
EditorGUILayout.BeginHorizontal();
foreach (GameBoardTile tile in Enum.GetValues(typeof (GameBoardTile)))
{
if (GUILayout.Button(tile.ToString(), (tile == selectedTile ? selectedButton : GUI.skin.button)))
{
selectedTile = tile;
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
for(int x = 0; x < boardTarget.SizeX; x++)
{
EditorGUILayout.BeginVertical();
for (int y = 0; y < boardTarget.SizeY; y++)
{
if (GUILayout.Button(boardTarget.GetTileValue(x, y).ToString(), GUILayout.Width(50), GUILayout.Height(50)))
{
boardTarget.SetTileValue(x, y, selectedTile);
}
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndHorizontal();
#endregion
if (GUILayout.Button("Generate"))
{
boardTarget.GenerateBoard();
}
}
public void FillRow(int y, GameBoardTile tileType)
{
for (int x = 0; x < SizeX; x++)
{
SetTileValue(x, y, tileType);
}
}
public void FillColumn(int x, GameBoardTile tileType)
{
for (int y = 0; y < SizeY; y++)
{
SetTileValue(x, y, tileType);
}
}
public TilePrefab(GameBoardTile key, GameObject value)
{
Key = key;
Value = value;
}
/// <summary>
/// 自定义编辑窗口核心工具类
/// </summary>
void OnGUI()
{
// 获得当前选择的对象
GameBoard selectedObjectBoard = null;
if (Selection.activeGameObject != null)
{
selectedObjectBoard = Selection.activeGameObject.GetComponent<GameBoard>();
}
{
EditorGUILayout.BeginHorizontal(); // 开始绘制窗口 BEGIN Whole Window
//Sidebar
EditorGUILayout.BeginVertical(GUILayout.Width(200)); // BEGIN Sidebar
EditorGUILayout.BeginHorizontal(); // BEGIN Board Size
currentData.SizeX = EditorGUILayout.IntField("Size X", currentData.SizeX);
currentData.SizeY = EditorGUILayout.IntField("Size Y", currentData.SizeY);
EditorGUILayout.EndHorizontal(); // END Board Size
}
EditorGUILayout.Space();
if (GUILayout.Button("Fill"))
{
currentData.Fill(selectedTile);
}
if (GUILayout.Button("Clear"))
{
currentData.Clear();
}
bool guiEnabled = GUI.enabled;
GUI.enabled = selectedObjectBoard != null;
// 将当前编辑器的内容写入选择的瓦片地图
if (GUILayout.Button("Save to Object"))
{
selectedObjectBoard.Load(currentData);
}
// 从当前选择的瓦片地图读取数据加载到编辑器
if (GUILayout.Button("Load From Object"))
{
currentData.Load(selectedObjectBoard);
}
GUI.enabled = guiEnabled;
EditorGUILayout.EndVertical(); // END Sidebar
//Board Editor
EditorGUILayout.BeginVertical(); // BEGIN Board Editor
EditorGUILayout.BeginHorizontal(); // BEGIN selectedTile Menu
foreach (GameBoardTile tile in Enum.GetValues(typeof(GameBoardTile)))
{
if (GUILayout.Button(tile.ToString(), (tile == selectedTile ? selectedButton : GUI.skin.button)))
{
selectedTile = tile;
}
}
EditorGUILayout.EndHorizontal(); // END selectedTile Menu
EditorGUILayout.BeginHorizontal(); // BEGIN Board Layout
#region V2 Code
EditorGUILayout.BeginVertical(); // BEGIN Row Fill Column
GUILayout.Space(20);
for (int y = 0; y < currentData.SizeY; y++)
{
if (GUILayout.Button(">", GUILayout.Width(20), GUILayout.Height(50)))
{
currentData.FillRow(y, selectedTile);
}
}
EditorGUILayout.EndVertical(); // END Row Fill Column
#endregion
for (int x = 0; x < currentData.SizeX; x++)
{
EditorGUILayout.BeginVertical(); // BEGIN Sub-Board Layout
#region V2 Code
if (GUILayout.Button("v", GUILayout.Width(50), GUILayout.Height(20)))
{
currentData.FillColumn(x, selectedTile);
}
#endregion
for (int y = 0; y < currentData.SizeY; y++)
{
if (GUILayout.Button(currentData.GetTileValue(x, y).ToString(), GUILayout.Width(50), GUILayout.Height(50)))
{
currentData.SetTileValue(x, y, selectedTile);
}
}
EditorGUILayout.EndVertical(); // END Sub-Board Layout
}
EditorGUILayout.EndHorizontal(); // END Board Layout
EditorGUILayout.EndVertical(); //END Board Editor
EditorGUILayout.EndHorizontal(); //END Whole Window
}
