Наследование: MonoBehaviour
Пример #1
0
        /// <summary>
        ///     Gets the style for the given tile.
        /// </summary>
        /// <param name="tile">The tile.</param>
        /// <param name="styles">The styles to choose from.</param>
        /// <param name="state">The style state associated with the tile.</param>
        /// <returns></returns>
        protected override IStyle GetStyle(TileBase tile, IStyle[] styles, ref object state)
        {
            Debug.Assert(tile != null, "tile != null");
            Debug.Assert(styles != null, "styles != null");

            if (styles.Length < 1) return null;

            Vector2 coords = tile.Centroid.Round(3);

            float random = TileRandom.Random(Seed, coords.X, coords.Y);

            // ReSharper disable once CompareOfFloatsByEqualityOperator
            if (random == 1) return styles[styles.Length - 1];

            return styles[(int) (random * styles.Length)];
        }
        /// <summary>
        ///     Gets the style for the given tile.
        /// </summary>
        /// <param name="tile">The tile.</param>
        /// <param name="styles">The styles to choose from.</param>
        /// <param name="state">The style state associated with the tile.</param>
        /// <returns></returns>
        protected override IStyle GetStyle(TileBase tile, IStyle[] styles, ref object state)
        {
            IStyle[] unusedStyles = styles.Except(tile.AdjacentTiles.Values.Select(t => t.Style)).ToArray();

            if (unusedStyles.Length == 0)
                return base.GetStyle(tile, styles, ref state);

            if (unusedStyles.Length == 1)
            {
                Vector2 coords = tile.Centroid.Round(3);

                float random = TileRandom.Random(Seed, coords.X, coords.Y);

                return random > (1f / styles.Length)
                    ? unusedStyles[0]
                    : base.GetStyle(tile, styles, ref state);
            }

            return base.GetStyle(tile, unusedStyles, ref state);
        }
Пример #3
0
 public Item(string name, int id, string desc, Sprite icon, GameObject model, int maxStack, ItemType type, string sendmessagetext, List <ItemAttribute> itemAttributes, TileBase aT)                 //function to create a instance of the Item
 {
     itemName            = name;
     itemID              = id;
     itemDesc            = desc;
     itemIcon            = icon;
     itemModel           = model;
     itemType            = type;
     this.maxStack       = maxStack;
     this.itemAttributes = itemAttributes;
     this.assetTile      = aT;
 }
        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;
            }
        }
Пример #5
0
 public void SetTile(TileBase tile)
 {
     _tile = tile;
 }
Пример #6
0
    public void DrawShootInput(List <Point> range)
    {
        TileBase tile = ResourceManager.Instance.TileBases[(int)TileType.Shoot];

        DrawTileOnLayer(range, Layers.Temporary, tile);
    }
Пример #7
0
        /// <summary>
        ///     Selects a tile from the tiling.
        /// </summary>
        /// <param name="initialTile">The initial tile.</param>
        /// <returns></returns>
        /// <exception cref="System.ObjectDisposedException"></exception>
        private Task<TileBase> SelectTileAsync(TileBase initialTile)
        {
            TilingController controller = _tilingController;
            if (controller == null) return Task.FromResult<TileBase>(null);

            _selectTileTool.LastTool = controller.CurrentTool;
            _selectTileTool.TileSelectedTcs = new TaskCompletionSource<TileBase>();
            controller.CurrentTool = _selectTileTool;
            return _selectTileTool.TileSelectedTcs.Task;
        }
    public static Tile GetRight(TileBase t)
    {
        if (t.i >= max_i)
                return null;

            return PathFinder.matrix[t.i + 1, t.j];
    }
Пример #9
0
        private Vector3Int PlaceTilesToTheRight(Vector3Int currentPos, Vector3Int targetPos, TileBase tileToPlace)
        {
            var howManyToTheRight = targetPos.x - currentPos.x;

            for (int i = 0; i < howManyToTheRight; i++)
            {
                currentPos += Vector3Int.right;
                _map.SetTile(currentPos, tileToPlace);
            }

            var lastPosition = currentPos;

            return(lastPosition);
        }
Пример #10
0
        public override TileBase GetTile(Vector3Int position)
        {
            TileBase editorPreviewTile = this.m_Tilemap.GetEditorPreviewTile(position);

            return(editorPreviewTile ?? this.m_Tilemap.GetTile(position));
        }
Пример #11
0
        public override TileFlags GetTileFlags(Vector3Int position)
        {
            TileBase editorPreviewTile = this.m_Tilemap.GetEditorPreviewTile(position);

            return((!editorPreviewTile) ? this.m_Tilemap.GetTileFlags(position) : this.m_Tilemap.GetEditorPreviewTileFlags(position));
        }
