스크립터블 타일 생성

이 페이지의 코드 예시는 스크립터블 타일을 직접 만들고 프로젝트에서 사용하는 방법을 보여줍니다. PipelineExampleTile 스크립터블 타일은 타일맵에 선형 세그먼트를 레이아웃하는 데 사용할 수 있는 타일의 하나로서, 페인트할 때 자동으로 해당 세그먼트가 연결됩니다. 이는 도로나 파이프를 구현하는 타일을 디자인할 때 매우 유용합니다.

프로젝트의 스크립터블 타일을 생성하려면 다음 단계를 따르십시오.

스크립트를 사용하여 스크립터블 타일과 동작을 생성
스크립터블 타일로 페인트하기

선행 조건

작업을 진행하기 전에 2D Tilemap Editor 패키지를 설치해야 합니다. 이 패키지는 2D 기능 집합의 일부이며 새 프로젝트를 생성할 때 2D 템플릿 중 하나를 선택하면 자동으로 설치됩니다. 또한 Unity의 패키지 관리자를 통해 이 패키지를 수동으로 설치할 수도 있습니다.

스크립트를 사용해 스크립터블 타일 생성

PipelineExampleTile 스크립터블 타일을 만들고 UnityEditor의 Asset 메뉴에서 사용할 수 있는 옵션으로 만들려면 다음 과정을 따르십시오.

Assets > Create > MonoBehaviour Script로 이동해 빈 MonoBehaviour 스크립트를 생성합니다.
파일 이름을 PipelineExampleTile.cs로 지정합니다.
텍스트 편집기에서 파일을 엽니다.
기존 코드를 다음으로 대체한 뒤 파일을 저장합니다.

using System;

#if UNITY_EDITOR
using UnityEditor;
#endif


namespace UnityEngine.Tilemaps
{
   /// <summary>
   /// Pipeline Tiles are tiles which take into consideration its orthogonal neighboring tiles and displays a sprite depending on whether the neighboring tile is the same tile.
   /// </summary>
   [Serializable]
   public class PipelineExampleTile : TileBase
   {
       /// <summary>
       /// The Sprites used for defining the Pipeline.
       /// </summary>
       [SerializeField]
       public Sprite[] m_Sprites;


       /// <summary>
       /// This method is called when the tile is refreshed. The PipelineExampleTile will refresh all neighboring tiles to update their rendering data if they are the same tile.
       /// </summary>
       /// <param name="position">Position of the tile on the Tilemap.</param>
       /// <param name="tilemap">The Tilemap the tile is present on.</param>
       public override void RefreshTile(Vector3Int position, ITilemap tilemap)
       {
           for (int yd = -1; yd <= 1; yd++)
               for (int xd = -1; xd <= 1; xd++)
               {
                   Vector3Int pos = new Vector3Int(position.x + xd, position.y + yd, position.z);
                   if (TileValue(tilemap, pos))
                       tilemap.RefreshTile(pos);
               }
       }


       /// <summary>
       /// Retrieves any tile rendering data from the scripted tile.
       /// </summary>
       /// <param name="position">Position of the tile on the Tilemap.</param>
       /// <param name="tilemap">The Tilemap the tile is present on.</param>
       /// <param name="tileData">Data to render the tile.</param>
       public override void GetTileData(Vector3Int position, ITilemap tilemap, ref TileData tileData)
       {
           UpdateTile(position, tilemap, ref tileData);
       }


       /// <summary>
       /// Checks the orthogonal neighbouring positions of the tile and generates a mask based on whether the neighboring tiles are the same. The mask will determine the according Sprite and transform to be rendered at the given position. The Sprite and Transform is then filled into TileData for the Tilemap to use. The Flags lock the color and transform to the data provided by the tile. The ColliderType is set to the shape of the Sprite used.
       /// </summary>
       private void UpdateTile(Vector3Int position, ITilemap tilemap, ref TileData tileData)
       {
           tileData.transform = Matrix4x4.identity;
           tileData.color = Color.white;


           int mask = TileValue(tilemap, position + new Vector3Int(0, 1, 0)) ? 1 : 0;
           mask += TileValue(tilemap, position + new Vector3Int(1, 0, 0)) ? 2 : 0;
           mask += TileValue(tilemap, position + new Vector3Int(0, -1, 0)) ? 4 : 0;
           mask += TileValue(tilemap, position + new Vector3Int(-1, 0, 0)) ? 8 : 0;


           int index = GetIndex((byte)mask);
           if (index >= 0 && index < m_Sprites.Length && TileValue(tilemap, position))
           {
               tileData.sprite = m_Sprites[index];
               tileData.transform = GetTransform((byte)mask);
               tileData.flags = TileFlags.LockTransform | TileFlags.LockColor;
               tileData.colliderType = Tile.ColliderType.Sprite;
           }
       }


       /// <summary>
       /// Determines if the tile at the given position is the same tile as this.
       /// </summary>
       private bool TileValue(ITilemap tileMap, Vector3Int position)
       {
           TileBase tile = tileMap.GetTile(position);
           return (tile != null && tile == this);
       }


