void FillFogOfWarData() { m_animatedTiles.Clear(); m_animatedWaterfallTiles.Clear(); m_vertices = new Vector3[TileWidth * TileHeight * 4 * 4]; // 4 subtiles x 4 vertex per tile m_colors = new Color32[TileWidth * TileHeight * 4 * 4]; m_uv = new Vector2[m_vertices.Length]; m_triangles = new int[TileWidth * TileHeight * 4 * 2 * 3]; // 4 subtiles x 2 triangles per tile x 3 vertex per triangle int vertexIdx = 0; int triangleIdx = 0; //TODO: optimize updating only updated tiles inside the chunk Dictionary <int, AutoTile> tileCache = new Dictionary <int, AutoTile>(); int mapWidth = MyAutoTileMap.MapTileWidth; int mapHeight = MyAutoTileMap.MapTileHeight; for (int tileX = 0; tileX < TileWidth; ++tileX) { for (int tileY = 0; tileY < TileHeight; ++tileY) { int tx = StartTileX + tileX; int ty = StartTileY + tileY; if (tx >= mapWidth || ty >= mapHeight) { continue; } int tileIdx = ty * MyAutoTileMap.MapTileWidth + tx; AutoTile autoTile; if (!tileCache.TryGetValue(tileIdx, out autoTile)) { //Debug.Log(" Cache miss! "); autoTile = MyAutoTileMap.GetAutoTile(StartTileX + tileX, StartTileY + tileY, MapLayerIdx); tileCache[tileIdx] = autoTile; } byte[] fogColors = System.BitConverter.GetBytes(autoTile.Id); { int subTileXBase = tileX << 1; // <<1 == *2 int subTileYBase = tileY << 1; // <<1 == *2 int fogColorIdx = 0; for (int xf = 0; xf < 2; ++xf) { for (int yf = 0; yf < 2; ++yf, ++fogColorIdx) { int subTileX = subTileXBase + xf; int subTileY = subTileYBase + yf; float px0 = subTileX * (MyAutoTileMap.CellSize.x / 2f); float py0 = -subTileY * (MyAutoTileMap.CellSize.y / 2f); float px1 = (subTileX + 1) * (MyAutoTileMap.CellSize.x / 2f); float py1 = -(subTileY + 1) * (MyAutoTileMap.CellSize.y / 2f); m_vertices[vertexIdx + 0] = new Vector3(px0, py0, 0); m_vertices[vertexIdx + 1] = new Vector3(px0, py1, 0); m_vertices[vertexIdx + 2] = new Vector3(px1, py1, 0); m_vertices[vertexIdx + 3] = new Vector3(px1, py0, 0); m_colors[vertexIdx + 0] = new Color32(0, 0, 0, fogColors[fogColorIdx]); m_colors[vertexIdx + 1] = new Color32(0, 0, 0, fogColors[fogColorIdx]); m_colors[vertexIdx + 2] = new Color32(0, 0, 0, fogColors[fogColorIdx]); m_colors[vertexIdx + 3] = new Color32(0, 0, 0, fogColors[fogColorIdx]); m_triangles[triangleIdx + 0] = vertexIdx + 2; m_triangles[triangleIdx + 1] = vertexIdx + 1; m_triangles[triangleIdx + 2] = vertexIdx + 0; m_triangles[triangleIdx + 3] = vertexIdx + 0; m_triangles[triangleIdx + 4] = vertexIdx + 3; m_triangles[triangleIdx + 5] = vertexIdx + 2; float u0 = 0; float u1 = 0; float v0 = 1; float v1 = 1; m_uv[vertexIdx + 0] = new Vector3(u0, v0, 0); m_uv[vertexIdx + 1] = new Vector3(u0, v1, 0); m_uv[vertexIdx + 2] = new Vector3(u1, v1, 0); m_uv[vertexIdx + 3] = new Vector3(u1, v0, 0); // increment vectex and triangle idx vertexIdx += 4; triangleIdx += 6; } } } } } // resize arrays System.Array.Resize(ref m_vertices, vertexIdx); System.Array.Resize(ref m_colors, vertexIdx); System.Array.Resize(ref m_uv, vertexIdx); System.Array.Resize(ref m_triangles, triangleIdx); }
//Return only 1 TileData has change public TileData DoAction(AutoTileMap _autoTileMap) { TileData onlyChange = null; //Check is ok with Size Large { var brush = aTileData[0]; int tile_id = brush.Tile_id; if (_autoTileMap.Tileset.IsExitSlot(tile_id)) { var slot = _autoTileMap.Tileset.GetSlot(tile_id); if (slot.Size.x > 1 || slot.Size.y > 1) { if (brush.Tile_x < 0) { Debug.Log("Out Left Map"); return(onlyChange); } if (brush.Tile_y < 0) { Debug.Log("Out Top Map"); return(onlyChange); } if (brush.Tile_x + slot.Size.x > (_autoTileMap.MapTileWidth)) { Debug.Log("Out Right Map"); return(onlyChange); } if (brush.Tile_y + slot.Size.x > (_autoTileMap.MapTileWidth)) { Debug.Log("Out Bot Map"); return(onlyChange); } //Check all tile will be brush don't have other Size Large for (int x = brush.Tile_x; x < brush.Tile_x + slot.Size.x; x++) { for (int y = brush.Tile_y; y < brush.Tile_y + slot.Size.y; y++) { int idCheck = _autoTileMap.GetAutoTile(x, y, brush.Tile_layer).Id; if (_autoTileMap.Tileset.IsExitSlot(idCheck)) { var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck); if (slotCheck.Size.x > 1 || slotCheck.Size.y > 1) { Debug.Log("Have other Size Large"); return(onlyChange); } } } } } } } // int tileMinX = _autoTileMap.MapTileWidth - 1; int tileMinY = _autoTileMap.MapTileHeight - 1; int tileMaxX = 0; int tileMaxY = 0; bool HasChangedTile = false; for (int i = 0; i < aTileData.Count; ++i) { TileData tileData = aTileData[i]; // save prev tile type for undo action // tileData.Tile_type_prev = _autoTileMap.GetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer ).Id; // if(!_autoTileMap.Tileset.IsExitSlot(tileData.Tile_id)){ // continue; // } int idCheck = _autoTileMap.GetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer).Id; if (_autoTileMap.Tileset.IsExitSlot(idCheck)) { var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck); if (!slotCheck.IsCanCopyWhenDraw) { continue; } } if (tileData.Tile_id >= -1) { bool isUpdate = _autoTileMap.SetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer, true); if (isUpdate) { HasChangedTile = true; } } if (tileData.Tile_high >= 0) { bool isUpdate = _autoTileMap.MapSelect.SetHighRef(tileData.Tile_x, tileData.Tile_y, tileData.Tile_high); if (isUpdate) { HasChangedTile = true; int tile_layer_high = (int)eSlotAonTypeLayer.Trigger; _autoTileMap.RefreshTile(tileData.Tile_x, tileData.Tile_y, tile_layer_high); } } if (aTileData.Count == 1) { onlyChange = tileData; } // if(slot.Size.x == 1 && slot.Size.y == 1){ // }else{ // // _autoTileMap.SetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer ); // for(int x = tileData.Tile_x; x < tileData.Tile_x + slot.Size.x; x++){ // for(int y = tileData.Tile_y; y < tileData.Tile_y + slot.Size.y; y++){ // // _autoTileMap.SetAutoTile( x, y, -2, tileData.Tile_layer ); // _autoTileMap.SetAutoTile( x, y, tileData.Tile_id, tileData.Tile_layer ); // } // } // } if (HasChangedTile) { tileMinX = Mathf.Min(tileMinX, tileData.Tile_x); tileMinY = Mathf.Min(tileMinY, tileData.Tile_y); tileMaxX = Mathf.Max(tileMaxX, tileData.Tile_x); tileMaxY = Mathf.Max(tileMaxY, tileData.Tile_y); } } if (HasChangedTile) { // if (_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled) { _autoTileMap.RefreshMinimapTexture(tileMinX, tileMinY, (tileMaxX - tileMinX) + 1, (tileMaxY - tileMinY) + 1); } _autoTileMap.UpdateChunks(); } return(onlyChange); }
public void OnSceneGUI() { #region Undo / Redo if (Event.current.isKey && Event.current.shift && Event.current.type == EventType.KeyUp) { if (Event.current.keyCode == KeyCode.Z) { m_autoTileMap.BrushGizmo.UndoAction(); } if (Event.current.keyCode == KeyCode.Y) { m_autoTileMap.BrushGizmo.RedoAction(); } } #endregion Rect rSceneView = new Rect(0, 0, Screen.width, Screen.height); if (rSceneView.Contains(Event.current.mousePosition)) { UpdateMouseInputs(); Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); Plane hPlane = new Plane(Vector3.forward, Vector3.zero); float distance = 0; if (hPlane.Raycast(ray, out distance)) { // get the hit point: Vector3 vPos = ray.GetPoint(distance); m_autoTileMap.BrushGizmo.UpdateBrushGizmo(vPos); if (m_isMouseRight || m_isMouseLeft) { int tile_x = (int)(vPos.x / m_autoTileMap.Tileset.TileWorldWidth); int tile_y = (int)(-vPos.y / m_autoTileMap.Tileset.TileWorldHeight); // for optimization, is true when mouse is over a diffent tile during the first update bool isMouseTileChanged = (tile_x != m_prevMouseTileX) || (tile_y != m_prevMouseTileY); //if ( m_autoTileMap.IsValidAutoTilePos(tile_x, tile_y)) // commented to allow drawing outside map, useful when brush has a lot of copied tiles { int gndTileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, m_autoTileMap.BrushGizmo.SelectedLayer).Id; int gndOverlayTileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, m_autoTileMap.BrushGizmo.SelectedLayer + 1).Id; // mouse right for tile selection if (m_isMouseRightDown || m_isMouseRight && isMouseTileChanged) { if (m_isMouseRightDown) { m_startDragTileX = tile_x; m_startDragTileY = tile_y; // Remove Brush m_autoTileMap.BrushGizmo.Clear(); m_tilesetSelStart = m_tilesetSelEnd = -1; // copy tile if (Event.current.shift) { m_selectedTileIdx = -2; //NOTE: -2 means, ignore this tile when painting } else { m_selectedTileIdx = gndTileType >= 0? gndTileType : gndOverlayTileType; } } m_dragTileX = tile_x; m_dragTileY = tile_y; } // isMouseLeft else if (m_isMouseLeftDown || isMouseTileChanged) // avoid Push the same action twice during mouse drag { AutoTileBrush.TileAction action = new AutoTileBrush.TileAction(); if (m_autoTileMap.BrushGizmo.BrushAction != null) { //+++ case of multiple tiles painting action.CopyRelative(m_autoTileMap, m_autoTileMap.BrushGizmo.BrushAction, tile_x, tile_y); if (Event.current.shift && (m_autoTileMap.BrushGizmo.SelectedLayer + 1) < m_autoTileMap.GetLayerCount()) { // old functionality: ground tiles become ground overlay, ground overlay are removed, overlay tiles remains // Tiles in SelectedLayer are moved to next layer action.BecomeOverlay(m_autoTileMap.BrushGizmo.SelectedLayer); } } else { //+++ case of single tile painting // If smart brush is enabled, the tiles with collision type Overlay will be placed directly in the first overlay layer found over current SelectedLayer int overlayLayer = m_autoTileMap.FindFirstLayerIdx(AutoTileMap.eLayerType.Overlay, m_autoTileMap.BrushGizmo.SelectedLayer); if (m_autoTileMap.BrushGizmo.SmartBrushEnabled && overlayLayer >= 0 && m_selectedTileIdx >= 0 && m_autoTileMap.Tileset.AutotileCollType[m_selectedTileIdx] == AutoTileMap.eTileCollisionType.OVERLAY) { action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, overlayLayer); } else { if (Event.current.shift || m_autoTileMap.IsAutoTileHasAlpha(m_selectedTileIdx) && m_autoTileMap.BrushGizmo.SmartBrushEnabled) { // Put tiles with alpha in the layer over Selected Layer action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, m_autoTileMap.BrushGizmo.SelectedLayer + 1); } else { action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, m_autoTileMap.BrushGizmo.SelectedLayer); } } } m_autoTileMap.BrushGizmo.PerformAction(action); EditorUtility.SetDirty(m_autoTileMap); } } m_prevMouseTileX = tile_x; m_prevMouseTileY = tile_y; } else { // Copy selected tiles if (m_dragTileX != -1 && m_dragTileY != -1) { m_autoTileMap.BrushGizmo.BrushAction = new AutoTileBrush.TileAction(); int startTileX = Mathf.Min(m_startDragTileX, m_dragTileX); int startTileY = Mathf.Min(m_startDragTileY, m_dragTileY); int endTileX = Mathf.Max(m_startDragTileX, m_dragTileX); int endTileY = Mathf.Max(m_startDragTileY, m_dragTileY); for (int tile_x = startTileX; tile_x <= endTileX; ++tile_x) { for (int tile_y = startTileY; tile_y <= endTileY; ++tile_y) { // Tile position is relative to last released position ( m_dragTile ) if (Event.current.shift) { // Copy overlay only for (int i = m_autoTileMap.BrushGizmo.SelectedLayer + 1; i < m_autoTileMap.GetLayerCount(); ++i) { int tileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, i).Id; if ( (m_autoTileMap.MapLayers[i].LayerType != AutoTileMap.eLayerType.Ground) || (tileType >= 0) // this allow paste overlay tiles without removing ground or ground overlay ) { m_autoTileMap.BrushGizmo.BrushAction.Push(m_autoTileMap, tile_x - m_dragTileX, tile_y - m_dragTileY, tileType, i); } } } else { for (int i = 0; i < m_autoTileMap.GetLayerCount(); ++i) { int tileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, i).Id; m_autoTileMap.BrushGizmo.BrushAction.Push(m_autoTileMap, tile_x - m_dragTileX, tile_y - m_dragTileY, tileType, i); } } } } m_autoTileMap.BrushGizmo.RefreshBrushGizmo(startTileX, startTileY, endTileX, endTileY, m_dragTileX, m_dragTileY, Event.current.shift); m_dragTileX = m_dragTileY = -1; } } } // Draw selection rect if (m_isMouseRight) { float rX = m_autoTileMap.transform.position.x + Mathf.Min(m_startDragTileX, m_dragTileX) * m_autoTileMap.Tileset.TileWorldWidth; float rY = m_autoTileMap.transform.position.y + Mathf.Min(m_startDragTileY, m_dragTileY) * m_autoTileMap.Tileset.TileWorldHeight; float rWidth = (Mathf.Abs(m_dragTileX - m_startDragTileX) + 1) * m_autoTileMap.Tileset.TileWorldWidth; float rHeight = (Mathf.Abs(m_dragTileY - m_startDragTileY) + 1) * m_autoTileMap.Tileset.TileWorldHeight; Rect rSelection = new Rect(rX, -rY, rWidth, -rHeight); UtilsGuiDrawing.DrawRectWithOutline(rSelection, new Color(0f, 1f, 0f, 0.2f), new Color(0f, 1f, 0f, 1f)); } } }
/// <summary> /// Copy a section of the map and use it as drawing template /// </summary> /// <param name="tile_start_x"></param> /// <param name="tile_start_y"></param> /// <param name="tile_end_x"></param> /// <param name="tile_end_y"></param> /// <param name="_dragEndTileX"></param> /// <param name="_dragEndTileY"></param> /// <param name="isCtrlKeyHold"></param> public void RefreshBrushGizmo(int tile_start_x, int tile_start_y, int tile_end_x, int tile_end_y, int _dragEndTileX, int _dragEndTileY, bool isCtrlKeyHold) { Vector2 pivot = new Vector2(0f, 1f); SpriteRenderer[] aSprites = GetComponentsInChildren <SpriteRenderer>(); int sprIdx = 0; for (int tile_x = tile_start_x; tile_x <= tile_end_x; ++tile_x) { for (int tile_y = tile_start_y; tile_y <= tile_end_y; ++tile_y) { for (int tile_layer = 0; tile_layer < MyAutoTileMap.GetLayerCount(); ++tile_layer) { // if( // (isCtrlKeyHold && tile_layer == SelectedLayer) || //copy all layers over the SelectedLayer // !MyAutoTileMap.MapLayers[tile_layer].Visible // skip invisible layers // ) // { // continue; // } AutoTile autoTile = MyAutoTileMap.GetAutoTile(tile_x, tile_y, tile_layer); if (autoTile != null && autoTile.Id >= 0) { // for( int partIdx = 0; partIdx < autoTile.TilePartsLength; ++partIdx, ++sprIdx ) // { int idSlot = autoTile.Id; if (!MyAutoTileMap.Tileset.IsExitSlot(idSlot)) { continue; } var slot = MyAutoTileMap.Tileset.GetSlot(idSlot); if (!slot.IsCanCopyWhenDraw) { continue; } SpriteRenderer spriteRender = GetSpriteRenderer(aSprites, ref sprIdx); SetSpriteRendererSlot(spriteRender, slot, pivot); spriteRender.sortingOrder = 50; //TODO: +50 temporal? see for a const number later // get last tile as relative position int tilePart_x = (tile_x - _dragEndTileX) * 2; int tilePart_y = (tile_y - _dragEndTileY) * 2; float xFactor = MyAutoTileMap.CellSize.x / 2f; float yFactor = MyAutoTileMap.CellSize.y / 2f; spriteRender.transform.localPosition = new Vector3(tilePart_x * xFactor, -tilePart_y * yFactor, spriteRender.transform.position.z); spriteRender.transform.localScale = new Vector3(MyAutoTileMap.CellSize.x * AutoTileset.PixelToUnits / MyAutoTileMap.Tileset.TileWidth, MyAutoTileMap.CellSize.y * AutoTileset.PixelToUnits / MyAutoTileMap.Tileset.TileHeight, 1f); // } } } } } // clean unused sprite objects while (sprIdx < aSprites.Length) { if (Application.isEditor) { DestroyImmediate(aSprites[sprIdx].transform.gameObject); } else { Destroy(aSprites[sprIdx].transform.gameObject); } ++sprIdx; } }
void Update() { if (!m_isInitialized) { Init(); return; } #region Draw Collisions // Generate texture again in case window has been resized Vector2 screenSize = new Vector2(Screen.width, Screen.height); if (m_prevScreenSize != screenSize) { _GenerateCollisionTexture(); } m_prevScreenSize = screenSize; m_spriteCollLayer.SetActive(m_showCollisions); if (m_showCollisions && (int)(Time.timeSinceLevelLoad * 4) % 2 == 0) { SpriteRenderer sprRender = m_spriteCollLayer.GetComponent <SpriteRenderer>(); Vector3 vPos = m_camera2D.transform.position; vPos.x -= (vPos.x % (m_autoTileMap.CellSize.x / 4)); vPos.y -= (vPos.y % (m_autoTileMap.CellSize.y / 4)); vPos.z += 1f; // Collision texture position snap to a quarter of tile part sprRender.transform.position = vPos; // Collision texture pixel scaled to a quarter of tile part sprRender.transform.localScale = new Vector3((m_autoTileMap.Tileset.TilePartWidth / 2), (m_autoTileMap.Tileset.TilePartHeight / 2), 1f); vPos = m_camera2D.Camera.WorldToScreenPoint(sprRender.transform.position); // vPos = center of collision texture in screen coords Vector3 vTopLeftOff = new Vector3(sprRender.sprite.texture.width * (m_autoTileMap.Tileset.TilePartWidth / 2) / 2, -sprRender.sprite.texture.height * (m_autoTileMap.Tileset.TilePartHeight / 2) / 2) * m_camera2D.Zoom; vPos -= vTopLeftOff; vPos = m_camera2D.Camera.ScreenToWorldPoint(vPos); // vPos is now the top left corner of the collison texture in world coordinates Color32[] colors = sprRender.sprite.texture.GetPixels32(); float factorX = m_autoTileMap.CellSize.x / 4; //smallest collision part has a size of a quarter of tile part float factorY = m_autoTileMap.CellSize.y / 4; for (int y = 0; y < sprRender.sprite.texture.height; ++y) { for (int x = 0; x < sprRender.sprite.texture.width; ++x) { Vector3 vCheckPos = vPos; vCheckPos.x += (x + 0.5f) * factorX; vCheckPos.y -= (y + 0.5f) * factorY; eTileCollisionType collType = m_autoTileMap.GetAutotileCollisionAtPosition(vCheckPos); //Color32 color = (x+y)%2 == 0? new Color32(0, 0, 64, 128) : new Color32(64, 0, 0, 128) ; Color32 color = new Color32(0, 0, 0, 0); colors[(sprRender.sprite.texture.height - 1 - y) * sprRender.sprite.texture.width + x] = (collType != eTileCollisionType.PASSABLE)? new Color32(255, 0, 0, 128) : color; } } sprRender.sprite.texture.SetPixels32(colors); sprRender.sprite.texture.Apply(); } #endregion if (Input.GetKeyDown(KeyCode.Delete)) //TODO: only delete the tiles in ground layer, fix this { // select delete tile m_selectedTileIdx = -1; // Remove Brush m_autoTileMap.BrushGizmo.Clear(); m_tilesetSelStart = m_tilesetSelEnd = -1; } #region Undo / Redo if (m_isCtrlKeyHold) { if (Input.GetKeyDown(KeyCode.Z)) { m_autoTileMap.BrushGizmo.UndoAction(); } else if (Input.GetKeyDown(KeyCode.Y)) { m_autoTileMap.BrushGizmo.RedoAction(); } //+++ Key Repetition Implementation if (Input.GetKey(KeyCode.Z)) { m_keyPressTimer += Time.deltaTime; if (m_keyPressTimer >= k_timeBeforeKeyRepeat) { m_keyPressTimer -= k_timeBetweenKeyRepeat; m_autoTileMap.BrushGizmo.UndoAction(); } } else if (Input.GetKey(KeyCode.Y)) { m_keyPressTimer += Time.deltaTime; if (m_keyPressTimer >= k_timeBeforeKeyRepeat) { m_keyPressTimer -= k_timeBetweenKeyRepeat; m_autoTileMap.BrushGizmo.RedoAction(); } } else { m_keyPressTimer = 0f; } //--- } #endregion if (Input.GetKeyDown(KeyCode.M)) { m_showMinimap = !m_showMinimap; } if (Input.GetKeyDown(KeyCode.C)) { m_showCollisions = !m_showCollisions; } bool isMouseLeft = Input.GetMouseButton(0); bool isMouseRight = Input.GetMouseButton(1); bool isMouseMiddle = Input.GetMouseButton(2); bool isMouseLeftDown = Input.GetMouseButtonDown(0); bool isMouseRightDown = Input.GetMouseButtonDown(1); m_drawSelectionRect = false; Vector3 vGuiMouse = new Vector2(Input.mousePosition.x, Screen.height - Input.mousePosition.y); Vector3 vGuiMouseDelta = vGuiMouse - m_mousePrevPos; m_mousePrevPos = vGuiMouse; //+++ Set window with focus if (!isMouseLeft) { if (m_rEditorRect.Contains(vGuiMouse)) { m_focusWindow = eEditorWindow.TOOLS; } else if (m_rMinimapRect.Contains(vGuiMouse) && m_showMinimap) { m_focusWindow = eEditorWindow.MINIMAP; } // Added an extra padding to avoid drawing tiles when resizing window else if (new Rect(m_rEditorRect.x + m_rEditorRect.width + 10f, 10f, Screen.width - 20f - (m_rEditorRect.x + m_rEditorRect.width), Screen.height - 20f).Contains(vGuiMouse)) { m_focusWindow = eEditorWindow.MAPVIEW; } else { m_focusWindow = eEditorWindow.NONE; } } //--- // drag and move over the map if (isMouseMiddle) { if (m_camera2DFollowBehaviour) { m_camera2DFollowBehaviour.Target = null; } Vector3 vTemp = vGuiMouseDelta; vTemp.y = -vTemp.y; m_camera2D.transform.position -= (vTemp / 100) / m_camera2D.Zoom; } // // Inputs inside Editor Rect // if (m_rEditorRect.Contains(vGuiMouse)) { if (m_rTilesetRect.Contains(vGuiMouse)) { vGuiMouse += new Vector3(m_scrollPos.x, m_scrollPos.y); Vector3 vOff = new Vector2(vGuiMouse.x, vGuiMouse.y) - m_rTilesetRect.position; int tileX = (int)(vOff.x / k_visualTileWidth); int tileY = (int)(vOff.y / k_visualTileHeight); int autotileIdx = tileY * m_autoTileMap.Tileset.AutoTilesPerRow + tileX + (m_subTilesetIdx * 256); if (isMouseLeftDown || isMouseRightDown && m_isCtrlKeyHold) { if (m_isCtrlKeyHold) { // cycle pressed tile collision type int collType = (int)m_autoTileMap.Tileset.AutotileCollType[autotileIdx]; collType += isMouseLeftDown? 1 : (int)eTileCollisionType._SIZE - 1; collType %= (int)eTileCollisionType._SIZE; m_autoTileMap.Tileset.AutotileCollType[autotileIdx] = (eTileCollisionType)(collType); } else { // select pressed tile m_selectedTileIdx = autotileIdx; // Remove Brush m_autoTileMap.BrushGizmo.Clear(); m_tilesetSelStart = m_tilesetSelEnd = -1; } } else if (isMouseRightDown) { m_tilesetSelStart = m_tilesetSelEnd = autotileIdx; } else if (isMouseRight) { m_tilesetSelEnd = autotileIdx; } else if (m_tilesetSelStart >= 0 && m_tilesetSelEnd >= 0) { m_autoTileMap.BrushGizmo.RefreshBrushGizmoFromTileset(m_tilesetSelStart, m_tilesetSelEnd); m_tilesetSelStart = m_tilesetSelEnd = -1; } } } // // Inputs inside Minimap Rect // else if (m_showMinimap && m_rMinimapRect.Contains(vGuiMouse) && m_focusWindow == eEditorWindow.MINIMAP) { if (isMouseLeft) { float minimapScale = m_rMinimapRect.width / m_autoTileMap.MinimapTexture.width; Vector3 vPos = vGuiMouse - new Vector3(m_rMinimapRect.position.x, m_rMinimapRect.position.y); vPos.y = -vPos.y; vPos.x *= m_autoTileMap.CellSize.x / minimapScale; vPos.y *= m_autoTileMap.CellSize.y / minimapScale; vPos.z = m_camera2D.transform.position.z; m_camera2D.transform.position = vPos; if (m_camera2DFollowBehaviour) { m_camera2DFollowBehaviour.Target = null; } } } // // Insputs inside map view // else if (m_focusWindow == eEditorWindow.MAPVIEW) { Vector3 vWorldMousePos = m_autoTileMap.ViewCamera.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y)); m_autoTileMap.BrushGizmo.UpdateBrushGizmo(vWorldMousePos); if (isMouseRight || isMouseLeft) { m_drawSelectionRect = isMouseRight; //+++ Move camera automatically when near bounds if (isMouseLeft) { float fAutoDragDistX = m_rMapViewRect.width / 15; float fAutoDragDistY = m_rMapViewRect.height / 15; float fHDist = m_rMapViewRect.center.x - vGuiMouse.x; float fVDist = m_rMapViewRect.center.y - vGuiMouse.y; float fHSpeed = Mathf.Lerp(0f, -Mathf.Sign(fHDist), Mathf.Abs(fHDist) < (m_rMapViewRect.width / 2 - fAutoDragDistX)? 0 : 1f - (m_rMapViewRect.width / 2 - Mathf.Abs(fHDist)) / fAutoDragDistX); float fVSpeed = Mathf.Lerp(0f, Mathf.Sign(fVDist), Mathf.Abs(fVDist) < (m_rMapViewRect.height / 2 - fAutoDragDistY)? 0 : 1f - (m_rMapViewRect.height / 2 - Mathf.Abs(fVDist)) / fAutoDragDistY); if (fVSpeed != 0f || fHSpeed != 0f) { if (m_camera2DFollowBehaviour) { m_camera2DFollowBehaviour.Target = null; } m_camera2D.transform.position += (new Vector3(fHSpeed, fVSpeed, 0f) / 30) / m_camera2D.Zoom; } } //--- Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); Plane hPlane = new Plane(Vector3.forward, Vector3.zero); float distance = 0; if (hPlane.Raycast(ray, out distance)) { // get the hit point: Vector3 vPos = ray.GetPoint(distance); int tile_x = (int)(vPos.x / m_autoTileMap.CellSize.x); int tile_y = (int)(-vPos.y / m_autoTileMap.CellSize.y); // for optimization, is true when mouse is over a diffent tile during the first update bool isMouseTileChanged = (tile_x != m_prevMouseTileX) || (tile_y != m_prevMouseTileY); //if ( m_autoTileMap.IsValidAutoTilePos(tile_x, tile_y)) // commented to allow drawing outside map, useful when brush has a lot of copied tiles { int gndTileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, m_autoTileMap.BrushGizmo.SelectedLayer).Id; int gndOverlayTileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, m_autoTileMap.BrushGizmo.SelectedLayer + 1).Id; // mouse right for tile selection if (isMouseRightDown || isMouseRight && isMouseTileChanged) { if (isMouseRightDown) { m_startDragTileX = tile_x; m_startDragTileY = tile_y; // copy tile if (m_isCtrlKeyHold) { m_selectedTileIdx = -2; //NOTE: -2 means, ignore this tile when painting } else { m_selectedTileIdx = gndTileType >= 0? gndTileType : gndOverlayTileType; } } m_dragTileX = tile_x; m_dragTileY = tile_y; // Remove Brush m_autoTileMap.BrushGizmo.Clear(); m_tilesetSelStart = m_tilesetSelEnd = -1; } // isMouseLeft else if (isMouseLeftDown || isMouseTileChanged) // avoid Push the same action twice during mouse drag { AutoTileBrush.TileAction action = new AutoTileBrush.TileAction(); if (m_autoTileMap.BrushGizmo.BrushAction != null) { //+++ case of multiple tiles painting action.CopyRelative(m_autoTileMap, m_autoTileMap.BrushGizmo.BrushAction, tile_x, tile_y); if (m_isCtrlKeyHold && (m_autoTileMap.BrushGizmo.SelectedLayer + 1) < m_autoTileMap.GetLayerCount()) { // old functionality: ground tiles become ground overlay, ground overlay are removed, overlay tiles remains // Tiles in SelectedLayer are moved to next layer action.BecomeOverlay(m_autoTileMap.BrushGizmo.SelectedLayer); } } else { //+++ case of single tile painting // If smart brush is enabled, the tiles with collision type Overlay will be placed directly in the first overlay layer found over current SelectedLayer int overlayLayer = m_autoTileMap.FindFirstLayerIdx(eLayerType.Overlay, m_autoTileMap.BrushGizmo.SelectedLayer); if (m_autoTileMap.BrushGizmo.SmartBrushEnabled && overlayLayer >= 0 && m_selectedTileIdx >= 0 && m_autoTileMap.Tileset.AutotileCollType[m_selectedTileIdx] == eTileCollisionType.OVERLAY) { action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, overlayLayer); } else { if (m_isCtrlKeyHold || m_autoTileMap.IsAutoTileHasAlpha(m_selectedTileIdx) && m_autoTileMap.BrushGizmo.SmartBrushEnabled) { // Put tiles with alpha in the layer over Selected Layer action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, m_autoTileMap.BrushGizmo.SelectedLayer + 1); } else if (m_selectedTileIdx >= 0) { // Paint the selected tile action.Push(m_autoTileMap, tile_x, tile_y, m_selectedTileIdx, m_autoTileMap.BrushGizmo.SelectedLayer); } else //if (m_selectedTileIdx < 0) { // Delete all tiles of all layers for (int i = 0; i < m_autoTileMap.GetLayerCount(); ++i) { if ( m_autoTileMap.MapLayers[i].LayerType == eLayerType.Ground || m_autoTileMap.MapLayers[i].LayerType == eLayerType.Overlay || m_autoTileMap.MapLayers[i].LayerType == eLayerType.FogOfWar ) { action.Push(m_autoTileMap, tile_x, tile_y, -1, i); } } } } } m_autoTileMap.BrushGizmo.PerformAction(action); } } m_prevMouseTileX = tile_x; m_prevMouseTileY = tile_y; } } else { // Copy selected tiles if (m_dragTileX != -1 && m_dragTileY != -1) { m_autoTileMap.BrushGizmo.BrushAction = new AutoTileBrush.TileAction(); int startTileX = Mathf.Min(m_startDragTileX, m_dragTileX); int startTileY = Mathf.Min(m_startDragTileY, m_dragTileY); int endTileX = Mathf.Max(m_startDragTileX, m_dragTileX); int endTileY = Mathf.Max(m_startDragTileY, m_dragTileY); for (int tile_x = startTileX; tile_x <= endTileX; ++tile_x) { for (int tile_y = startTileY; tile_y <= endTileY; ++tile_y) { // Tile position is relative to last released position ( m_dragTile ) if (m_isCtrlKeyHold) { // Copy overlay only for (int i = m_autoTileMap.BrushGizmo.SelectedLayer + 1; i < m_autoTileMap.GetLayerCount(); ++i) { int tileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, i).Id; if ( (m_autoTileMap.MapLayers[i].LayerType != eLayerType.Ground) || (tileType >= 0) // this allow paste overlay tiles without removing ground or ground overlay ) { m_autoTileMap.BrushGizmo.BrushAction.Push(m_autoTileMap, tile_x - m_dragTileX, tile_y - m_dragTileY, tileType, i); } } } else { for (int i = 0; i < m_autoTileMap.GetLayerCount(); ++i) { int tileType = m_autoTileMap.GetAutoTile(tile_x, tile_y, i).Id; m_autoTileMap.BrushGizmo.BrushAction.Push(m_autoTileMap, tile_x - m_dragTileX, tile_y - m_dragTileY, tileType, i); } } } } m_autoTileMap.BrushGizmo.RefreshBrushGizmo(startTileX, startTileY, endTileX, endTileY, m_dragTileX, m_dragTileY, m_isCtrlKeyHold); m_dragTileX = m_dragTileY = -1; } if (Input.GetAxis("Mouse ScrollWheel") < 0) // back { if (m_camera2D.Zoom > 1f) { m_camera2D.Zoom = Mathf.Max(m_camera2D.Zoom - 1, 1); } else { m_camera2D.Zoom = Mathf.Max(m_camera2D.Zoom / 2f, 0.05f); } } else if (Input.GetAxis("Mouse ScrollWheel") > 0) // forward { if (m_camera2D.Zoom >= 1f) { m_camera2D.Zoom = Mathf.Min(m_camera2D.Zoom + 1, 10); } else { m_camera2D.Zoom *= 2f; } } } } }