Пример #12
0
        public override Matrix4x4 GetTransformMatrix(Vector3Int position)
        {
            TileBase editorPreviewTile = this.m_Tilemap.GetEditorPreviewTile(position);

            return((!editorPreviewTile) ? this.m_Tilemap.GetTransformMatrix(position) : this.m_Tilemap.GetEditorPreviewTransformMatrix(position));
        }
Пример #13
0
        public override Color GetColor(Vector3Int position)
        {
            TileBase editorPreviewTile = this.m_Tilemap.GetEditorPreviewTile(position);

            return((!editorPreviewTile) ? this.m_Tilemap.GetColor(position) : this.m_Tilemap.GetEditorPreviewColor(position));
        }
Пример #14
0
        public override Sprite GetSprite(Vector3Int position)
        {
            TileBase editorPreviewTile = this.m_Tilemap.GetEditorPreviewTile(position);

            return((!editorPreviewTile) ? this.m_Tilemap.GetSprite(position) : this.m_Tilemap.GetEditorPreviewSprite(position));
        }
Пример #15
0
 public static void BoxFill(this Tilemap map, TileBase tile, Vector3 start, Vector3 end)
 {
     BoxFill(map, tile, map.WorldToCell(start), map.WorldToCell(end));
 }
    public static Tile GetLeft(TileBase t)
    {
        if(t.i <= 0)
                return null;

            return PathFinder.matrix[t.i -1, t.j];
    }
