public SrpgTile CreateTileInto(SrpgLayer layer, Sprite tileSprt, int x, int y)
{
string tileName = string.Format("[{0}, {1}] {2}", x, y, tileSprt.name);
GameObject tileObj = new GameObject(tileName);
tileObj.transform.parent = layer.transform;
SpriteRenderer tileRndr = tileObj.AddComponent <SpriteRenderer>();
tileRndr.sprite = tileSprt;
tileRndr.sortingOrder = CalcZIndex(layer, y);
float tileScale = _tileWidth / tileRndr.bounds.size.x;
tileObj.transform.localScale = new Vector3(tileScale, tileScale, 1);
tileObj.transform.position = CalcTilePosition(x, y);
if (layer.touchable)
{
tileObj.AddComponent <BoxCollider2D>();
}
SrpgTile tile = tileObj.AddComponent <SrpgTile>();
tile.x = x;
tile.y = y;
return(tile);
}
public List <SrpgTile> GetAdjacentTiles(SrpgLayer layer, int x, int y)
{
List <SrpgNode> toFindNodes = new List <SrpgNode>();
// depending on tile types such as rectangle, hexagon..
if (x > 0)
{
toFindNodes.Add(new SrpgNode(x - 1, y));
}
if (x < _mapHeight - 1)
{
toFindNodes.Add(new SrpgNode(x + 1, y));
}
if (y > 0)
{
toFindNodes.Add(new SrpgNode(x, y - 1));
}
if (y < mapHeight - 1)
{
toFindNodes.Add(new SrpgNode(x, y + 1));
}
SrpgTile[] allTiles = layer.GetTiles();
List <SrpgTile> adjacentTiles = new List <SrpgTile>();
foreach (SrpgTile tile in allTiles)
{
if (toFindNodes.Contains(new SrpgNode(tile.x, tile.y)))
{
adjacentTiles.Add(tile);
}
}
return(adjacentTiles);
}
void OnDestroy()
{
SceneView.onSceneGUIDelegate -= OnSceneGUI;
EditorApplication.hierarchyWindowChanged -= OnHierarchyChanged;
SrpgMtUtils.ShowUnityGrid(true);
SrpgMtUtils.SetupGizmos(false);
if (_canvas != null)
{
DestroyImmediate(_canvas.gameObject);
_canvas = null;
}
if (_brush != null)
{
DestroyImmediate(_brush.gameObject);
_brush = null;
}
if (_currMap != null)
{
_currMap.lastEditedTime = DateTime.Now.Ticks;
_currMap = null;
}
if (_currLayer != null)
{
_currLayer.lastEditedTime = DateTime.Now.Ticks;
_currLayer = null;
}
}
public SrpgLayer CreateLayer(string layerName, bool touchable = false, int zIndexStart = -1)
{
if (zIndexStart < 0)
{
// magic number 5!?
List <SrpgLayer> layers = GetSortedLayers();
if (layers.Count > 0)
{
zIndexStart = layers[0].zIndexStart + _mapHeight + 5;
}
else
{
zIndexStart = 5;
}
}
GameObject layerObj = new GameObject(layerName);
layerObj.transform.parent = transform;
layerObj.transform.position = Vector3.zero;
SrpgLayer newLayer = layerObj.AddComponent <SrpgLayer>();
newLayer.touchable = touchable;
newLayer.SetZIndex(zIndexStart, _mapHeight);
return(newLayer);
}
private void LocateUnit(SrpgLayer layer, SrpgUnit unit, int x, int y)
{
unit.SetZIndex(CalcZIndex(layer, y));
unit.gameObject.name = string.Format("[{0}, {1}] {2}", x, y, unit.gameObject.name);
unit.x = x;
unit.y = y;
float unitX = _tileWidth * x + unit.offsetX;
float unitY = _tileHeight * y + unit.offsetY;
unit.transform.position = new Vector3(unitX, unitY);
}
public void LocateUnitFirst(SrpgLayer layer, SrpgUnit unit, int x, int y,
float fitRatio = 1f, SrpgBattle.UnitFitMode scaleMode = SrpgBattle.UnitFitMode.Inside)
{
unit.boundWidth = _tileWidth;
unit.boundHeight = _tileHeight;
Vector3 unitSize = unit.GetSize();
float unitScale = 0f;
if (scaleMode == SrpgBattle.UnitFitMode.Inside)
{
float widthScale = _tileWidth * fitRatio / unitSize.x;
float heightScale = _tileHeight * fitRatio / unitSize.y;
if (widthScale >= 1f && heightScale >= 1f) // tile width >= unit width && tile height >= unit height
{
unitScale = Mathf.Min(widthScale, heightScale);
}
else if (widthScale < 1f && heightScale < 1f) // tile width < unit width && tile height < unit height
{
unitScale = Mathf.Max(widthScale, heightScale);
}
else if (widthScale >= 1f && heightScale < 1f) // tile width >= unit width && tile height < unit height
{
unitScale = heightScale;
}
else if (widthScale < 1f && heightScale >= 1f) // tile width < unit width && tile height >= unit height
{
unitScale = widthScale;
}
}
else if (scaleMode == SrpgBattle.UnitFitMode.Width)
{
unitScale = _tileWidth * fitRatio / unitSize.x;
}
else if (scaleMode == SrpgBattle.UnitFitMode.Height)
{
unitScale = _tileHeight * fitRatio / unitSize.y;
}
unit.Scale(unitScale);
Vector3 unitCenter = unit.GetCenter();
unit.offsetX = _tileWidth / 2 + unitCenter.x;
unit.offsetY = _tileHeight / 2 - unitCenter.y;
LocateUnit(layer, unit, x, y);
}
public void ZIndexUp(int layerIndex)
{
if (layerIndex <= 0)
{
return;
}
List <SrpgLayer> layers = GetSortedLayers();
SrpgLayer destLayer = layers[layerIndex - 1];
SrpgLayer targetLayer = layers[layerIndex];
int destLayerZIndexStart = destLayer.zIndexStart;
destLayer.SetZIndex(targetLayer.zIndexStart, _mapHeight);
targetLayer.SetZIndex(destLayerZIndexStart, _mapHeight);
layers[layerIndex - 1] = targetLayer;
layers[layerIndex] = destLayer;
}
public void ZIndexDown(int layerIndex)
{
if (layerIndex >= transform.childCount - 1)
{
return;
}
List <SrpgLayer> layers = GetSortedLayers();
SrpgLayer destLayer = layers[layerIndex + 1];
SrpgLayer targetLayer = layers[layerIndex];
int destLayerZIndexStart = destLayer.zIndexStart;
destLayer.SetZIndex(targetLayer.zIndexStart, _mapHeight);
targetLayer.SetZIndex(destLayerZIndexStart, _mapHeight);
layers[layerIndex + 1] = targetLayer;
layers[layerIndex] = destLayer;
}
public SrpgCell InstantiateCellIntoLayer(SrpgLayer layer, GameObject cellPrefab, int x, int y)
{
GameObject cellObj = Instantiate(cellPrefab, layer.transform);
cellObj.name = string.Format("[{0}, {1}] {2}", x, y, cellObj.name);
SrpgCell cell = cellObj.GetComponent <SrpgCell>();
cell.x = x;
cell.y = y;
cell.SetZIndex(layer.zIndexStart);
float cellScale = _tileWidth / cell.GetSize().x;
cellObj.transform.localScale = new Vector3(cellScale, cellScale, 1);
cellObj.transform.position = CalcTilePosition(x, y);
return(cell);
}
private void SetupLayer()
{
if (_currMap.transform.childCount == 0)
{
_currLayer = _currMap.CreateLayer("Ground", true);
Undo.RegisterCreatedObjectUndo(_currLayer.gameObject, _currLayer.name);
_sortedLayer = new List <SrpgLayer>();
_sortedLayer.Add(_currLayer);
}
else
{
_sortedLayer = _currMap.GetSortedLayers();
if (_currLayer == null)
{
_currLayer = _currMap.GetLastestEditedLayer();
}
}
}
public void OnSceneGUI(SceneView sceneView, SrpgCanvas canvas, SrpgBrush brush,
SrpgMap map, SrpgLayer layer)
{
if (canvas == null || brush == null || map == null)
{
return;
}
//_canvas = canvas;
_brush = brush;
_currMap = map;
_currLayer = layer;
_brush.ShowHide(SrpgMapTool.toolMode == SrpgMapTool.ToolMode.Edit &&
SrpgMapTool.editMenu == SrpgMapTool.EditMenu.Brush);
if (SrpgMapTool.toolMode != SrpgMapTool.ToolMode.Edit)
{
return;
}
DrawButtons();
DoMouseEvent();
}
private void GUI_EditMode()
{
if (_currMap == null)
{
return;
}
EditorGUILayout.BeginHorizontal("box");
{
if (GUILayout.Button("Generate map"))
{
toolMode = ToolMode.Generate;
editMenu = EditMenu.None;
}
}
EditorGUILayout.EndHorizontal();
GUI_Title("Edit map: " + _currMap.gameObject.name);
EditorGUILayout.BeginVertical("box");
{
EditorGUILayout.LabelField("Layers (z-index rank. name)");
GUIStyle buttonStyle = GUI.skin.GetStyle("Button");
buttonStyle.padding = new RectOffset(2, 2, 1, 1);
String[] toolbars = { "↑", "↓", "x" };
for (int i = 0; i < _sortedLayer.Count; i++)
{
SrpgLayer layer = _sortedLayer[i];
if (layer == null)
{
Debug.LogWarning("layer is null");
continue;
}
EditorGUILayout.BeginHorizontal();
{
Texture2D layerTex = layer.gameObject.activeSelf ?
config.layerVisibleIcon :
config.layerHiddenIcon;
if (GUILayout.Button(layerTex, buttonStyle, GUILayout.Width(20), GUILayout.Height(15)))
{
layer.gameObject.SetActive(!layer.gameObject.activeSelf);
}
string layerName = (i + 1) + ". " + layer.gameObject.name;
if (EditorGUILayout.ToggleLeft(layerName, layer == _currLayer))
{
_currLayer = layer;
}
int clickedButton = GUILayout.Toolbar(-1, toolbars, GUILayout.Width(60));
if (clickedButton == 0) // up
{
_currMap.ZIndexUp(i);
SetupLayer();
}
else if (clickedButton == 1) // down
{
_currMap.ZIndexDown(i);
SetupLayer();
}
if (clickedButton == 2) // remove
{
if (_sortedLayer.Count > 1)
{
_sortedLayer.RemoveAt(i);
Undo.DestroyObjectImmediate(layer.gameObject);
}
}
}
EditorGUILayout.EndHorizontal();
}
if (!_layerAdding)
{
if (GUILayout.Button("Add Layer"))
{
_layerAdding = true;
}
}
else
{
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField("Name", GUILayout.Width(40));
_genLayerName = EditorGUILayout.TextField(_genLayerName);
EditorGUILayout.LabelField("", GUILayout.Width(10)); // space
//_genLayerTouchable = GUILayout.Toggle(_genLayerTouchable, "Touchable", GUILayout.Width(80));
if (GUILayout.Button("Add", GUILayout.Width(50)))
{
string layerName = _genLayerName;
if (layerName.Length == 0)
{
layerName = "Layer";
}
_currLayer = _currMap.CreateLayer(layerName, _genLayerTouchable);
Undo.RegisterCreatedObjectUndo(_currLayer.gameObject, _currLayer.name);
_layerAdding = false;
_genLayerName = "";
}
if (GUILayout.Button("Cancel", GUILayout.Width(50)))
{
_layerAdding = false;
}
}
EditorGUILayout.EndHorizontal();
}
}
EditorGUILayout.EndVertical();
Texture2D prevTex = _tileset.texture;
Rect boxRect = EditorGUILayout.BeginVertical("box");
{
string tilesetName = (_tileset.texture == null ? "not selected" : _tileset.texture.name);
_tileset.texture = (Texture2D)EditorGUILayout.ObjectField("Tileset: " + tilesetName, _tileset.texture, typeof(Texture2D), true, GUILayout.Height(40));
if (_tileset.texture == null && _currMap.lastTileset != null)
{
_tileset.texture = _currMap.lastTileset;
}
Sprite firstSprite = null;
if (_tileset.texture != null)
{
string tilesetPath = AssetDatabase.GetAssetPath(_tileset.texture.GetInstanceID());
firstSprite = AssetDatabase.LoadAssetAtPath <Sprite>(tilesetPath);
if (firstSprite != null)
{
_tileset.spriteWidth = firstSprite.rect.width;
_tileset.spriteHeight = firstSprite.rect.height;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.HelpBox("Texture Size: " + _tileset.texture.width + " X " + _tileset.texture.height, MessageType.Info);
EditorGUILayout.HelpBox("Sprite Size: " + _tileset.spriteWidth + " X " + _tileset.spriteHeight, MessageType.Info);
EditorGUILayout.EndHorizontal();
_currMap.lastTileset = _tileset.texture;
_tilesetBackColor = EditorGUILayout.ColorField("Background Color", _tilesetBackColor);
}
}
}
EditorGUILayout.EndVertical();
if (_tileset.texture == null)
{
return;
}
// draw background and tileset
float sideMargin = 5;
float rightMargin = 15;
float tilesetOriginX = sideMargin;
float tilesetOriginY = boxRect.y + boxRect.height + sideMargin;
#if UNITY_EDITOR_OSX
float scaledTilesetWidth = (Screen.width / 2) - (sideMargin + rightMargin);
#else
float scaledTilesetWidth = Screen.width - (sideMargin + rightMargin);
#endif
float tilesetScale = _tileset.texture.width / scaledTilesetWidth;
float scaledTilesetHeight = _tileset.texture.height / tilesetScale;
Rect tilesetRect = new Rect(tilesetOriginX, tilesetOriginY, scaledTilesetWidth, scaledTilesetHeight);
EditorGUILayout.LabelField("", GUILayout.Height(scaledTilesetHeight), GUILayout.Width(scaledTilesetWidth - 5)); // tileset place holder
Texture2D backTex = SrpgMtUtils.MakeAlphaTexture(1, 1, _tilesetBackColor);
GUI.DrawTexture(tilesetRect, backTex, ScaleMode.StretchToFill);
GUI.DrawTexture(tilesetRect, _tileset.texture);
// draw lines
int tilesetWidth = (int)(_tileset.texture.width / _tileset.spriteWidth);
int tilesetHeight = (int)(_tileset.texture.height / _tileset.spriteHeight);
float scaledSpriteWidth = _tileset.spriteWidth / tilesetScale;
float scaledSpriteHeight = _tileset.spriteHeight / tilesetScale;
//float scaledSpriteWidth = scaledTilesetWidth / tilesetWidth;
//float scaledSpriteHeight = scaledTilesetHeight / tilesetHeight;
Handles.BeginGUI();
{
Handles.color = Color.white;
for (int i = 1; i < tilesetWidth; i++)
{
float x = tilesetOriginX + scaledSpriteWidth * i;
Handles.DrawLine(new Vector3(x, tilesetOriginY), new Vector3(x, tilesetOriginY + scaledTilesetHeight));
}
for (int i = 1; i < tilesetHeight; i++)
{
float y = tilesetOriginY + scaledSpriteHeight * i;
Handles.DrawLine(new Vector3(tilesetOriginX, y), new Vector3(tilesetOriginX + scaledTilesetWidth, y));
}
}
Handles.EndGUI();
// fill _sprites
if (_tileset.texture != prevTex)
{
_sprites = new Sprite[tilesetWidth, tilesetHeight];
string tilesetPath = AssetDatabase.GetAssetPath(_tileset.texture.GetInstanceID());
Sprite[] rawSprites = AssetDatabase.LoadAllAssetsAtPath(tilesetPath).OfType <Sprite>().ToArray();
foreach (Sprite sprt in rawSprites)
{
float spriteCenterX = tilesetOriginX + sprt.rect.center.x / tilesetScale;
float spriteCenterY = tilesetOriginY + (_tileset.texture.height - (sprt.rect.center.y)) / tilesetScale;
int x = Mathf.FloorToInt((spriteCenterX - tilesetOriginX) / scaledSpriteWidth);
int y = Mathf.FloorToInt((spriteCenterY - tilesetOriginY) / scaledSpriteHeight);
_sprites[x, y] = sprt;
}
_spriteSelection.Init();
}
// select sprites
Event e = Event.current;
if (e.button == 0)
{
if (e.type == EventType.MouseDown || e.type == EventType.MouseDrag)
{
Vector2 mousePos = e.mousePosition;
foreach (Sprite sprt in _sprites)
{
if (sprt == null)
{
continue;
}
float spriteX = tilesetOriginX + sprt.rect.x / tilesetScale;
float spriteY = tilesetOriginY + (_tileset.texture.height - (sprt.rect.y + sprt.rect.height)) / tilesetScale;
if (mousePos.x > spriteX && mousePos.x < spriteX + scaledSpriteWidth &&
mousePos.y > spriteY && mousePos.y < spriteY + scaledSpriteHeight)
{
int selX = Mathf.FloorToInt((mousePos.x - tilesetOriginX) / scaledSpriteWidth);
int selY = Mathf.FloorToInt((mousePos.y - tilesetOriginY) / scaledSpriteHeight);
if (e.type == EventType.MouseDown)
{
_spriteSelection.dragSttX = _spriteSelection.dragEndX = selX;
_spriteSelection.dragSttY = _spriteSelection.dragEndY = selY;
_spriteSelection.changed = true;
}
else if (e.type == EventType.MouseDrag)
{
_spriteSelection.dragEndX = selX;
_spriteSelection.dragEndY = selY;
_spriteSelection.changed = true;
}
_spriteSelection.xMin = Mathf.Min(_spriteSelection.dragSttX, _spriteSelection.dragEndX);
_spriteSelection.yMin = Mathf.Min(_spriteSelection.dragSttY, _spriteSelection.dragEndY);
_spriteSelection.xMax = Mathf.Max(_spriteSelection.dragSttX, _spriteSelection.dragEndX);
_spriteSelection.yMax = Mathf.Max(_spriteSelection.dragSttY, _spriteSelection.dragEndY);
e.Use();
break;
}
}
}
else if (e.type == EventType.MouseUp)
{
if (_spriteSelection.changed)
{
_spriteSelection.changed = false;
_brush.ResetSprites(_spriteSelection.xMin, _spriteSelection.yMin, _spriteSelection.xMax, _spriteSelection.yMax, _sprites);
e.Use();
}
}
}
// draw selection
if (_spriteSelection.dragSttY >= 0 && _spriteSelection.dragSttX >= 0 &&
_spriteSelection.dragEndY >= 0 && _spriteSelection.dragEndX >= 0)
{
for (int y = _spriteSelection.yMin; y <= _spriteSelection.yMax; y++)
{
for (int x = _spriteSelection.xMin; x <= _spriteSelection.xMax; x++)
{
float scaledRectX = tilesetOriginX + scaledSpriteWidth * x;
float scaledRectY = tilesetOriginY + scaledSpriteHeight * y;
Rect selectionRect = new Rect(scaledRectX, scaledRectY, scaledSpriteWidth, scaledSpriteHeight);
Texture2D selectionTex = SrpgMtUtils.MakeAlphaTexture(1, 1, new Color(0, 0.5f, 0.5f, 0.5f));
GUI.DrawTexture(selectionRect, selectionTex, ScaleMode.StretchToFill);
}
}
}
}
void Start()
{
//----- init configuration and check -----
if (!InitConfig())
{
return;
}
if (_unitFitMode == UnitFitMode.Unknown)
{
Debug.LogError("unitFitMode is unknown");
return;
}
if (_moveMethod == MoveMethod.Unknown)
{
Debug.LogError("moveMethod is unknown");
return;
}
//----- init map & layers and check -----
if (!InitMap())
{
return;
}
if (_map == null)
{
Debug.LogError("map is null");
return;
}
List <SrpgLayer> layers = _map.GetSortedLayers();
if (layers.Count == 0)
{
Debug.LogError("no layers");
return;
}
if (_groundLayer == null)
{
_groundLayer = layers[layers.Count - 1];
}
// unit layer & cell layer z index 수정 필요
if (_unitLayer == null)
{
_unitLayer = _map.CreateLayer("Units");
}
// magic number 5!?
int cellLayerZ = _unitLayer.zIndexStart - 5;
_cellLayer = _map.CreateLayer("Cells", false, cellLayerZ);
foreach (SrpgLayer layer in layers)
{
if (layer.touchable)
{
SrpgTile[] tiles = layer.GetComponentsInChildren <SrpgTile>();
foreach (SrpgTile tile in tiles)
{
tile.clicked += OnTileClicked;
}
}
}
//----- init units and check -----
if (!InitUnits())
{
return;
}
Debug.Assert(_playerUnits.Count > 0 && _enemyUnits.Count > 0);
StartGame();
}
public SrpgTile GetTile(SrpgLayer layer, int x, int y)
{
return(layer.GetTile(x, y));
}
public override void OnInspectorGUI()
{
GUI.enabled = false;
_target.x = EditorGUILayout.IntField("X", _target.x);
_target.y = EditorGUILayout.IntField("Y", _target.y);
GUI.enabled = true;
EditorGUILayout.Space();
SrpgLayer parentLayer = _target.transform.parent.GetComponent <SrpgLayer>();
if (parentLayer == null || parentLayer.propertySchemes.Count == 0)
{
return;
}
Undo.RecordObject(_target, _target.name);
EditorGUILayout.BeginVertical("box");
{
EditorGUILayout.LabelField("Layer Properties");
GUILayoutOption valueWidth = GUILayout.Width(100);
foreach (SrpgPropertyScheme scheme in parentLayer.propertySchemes)
{
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField(scheme.name);
SrpgPropertyImpl prop = null;
if (!_target.TryGetProperty(scheme.name, out prop))
{
if (GUILayout.Button("Use", GUILayout.Width(100), GUILayout.Height(14)))
{
prop = _target.AddProperty(scheme.name);
if (scheme.type == SrpgPropertyScheme.PropType.Bool)
{
prop.b = false;
}
else if (scheme.type == SrpgPropertyScheme.PropType.Int)
{
prop.n = 0;
}
else if (scheme.type == SrpgPropertyScheme.PropType.Float)
{
prop.f = 0f;
}
else if (scheme.type == SrpgPropertyScheme.PropType.String)
{
prop.s = "";
}
else
{
Debug.LogError("Wrong type property!");
}
}
}
else
{
if (scheme.type == SrpgPropertyScheme.PropType.Bool)
{
prop.b = EditorGUILayout.Toggle(prop.b, valueWidth);
}
else if (scheme.type == SrpgPropertyScheme.PropType.Int)
{
prop.n = EditorGUILayout.IntField(prop.n, valueWidth);
}
else if (scheme.type == SrpgPropertyScheme.PropType.Float)
{
prop.f = EditorGUILayout.FloatField(prop.f, valueWidth);
}
else if (scheme.type == SrpgPropertyScheme.PropType.String)
{
prop.s = EditorGUILayout.TextField(prop.s, valueWidth);
}
else
{
Debug.LogError("Wrong type property!");
}
}
}
EditorGUILayout.EndHorizontal();
}
if (GUILayout.Button("Apply to same tiles"))
{
SrpgTile[] layerTiles = parentLayer.GetComponentsInChildren <SrpgTile>();
foreach (SrpgTile tile in layerTiles)
{
if (tile == _target)
{
continue;
}
if (tile.IsSameTile(_target))
{
tile.CopyProperties(_target.properties);
}
}
}
}
EditorGUILayout.EndVertical();
}
private int CalcZIndex(SrpgLayer layer, int y)
{
return(CalcZIndex(layer.zIndexStart, _mapHeight, y));
}
void OnEnable()
{
_target = (SrpgLayer)target;
}
