コード例 #1
0
        private CollisionDirection GetColShape(TilemapCollisionSource tilemapCollisionSource, int x, int y)
        {
            var tileInfos  = tilemapCollisionSource.SourceTilemap.Tileset.Res.TileData;
            var tileGrid   = tilemapCollisionSource.SourceTilemap.Tiles;
            var tile       = tileGrid[x, y];
            var tileInfo   = tileInfos[tile.Index];
            var usedLayers = _usedLayersCache[(int)tilemapCollisionSource.Layers];
            var shape      = TileCollisionShape.Free;

            foreach (var usedLayer in usedLayers)
            {
                shape |= tileInfo.Collision[usedLayer];
            }
            return((CollisionDirection)shape);
        }
コード例 #2
0
        private void GenerateTilemaps()
        {
            // Create a parent transform object, so we don't clutter the Scene too much
            GameObject rootObject = new GameObject("Map");

            rootObject.AddComponent <Transform>();

            // Generate all tilemap layers
            List <Tilemap> generatedTilemaps = new List <Tilemap>();

            for (int i = 0; i < this.settings.LayerCount; i++)
            {
                string layerName =
                    (i == 0 ? "BaseLayer" :
                     (i == this.settings.LayerCount - 1 ? "TopLayer" :
                      (this.settings.LayerCount == 3 ? "UpperLayer" :
                       ("UpperLayer" + i.ToString()))));

                GameObject layerObj = new GameObject(layerName, rootObject);
                layerObj.AddComponent <Transform>();

                Tilemap tilemap = layerObj.AddComponent <Tilemap>();
                TilemapsSetupUtility.SetupTilemap(
                    tilemap,
                    this.settings.Tileset,
                    this.settings.MapSize.X,
                    this.settings.MapSize.Y,
                    i > 0);

                TilemapRenderer renderer = layerObj.AddComponent <TilemapRenderer>();
                renderer.DepthOffset = -0.01f * i;
                if (this.settings.DeepTilemap)
                {
                    renderer.TileDepthMode  = TileDepthOffsetMode.World;
                    renderer.TileDepthScale = 0.01f;
                }
                else
                {
                    renderer.TileDepthMode  = TileDepthOffsetMode.Flat;
                    renderer.TileDepthScale = 0.0f;
                }

                generatedTilemaps.Add(tilemap);
            }

            // Generate a collision layer when requested
            if (this.settings.GenerateCollisionShapes)
            {
                GameObject layerObj = new GameObject("WorldGeometry", rootObject);
                layerObj.AddComponent <Transform>();

                RigidBody body = layerObj.AddComponent <RigidBody>();
                body.BodyType = BodyType.Static;

                TilemapCollider          collider         = layerObj.AddComponent <TilemapCollider>();
                TilemapCollisionSource[] collisionSources = new TilemapCollisionSource[generatedTilemaps.Count];
                for (int i = 0; i < generatedTilemaps.Count; i++)
                {
                    collisionSources[i].Layers        = TileCollisionLayer.Layer0;
                    collisionSources[i].SourceTilemap = generatedTilemaps[i];
                }
                collider.RoundedCorners  = true;
                collider.CollisionSource = collisionSources;
            }

            // Add the new objects to the current Scene as an UndoRedo operation.
            UndoRedoManager.Do(new CreateGameObjectAction(
                                   null,
                                   rootObject));
        }