Пример #17
0
        private void OnSceneGUIDelegate(SceneView sceneView)
        {
            Event current = Event.current;

            if (current.type == EventType.DragUpdated || current.type == EventType.DragPerform || current.type == EventType.DragExited || current.type == EventType.Repaint)
            {
                Grid activeGrid = TileDragAndDropManager.GetActiveGrid();
                if (!(activeGrid == null) && DragAndDrop.objectReferences.Length != 0)
                {
                    Vector3    localPosition = GridEditorUtility.ScreenToLocal(activeGrid.transform, current.mousePosition);
                    Vector3Int a             = activeGrid.LocalToCell(localPosition);
                    EventType  type          = current.type;
                    if (type != EventType.DragUpdated)
                    {
                        if (type != EventType.DragPerform)
                        {
                            if (type == EventType.Repaint)
                            {
                                if (ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData != null)
                                {
                                    Tilemap componentInParent = Selection.activeGameObject.GetComponentInParent <Tilemap>();
                                    if (componentInParent != null)
                                    {
                                        componentInParent.ClearAllEditorPreviewTiles();
                                    }
                                    DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                                    foreach (KeyValuePair <Vector2Int, UnityEngine.Object> current2 in ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData)
                                    {
                                        Vector3Int position = a + new Vector3Int(current2.Key.x, current2.Key.y, 0);
                                        if (current2.Value is TileBase)
                                        {
                                            TileBase tile = current2.Value as TileBase;
                                            if (componentInParent != null)
                                            {
                                                componentInParent.SetEditorPreviewTile(position, tile);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else if (ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData.Count > 0)
                        {
                            DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                            Dictionary <Vector2Int, TileBase> dictionary = TileDragAndDrop.ConvertToTileSheet(ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData);
                            Tilemap orCreateActiveTilemap = TileDragAndDropManager.GetOrCreateActiveTilemap();
                            orCreateActiveTilemap.ClearAllEditorPreviewTiles();
                            foreach (KeyValuePair <Vector2Int, TileBase> current3 in dictionary)
                            {
                                Vector3Int position2 = new Vector3Int(a.x + current3.Key.x, a.y + current3.Key.y, 0);
                                orCreateActiveTilemap.SetTile(position2, current3.Value);
                            }
                            ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData = null;
                            GUI.changed = true;
                            Event.current.Use();
                        }
                    }
                    else
                    {
                        DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                        List <TileBase> validTiles = TileDragAndDrop.GetValidTiles(DragAndDrop.objectReferences);
                        ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData = TileDragAndDrop.CreateHoverData(null, null, validTiles);
                        if (ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData.Count > 0)
                        {
                            Event.current.Use();
                            GUI.changed = true;
                        }
                    }
                    if (ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData != null && (Event.current.type == EventType.DragExited || (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape)))
                    {
                        if (ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData.Count > 0)
                        {
                            Tilemap componentInParent2 = Selection.activeGameObject.GetComponentInParent <Tilemap>();
                            if (componentInParent2 != null)
                            {
                                componentInParent2.ClearAllEditorPreviewTiles();
                            }
                            Event.current.Use();
                        }
                        ScriptableSingleton <TileDragAndDropManager> .instance.m_HoverData = null;
                    }
                }
            }
        }
Пример #18
0
            /// <summary>
            ///     Called when the highlighted location (ie the cursor location) changes.
            /// </summary>
            /// <param name="rawLocation">
            ///     The raw location.
            ///     Should be transformed by the <see cref="IView.InverseViewMatrix" /> for the
            ///     <see cref="Controller">Controllers</see> <see cref="EscherTiler.Controllers.Controller.View" /> to get the
            ///     location in the tiling itself.
            /// </param>
            public override void UpdateLocation(Vector2 rawLocation)
            {
                base.UpdateLocation(rawLocation);

                _hoverTile = GetTileOver(rawLocation);
            }
Пример #19
0
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="x">基于(0,0),在地图上X的相对位置</param>
 /// <param name="y">基于(0,0),在地图上Y的相对位置</param>
 /// <param name="tile">对应的色块</param>
 public LogicTile(int x, int y, TileBase tile)
 {
     X    = x;
     Y    = y;
     Tile = tile;
 }
Пример #20
0
        /// <summary>
        ///     Gets the style for the given tile.
        /// </summary>
        /// <param name="tile">The tile.</param>
        /// <param name="styles">The styles to choose from.</param>
        /// <param name="state">The style state associated with the tile.</param>
        /// <returns></returns>
        protected override IStyle GetStyle(TileBase tile, IStyle[] styles, ref object state)
        {
            // ReSharper disable once AssignNullToNotNullAttribute
            TileBase[] neighbours = tile.AdjacentTiles.Values.Distinct().ToArray();

            State st = GetTileState(ref state);

            IStyle style = null;

            int offset = st.Offset;
            for (int i = 0; i < styles.Length; i++)
            {
                style = styles[offset % styles.Length];
                if (neighbours.All(n => n.Style != style))
                    break;

                style = null;
                offset += ParamC;
            }

            if (style == null)
            {
                style = styles[offset % styles.Length];
                offset += ParamB;
                st.Offset = offset;
            }

            foreach (TileBase neighbour in neighbours)
            {
                Debug.Assert(neighbour != null, "neighbour != null");

                GetTileState(neighbour).Offset = offset;
                offset += ParamA;
            }

            return style;
        }
Пример #21
0
        public PlanetData(TileBase dirt, TileBase sand, TileBase stone, TileBase rare, TileBase medium, TileBase common)
        {
            dirtTile  = dirt;
            sandTile  = sand;
            stoneTile = stone;

            rareOre   = rare;
            mediumOre = medium;
            commonOre = common;
        }
Пример #22
0
    void Awake()
    {
        tile = GetComponent<TileBase> ();

        //iTween.MoveTo (gameObject, iTween.Hash ("z", 2f, "time", .5f, "delay", 0f, "easetype", "easeInOutQuart"));
    }
Пример #23
0
        public void SetTileID(int idx, LVector2Int pos, ushort id)
        {
            TileBase tileBase = UnityMap2DUtil.ID2Tile(id);

            this.tilemap.SetTile(new Vector3Int(pos.x, pos.y, 0), tileBase);
        }
Пример #24
0
    public static void CheckSurroundingTile(Tilemap tilemap, Tilemap tilemapOverlay, Vector2Int position, TerrainType[] regions, Tile[] tileVariations)
    {
        Vector3Int[] neighborTiles =
        {
            new Vector3Int(0,   0, 0),
            new Vector3Int(1,   0, 0),
            new Vector3Int(-1,  0, 0),
            new Vector3Int(0,   1, 0),
            new Vector3Int(0,  -1, 0),
        };

        for (int i = 0; i < neighborTiles.Length; i++)
        {
            tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0) + neighborTiles[i], null);
        }

        TileBase posRight  = tilemap.GetTile(new Vector3Int(position.x + 1, position.y, 0));
        TileBase posLeft   = tilemap.GetTile(new Vector3Int(position.x - 1, position.y, 0));
        TileBase posUp     = tilemap.GetTile(new Vector3Int(position.x, position.y + 1, 0));
        TileBase posDown   = tilemap.GetTile(new Vector3Int(position.x, position.y - 1, 0));
        int      totalTile = 0;

        int left  = 1;
        int right = 8;
        int up    = 4;
        int down  = 16;

        if (posRight == regions[4].tile)
        {
            totalTile += right;
        }
        if (posLeft == regions[4].tile)
        {
            totalTile += left;
        }
        if (posUp == regions[4].tile)
        {
            totalTile += up;
        }
        if (posDown == regions[4].tile)
        {
            totalTile += down;
        }

        // Checks north, south, west and east then follows the if rules below to place correct Tile
        switch (totalTile)
        {
        case 0: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[5]); break;

        case 1: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[4]); break;

        case 4: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[1]); break;

        case 5: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[0]); break;

        case 8: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[6]); break;

        case 9: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[13]); break;

        case 12: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[2]); break;

        case 13: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[7]); break;

        case 16: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[9]); break;

        case 17: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[8]); break;

        case 20: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[12]); break;

        case 21: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[11]); break;

        case 24: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[10]); break;

        case 25: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[3]); break;

        case 28: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[15]); break;

        case 29: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[14]); break;

        default: tilemapOverlay.SetTile(new Vector3Int(position.x, position.y, 0), tileVariations[5]); break;
        }
    }
