private void UpdateHexTileData(HexTile tile, HexTileModel model)
{
// Find model index
HexTileModel hexModel = null;
for (int i = 0; i < _tiles.Count; i++)
{
if (tile == _tiles[i])
{
hexModel = _boardModel.HexTileModels[i];
break;
}
}
if (hexModel == null)
{
Debug.LogError("Unable to update hext tile data, could not be found: " + tile.name);
return;
}
hexModel.MaterialName = model.MaterialName;
hexModel.TextureName = model.TextureName;
hexModel.MovementCost = model.MovementCost;
hexModel.DefenseRating = model.DefenseRating;
hexModel.Scale = model.Scale;
Texture texture = Preferences.Textures[model.TextureName];
//tile.Model = model;
tile.View.SetTexture(texture);
tile.transform.localScale = model.Scale.Convert();
}
//---- Public
//-----------
public void BuildHexBoardFromModel(HexBoardModel model)
{
if (_tiles != null && _tiles.Count > 0)
{
Clean();
}
_boardModel = model;
_tiles = new List <HexTile>(model.HexTileModels.Count);
for (int i = 0; i < _boardModel.HexTileModels.Count; i++)
{
HexTileModel modelData = _boardModel.HexTileModels[i];
Texture texture = Preferences.Textures[modelData.TextureName];
Material material = Preferences.Materials[modelData.MaterialName];
HexTile hex = Instantiate <HexTile>(Preferences.Prefab, Board.transform);
hex.name = "Tile_" + i;
hex.Model = modelData;
hex.View.SetMaterial(material);
hex.View.SetTexture(texture);
hex.transform.localPosition = modelData.Position.Convert();
hex.transform.localRotation = Quaternion.Euler(modelData.Rotation.Convert());
hex.transform.localScale = modelData.Scale.Convert();
_tiles.Add(hex);
}
CenterCamera();
}
private void PreviewName()
{
GUIHorizontalGroup(() =>
{
GUILayout.Label("File Name");
int selection = EditorGUILayout.Popup(_jsonSelection, _jsonContent);
if (selection != _jsonSelection)
{
_jsonSelection = selection;
if (_jsonSelection != 0)
{
HexTileModel data = LoadHexTileModel(_jsonContent[_jsonSelection].text);
if (data != null)
{
_textureIndex = IndexOfTexture(data.TextureName);
UpdateTexture(_textureContent[_textureIndex].text);
_movementCost = data.MovementCost;
_defenseRating = data.DefenseRating;
_terrainType = data.TerrainType;
_scale = data.Scale.Convert();
UpdateScale();
}
}
_filename = "Hex_" + _textureContent[_textureIndex].text;
}
EditorGUILayout.LabelField(_filename, EditorStyles.textArea);
});
}
public static void Copy(this HexTileModel copy, HexTileModel origin)
{
copy.Position = new Point3(origin.Position);
copy.Scale = new Point3(origin.Scale);
copy.MaterialName = origin.MaterialName;
copy.TextureName = origin.TextureName;
copy.MovementCost = origin.MovementCost;
copy.DefenseRating = origin.DefenseRating;
copy.TerrainType = origin.TerrainType;
}
public HexTileModel(HexTileModel other)
{
Position = new Point3(other.Position);
Scale = new Point3(other.Scale);
MaterialName = other.MaterialName;
TextureName = other.TextureName;
MovementCost = other.MovementCost;
DefenseRating = other.DefenseRating;
TerrainType = other.TerrainType;
}
private void BuildPointy(HexBoardModel model, HexTileModel tile, float width, float height, int index, ref int col, ref int row, ref float offset)
{
if (col >= model.Size.X)
{
offset += height;
col = 0;
++row;
}
tile = model.HexTileModels[index];
tile.Position = (row & 1) == 1 ? new Point3((col * width * 2) + width, 0, offset) :
new Point3(col * width * 2, 0, offset);
Point3 rotation = new Point3(0, 30, 0);
tile.Rotation = rotation;
++col;
}
private void BuildHexBoard(HexBoardModel model)
{
if (_hexTilePreferences == null)
{
LoadPreference();
}
int size = (int)(model.Size.X * model.Size.Y);
float w, h;
if (model.Layout == HexLayout.Flat)
{
w = _hexTilePreferences.SizeX * model.Scale.X;
h = _hexTilePreferences.SizeY * model.Scale.Z;
}
else
{
w = _hexTilePreferences.SizeY * model.Scale.X;
h = _hexTilePreferences.SizeX * model.Scale.Z;
}
int col = 0;
int row = 0;
float offset = 0;
for (int i = 0; i < size; i++)
{
HexTileModel tile = model.HexTileModels[i];
if (model.Layout == HexLayout.Flat)
{
BuildFlat(model, tile, w, h, i, ref col, ref row, ref offset);
}
else
{
BuildPointy(model, tile, w, h, i, ref col, ref row, ref offset);
}
}
}
public void OnModelSelectionChange(HexTileModel hexModel)
{
_selectedHexData = hexModel;
}
//---- Edit Functions
//-------------------
private void EnterEdit()
{
if (_boardTool == null)
{
// Get tool object from scene
Scene scene = SceneManager.GetActiveScene();
GameObject[] roots = scene.GetRootGameObjects();
for (int i = 0; i < roots.Length; i++)
{
BoardEditorTool tool = roots[i].GetComponent <BoardEditorTool>();
if (tool != null)
{
_boardTool = tool;
break;
}
}
if (_boardTool == null)
{
Debug.LogError("Unable to load scene with board tool as root object");
return;
}
}
// New board - build out default
if (_boardModel.HexTileModels == null || _boardModel.HexTileModels.Count == 0)
{
int total = Mathf.CeilToInt(_boardModel.Size.X * _boardModel.Size.Y);
_boardModel.HexTileModels = new List <HexTileModel>(total);
// Build default hex tile
for (int i = 0; i < total; i++)
{
HexTileModel tile = new HexTileModel();
tile.Scale = _boardModel.Scale;
tile.MaterialName = DEFAULT_MATERIAL;
tile.TextureName = DEFAULT_TEXTURE;
tile.MovementCost = 0;
tile.DefenseRating = 0;
tile.TerrainType = TerrainType.Water;
_boardModel.AddHexTile(tile);
}
// Build out the model positions data
BuildHexBoard(_boardModel);
}
// Send model data to scene to build board
_boardTool.BuildHexBoardFromModel(_boardModel);
// set oringal file name
_orginalFileName = _boardModel.ID;
// set filter list
_filteredTileContent = new List <GUIContent>(_tileContent);
HexTileFilterContent();
_tileHeight = 1.0f;
HexTileModel model = _hexTileModels[_filteredTileContent[_tileSelectedIndex].text];
model.Scale.Y = _tileHeight;
_boardTool.OnModelSelectionChange(model);
_initBoard = true;
}
private void EditBoard()
{
// Build scene
if (!_initBoard)
{
EnterEdit();
return;
}
Rect rect = new Rect(0, 0, 100, 20);
// Board data
GUI.Label(rect, "Edit Board", EditorStyles.boldLabel);
// ID
rect.y += LINE;
rect.width = SMALL_WIDTH;
GUI.Label(rect, "ID");
rect.x += SMALL_WIDTH;
rect.width = LARGE_WIDTH;
string strName = EditorGUI.DelayedTextField(rect, _boardModel.ID);
if (strName != _boardModel.ID)
{
_boardModel.ID = strName;
_isEdit = true;
}
// Size
rect.y += LINE;
rect.x = 0;
GUI.Label(rect, "Size");
rect.y += LINE;
rect.width = MEDIUM_WIDTH;
GUI.Label(rect, "Col");
rect.x += MEDIUM_WIDTH;
rect.width = MEDIUM_WIDTH;
float x = EditorGUI.DelayedFloatField(rect, _boardModel.Size.X);
if (x != _boardModel.Size.X)
{
_boardModel.Size.X = x;
_isEdit = true;
}
rect.x += MEDIUM_WIDTH;
rect.width = MEDIUM_WIDTH;
GUI.Label(rect, "Row");
rect.x += MEDIUM_WIDTH;
rect.width = MEDIUM_WIDTH;
float y = EditorGUI.DelayedFloatField(rect, _boardModel.Size.Y);
if (y != _boardModel.Size.Y)
{
_boardModel.Size.Y = y;
_isEdit = true;
}
// Scale
rect.x = 0;
rect.y += LINE;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "Scale");
rect.y += LINE;
rect.width = SMALL_WIDTH;
GUI.Label(rect, "X");
rect.x += SMALL_WIDTH;
rect.width = MEDIUM_WIDTH;
x = EditorGUI.DelayedFloatField(rect, _boardModel.Scale.X);
if (x != _boardModel.Scale.X)
{
_boardModel.Scale.X = x;
_isEdit = true;
}
rect.x += MEDIUM_WIDTH;
rect.width = SMALL_WIDTH;
GUI.Label(rect, "Y");
rect.x += SMALL_WIDTH;
rect.width = MEDIUM_WIDTH;
y = EditorGUI.DelayedFloatField(rect, _boardModel.Scale.Y);
if (y != _boardModel.Scale.Y)
{
_boardModel.Scale.Y = y;
_isEdit = true;
}
rect.x += MEDIUM_WIDTH;
rect.width = SMALL_WIDTH;
GUI.Label(rect, "Z");
rect.x += SMALL_WIDTH;
rect.width = MEDIUM_WIDTH;
float z = EditorGUI.DelayedFloatField(rect, _boardModel.Scale.Z);
if (z != _boardModel.Scale.Z)
{
_boardModel.Scale.Z = z;
_isEdit = true;
}
// Layout
rect.x = 0;
rect.y += LINE;
rect.width = MEDIUM_WIDTH;
GUI.Label(rect, "Layout");
rect.x += MEDIUM_WIDTH;
rect.width = LARGE_WIDTH;
HexLayout value = (HexLayout)EditorGUI.EnumPopup(rect, _boardModel.Layout);
if (value != _boardModel.Layout)
{
_boardModel.Layout = value;
_isEdit = true;
}
// Rebuild with new data
if (_isEdit)
{
rect.y += LINE;
rect.x = 0;
if (GUI.Button(rect, "Rebuild"))
{
_boardTool.Clean();
_boardModel.HexTileModels.Clear();
_initBoard = false;
_isEdit = false;
return;
}
}
rect.y += LINE + LINE;
rect.x = 0;
GUI.Label(rect, "Edit Tile", EditorStyles.boldLabel);
// Filters
rect.x = 0;
rect.y += LINE;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "Movement");
rect.x += LARGE_WIDTH;
rect.width = MEDIUM_WIDTH;
int moveSelection = EditorGUI.Popup(rect, _filterMovementIndex, _filterMovementContent.ToArray());
if (moveSelection != _filterMovementIndex)
{
_filterMovementIndex = moveSelection;
FilterHexTiles(_filterMovementIndex, _filterDefenseIndex);
_tileSelectedIndex = 0;
HexTileModel model = _hexTileModels[_filteredTileContent[_tileSelectedIndex].text];
model.Scale.Y = _tileHeight;
_boardTool.OnModelSelectionChange(model);
return;
}
rect.x = 0;
rect.y += LINE;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "Defense");
rect.x += LARGE_WIDTH;
rect.width = MEDIUM_WIDTH;
int defenseSelection = EditorGUI.Popup(rect, _filterDefenseIndex, _filterDefenseContent.ToArray());
if (defenseSelection != _filterDefenseIndex)
{
_filterDefenseIndex = defenseSelection;
FilterHexTiles(_filterMovementIndex, _filterDefenseIndex);
_tileSelectedIndex = 0;
HexTileModel model = _hexTileModels[_filteredTileContent[_tileSelectedIndex].text];
model.Scale.Y = _tileHeight;
_boardTool.OnModelSelectionChange(model);
return;
}
rect.x = 0;
rect.y += LINE;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "HexTile");
// Filtered selection
if (_filteredTileContent.Count > 0)
{
rect.x += LARGE_WIDTH;
rect.width = LARGE_WIDTH;
int selection = EditorGUI.Popup(rect, _tileSelectedIndex, _filteredTileContent.ToArray());
if (selection != _tileSelectedIndex)
{
_tileSelectedIndex = selection;
HexTileModel model = _hexTileModels[_filteredTileContent[_tileSelectedIndex].text];
model.Scale.Y = _tileHeight;
_boardTool.OnModelSelectionChange(model);
}
rect.x = 0;
rect.y += LINE;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "Height");
rect.x += LARGE_WIDTH;
float height = EditorGUI.DelayedFloatField(rect, _tileHeight);
if (height != _tileHeight)
{
_tileHeight = height;
HexTileModel model = _hexTileModels[_filteredTileContent[_tileSelectedIndex].text];
model.Scale.Y = _tileHeight;
_boardTool.OnModelSelectionChange(model);
}
}
else
{
rect.x += LARGE_WIDTH;
rect.width = LARGE_WIDTH;
GUI.Label(rect, "No results");
}
// Save
if (ValidateModel())
{
rect.y += LINE;
rect.x = 0;
rect.width = LARGE_WIDTH;
if (GUI.Button(rect, "Save"))
{
string jsonPath = Application.dataPath + "/Json/HexBoards/";
// Remove old name first
if (_boardModel.ID != _orginalFileName)
{
string oldFile = jsonPath + _orginalFileName + ".json";
if (File.Exists(oldFile))
{
File.Delete(oldFile);
Debug.LogWarning("File " + oldFile + " removed");
}
}
// Save data
string file = _boardModel.ID + ".json";
string json = JsonUtility.ToJson(_boardModel);
File.WriteAllText(jsonPath + file, json);
AssetDatabase.Refresh();
Debug.LogWarning("Json saved: " + jsonPath + file);
LoadHexBoardFiles();
}
rect.x += LARGE_WIDTH;
if (GUI.Button(rect, "Return"))
{
ExitEdit();
_state = State.MainMenu;
}
}
else
{
if (GUI.Button(rect, "Return"))
{
ExitEdit();
_state = State.MainMenu;
}
}
}
