Exemple #1
0
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        EditorGUI.BeginChangeCheck();
        serializedObject.UpdateIfRequiredOrScript();

        EditorGUILayout.PropertyField(s_type, new GUIContent("Tile Type"));
        EditorGUILayout.PropertyField(s_owner, new GUIContent("Owner"));

        serializedObject.ApplyModifiedProperties();

        if (GUILayout.Button("Update Tile"))
        {
            foreach (Object tar in targets)
            {
                Tile       tile   = null;
                TileEditor editor = tar as TileEditor;
                if (editor)
                {
                    tile = editor.GetComponent <Tile>();
                }
                if (tile)
                {
                    tile.ChangeTile(editor.editor_type, editor.editor_owner);
                }
                editor.ready_to_delete = true;
            }
            Selection.activeObject = null;
        }
    }
Exemple #2
0
    /* Здесь такое вроде не нужно будет
     * public void SetOnClickListener(Predicate<string> onClickAction)
     * {
     *  button.onClick.AddListener(delegate { onClickAction(inputField.text); });
     * }
     */
    public void ShowDialog(string[] elements, string buttonText = "Ok")
    {
        TileEditor te = GameObject.FindObjectOfType <TileEditor>();

        if (te != null)
        {
            te.SetDefault();
        }
        TilePlacer tp = GameObject.FindObjectOfType <TilePlacer>();

        if (tp != null)
        {
            tp.CancelPlacing();
        }

        dialogCanvas.SetActive(true);
        scrollRect.content.sizeDelta        = new Vector2(0, 17 * elements.Length);
        contentText.rectTransform.sizeDelta = new Vector2(160 * 4, 16 * 5 * elements.Length);
        contentText.text = "";
        foreach (string elem in elements)
        {
            contentText.text += elem + "\n";
        }
        button.GetComponentInChildren <Text>().text = buttonText;
    }
Exemple #3
0
        private void TileEditorToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (tileEditor == null)
            {
                tileEditor = new TileEditor();
                tileEditor.SetMemory(system.MemoryManager);
                system.GPU.TileEditorMode = true;
                //// Set Vicky into Tile mode
                //previousGraphicMode = system.VICKY.ReadByte(0);
                //system.VICKY.WriteByte(0, 0x10);
                //// Enable borders
                //system.VICKY.WriteByte(4, 1);
                // Set Vicky into Tile mode
                previousGraphicMode = FoenixSystem.Current.MemoryManager.ReadByte(MemoryMap.VICKY_BASE_ADDR);
                FoenixSystem.Current.MemoryManager.WriteByte(MemoryMap.VICKY_BASE_ADDR, 0x10);
                // Enable borders
                FoenixSystem.Current.MemoryManager.WriteByte(MemoryMap.VICKY_BASE_ADDR + 4, 1);
                tileEditor.Show();
                tileEditor.FormClosed += new FormClosedEventHandler(EditorWindowClosed);

                // coordinate between the tile editor window and the GPU canvas
                this.TileClicked += new TileClickEvent(tileEditor.TileClicked_Click);
            }
            else
            {
                tileEditor.BringToFront();
            }
        }
        /// <summary>
        /// Creates new Tile editor GUI configurer.
        /// </summary>
        /// <param name="editor">tile editor instance that windows and user controls will need</param>
        public TileEditorGUIConfigurer(TileEditor editor)
        {
            this.editor = editor;

            tilesetsViewModel = new TilesetsViewModel(editor);
            brushesViewModel  = new BrushesViewModel(editor, tilesetsViewModel);
        }
Exemple #5
0
        private void TileEditorToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (tileEditor == null)
            {
                tileEditor = new TileEditor();
                tileEditor.SetMemory(kernel.MemMgr);
                tileEditor.SetResourceChecker(kernel.ResCheckerRef);
                gpu.TileEditorMode = true;
                // Set Vicky into Tile mode
                previousGraphicMode = kernel.MemMgr.VICKY.ReadByte(0);
                kernel.MemMgr.VICKY.WriteByte(0, 0x10);
                // Enable borders
                kernel.MemMgr.VICKY.WriteByte(4, 1);
                CenterForm(tileEditor);
                tileEditor.Show();
                tileEditor.FormClosed += new FormClosedEventHandler(EditorWindowClosed);

                // coordinate between the tile editor window and the GPU canvas
                this.TileClicked += new TileClickEvent(tileEditor.TileClicked_Click);
            }
            else
            {
                tileEditor.BringToFront();
            }
        }