Пример #25
0
    //Returns the weight of a node at some position
    public int Weight(Vector3Int node)
    {
        TileBase t = tilemap.GetTile(node);

        return(WforEachBase[t]);
    }
Пример #26
0
    public void Generate(BezierMap bm, Map map)
    {
        // references

        this.bm          = bm;
        this.trunkWidth  = map.trunkWidth;
        this.branchWidth = map.branchWidth;
        this.wallWidth   = map.wallWidth;
        this.precision   = map.precision;

        this.floorTile   = map.floorTile;
        this.wallTiles   = map.wallTiles;
        this.shadowTiles = map.shadowTiles;

        this.graftSize = map.graftSize;
        this.leafSize  = map.leafSize;
        this.rootSize  = map.rootSize;
        this.crownSize = map.crownSize;

        wallPositions.Clear();
        floorPositions.Clear();
        wallContours.Clear();

        walls.ClearAllTiles();
        floor.ClearAllTiles();
        decor.ClearAllTiles();

        // shaping

        BrushBezier(bm.trunk, wallPositions, trunkWidth + wallWidth, true);
        BrushBezier(bm.trunk, floorPositions, trunkWidth + wallWidth / 2, true);

        BrushPos(bm.trunk.start, wallPositions, rootSize + wallWidth, true);
        BrushPos(bm.trunk.start, floorPositions, rootSize + wallWidth / 2, true);

        BrushPos(bm.trunk.end, wallPositions, crownSize + wallWidth, true);
        BrushPos(bm.trunk.end, floorPositions, crownSize + wallWidth / 2, true);

        foreach (Bezier bez in bm.branches)
        {
            BrushBezier(bez, wallPositions, branchWidth + wallWidth, true);
            BrushBezier(bez, floorPositions, branchWidth + wallWidth / 2, true);

            BrushPos(bez.start, wallPositions, graftSize + wallWidth, true);
            BrushPos(bez.start, floorPositions, graftSize + wallWidth / 2, true);

            BrushPos(bez.end, wallPositions, leafSize + wallWidth, true);
            BrushPos(bez.end, floorPositions, leafSize + wallWidth / 2, true);
        }

        // paving

        BrushBezier(bm.trunk, wallPositions, trunkWidth, false);
        BrushPos(bm.trunk.start, wallPositions, rootSize, false);
        BrushPos(bm.trunk.end, wallPositions, crownSize, false);

        foreach (Bezier bez in bm.branches)
        {
            BrushBezier(bez, wallPositions, branchWidth, false);
            BrushPos(bez.start, wallPositions, graftSize, false);
            BrushPos(bez.end, wallPositions, leafSize, false);
        }

        wallContours = ContourPositions(wallPositions);

        MapContours(walls, wallContours, wallTiles);
        MapPositions(floor, floorPositions, floorTile);
        MapShadows(decor, wallContours, shadowTiles);
    }
Пример #27
0
        private bool ReturnFalseIf(TilingRule rule, TileBase tile, TilingRule.Neighbor RULE)
        {
            TileBase[] Q;
            #region this is bad
            switch ((int)RULE)
            {
            case 3:
                Q = t1;
                break;

            case 4:
                Q = t2;
                break;

            case 5:
                Q = t3;
                break;

            case 6:
                Q = t4;
                break;

            case 7:
                Q = t5;
                break;

            case 8:
                Q = t6;
                break;

            case 9:
                Q = t7;
                break;

            case 10:
                Q = n1;
                break;

            case 11:
                Q = n2;
                break;

            case 12:
                Q = n3;
                break;

            case 13:
                Q = n4;
                break;

            case 14:
                Q = n5;
                break;

            case 15:
                Q = n6;
                break;

            default:
                Q = t1;
                break;
            }
            #endregion

            if (RULE == TilingRule.Neighbor.This && tile == m_Self || RULE == TilingRule.Neighbor.NotThis && tile != m_Self)
            {
                return(false);
            }
            if ((int)RULE > 2 && (int)RULE < 10)
            {
                foreach (TileBase q in Q)   //No, .Contains() does not exist for TileBase[]
                {
                    if (q == tile)
                    {
                        return(false);
                    }
                }
                return(true);
            }
            if ((int)RULE > 9)
            {
                foreach (TileBase q in Q)
                {
                    if (q == tile)
                    {
                        return(true);
                    }
                }
                return(false);
            }
            if (RULE == TilingRule.Neighbor.DontCare)
            {
                return(false);
            }
            return(true);
        }