       /// <summary>
       /// Determines the index of the Sprite to be used based on the neighbour mask.
       /// </summary>
       private int GetIndex(byte mask)
       {
           switch (mask)
           {
               case 0: return 0;
               case 3:
               case 6:
               case 9:
               case 12: return 1;
               case 1:
               case 2:
               case 4:
               case 5:
               case 10:
               case 8: return 2;
               case 7:
               case 11:
               case 13:
               case 14: return 3;
               case 15: return 4;
           }
           return -1;
       }


       /// <summary>
       /// Determines the Transform to be used based on the neighbour mask.
       /// </summary>
       private Matrix4x4 GetTransform(byte mask)
       {
           switch (mask)
           {
               case 9:
               case 10:
               case 7:
               case 2:
               case 8:
                   return Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, -90f), Vector3.one);
               case 3:
               case 14:
                   return Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, -180f), Vector3.one);
               case 6:
               case 13:
                   return Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, -270f), Vector3.one);
           }
           return Matrix4x4.identity;
       }
   }
  
#if UNITY_EDITOR
   /// <summary>
   /// Custom Editor for a PipelineExampleTile. This is shown in the Inspector window when a PipelineExampleTile asset is selected.
   /// </summary>
   [CustomEditor(typeof(PipelineExampleTile))]
   public class PipelineExampleTileEditor : Editor
   {
       private PipelineExampleTile tile { get { return (target as PipelineExampleTile); } }


       public void OnEnable()
       {
           if (tile.m_Sprites == null || tile.m_Sprites.Length != 5)
               tile.m_Sprites = new Sprite[5];
       }


       /// <summary>
       /// Draws an Inspector for the PipelineExampleTile.
       /// </summary>
       public override void OnInspectorGUI()
       {
           EditorGUILayout.LabelField("Place sprites shown based on the number of tiles bordering it.");
           EditorGUILayout.Space();
          
           EditorGUI.BeginChangeCheck();
           tile.m_Sprites[0] = (Sprite) EditorGUILayout.ObjectField("None", tile.m_Sprites[0], typeof(Sprite), false, null);
           tile.m_Sprites[2] = (Sprite) EditorGUILayout.ObjectField("One", tile.m_Sprites[2], typeof(Sprite), false, null);
           tile.m_Sprites[1] = (Sprite) EditorGUILayout.ObjectField("Two", tile.m_Sprites[1], typeof(Sprite), false, null);
           tile.m_Sprites[3] = (Sprite) EditorGUILayout.ObjectField("Three", tile.m_Sprites[3], typeof(Sprite), false, null);
           tile.m_Sprites[4] = (Sprite) EditorGUILayout.ObjectField("Four", tile.m_Sprites[4], typeof(Sprite), false, null);
           if (EditorGUI.EndChangeCheck())
               EditorUtility.SetDirty(tile);
       }


       /// <summary>
       /// The following is a helper that adds a menu item to create a PipelineExampleTile Asset in the project.
       /// </summary>
       [MenuItem("Assets/Create/PipelineExampleTile")]
       public static void CreatePipelineExampleTile()
       {
           string path = EditorUtility.SaveFilePanelInProject("Save Pipeline Example Tile", "New Pipeline Example Tile", "Asset", "Save Pipeline Example Tile", "Assets");
           if (path == "")
               return;                           
           AssetDatabase.CreateAsset(ScriptableObject.CreateInstance<PipelineExampleTile>(), path);
        }
   }
#endif
}

이제 해당 스크립터블 타일을 사용해야 할 때마다 ScriptableObject.CreateInstance<YOUR_TILE_CLASS>()를 사용하여 새 클래스의 인스턴스를 생성할 수 있습니다. 또한 이 새 인스턴스를 에디터에서 에셋으로 전환하면 AssetDatabase.CreateAsset()를 호출하여 반복적으로 사용할 수 있습니다.

스크립터블 타일로 페인트

프로젝트에 PipelineExampleTile.cs 스크립트를 임포트하거나 저장한 후에는 PipelineExampleTile 타일 에셋을 생성할 수 있습니다.

PipelineExampleTile 타일로 페인팅하려면 다음과 같이 하십시오.

PipelineExampleTile 타일 에셋을 생성합니다(메뉴: Assets > Create > PipelineExampleTile).
생성된 타일 에셋을 선택하고 해당 인스펙터 창으로 이동합니다.
인접한 타일의 수에 따라 PipelineExampleTile을 스프라이트를 채웁니다. 예를 들어 One의 스프라이트에는 한 개의 열린 방향, Three의 스프라이트에는 스프라이트의 가장자리를 따라 세 개의 열린 방향이 있습니다. 참고: 자체 스프라이트를 사용하는 경우 위치와 방향을 다음 예시와 동일하게 하는 것이 좋습니다.
프로젝트를 저장하여 타일에 적용된 변경 사항을 저장합니다.
프로젝트 창의 타일 에셋을 Tile Palette 에디터 창의 타일 팔레트로 드래그하여 타일을 타일 팔레트에 추가합니다.
페인트 툴을 스크립터블 타일과 함께 사용하여 타일맵에 페인트합니다.