Exemple #6
0
    static void Init()
    {
        TileEditor tEditor = (TileEditor)EditorWindow.GetWindow(typeof(TileEditor));

        tEditor.Show();
        tEditor.refreshSelection();
    }
        public TilesetsView(TileEditor editor, BrushesViewModel brushesViewModel, TilesetsViewModel tilesetsViewModel)
        {
            this.editor            = editor;
            this.brushesViewModel  = brushesViewModel;
            this.tilesetsViewModel = tilesetsViewModel;

            brushesViewModel.PropertyChanged += brushesViewModel_PropertyChanged;

            // Set data context.
            DataContext = tilesetsViewModel;

            InitializeComponent();

            CollectionView collectionView = (CollectionView)CollectionViewSource.GetDefaultView(setsListView.ItemsSource);

            collectionView.SortDescriptions.Add(new SortDescription("Name", ListSortDirection.Descending));

            tileGridManager      = new TileGridManager(tileGrid, gridBorder);
            selectionGridManager = new TileGridManager(selectionGrid, selectionBorder);

            rectangles = new List <Rectangle>();

            // Hide view by default.
            tilesetView.Visibility = Visibility.Hidden;
        }
Exemple #8
0
        public BrushesViewModel(TileEditor editor, TilesetsViewModel tilesetsViewModel)
        {
            this.editor            = editor;
            this.tilesetsViewModel = tilesetsViewModel;

            tilesetsViewModel.PropertyChanged += tilesetsViewModel_PropertyChanged;
        }
Exemple #9
0
 // When the editor window is closed, exit the TileEditorMode
 private void EditorWindowClosed(object sender, FormClosedEventArgs e)
 {
     gpu.TileEditorMode = false;
     // Restore the previous graphics mode
     kernel.MemMgr.VICKY.WriteByte(0, previousGraphicMode);
     tileEditor.Dispose();
     tileEditor = null;
 }
Exemple #10
0
 // When the editor window is closed, exit the TileEditorMode
 private void EditorWindowClosed(object sender, FormClosedEventArgs e)
 {
     system.GPU.TileEditorMode = false;
     // Restore the previous graphics mode
     //system.VICKY.WriteByte(0, previousGraphicMode);
     FoenixSystem.Current.MemoryManager.WriteByte(MemoryMap.VICKY_BASE_ADDR, previousGraphicMode);
     tileEditor.Dispose();
     tileEditor = null;
 }
Exemple #11
0
 private void HideEditor()
 {
     engine.Camera.SelectedTileX = -1;
     engine.Camera.SelectedTileY = -1;
     if (editor != null)
     {
         editor.Cancel();
         editor = null;
     }
 }
Exemple #12
0
 private void MakeEditor(int x, int y)
 {
     HideEditor();
     editor = new TileEditor(this, screen, engine.Map, x, y)
     {
         CloseGadget      = true,
         DepthGadget      = true,
         WindowCloseEvent = (o, i) => { HideEditor(); }
     };
 }
 private void LoadTileEditor()
 {
     if (tileEditor == null)
     {
         tileEditor       = new TileEditor(this, new TileUpdater(), tileset.Tileset_tiles[mouseDownTile], graphics);
         tileEditor.Owner = this;
     }
     else
     {
         tileEditor.Reload(tileset.Tileset_tiles[mouseDownTile], graphics);
     }
 }
Exemple #14
0
 public void LoadTileEditor()
 {
     if (tileEditor == null)
     {
         tileEditor              = new TileEditor(this, new TileUpdater(), tileset.Tiles[mouseDownTile], tileset.Graphics);
         tileEditor.FormClosing += new FormClosingEventHandler(editor_FormClosing);
     }
     else
     {
         tileEditor.Reload(this.tileset.Tiles[mouseDownTile], tileset.Graphics);
     }
 }