Пример #28
0
    private bool TileValue(ITilemap tileMap, Vector3Int position)
    {
        TileBase tile = tileMap.GetTile(position);

        return(tile != null && (tile == this || _sisterTilesHashSet.Contains(tile)));
    }
Пример #29
0
 public void TillSoil(Tilemap tileMap, TileBase tileBase, Vector3Int position)
 {
     tileMap.SetTile(position, tileBase);
     tileMap.RefreshTile(position);
     //GameObject.Instantiate (testObj, position, Quaternion.identity);
 }
    void CheckCharacterMovementInput()
    {
        CharacterAction nextAction  = CharacterAction.NoAction;
        bool            interacting = false;

        if (stunned)
        {
            nextAction = CharacterAction.Wait;
        }
        else if (confused)
        {
            nextAction = m_Input.GetRandomAction();
        }
        else
        {
            nextAction  = m_Input.CheckMovementInput();
            interacting = m_Input.CheckInteractionInput();
        }

        switch (nextAction)
        {
        case CharacterAction.MoveForward:
            m_MovementController.Move(transform.forward);
            break;

        case CharacterAction.Backstep:
            m_MovementController.Move(transform.forward * -1);
            break;

        case CharacterAction.MoveLeft:
            m_MovementController.Move(transform.right * -1);
            break;

        case CharacterAction.MoveRight:
            m_MovementController.Move(transform.right);
            break;

        case CharacterAction.TurnLeft:
            m_MovementController.Turn(-1);
            break;

        case CharacterAction.TurnRight:
            m_MovementController.Turn(1);
            break;

        case CharacterAction.Wait:
            SwitchCharacterStatus(CharacterStatus.idle);
            ActivationIsDone();
            break;
        }

        if (interacting)
        {
            TileBase tile = m_MovementController.CheckTile(transform.forward);

            InteractableBase interactable = tile.GetComponentInChildren <InteractableBase>();

            if (interactable != null)
            {
                interactable.InteractedWith();
                SwitchCharacterStatus(CharacterStatus.idle);

                if (DungeonBaseController.instance.currentDungeonTurnState != DungeonBaseController.dungeonTurnState.SettingUpDungeon)
                {
                    ActivationIsDone();
                }
            }
        }

        if (nextAction != CharacterAction.NoAction)
        {
            LastAction = nextAction;
        }
    }
Пример #31
0
 abstract public int FindTileIndex(TileBase tile);
    public static Tile GetBottom(TileBase t)
    {
        if (t.j <= 0)
                return null;

            return PathFinder.matrix[t.i, t.j - 1];
    }
Пример #33
0
 public TileContainer(TileBase tile, int X, int Y)
 {
     this.Tile = tile;
     this.X    = X;
     this.Y    = Y;
 }
    public static List<Tile> GetNeighbours(TileBase t)
    {
        List<Tile> list = new List<Tile>();
            if (GetLeft(t) != null)
                list.Add(GetLeft(t));

            if (GetRight(t) != null)
                list.Add(GetRight(t));

            if (GetTop(t) != null)
                list.Add(GetTop(t));

            if(GetBottom(t) != null)
                list.Add(GetBottom(t));

            return list;
    }
