protected override List <Layer> BuildTileLayers(List <Tileset> tilesets)
        {
            // Letting basic layer builder do its stuff.
            var layers = base.BuildTileLayers(tilesets);

            // Now we need to add position and collider components to entity to make it count as a solid.
            foreach (var layer in layers)
            {
                // Getting list of all tilemaps on this layer.
                var tilemaps = layer.GetEntityListByComponent <BasicTilemapComponent>();

                foreach (var tilemap in tilemaps)
                {
                    var tilemapComponent = tilemap.GetComponent <BasicTilemapComponent>();

                    tilemapComponent.Padding = 3;                     // Padding is increased, so biffer tiles like trees won't disappear while still on screen.

                    // Making collider.
                    var collider = new TilemapCollider();
                    collider.Tilemap = tilemapComponent;
                    collider.Size    = new Vector2(
                        tilemapComponent.Width * tilemapComponent.TileWidth,
                        tilemapComponent.Height * tilemapComponent.TileHeight
                        );
                    var solid = new SolidComponent();
                    solid.Collider = collider;
                    // Making collider.

                    tilemap.AddComponent(solid);
                    tilemap.AddComponent(new PositionComponent(tilemapComponent.Offset));
                }
            }

            return(layers);
        }
Example #2
0
 /// <summary>
 /// Creates a new instance of the <see cref="TilemapCollider"/> and adds the <see cref="RigidBody"/> thats on the same <see cref="GameObject"/>
 /// </summary>
 /// <param name="tilemapCollider"></param>
 public TilemapColliderWithBody(TilemapCollider tilemapCollider)
 {
     TilemapCollider         = tilemapCollider;
     RigidBody               = tilemapCollider.GameObj.GetComponent <RigidBody>();
     Width                   = tilemapCollider.CollisionSource[0].SourceTilemap.Tiles.Width;
     Height                  = tilemapCollider.CollisionSource[0].SourceTilemap.Tiles.Height;
     TilemapCollisionSources = tilemapCollider.CollisionSource.ToArray();
 }
Example #3
0
 /// <summary>
 /// Creates a new instance of the <see cref="TilemapCollider"/> and adds the <see cref="RigidBody"/> thats on the same <see cref="GameObject"/>
 /// </summary>
 /// <param name="tilemapCollider"></param>
 public TilemapColliderWithBody(TilemapCollider tilemapCollider)
 {
     CollisionCategory       = (PathfindaxCollisionCategory)tilemapCollider.GameObj.GetComponent <RigidBody>().CollisionCategory;
     TilemapCollisionSources = tilemapCollider.CollisionSource.ToArray();
 }
Example #4
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));
        }