Exemple #15
0
 public void LoadTileEditor()
 {
     if (tileEditor == null)
     {
         tileEditor       = new TileEditor(this, new TileUpdater(), Tileset.Tileset_tiles[MouseDownTile], Tileset.Graphics, true);
         tileEditor.Owner = this;
     }
     else
     {
         tileEditor.Reload(Tileset.Tileset_tiles[MouseDownTile], Tileset.Graphics);
     }
 }
Exemple #16
0
    public void Setup(TileEditor editor,
                      Sprite avatar,
                      System.Action save,
                      System.Action reset)
    {
        this.editor = editor;
        this.avatar = avatar;
        this.save = save;
        this.reset = reset;

        avatarImage.sprite = avatar;
    }
Exemple #17
0
 public static void SetTile(TileEditor tileEditor)
 {
     if (tileEditor == currentTileEditor)
     {
         return;
     }
     if (currentTileEditor != null)
     {
         currentTileEditor.UpdateHighLight(false);
     }
     currentTileEditor = tileEditor;
     currentTile       = tileEditor.tile;
 }
Exemple #18
0
        /// <summary>
        /// Build new tile map project from given project properties.
        /// </summary>
        public static Project BuildTileMapProject(NewProjectProperties properties, IntPtr windowHandle)
        {
            TileEngine tileEngine = new TileEngine(new Point(properties.MapWidth, properties.MapHeight),
                                                   new Point(properties.TileWidth, properties.TileHeight));

            TileEditor editor = new TileEditor(tileEngine);
            EditorGame game   = new EditorGame(windowHandle, editor);

            return(new Project(new TileEditorGUIConfigurer(editor),
                               game, editor,
                               properties.ProjectName,
                               properties.MapName,
                               properties.MapType.ToString()));
        }
Exemple #19
0
        public TilesetsViewModel(TileEditor editor)
        {
            this.editor = editor;

            editor.TilesetAdded   += editor_TilesetAdded;
            editor.TilesetRemoved += editor_TilesetRemoved;

            // Generate view models.
            tilesetViewModels = new ObservableCollection <TilesetViewModel>();

            foreach (Tileset tileset in editor.Tilesets)
            {
                tilesetViewModels.Add(new TilesetViewModel(tileset));
            }
        }
Exemple #20
0
    public UIInputBox(Vector2 position)
    {
        TileEditor te = GameObject.FindObjectOfType <TileEditor>();

        te.SetDefault();
        TilePlacer tp = GameObject.FindObjectOfType <TilePlacer>();

        tp.CancelPlacing();

        dialogCanvas = GameObject.Instantiate(Resources.Load("Prefabs/InputBoxPrefab")) as GameObject;
        dialogCanvas.transform.position = new Vector3(position.x, position.y, 0);
        button     = dialogCanvas.GetComponentInChildren <Button>();
        inputField = dialogCanvas.GetComponentInChildren <InputField>();
        title      = dialogCanvas.GetComponentInChildren <Text>();
        HideDialog();
    }
Exemple #21
0
    public void NewTile(string name)
    {
        if (name == "" && !TilesContains(name))
        {
            return;
        }
        TileEditor newTile = Instantiate(tilePrefab, transform);

        TileEditor[] newTiles = new TileEditor[tiles.Length + 1];
        for (int i = 0; i < tiles.Length; i++)
        {
            newTiles[i] = tiles[i];
        }
        newTiles[newTiles.Length - 1] = newTile;
        newTile.tile.TileData.name    = name;
        newTile.SetUp();
    }