Пример #35
0
 private void SpawnTile(Vector2 spawnPos, Tilemap tilemapLayer, TileBase tile)
 {
     tilemapLayer.SetTile(ToInt3(spawnPos), tile); // Plan to implement randomness in tile selection
 }
    public static Tile GetTop(TileBase t)
    {
        if (t.j >= max_j)
                return null;

            return PathFinder.matrix[t.i, t.j + 1];
    }
        private bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_InputData inputData)
        {
            if (settings == null)
            {
                HEU_Logger.LogError("Tilemap Settings not found!");
                return(false);
            }

            HEU_InputDataTilemap inputTilemap = inputData as HEU_InputDataTilemap;

            if (inputTilemap == null)
            {
                HEU_Logger.LogError("Expected HEU_InputDataTilemap type for inputData, but received unssupported type.");
                return(false);
            }

            List <Vector3> vertices = new List <Vector3>();
            List <Vector3> colors   = new List <Vector3>();

            List <string>     tileNames  = new List <string>();
            List <Vector3>    tileSizes  = new List <Vector3>();
            List <Vector3Int> tileCoords = new List <Vector3Int>();

            Tilemap tileMap = inputTilemap._tilemap;

            if (!tileMap.gameObject.activeInHierarchy)
            {
                HEU_Logger.LogWarning("Tilemap inputs must be active in the hierarchy in order to properly send input data");
            }

            Grid gridLayout = tileMap.layoutGrid;

            Matrix4x4 orientation              = tileMap.orientationMatrix;
            Vector3   orientationPosition      = orientation.DecomposeToPosition();
            Vector3   orientationRotationEuler = orientation.DecomposeToRotation().eulerAngles;

            orientationRotationEuler.y = -orientationRotationEuler.y;
            orientationRotationEuler.z = -orientationRotationEuler.z;
            Quaternion orientationRotation = Quaternion.Euler(orientationRotationEuler);
            Vector3    orientationScale    = orientation.DecomposeToScale();

            List <float>   pointOrient = new List <float>();
            List <Vector3> pointScale  = new List <Vector3>();

            TileBase[] tileArray = tileMap.GetTilesBlock(tileMap.cellBounds);

            int     tileCount    = 0;
            Vector3 anchorOffset = tileMap.tileAnchor;

            anchorOffset.Scale(gridLayout.cellSize);

            Vector3 pointPos;

            Vector3Int boundsMin = new Vector3Int(int.MaxValue, int.MaxValue, int.MaxValue);
            Vector3Int boundsMax = new Vector3Int(int.MinValue, int.MinValue, int.MinValue);

            foreach (Vector3Int tilePos in tileMap.cellBounds.allPositionsWithin)
            {
                if (tileMap.HasTile(tilePos))
                {
                    boundsMin = Vector3Int.Min(tilePos, boundsMin);
                    boundsMax = Vector3Int.Max(tilePos, boundsMax);
                }
            }

            boundsMax += Vector3Int.one;
            BoundsInt tileMapBounds = new BoundsInt {
                min = boundsMin, max = boundsMax
            };

            foreach (Vector3Int tilePos in tileMapBounds.allPositionsWithin)
            {
                if (!settings._exportUnusedTiles && !tileMap.HasTile(tilePos))
                {
                    continue;
                }

                Vector3Int usedTilePos = tilePos;
                //For Houdini (to use Labs Wang Tile tools, we need to reverse point order on the x axis)
                //so we just iterate in reverse order on the x
                //usedTilePos.x = tileMapBounds.size.x - 1 - tilePos.x + 2 * tileMapBounds.min.x;

                tileCount++;
                pointPos = tileMap.CellToLocal(usedTilePos) + anchorOffset;
                if (settings._applyTilemapOrientation)
                {
                    pointPos += orientationPosition;
                    pointOrient.Add(orientationRotation[0]);
                    pointOrient.Add(orientationRotation[1]);
                    pointOrient.Add(orientationRotation[2]);
                    pointOrient.Add(orientationRotation[3]);

                    pointScale.Add(orientationScale);
                }

                vertices.Add(pointPos);

                if (tileMap.HasTile(usedTilePos))
                {
                    Tile tile = tileMap.GetTile <Tile>(usedTilePos);
                    tileNames.Add(tile.name);
                    if (settings._applyTileColor)
                    {
                        colors.Add(new Vector3(tile.color.r, tile.color.g, tile.color.b));
                    }
                    tileSizes.Add(new Vector3(tile.sprite.rect.size.x / tile.sprite.pixelsPerUnit, tile.sprite.rect.size.y / tile.sprite.pixelsPerUnit, 0.0f));
                }
                else
                {
                    tileNames.Add("");
                    if (settings._applyTileColor)
                    {
                        colors.Add(Vector3.zero);
                    }
                    tileSizes.Add(Vector3.zero);
                }

                tileCoords.Add(usedTilePos);
            }

            HAPI_PartInfo partInfo = new HAPI_PartInfo();

            partInfo.faceCount               = 0;
            partInfo.vertexCount             = 0;
            partInfo.pointCount              = tileCount;
            partInfo.pointAttributeCount     = 1;
            partInfo.vertexAttributeCount    = 0;
            partInfo.primitiveAttributeCount = 0;
            partInfo.detailAttributeCount    = 1;

            if (tileSizes.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }

            if (settings._applyTileColor && colors.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }

            if (tileCoords.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }

            if (pointOrient.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }

            if (pointScale.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }

            if (!settings._createGroupsForTiles && tileNames.Count > 0)
            {
                partInfo.pointAttributeCount++;
            }


            HAPI_GeoInfo displayGeoInfo = new HAPI_GeoInfo();

            if (!session.GetDisplayGeoInfo(inputNodeID, ref displayGeoInfo))
            {
                return(false);
            }

            HAPI_NodeId displayNodeID = displayGeoInfo.nodeId;

            if (!session.SetPartInfo(displayNodeID, 0, ref partInfo))
            {
                Debug.LogError("Failed to set input part info. ");
                return(false);
            }

            if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_HAPIConstants.HAPI_ATTRIB_POSITION, 3, vertices.ToArray(), ref partInfo, true))
            {
                Debug.LogError("Failed to set point positions.");
                return(false);
            }

            if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_size", 2, tileSizes.ToArray(), ref partInfo, false))
            {
                Debug.Log("Failed to set tile size attributes. ");
                return(false);
            }

            if (settings._applyTileColor)
            {
                if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_HAPIConstants.HAPI_ATTRIB_COLOR, 3, colors.ToArray(), ref partInfo, false))
                {
                    Debug.Log("Failed to set tile color attributes. ");
                    return(false);
                }
            }


            if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_pos", 2, tileCoords.ToArray(), ref partInfo))
            {
                Debug.Log("Failed to set point tile coordinates attributes.");
                return(false);
            }

            if (settings._createGroupsForTiles)
            {
                //Get a list of unique tiles used
                TileBase[] usedTiles = new TileBase[tileMap.GetUsedTilesCount()];
                tileMap.GetUsedTilesNonAlloc(usedTiles);

                //Set point groups based on tile type
                int[] pointGroupMembership = new int[tileCount];
                foreach (TileBase tileType in usedTiles)
                {
                    if (!session.AddGroup(displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name))
                    {
                        return(false);
                    }

                    int index = 0;
                    foreach (string tileName in tileNames)
                    {
                        if (tileName.Equals(tileType.name))
                        {
                            pointGroupMembership[index] = 1;
                        }
                        else
                        {
                            pointGroupMembership[index] = 0;
                        }
                        index++;
                    }

                    if (!session.SetGroupMembership(displayNodeID, 0, HAPI_GroupType.HAPI_GROUPTYPE_POINT, tileType.name, pointGroupMembership, 0, tileCount))
                    {
                        return(false);
                    }
                }
            }
            else
            {
                if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, "unity_tile_name", tileNames.ToArray(), ref partInfo))
                {
                    Debug.Log("Failed to set point tile name attributes.");
                    return(false);
                }
            }

            if (!HEU_InputMeshUtility.SetMeshDetailAttribute(session, displayNodeID, 0, "unity_tile_bounds", 2, tileMapBounds.size, ref partInfo))
            {
                Debug.Log("Failed to set detail tile map bounds attribute.");
                return(false);
            }

            if (settings._applyTilemapOrientation)
            {
                if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_ORIENT, 4, pointOrient.ToArray(), ref partInfo))
                {
                    Debug.LogError("Failed to set point rotations.");
                    return(false);
                }

                if (!HEU_InputMeshUtility.SetMeshPointAttribute(session, displayNodeID, 0, HEU_Defines.HAPI_ATTRIB_SCALE, 3, pointScale.ToArray(), ref partInfo, false))
                {
                    Debug.LogError("Failed to set point scales.");
                    return(false);
                }
            }

            return(session.CommitGeo(displayNodeID));
        }