Exemple #22
0
        public NewTileLayerDialog(TileEditor tileEditor)
        {
            this.tileEditor = tileEditor;

            // Initialize model and view.
            string[] takenNames = tileEditor.Layers
                                  .Select(s => s.Name)
                                  .ToArray();

            newTileLayerProperties          = new NewTileLayerProperties(takenNames, tileEditor.TileEngine.MaxLayerSizeInTiles.X, tileEditor.TileEngine.MaxLayerSizeInTiles.Y);
            newTileLayerPropertiesViewModel = new NewTileLayerPropertiesViewModel(newTileLayerProperties);

            // Set data context for this window.
            DataContext = newTileLayerPropertiesViewModel;

            InitializeComponent();
        }
        public NewTilesetDialog(TileEditor tileEditor)
        {
            this.tileEditor = tileEditor;

            // Get taken names.
            string[] takenNames = tileEditor.Tilesets
                                  .Select(s => s.Name)
                                  .ToArray();

            // Initialize view model.
            newTilesetProperties          = new MapEditorViewModels.NewTilesetProperties(takenNames);
            newTilesetPropertiesViewModel = new NewTilesetPropertiesViewModel(newTilesetProperties);

            // Set data context.
            DataContext = newTilesetPropertiesViewModel;

            InitializeComponent();
        }
Exemple #24
0
    public override void OnInspectorGUI()
    {
        TileEditor       myTileEditor   = (TileEditor)target;
        SerializedObject editorInstance = new SerializedObject(myTileEditor);

        editorInstance.Update();

        myTileEditor.MyWidth  = EditorGUILayout.IntField("Width", myTileEditor.MyWidth);
        myTileEditor.MyHeight = EditorGUILayout.IntField("Height", myTileEditor.MyHeight);

        if (GUILayout.Button("Generate Level"))
        {
            myTileEditor.GenerateTiles();
        }

        if (GUILayout.Button("Clear Level"))
        {
            myTileEditor.ClearTiles();
        }

        editorInstance.ApplyModifiedProperties();
    }
Exemple #25
0
        public void ShowDialog()
        {
            TileEditor te = GameObject.FindObjectOfType <TileEditor>();

            te.SetDefault();
            TilePlacer tp = GameObject.FindObjectOfType <TilePlacer>();

            tp.CancelPlacing();

            List <string> fileNames = GetFilesList();

            dialogCanvas.SetActive(true);

            for (int i = 0; i < fileNames.Count; i++)
            {
                if (!buttons.ContainsKey(fileNames[i]))
                {
                    GameObject newButton = GameObject.Instantiate(Resources.Load("Prefabs/ButtonPrefab")) as GameObject;
                    newButton.transform.position = contentField.transform.position;

                    newButton.transform.position += new Vector3(0.06f, -i * 0.55f - 0.06f, 0);
                    newButton.GetComponent <RectTransform>().SetParent(contentField.transform);
                    newButton.GetComponent <RectTransform>().localScale = new Vector3(1, 1, 1);

                    newButton.GetComponentInChildren <Text>().text = fileNames[i];

                    newButton.GetComponent <Button>().onClick.AddListener(delegate
                    {
                        ChooseLevelTask(newButton.GetComponentInChildren <Text>().text);
                    });
                    buttons.Add(fileNames[i], newButton);
                }
            }

            scrollRect.content.sizeDelta = new Vector2(0, (float)Math.Max(25 * fileNames.Count, 100.1));

            cancelButton.GetComponentInChildren <Text>().text = "Отмена";
            cancelButton.onClick.AddListener(CancelTask);
        }