Пример #38
0
 /// <summary>
 ///     Starts the action associated with this tool at the location given.
 /// </summary>
 /// <param name="rawLocation">
 ///     The raw location to start the action.
 ///     Should be transformed by the <see cref="IView.InverseViewMatrix" /> for the
 ///     <see cref="Controller">Controllers</see> <see cref="EscherTiler.Controllers.Controller.View" /> to get the
 ///     location in the tiling itself.
 /// </param>
 /// <returns>
 ///     The action that was performed, or null if no action was performed.
 /// </returns>
 public override Action StartAction(Vector2 rawLocation)
 {
     _hoverTile = GetTileOver(rawLocation);
     TileSelectedTcs.TrySetResult(_hoverTile);
     Controller.CurrentTool = LastTool;
     return InstantAction.PureInstance;
 }
 public WorldGeneratorToDoorManager(LogicGrid masterLogicGrid, Tilemap floor, Tilemap door, TileBase tileFloor, TileBase tileDoor, List <RoomInfo> roomInMap)
 {
     this.masterLogicGrid = masterLogicGrid;
     this.floor           = floor;
     this.door            = door;
     this.tileFloor       = tileFloor;
     this.tileDoor        = tileDoor;
     this.roomInMap       = roomInMap;
 }
Пример #40
0
        private void BuildMapOffset(int offsetX, int offsetY)
        {
            foreach (var item in tempSpawnerPositions)
            {
                item.Value.Clear();
            }
            bool hasComplained = false;
            int  maxX          = offsetX + subChunkSize;
            int  maxY          = offsetY + subChunkSize;

            for (int y = offsetY; y < maxY; y++)
            {
                for (int x = offsetX; x < maxX; x++)
                {
                    int   key = x - offsetX + subChunkSize * (y - offsetY);
                    float c0  = noiseMap[x + 1, y + 1];
                    float c1  = noiseMap[x + 1, y];
                    float c2  = noiseMap[x, y];
                    float c3  = noiseMap[x, y + 1];

                    float highest = 0;
                    float lowest  = 0;
                    Utils.MinMaxCorners(c0, c1, c2, c3, out highest, out lowest);
                    biome = GetTileLookup(lowest);
                    int  biomeHash = biome.Item1;
                    bool isSloped  = false;
                    tile = biome.Item2[flat];
                    if (lowest < bottomHeight)
                    {
                        if (c0 < bottomHeight)
                        {
                            c0 = bottomHeight - 1;
                            noiseMap[x + 1, y + 1] = bottomMinus1;
                        }
                        if (c1 < bottomHeight)
                        {
                            c1 = bottomHeight - 1;
                            noiseMap[x + 1, y] = bottomMinus1;
                        }
                        if (c2 < bottomHeight)
                        {
                            c2             = bottomHeight - 1;
                            noiseMap[x, y] = bottomMinus1;
                        }
                        if (c3 < bottomHeight)
                        {
                            c3 = bottomHeight - 1;
                            noiseMap[x, y + 1] = bottomMinus1;
                        }
                        Utils.MinMaxCorners(c0, c1, c2, c3, out highest, out lowest);
                    }
                    if (highest != lowest)
                    {
                        float   c0n     = Mathf.InverseLerp(lowest, highest, c0);
                        float   c1n     = Mathf.InverseLerp(lowest, highest, c1);
                        float   c2n     = Mathf.InverseLerp(lowest, highest, c2);
                        float   c3n     = Mathf.InverseLerp(lowest, highest, c3);
                        Vector4 corners = new Vector4(c0n, c1n, c2n, c3n);
                        if (biome.Item2.ContainsKey(corners))
                        {
                            tile = biome.Item2[corners];
                        }
                        else if (!hasComplained)
                        {
                            hasComplained = true;
                            Debug.LogWarning("Unmatched corner: " + corners + " at height: " + highest);
                        }
                        isSloped = true;
                    }
                    foreach (var item in cachedSpawners[biomeHash])
                    {
                        if (
                            item.Value.Spawer.Enabled &&
                            prng.NextDouble() <= item.Value.Probability &&
                            (
                                (item.Value.Spawer.OnSlopes && isSloped) ||
                                (item.Value.Spawer.OnFlat && !isSloped)
                            )
                            )
                        {
                            float   textureCount = (float)item.Value.Spawer.PackedTexture.depth;
                            float   index        = Mathf.Round((float)prng.NextDouble() * textureCount) / textureCount + (0.5f / textureCount);
                            Vector4 worldPos     = Provider.Generator.MapToWorld(new Vector3(rect.min.x + x, rect.min.y + y));
                            worldPos.y += c2 * 0.25f;
                            worldPos.z  = worldPos.y * 0.1f;
                            worldPos.w  = index;
                            spawnerPositions[item.Key].Add(worldPos);
                            tempSpawnerPositions[item.Key].Add(worldPos);
                        }
                    }
                    positions[key] = new Vector3Int(x - halfMap, y - halfMap, noiseMap[x, y]);
                    tiles[key]     = tile;
                }
            }
            Tilemap.SetTiles(positions, tiles);
            foreach (var item in tempSpawnerPositions)
            {
                Provider.Generator.CachedRenderers[item.Key].AddInstances(item.Value);
            }
        }
Пример #41
0
    public void DrawMovePath(List <Point> path)
    {
        TileBase tile = ResourceManager.Instance.TileBases[(int)TileType.Path];

        DrawTileOnLayer(path, Layers.Movement, tile);
    }
Пример #42
0
 public void MoveEdgeTile(bool leftToRight, TileBase newTile)
 {
     (newTile ?? TileHardWall.OuterWall).InitGraphic(GetComponentsInChildren<Graphic>().TurnEdgeSibling(leftToRight));
 }
Пример #43
0
    public void DrawShootingRange(List <Point> range)
    {
        TileBase tile = ResourceManager.Instance.TileBases[(int)TileType.Shoot];

        DrawTileOnLayer(range, Layers.Shooting, tile);
    }
Пример #44
0
 /// <summary>
 ///     Gets the style for the given tile.
 /// </summary>
 /// <param name="tile">The tile.</param>
 /// <param name="styles">The styles to choose from.</param>
 /// <param name="state">The style state associated with the tile.</param>
 /// <returns></returns>
 protected override IStyle GetStyle(TileBase tile, IStyle[] styles, ref object state)
 {
     Debug.Assert(styles.Length == 1);
     return styles[0];
 }
Пример #45
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="SelectedLine" /> class.
 /// </summary>
 /// <param name="tile">The tile.</param>
 /// <param name="edgePart">The edge part.</param>
 /// <param name="line">The line.</param>
 /// <param name="lineTransform">The line transform.</param>
 public SelectedLine(TileBase tile, EdgePartShape edgePart, ILine line, Matrix3x2 lineTransform)
 {
     Debug.Assert(tile != null, "tile != null");
     Debug.Assert(edgePart != null, "edgePart != null");
     Debug.Assert(line != null, "line != null");
     Tile = tile;
     EdgePart = edgePart;
     Line = line;
     LineTransform = lineTransform;
 }