Exemple #26
0
        public MapEditor()
        {
            InitializeComponent();
            tileEditor     = new TileEditor(this);
            tileController = new EditController(tileEditor);

            createMapButton.Click += createMapButton_click;
            saveMapButton.Click   += saveMapButton_Click;
            loadMapButton.Click   += loadMapButton_Click;

            rotateRight.Click += tileEditor.rotateRight;
            rotateLeft.Click  += tileEditor.rotateLeft;

            enterableTop.Click    += tileEditor.enterable_click;
            enterableBottom.Click += tileEditor.enterable_click;
            enterableLeft.Click   += tileEditor.enterable_click;
            enterableRight.Click  += tileEditor.enterable_click;
            canGoUp.Click         += tileEditor.enterable_click;
            canGoDown.Click       += tileEditor.enterable_click;

            String t = Path.GetDirectoryName(Application.ExecutablePath) + @"\Tiles\";

            if (Directory.Exists(Path.GetDirectoryName(Application.ExecutablePath) + @"\Tiles\"))
            {
                foreach (String file in Directory.GetFiles(Path.GetDirectoryName(Application.ExecutablePath) + @"\Tiles\"))
                {
                    BackgroundPanel pane = new BackgroundPanel(Image.FromFile(file));
                    pane.Click += tileEditor.backgroundImageClick;
                    BackgroundPanel.Controls.Add(pane);
                }
            }
            else
            {
                BackgroundPanel.BackColor = Color.Red;
            }
        }
Exemple #27
0
        /// <summary>Callback for drawing the Inspector GUI when there is an active GridSelection made in a Tilemap.</summary>
        public override void OnSelectionInspectorGUI()
        {
            BoundsInt selection = GridSelection.position;
            Tilemap   tilemap   = GridSelection.target.GetComponent <Tilemap>();

            int cellCount = selection.size.x * selection.size.y * selection.size.z;

            if (tilemap != null && cellCount > 0)
            {
                base.OnSelectionInspectorGUI();
                GUILayout.Space(10f);

                if (m_SelectionTiles == null || m_SelectionTiles.Length != cellCount)
                {
                    m_SelectionTiles         = new TileBase[cellCount];
                    m_SelectionColors        = new Color[cellCount];
                    m_SelectionMatrices      = new Matrix4x4[cellCount];
                    m_SelectionFlagsArray    = new TileFlags[cellCount];
                    m_SelectionSprites       = new Sprite[cellCount];
                    m_SelectionColliderTypes = new Tile.ColliderType[cellCount];
                }

                int index = 0;
                foreach (var p in selection.allPositionsWithin)
                {
                    m_SelectionTiles[index]         = tilemap.GetTile(p);
                    m_SelectionColors[index]        = tilemap.GetColor(p);
                    m_SelectionMatrices[index]      = tilemap.GetTransformMatrix(p);
                    m_SelectionFlagsArray[index]    = tilemap.GetTileFlags(p);
                    m_SelectionSprites[index]       = tilemap.GetSprite(p);
                    m_SelectionColliderTypes[index] = tilemap.GetColliderType(p);
                    index++;
                }

                EditorGUI.BeginChangeCheck();
                EditorGUI.showMixedValue = m_SelectionTiles.Any(tile => tile != m_SelectionTiles.First());
                var      position = new Vector3Int(selection.xMin, selection.yMin, selection.zMin);
                TileBase newTile  = EditorGUILayout.ObjectField(Styles.tileLabel, tilemap.GetTile(position), typeof(TileBase), false) as TileBase;
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(tilemap, "Edit Tilemap");
                    foreach (var p in selection.allPositionsWithin)
                    {
                        tilemap.SetTile(p, newTile);
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = m_SelectionSprites.Any(sprite => sprite != m_SelectionSprites.First());
                    EditorGUILayout.ObjectField(Styles.spriteLabel, m_SelectionSprites[0], typeof(Sprite), false, GUILayout.Height(EditorGUI.kSingleLineHeight));
                }

                bool colorFlagsAllEqual = m_SelectionFlagsArray.All(flags => (flags & TileFlags.LockColor) == (m_SelectionFlagsArray.First() & TileFlags.LockColor));
                using (new EditorGUI.DisabledScope(!colorFlagsAllEqual || (m_SelectionFlagsArray[0] & TileFlags.LockColor) != 0))
                {
                    EditorGUI.showMixedValue = m_SelectionColors.Any(color => color != m_SelectionColors.First());
                    EditorGUI.BeginChangeCheck();
                    Color newColor = EditorGUILayout.ColorField(Styles.colorLabel, m_SelectionColors[0]);
                    if (EditorGUI.EndChangeCheck())
                    {
                        Undo.RecordObject(tilemap, "Edit Tilemap");
                        foreach (var p in selection.allPositionsWithin)
                        {
                            tilemap.SetColor(p, newColor);
                        }
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = m_SelectionColliderTypes.Any(colliderType => colliderType != m_SelectionColliderTypes.First());
                    EditorGUILayout.EnumPopup(Styles.colliderTypeLabel, m_SelectionColliderTypes[0]);
                }

                bool transformFlagsAllEqual = m_SelectionFlagsArray.All(flags => (flags & TileFlags.LockTransform) == (m_SelectionFlagsArray.First() & TileFlags.LockTransform));
                using (new EditorGUI.DisabledScope(!transformFlagsAllEqual || (m_SelectionFlagsArray[0] & TileFlags.LockTransform) != 0))
                {
                    EditorGUI.showMixedValue = m_SelectionMatrices.Any(matrix => matrix != m_SelectionMatrices.First());
                    EditorGUI.BeginChangeCheck();
                    Matrix4x4 newTransformMatrix = TileEditor.TransformMatrixOnGUI(m_SelectionMatrices[0]);
                    if (EditorGUI.EndChangeCheck())
                    {
                        Undo.RecordObject(tilemap, "Edit Tilemap");
                        foreach (var p in selection.allPositionsWithin)
                        {
                            tilemap.SetTransformMatrix(p, newTransformMatrix);
                        }
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = !colorFlagsAllEqual;
                    EditorGUILayout.Toggle(Styles.lockColorLabel, (m_SelectionFlagsArray[0] & TileFlags.LockColor) != 0);
                    EditorGUI.showMixedValue = !transformFlagsAllEqual;
                    EditorGUILayout.Toggle(Styles.lockTransformLabel, (m_SelectionFlagsArray[0] & TileFlags.LockTransform) != 0);
                }

                EditorGUI.showMixedValue = false;
            }
        }
Exemple #28
0
    void TileManagerTools()
    {
        if (Grid == null)
        {
            return;
        }

        if (Selection.activeGameObject != null &&
            Selection.activeGameObject != Grid.gameObject &&
            Selection.activeGameObject.GetComponent <TileManager>() != null &&
            GUILayout.Button("Append Grid Test", GUILayout.Width(100))
            )
        {
            Grid.AppendGrid(Selection.activeGameObject.GetComponent <TileManager>());
        }


        if (GUILayout.Button("Spawn Random Region"))
        {
            //  WorldExtender.SpawnRegion(  RegionLoader.GetWeightedRegionForLevel(0, new List<RegionConfig>()), Grid);

            if (CurrentTileSelection != null)
            {
                CurrentTileSelection.Clear();
            }
        }

        if (GUILayout.Button("Spawn Next Region"))
        {
            WorldExtender.Instance.SpawnNext();

            if (CurrentTileSelection != null)
            {
                CurrentTileSelection.Clear();
            }
        }

        if (GUILayout.Button("Spawn Camp Region"))
        {
            // WorldExtender.SpawnRegion(RegionLoader.GetCamp(0), Grid);

            if (CurrentTileSelection != null)
            {
                CurrentTileSelection.Clear();
            }
        }

        if (GUILayout.Button("Select All"))
        {
            CurrentTileSelection.Clear();
            CurrentTileSelection.AddRange(Grid.GetTileList());
            SelectCurrentTilesInEditor();
        }
        if (GUILayout.Button("Select Border"))
        {
            List <Tile> border = TileManager.GetBorderTiles(CurrentTileSelection, Grid, true);
            CurrentTileSelection.Clear();
            CurrentTileSelection.AddRange(border);
            SelectCurrentTilesInEditor();
        }


        if (GUILayout.Button("Show Current Crumble Weights"))
        {
            if (weighted == null)
            {
                weighted = TileWeighted.GetWeightedTiles(Grid);
            }
            else
            {
                weighted = null;
            }
            SceneView.RepaintAll();
        }

        if (GUILayout.Button("Reset Tile Visual States"))
        {
            foreach (Tile t in Grid.FetchTiles())
            {
                t.SetBaseState();
            }
        }

        if (Application.isPlaying && GUILayout.Button("Test Crumble"))
        {
            TileWeighted.GetCrumbleTiles(20, Grid).ForEach(t => t.StartCrumble());

            //  MDebug.Log(Grid.GetLastActiveRow());

            Grid.GetTileList().ForEach(t => t.OnCrumbleTurn(0));
            SceneView.RepaintAll();
        }

        if (GUILayout.Button("Spawn Meshes"))
        {
            List <Tile> tiles = Grid.GetTileList();
            foreach (Tile t in tiles)
            {
                TileEditor.SpawnMesh(t);
            }
            SceneView.RepaintAll();
        }

        if (GUILayout.Button("Bake"))
        {
            BakeGrid.Bake(Grid);
            SceneView.RepaintAll();
        }
    }
Exemple #29
0
 void OnEnable()
 {
     tileEditor = (TileEditor)target;
 }
Exemple #30
0
 void Start()
 {
     levelmanager = GameObject.Find("Level1Manager");
     editor       = levelmanager.GetComponent <TileEditor>();
 }
    private void EditButtonPressed(object sender, EventArgs e)
    {
        TileEditor form = new TileEditor(textureList.SelectedItems[0] as TextureItem);

        form.ShowDialog();
    }
Exemple #32
0
        /// <summary>Callback for drawing the Inspector GUI when there is an active GridSelection made in a Tilemap.</summary>
        public override void OnSelectionInspectorGUI()
        {
            BoundsInt selection = GridSelection.position;
            Tilemap   tilemap   = GridSelection.target.GetComponent <Tilemap>();

            int cellCount = selectionCellCount;

            if (tilemap != null && cellCount > 0)
            {
                base.OnSelectionInspectorGUI();

                if (!EditorGUIUtility.editingTextField &&
                    Event.current.type == EventType.KeyDown &&
                    (Event.current.keyCode == KeyCode.Delete ||
                     Event.current.keyCode == KeyCode.Backspace))
                {
                    DeleteSelection(tilemap, selection);
                    Event.current.Use();
                }

                GUILayout.Space(10f);

                EditorGUILayout.LabelField(Styles.gridSelectionPropertiesLabel, EditorStyles.boldLabel);

                UpdateSelection(tilemap);

                EditorGUI.BeginChangeCheck();
                EditorGUI.showMixedValue = m_SelectionTiles.Any(tile => tile != m_SelectionTiles.First());
                var      position = new Vector3Int(selection.xMin, selection.yMin, selection.zMin);
                TileBase newTile  = EditorGUILayout.ObjectField(Styles.tileLabel, tilemap.GetTile(position), typeof(TileBase), false) as TileBase;
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObject(tilemap, "Edit Tilemap");
                    foreach (var p in selection.allPositionsWithin)
                    {
                        tilemap.SetTile(p, newTile);
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = m_SelectionSprites.Any(sprite => sprite != m_SelectionSprites.First());
                    EditorGUILayout.ObjectField(Styles.spriteLabel, m_SelectionSprites[0], typeof(Sprite), false, GUILayout.Height(EditorGUI.kSingleLineHeight));
                }

                bool colorFlagsAllEqual = m_SelectionFlagsArray.All(flags => (flags & TileFlags.LockColor) == (m_SelectionFlagsArray.First() & TileFlags.LockColor));
                using (new EditorGUI.DisabledScope(!colorFlagsAllEqual || (m_SelectionFlagsArray[0] & TileFlags.LockColor) != 0))
                {
                    EditorGUI.showMixedValue = m_SelectionColors.Any(color => color != m_SelectionColors.First());
                    EditorGUI.BeginChangeCheck();
                    Color newColor = EditorGUILayout.ColorField(Styles.colorLabel, m_SelectionColors[0]);
                    if (EditorGUI.EndChangeCheck())
                    {
                        Undo.RecordObject(tilemap, "Edit Tilemap");
                        foreach (var p in selection.allPositionsWithin)
                        {
                            tilemap.SetColor(p, newColor);
                        }
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = m_SelectionColliderTypes.Any(colliderType => colliderType != m_SelectionColliderTypes.First());
                    EditorGUILayout.EnumPopup(Styles.colliderTypeLabel, m_SelectionColliderTypes[0]);
                }

                bool transformFlagsAllEqual = m_SelectionFlagsArray.All(flags => (flags & TileFlags.LockTransform) == (m_SelectionFlagsArray.First() & TileFlags.LockTransform));
                using (new EditorGUI.DisabledScope(!transformFlagsAllEqual || (m_SelectionFlagsArray[0] & TileFlags.LockTransform) != 0))
                {
                    EditorGUI.showMixedValue = m_SelectionMatrices.Any(matrix => matrix != m_SelectionMatrices.First());
                    EditorGUI.BeginChangeCheck();
                    Matrix4x4 newTransformMatrix = TileEditor.TransformMatrixOnGUI(m_SelectionMatrices[0]);
                    if (EditorGUI.EndChangeCheck())
                    {
                        Undo.RecordObject(tilemap, "Edit Tilemap");
                        foreach (var p in selection.allPositionsWithin)
                        {
                            tilemap.SetTransformMatrix(p, newTransformMatrix);
                        }
                    }
                }

                using (new EditorGUI.DisabledScope(true))
                {
                    EditorGUI.showMixedValue = !colorFlagsAllEqual;
                    EditorGUILayout.Toggle(Styles.lockColorLabel, (m_SelectionFlagsArray[0] & TileFlags.LockColor) != 0);
                    EditorGUI.showMixedValue = !transformFlagsAllEqual;
                    EditorGUILayout.Toggle(Styles.lockTransformLabel, (m_SelectionFlagsArray[0] & TileFlags.LockTransform) != 0);
                }

                EditorGUI.showMixedValue = false;

                if (GUILayout.Button(Styles.deleteSelectionLabel))
                {
                    DeleteSelection(tilemap, selection);
                }

                EditorGUILayout.Space();
                EditorGUILayout.LabelField(Styles.modifyTilemapLabel, EditorStyles.boldLabel);
                EditorGUILayout.Space();

                EditorGUI.BeginChangeCheck();
                m_SelectedTransformTool = GUILayout.Toolbar(m_SelectedTransformTool, Styles.selectionTools);
                if (EditorGUI.EndChangeCheck())
                {
                    SceneView.RepaintAll();
                }
                EditorGUILayout.Space();

                GUILayout.BeginHorizontal();
                m_ModifyCells = (ModifyCells)EditorGUILayout.EnumPopup(m_ModifyCells);
                m_CellCount   = EditorGUILayout.IntField(m_CellCount);
                if (GUILayout.Button(Styles.modifyLabel))
                {
                    RegisterUndoForTilemap(tilemap, Enum.GetName(typeof(ModifyCells), m_ModifyCells));
                    switch (m_ModifyCells)
                    {
                    case ModifyCells.InsertRow:
                    {
                        tilemap.InsertCells(GridSelection.position.position, 0, m_CellCount, 0);
                        break;
                    }

                    case ModifyCells.InsertRowBefore:
                    {
                        tilemap.InsertCells(GridSelection.position.position, 0, -m_CellCount, 0);
                        break;
                    }

                    case ModifyCells.InsertColumn:
                    {
                        tilemap.InsertCells(GridSelection.position.position, m_CellCount, 0, 0);
                        break;
                    }

                    case ModifyCells.InsertColumnBefore:
                    {
                        tilemap.InsertCells(GridSelection.position.position, -m_CellCount, 0, 0);
                        break;
                    }

                    case ModifyCells.DeleteRow:
                    {
                        tilemap.DeleteCells(GridSelection.position.position, 0, m_CellCount, 0);
                        break;
                    }

                    case ModifyCells.DeleteRowBefore:
                    {
                        tilemap.DeleteCells(GridSelection.position.position, 0, -m_CellCount, 0);
                        break;
                    }

                    case ModifyCells.DeleteColumn:
                    {
                        tilemap.DeleteCells(GridSelection.position.position, m_CellCount, 0, 0);
                        break;
                    }

                    case ModifyCells.DeleteColumnBefore:
                    {
                        tilemap.DeleteCells(GridSelection.position.position, -m_CellCount, 0, 0);
                        break;
                    }
                    }
                }
                GUILayout.EndHorizontal();
            }
        }