Welcome to the Daedalus!

Welcome to the Daedalus!

Please note that the documentation is still under development, so it’s uncomplete and may change often. Check back this page from time to time!



  • v1.1.15 – Current Version
    • Bugfix: too small room now have insidefloor tiles
  • v1.1.14
    • Bugfix: fillwithfloor bug with internal columns
  • v1.1.13
    • Bugfix: ceiling not getting created over a tilemap
    • Added ToString to VirtualCell
  • v1.1.12
    • Bugfix: entrance/exit in the same room even with large distance fixed
  • v1.1.11
    • Bugfix: diminished split range
    • Bugfix: fixed some corridors in BSP getting generated in the wrong way
    • Bugfix: fixed too small rooms not being created in BSP
  • v1.1.10
    • Bugfix: fixed missing internal floors in tilemaps
      Bugfix: added default Player2D
      Bugfix: fake3d doors get spawned in the wrong way
      Bugfix: removable columns sometimes are inner floors, or inner room floors, or inner column, while other times they are OUTSIDE!! I should code it better!
  • v1.1.9
    • Bugfix: fixed Add entrance/exit when not creating start/end
      Bugfix: fixed draw columns in rooms does not work anymore
  • v1.1.8
    • Fixed interface bug with missing VirtualMapGeneratorBehaviour
    • Fixed passage doors placement
    • Fixed tilemap with BSP
    • Changed door placement in BSP with wide corridors to only use one door
    • Changed BSP wide corridors size limits check
  • v1.1.7 (Unity 5)
    • Added 3-4 length corridors
    • Fixed start and end computation
    • Fixed support for Unity5
      • Removed image effects folder (Daedalus Core\Editor)
      • VirtualMap gave a maxrecursiondepth error for serialization
        • Fixed by changing VirtualRoom & RoomGenerator’s handling of connectedRooms
        • Added GetRoom(index) to VirtualMap
        • Added index handling to BSPVirtualMapGenerator and DiggingVirtualMapGenerator
        • Also changed RoomGenerator to reflect this
    • Added HasRooms() to virtualmapgeneratorbehaviour for checks
    • Removed most GeneratorValues
    • Updated all maps to use the new VirtualMapGeneratorBehaviour
    • Removed forceInRooms for sectionsmap
    • Fixed distance computations
    • Added createEntranceAndExit to PhysicalMap (decoupled from the generator behaviour)
    • Moved entrance and exit parameters to VirtualMapGeneratorBehaviour
    • Fixed various bugs with tilemap interpreter
      • Rock generation
      • Inside columns
      • Wall corners
      • Orientations
    • Added warning when missing a VirtualMapGeneratorBehaviour
  • v1.1.6
    • Refactored door creation, now better finds minimum door number
    • Fixed parameter limits for BSP
    • Fixed bugs with corridor creation
  • v1.1.5
    • Added connection checks for cells
    • Added debug lines for connections
    • Added path existing check
    • Refactored start and end computation
  • v1.1.4
    • Separated IsRemovable to IsColumnRemovable and IsWallRemovable (used both for the same thing, was wrong!)
    • Fixed column removal
    • Fixed wall instantiation checks (now faster and better coded)
    • Added ResetToWalls() to VirtualMap
    • Refactored Digging algorithms to standardize with BSP
    • Refactored VirtualMap functions
    • CreateCorridor now takes also a width
  • v1.1.3
    • Limited splitRange to 0.99f to avoid exceptions
    • Refactored the door creation algorithm a bit
    • Fixed door creation to consider other doors correctly
    • Refactored GeneratorBehaviour and GeneratorValues
    • Refactored DiggingVirtualMapGenerator
    • Refactored room creation algorithm
  • v1.1.2
    • Refactored VirtualMapGenerator and GeneratorBehaviour:
      • No more MazeGenerationAlgorithm, now they are all VirtualMapGenerator
      • Added VirtualMapGeneratorBehaviour and derived classes for all generation algorithms
      • Refactored GeneratorBehaviour to use the new VirtualMapGeneratorBehaviour classes
      • Added interfaces for the new generators
  • v1.1.1
    • Added new generation algorithm: BSP generation
    • Refactored virtual map and room generator
    • Added ResetToEmpty to VirtualMap
    • Added debug coordinates as a GeneratorBehaviourInterface option
    • Added GetAllObjects (public) to PhysicalMap
    • Changed getVirtualMaps to GetVirtualMaps in GeneratorBehaviour
    • Changed getPhysicalMap to GetPhysicalMaps in GeneratorBehaviour
    • Added HasGeneratedDungeon() check to GeneratorBehaviour
    • Added GetRealWorldPosition() to PhysicalMap
    • Fixed bug with GetClockwiseDirection() and directions in VirtualMap
  • v1.1.0b
    • Added new defaults for OrientedSectionsMap
  • v1.1.0a
    • Added new defaults for OrientedSectionsMap
      Bugfix: call loop with new GetVariations
  • v1.1.0
    • Added GetVariations that takes into account a requested orientation
    • Added OrientedSectionsMap (for Zelda-esque games, i.e. Rogue Legacy or Binding of Isaac)
  • v1.0.9c
    • Fixed bug with width different from height
    • Virtualmap cells are now correctly serialized
    • Added some guards to missing prefabs
  • v1.0.9b
    • Added multi-storey for sections map
    • Added GetMapDimensions to VirtualMap
  • v1.0.9a
    • Added option to specify whether rooms are isolated or not, for directional wall purposes
    • Bugfix: default scene was missing some variations
  • v1.0.9
    • Added option to force transversal for rooms
    • Bugfix: fixed bugs with generator’s interface when no interpreter or physical map was present
    • Bugfix: added missing default assets
  • v1.0.8
    • Fixed WP8 support
      • Bugfix: fixed bug with WP8 and serialization
        • Files changed: SerializableDictionary.cs
        • The bug comes from the serialization of GenericChoice arrays! (GenericChoice[])
        • Fixed in Unity 4.5.4! Make sure you upgrade!
    • Added new type of dungeon: Section dungeon. A Section dungeon is composed of multiple, oriented sections (like entire rooms), and has no walls, doors nor columns.
      • Added new SectionMapInterpreter and the corresponding PrefabSectionsPhysicalMapBehaviour
    • Added GetAllRoomDimensions in PhysicalMap
      • Added Test_GetRoomDimensions script for testing
  • v1.0.7
    • Changed default materials of columns to a lighter green, so they can be better singled out
    • ISSUE: corruption problem with Unity (was a problem of Unity 4.5.0, solved now!)
  • v1.0.6
    • Added DoorHorizontal e DoorVertical for the doors
    • DoorHorizontal needs a slightly taller sprite
  • v1.0.5
    • Added new fake3d assets
    • Rocks behave better with fake3d assets, as does the bottom side of the dungeon
  • v1.0.4
    • Directional tiles now work with fak3D tiles
    • Bugfix: fixed orientation of fake3d assets
    • Bugfix: fixed IsCorridorDirectionalWall()
  • v1.0.3
    • Added default fake3d assets
    • Added default standard map directional columns
    • Enabled directional walls for StandardMap
    • Changed directional Walls to Columns (only for StandardMap)
    • Bugfix: if using directional tiles, fake3D is automatically disabled
    • Bugfix: fixed Sprites2D_Prefabs tile priorities issues
    • Known issue: 2DToolkit will give a “GUILayout: Mismatched LayourGroup.Repaint” exception when using the editor. This is harmless
  • v1.0.2
    • Bugfix: fixed small bug with default loading for Sprites3D
    • Bugfix: fixed a few bugs while generating directional tiles
    • Updated 2DToolkit with support for directional walls
    • Updated with new directional wall assets
    • Fake3dWalls option is now enabled only for Sprites2DPhysicalMap
  • v1.0.1
    • Feature: added Fake3D option to the TileMapInterpreter, when used with a 2D map. It will change all Walls and Columns to either Fake_FrontWall or Fake_AboveWall.
    • Feature: more control on how the entrance and exit are placed
      • Allows a minimum and maximum distance to be specified (leaving both to 100%, it will always place it at the farthest distance)
      • The entrance is never placed in the middle of a corridor
      • Modified VirtualMap to check floor cell distances (added different methods for the purpose)
    • Feature: added directional walls for StandardMap and TileMap
    • Feature: Added Prefabs2DPhysicalMap, which works similarly to Meshes3DPhysicalMap but uses prefabs created using Sprites. This can be useful to instantiate sprites just like prefabs (with other gameobjects as children).
    • Minor feature: Meshes3DPhysicalMap and Prefabs2DPhysicalMap now support setting the tile sizes manually.
    • Bugfix: rooms that are too small to have directional floors will now use the RoomFloorInside tile instead of the default RoomFloor tile.
    • Bugfix: removed useless DimensionalMapInterpreterAddon file
    • Bugfix: added ladders in the SelectionManager
    • Bugfix: exit and entrance with map orientation YZ now works correctly
    • Bugfix: meshes 3D physical map now uses correct distances for computing exit and entrance positions
    • Bugfix: updated to Unity 4.5 (there was an issue with GenericDrawer)
    • Misc: added assert to guarda against missing variations
    • Misc: renamed “MapGenerator” to “VirtualMapGenerator”
    • Misc: renamed some methods in VirtualMap to match camel case
    • Misc: changed ‘SendMessage’ to ‘BroadcastMessage’ when generation ends
    • Misc: added ‘IsCurrentlyGenerating’ public flag to GeneratorBehaviour
    • Misc: Meshes3DPhysicalMap now will raise an assertion error when it cannot get the mesh filter bounds
    • Misc: When Generate is clicked, any existing older maps are now deleted (useful for when errors appear)
  • v1.0.0
    • Fixed ceiling over the stairs bug
    • Added ‘last used seed’ in the GeneratorBehaviour advanced panel. This can be useful for reporting bugs (even when not choosing a seed)
    • Added new physicalMap.GetObjectsOfZone(int zone_number) method, that allows to select a portion of the map. This is used now for differentiating storeys
    • Added default values to Sprites2DMap

  • v0.13.10
    • Fixed default bugs and values: now any PhysicalMap is ready-to-go just after being added to the Generator Behaviour!
      • default storey height is now 1
      • fixed orientations of StandardMap3D and TileMap3D
      • tk2dspritephysicalmap now has default tile texture size of 4
      • all default IDs for tk2dspritephysicalmap
      • tk2dspritephysicalmap now has default tile texture size of 32 and pixels per meter of 8
      • all defaults IDs and layers for tk2dtilesphysicalmap
      • added default values to Sprite2DMap

  • v0.13.9
    • Added new defaults for everything

  • v0.13.8
    • Added option for TileMap perimeter orientation

  • v0.13.7
    • Perimeter walls are now correctly oriented in StandardMaps

  • v0.13.6
    • BugFix: 2×1 stairs now appear correctly in TileMaps

  • v0.13.5
    • BugFix: 2×1 stairs now do not appear in front of doors
    • Removed some leftover debug logs

  • v0.13.4
    • Fixed bug with stairs being created in corridors
    • Fixed bug with >2 storeys loosing their main type
    • Set default options to the simplest dungeon

  • v0.13.3
    • Fixed bug with door orientation
    • Fixed bug with columns being created in the void part in a StandardMap
    • Fixed bugs with column creation in TileMap

  • v0.13.2
    • Updated all the TileMap interpreters with the new modifications
    • Set minimum variation weight to 1
    • Refactored VirtualMap and MapInterpreter (and others)
    • Added all defaults

  • v0.13.1
    • Added Ladder2 cell type, a ladder (or stairs) of two tiles
    • Modified MetricLocation to report the storeys number
      • modified all interpreters to work with this modification
    • Added subtypes to VirtualCell, for multiple typing checks (they work like tags, basically, and CreateObjects should be called for each tag!)
      • this allows for multiple ‘things’ to be placed in a single cell by the interpreter. For example: ladders
    • Reworked map interpreter to work in two phases:
      • phase 1: the map is actually interpreted, changing the cell types (and subtypes) as needed (much like shader code)
      • phase 2: the current interpreted map is ‘rendered’ through CreateObject
    • Completely refactored Map Interpreters:
      • the interpreters now function similarly (easier code manteinance)
      • they now work in phases: Read and Build
      • they do not longer need Width, Height or Initialise
      • they work on the whole array of virtual maps
      • support for multiple types in a cell, while retaining old support (main type)
      • easier manteinance (most code is in the abstract map interpreter now
      • easier addition of new cell types
    • Added ‘Perimeter’ option and two new cell types: ‘PerimeterWall’ and ‘PerimeterColumn’

  • v0.13.0 – Multistorey update!
    • Added option for multiple storeys
    • Added a new cell type, ‘Ladder’ (it is placed in the storey below and reaches the storey above)
    • Added option for 2D or 3D map type
      • added warning and disabled generation if a 2D physical map is used with a 3D map type
    • Added default Ladder

  • v0.12.10
    • Added various warnings when necessary prefabs are missing
    • Stop generation if necessary prefabs are missing
    • Added guards on existence of ‘physicalMap’ when destroying it to avoid null references

  • v0.12.9
    • Fixed ‘Randomize Orientations': if disabled, all tiles will have the same orientation. If enabled, the orientation will be randomized
    • ‘Advanced Tiles’ renamed to ‘Directional Tiles’
    • ‘Randomize Orientations’ is now hidden to the user if ‘Directional Tiles’ is enabled
    • ‘Door Columns’ now renamed to ‘Passage Columns’. They are now available even if ‘Draw Doors in Passages’ is Disabled
    • Fixed defaults of ‘Sprites2DPhysicalMapBehaviour’



    Daedalus works with Unity Personal Edition and all of its features are compatible with it.

    Daedalus can work with 2D, too, and it also supports 2DToolKit by Unikron. If you want to use this feature, you will need to buy a copy of 2DToolKit.

    Package Contents

    Once imported into Unity, the package will create a “Daedalus_Core” folder. Within this folder, you will find all the files and folders needed by Daedalus.

    2DToolKit integration needs the 2DToolKit plugin by Unikron, which is not included in this package. Check it out here.

    If you want to use 2DToolKit integration, first import the 2DToolKit package itself, and then import the Daedalus_2DToolKit_Integration package.

    Folder Structure

    • Daedalus_Core Contains all the necessary files to use Daedalus
      • Art_Assets The art assets (meshes and textures) included as examples
      • Daedalus_Import Contains the 2DToolKit integration package to import
      • Editor Contains Editor scripts
        • Daedalus_Editor Editor script files
      • Map_Presets StandarMap and TileMap preset prefabs
      • Prefabs Player prefabs to test the maps in Play mode
      • Resources Contains materials, textures and prefabs used by default tiles
        • Daedalus_Resources
          • 2D Defaults for 2D
          • 3D Defaults for 3D
            • StandardMap Defaults for StandardMaps
            • Tiles3DDefaults for TileMaps
          • Shared Defaults shared by all map types
            • Prefabs Default prefabs
            • Textures Default textures
          • tk2D Defaults
      • Scenes Ready to use scene files with different types of map
      • Scripts All the script components
        • Algorithms Generation algorithms
        • Generation Generation script files
        • Interpretation Interpretation script files
          • DimensionalMapInterpreterAddon
        • Misc Various script
        • PhysicalMap Contains all the PhysicalMap types
          • Meshes3D Meshes3D PhysicalMap scripts
          • Sprites2D Sprites2D PhysicalMap scripts
          • Sprites3D Sprites3D PhysicalMap scripts
        • Utilities Utility scripts
      • Standard Assets Unity’s standard assets folder
        • Character Controllers Character controller files
          • Sources
            • Scripts Character controller scripts

      What Daedalus can do

      Daedalus is a random maze and dungeon generator add-on for Unity3D. Its purpose is to give game developers a different and quick way of creating game levels, adding a little bit of randomness to them.

      Daedalus creates tile-based maps and can be used both in Unity Editor, to generate game levels for later editing, and in runtime applications, to randomly create levels while playing.

      Daedalus can create full 3D game levels (e.g., game levels extending in height with multiple floors). With this feature you can create multi-level dungeons, towers, buildings, etc.

      What Daedalus CAN’T do (yet?)

      At this stage, Daedalus only creates game levels, it does not take care of decorating them or populating them with enemies, power-ups, etc., though you can add all these things in pre-built tiles and you can even extend Daedalus to make it do whatever you need (full source code is provided with the package).

      Some utility scripts are included (for example, to open/close doors), but the Daedalus package does not contain games examples or starter kits: we give you a tool to quickly create dungeons and game levels, you create the game.

      Daedalus is still under development and there will be more features in next releases.

      Please use our Questions page (here) to suggest features and improvements!

      Features List

      • Full 3D generation: create multi-level dungeons/buildings/towers spanning on multiple floors!
      • Fast generation times
      • Perimeter definition: perimeter walls/columns use their own prefabs
      • Editor generation: create your game levels in Editor and modify/edit them as you see fit
      • Runtime generation: give your players a different gaming experience every time they play your game!
      • StandardMap: great for complex game levels and dungeons
      • 2D/3D TileMap: ideal for classic 2D/3D rogue-like games
      • 2DToolKit support: generate random 2DToolKit TileMaps in a breeze!
      • two different generation algorithms: more to come!
      • non-linearity percentage value: straight, ordinary mazes or twisted, complex dungeons? You decide
      • sparseness percentage value: add “rocky” (empty) zones to your map for more unpredictable results
      • dead-end percentage value: decide whether to open dead-ends or not
      • min/max number of rooms in a map
      • min/max room width/length
      • doors density percentage
      • spawn player
      • create entrance/exit
      • force entrance/exit in rooms only (or both in corridors and/or rooms)
      • draw “rocks” (unwalkable tiles)
      • save/load maps as Prefabs
      • map orientation plane (XY, XZ, YZ)
      • create ceilings (in corridors only, rooms only or both)
      • tile variations (randomize each feature: walls, floors, ceilings, columns, doors, etc.)
      • variation weights: choose which tile variations are most often used
      • visual debug: quickly select and isolate map features such as floors, walls, columns, etc.
      • tile rotations: add some more randomness to your map
      • default Art Assets included (2D and 3D)
      • static batching support: save some precious drawcalls with MeshCombine and Static Batching (Unity Pro only)
      • seed-based generation

      2DToolKit support needs the 2DToolKit plugin by Unikron, which is not included in this package. Check it out here

      General Concepts

      Daedalus is made of two main entities: scripts and art assets. Scripts are used to set generation parameters for both editor and runtime map creation, while art assets are the graphic elements which will made up your game level’s visuals.

      The scripts components allow the user to set generation values to create random game levels, from regular, straight mazes to complex dungeons with different sizes rooms and contorted hallways.

      Art Assets

      Together with the scripts, in the package you will find some ready-to-use art assets. If you don’t specify your own art assets to use for the game level that will be generated, default ones will be used.

      In order to make art assets correctly work together with the generation algorithm, they need to be created in your graphic software (e.g. 3Dsmax™, Maya™, Blender, Photoshop™, etc.) following a few rules.

      Have a look at the Art Assets Creation Guidelines chapter to see how art assets should be created.

      Script Components

      To generate a map, you need at least three script components associated to a GameObject (e.g., an empty GameObject): Generator Behaviour, Map Interpreter Behaviour and Physical Map Behaviour.

      Generator Behaviour is a script component that controls the virtual map generation; it sets map generation parameters such as Width, Length, rooms creation, etc.

      Map Interpreter Behaviour adds options and paramters to the map interpretation and decides what to create and how; as of now, it can handle two main map types: StandardMap and TileMap.

      Check out the Map Types chapter for more info about map types.

      Physical Map Behaviour takes care of creating the physical map itself. Here you can also set graphic variations and their weights.

      For an in-depth sight of script components and how to use them, have a look at the Using Daedalus and Interface chapters.

      Runtime Generation Component

      For runtime level generation, you need to assign one more script component: Runtime Generator Behaviour. This script will tell Daedalus that you want to generate game levels at runtime. Any time you will press Play in the Editor, a different map will be generated, using all of the parameters set in the other scripts (Generator Behaviour, Interpreter Behaviour and Physical Map Behaviour).

      Editor Generation / Runtime Generation

      Daedalus can create game levels both in Editor and at runtime.

      Editor Generation

      Using Daedalus in Editor mode you can quickly generate maps and game levels and modify them as you see fit. After you set the generation parameters, creating a game level is a one-click operation: Daedalus will lay down the tiles in the map for you.

      Once the generation is done, you can place items, enemies, power-ups, treasure chests and any other sort of game entities anywhere you like and start creating your game logic. This process speeds up the creation of game levels which will otherwise require great time and effort.

      If you don’t like one particular portion of the map, you can delete it and add different features by hand.

      Runtime Generation

      Runtime generation offers game developers the chance to create different maps and game levels at runtime. Everytime your game level starts, a different map will be generated, thus giving players a different gaming experience any time they play your game.

      You’ll still have to create your own game logic and items distribution algorithms, but Daedalus will handle all the game level generation for you. In fact, you can extend the provided code to decide when, where and how to spawn enemies, treasure chests, power-ups, etc.

      Highly-tested generation algorithms used by Daedalus make it safe to use runtime generation: your player will never get stuck in a dead-end dungeon! It is also possible to use the option to create an entrance and an exit from the dungeon, so you can safely give your players a starting and ending point in the map.

      Map Types

      At this stage, Daedalus is able to create two different kind of maps: StandardMap and TileMap. StandardMap is used only for 3D game levels while TileMap can be used for both levels made up of 3D prefabs and sprite-based maps.

      Both map types are tile-based, but each one uses a different layout.
      From version 1.0.0, Daedalus can generate full 3D game levels, both with StandardMaps and TileMaps. Check out the Multi-Storey chapter to learn more.

      Since the implementation of the Multi-Storey feature in version 1.0.0, it is possible to define a map as ‘TWO_DEE‘ or ‘THREE_DEE‘. This is not something about 2D graphics VS 3D, but it’s a way to tell the generator that you want to create a single-floor map (‘TWO_DEE’) instead of a multi-floor dungeon (‘THREE_DEE’). All 2D maps such as Sprites2D, Sprites3D and 2DToolKit maps are forced to be ‘TWO_DEE’ since multi-floor is not enabled for them.


      In StandardMap, you can have walls with any size. They are generated above the floor, between one tile and it’s neighbours. Columns are placed at the four corners of a floor tile. The only rule is that the floor tile side must be equivalent to the sum of the column length and the wall length.


      TileMaps use a more classic approach: every feature (wall, floor, column, etc.) is big exacly one tile. This type of layout allows you to create 2D game levels as well. In fact, Daedalus offers integration with 2DToolKit by Unikron.

      Map Elements

      Daedalus uses a few map elements to generate game levels. Some are optional (like ceilings, doors, rocks), while others are necessary (floors, walls). The resulting map can be a maze (only corridors connecting to each other, no rooms) or a dungeon (corridors connecting to each other, rooms connecting to each other, corridors connecting to rooms).


      Floors can be of two types: corridor floors and room floors. You can specify a different prefab to use for each type of floor.


      Walls are used to define corridors and rooms. You can specify a different prefab to use for each type of wall (e.g., corridor walls, room walls) and you can even use a different prefab for the map perimeter.


      In StandardMap, columns are placed at the four corners of each floor tile (or, if you prefer, at the sides of each wall). In TileMap each column is one tile big (as any other feature). You can specify a different type of column (prefab) for corridors and rooms, and you can also create columns in the middle of a room (using yet another prefab). You can use a different column prefab for the perimeter, too.


      In StandardMap, doors occupy one full wall. In TileMap each door is one tile big (as any other feature of the map). You can specify two different prefabs for doors connecting a corridor to a room and doors connecting two rooms.


      Ceilings work just as the floors: they are always one tile big (both in StandardMap and TileMap). Two different prefabs can be specified for ceilings: corridor ceiling and room ceiling. TileMap can use ceilings only for 3D game levels (e.g., they make no sense in 2D game levels).


      Rocks represent “empty” tiles. You can use them both in StandardMap and TileMap. They are useful if you want to show some details in empty zones, not just a flat, black color.


      Two different prefabs can be specified to use with the Create Entrance/Exit option. This is especially useful if you want to create custom graphics for the entrance/exit of the game level. For example, you may use this feature to create a special tile prefab that spawns the player in the entrance tile, or you may place a prefab that contains the logic to solve a quest when you reach the exit tile of the dungeon.


      Ladders are used to connect two floors of a multi-storey dungeon. There are two types of prefab: Ladder and Ladder2. The former is a 1-tile big prefab which is used in corridors, while the latter is a 2-tiles big prefab connecting two rooms on different floors.

      Advanced Features


      The Multi-Storey feature allows you to create multiple floors dungeons, towers, buildings, etc. You can set some values such as number of storeys or distance between two floors, and let the generator take care of the everything else.

      All the floors will be connected through ladders, stairs or elevators (which you will need to specify prefabs for) thus ensuring full navigability of the map.

      At this stage, if you enable the ‘Create Entrance and Exit‘ option, entrance will be created on the base floor and exit will be created on the top-most floor. In next versions you will be able to decide on which floor to create etrance/exit points.

      It is not possible (yet) using different Art Assets on different floors of a multi-storey dungeon, but it will be in the next releases.

      Multi-Storey will work only with 3D maps (StandardMap/TileMap); it does not support sprite-based maps (Sprites2D, Sprites3D or 2DToolKit).

      Directional Floors

      Directional Floors feature will create consecutive floor tiles. This is especially useful if you want to create road-like floors. In order for this feature to work, you will need to supply the generator with all the directional tiles needed (e.g., straight tile, U-tile, cross tile, curve tile, T-Tile).

      Directional Floors will work both with 2D and 3D maps (StandardMap/TileMap). When this option is enabled, inner rooms borders will be directional, too.

      Have a look at the Art Assets Creation Guidelines chapter to see how to create directional floors.

      Perimeter Walls

      The Perimeter Walls feature creates a perimeter all around the map’s rectangle with given prefabs (e.g., walls, columns). It is useful to differentiate the perimeter from the inner side of the map. If used in combo with the Multi-Storey feature it can create really nice game levels (for example, think of a whole building with external walls and inner rooms/corridors).

      Seed-Based Generation

      Daedalus uses seed-based generation to help you recreate the same map anytime you need it. For example, in a multiplayer game scenario, you would just setup a scene with a dungeon in it, make all the players load this scene and just pass them a seed value to make all the clients create the same map for everyone.

      Even when the ‘Use Seed‘ option is not in use, the generator will rely on seeds. In the ‘Advanced Options‘ area of the GeneratorBehaviour inspector you will find which seed was used for the last generation task.

      Visual Debugger

      Daedalus comes with a Visual Debugger Editor script. This tool can be really useful to select specific elements of the map for multi-object editing. It also works as a visual debugger for the game level.

      All of the commands in the Visual Debugger window are actually methods you can use and extend in code. For example, the ‘Select Corridor Floors‘ command will select all the corridor floors in the map; you could use this method to retrieve all the corridor floors via code and maybe randomly spawn some monster on them or add some particular properties to those tiles.

      Have a look at the Scripting Reference chapter for a list of all the methods exposed in the code.

      Generation Algorithms

      At this stage, Daedalus supports two different generation algorithms: “Hunt & Kill” and “Recursive Backtracking”. You can read more about them here and here. More will be added in next releases of Daedalus.

      Using Daedalus

      Map Templates

      Map Templates are ready-to-use prefabs to get you started using Daedalus. Just drag one of the prefabs from the Map_Templates folder into the scene: a map will appear using the default graphics. Now you can select the map GameObject in the hierarchy and start modifying its parameters and options in the inspector. For example, you can start modifying the map using some of the art assets included in the package (you can find them into the Art_Assets folder) or import your own and use them instead.

      Scene Files

      Inside the folder structure you will find a ‘Scenes’ folder. The scenes contained in this folder were made to show you some of the main features of Daedalus. They also work as a starting point to create your own game levels.

      • StandardMap_Default_Multi-Floor: This example shows a StandardMap using default graphics. It also shows the ‘Multi-Storey‘ feature.
      • StandardMap_Fantasy_Multi-Floor: This scene is basically like the previous, but it uses the Fantasy Art Assets included with the package.
      • StandardMap_SciFi: An example scene using the SciFi Art Assets included with the package, featuring ‘Directional Floors
      • StandardMap_SciFi_Runtime_Multi-Floor: An example of a StandardMap using Runtime generation and multiple floors
      • TileMap_Sprite2D: This scene uses Unity 2D sprites for the tiles
      • TileMap_Sprite3D: An example of a TileMap using ‘3D sprites’ (simple planes with a texture)
      • TileMap_Tiles3D_Default_DirectionalPerimeter: This scene uses a TileMap with default graphics and Directional Floors
      • TileMap_Tiles3D_Maze: A simple maze based on TileMap
      • TileMap_Tiles3D_MultiFloor: This example shows a TileMap with multiple floors
      • TileMap_2DToolKit_Sprites: TileMap using 2DToolKit integration and default sprites
      • TileMap_2DToolKit_Sprites_Sample1: TileMap using 2DToolKit integration and custom sprites
      • TileMap_2DToolKit_TileMap: An example scene using 2DToolKit’s TileMap
      • TileMap_2DToolKit_TileMap_Sample1: An example scene using 2DToolKit’s TileMap with custom art assets

      In order to load the 2DToolKit scene examples, you need to first import 2DToolKit package and then the Daedalus_2DToolKit_Integration package from the Daedalus_Import folder.

      Starting from scratch

      If you want to create a new map from scratch, follow these simple steps:

      1. Create an empty GameObject
      2. Assign the Generator Behaviour script to the GameObject (you can find it in the Daedalus_Core/Scripts/Generation folder)
      3. The Generator Behaviour component will ask you to add two more components: Map Interpreter and Physical Map
      4. Decide what kind of map you want to generate, and assign the relative Map Interpreter Behaviour script (they’re in the Daedalus_Core/Scripts/Interpretation folder)
      5. Now assign the correct Physical Map Behaviour script (from the Daedalus_Core/Scripts/PhysicalMap sub-folders)
      6. Hit the ‘Generate‘ button in the Generator Behaviour script: a new map will be created, using the default graphics

      Now you can go on and modify options, parameters and art assets you wish to use for your map.


      Generator Behaviour

      The Generator Behaviour script component gathers all the information, options and parameters relating to the map creation, and this is where you actually generate a map or save a game level as a prefab.

      • Map Dimensions Type: ‘TWO_DEE’ for single-floor maps, ‘THREE_DEE’ for multi-floor
      • Map Width: the map width
      • Map Length: the map length
      • Generation Algorithm: the algorithm to use
      • Use Seed: whether to use seed-based generation or not
      • Seed: the seed value to use with seed-based generation. Requires ‘Use Seed‘ to be enabled
      • Non-Linearity %: a percentage value to generate straight corridors (0%) or contorted ones (100%)
      • Sparseness %: a percentage value to generate ‘sparse’ maps (with ‘empty’ spots)
      • Link Dead-Ends %: a percentage value to avoid dead-end corridors
      • Create Rooms: when enabled, rooms will be generated
      • Min Rooms: minimum number of rooms in the map (only active if ‘Create Rooms‘ is enabled)
      • Max Rooms: maximum number of rooms in the map (only active if ‘Create Rooms‘ is enabled)
      • Min Room Width: minimum desired width for the rooms (only active if ‘Create Rooms‘ is enabled)
      • Max Room Width: maximum desired width for the rooms (only active if ‘Create Rooms‘ is enabled)
      • Min Room Length: minimum desired length for the rooms (only active if ‘Create Rooms‘ is enabled)
      • Max Room Length: maximum desired length for the rooms (only active if ‘Create Rooms‘ is enabled)
      • Passage Density %: the percentage value to open passages (‘doors’) (only active if ‘Create Rooms‘ is enabled)
      • Multi-Storey: when enabled will generate multi-floor maps (only active if ‘Map Dimensions Type‘ is ‘THREE_DEE’)
      • Number of Storeys: the number of floors in a multi-floor map (only active if ‘Multi-Storey‘ is enabled)
      • Create Entrance and Exit: whether to instantiate entrance and exit prefabs
      • Force in Room: if enabled, entrance/exit prefabs will be created into rooms; otherwise, they could be created in rooms as well as in corridors (only active if ‘Create Rooms‘ is enabled)
      • Print Timings: this option will print debug messages with generation timings (just for testing and debug purposes)
      • Generate!: this is the one button to generate a map
      • Save: this button will allow you to save your map as a prefab

      Map Interpreter Behaviour

      A Map Interpreter Behaviour interprets all the data according to its type and creates the virtual map. There are two main interpreters at this time: Standard Map Interpreter Behaviour and Tile Map Interpreter Behaviour. They both share almost all the same options, except for a couple that are only used by the TileMap interpreter.

      Shared Map Interpreter Options (StandardMap and TileMap)

      • Draw Rocks: when enabled, it will work together with the Sparseness % value and will instantiate prefabs in empty areas
      • Draw Wall Corners: when enabled, corner tiles will be created
      • Place Doors in Passages: when enabled, doors will be created in all the passages
      • Draw Columns in Rooms: whether to create columns in rooms
      • Use Directional Floors: whether to use directional floors
      • Randomize Orientations: when enabled, orientation of each tile will be randomly chosen (0°, 90°, 180°, 270°)
      • Use Perimeter Walls: if enabled, you will be able to use different prefabs for the map’s perimeter
      • Add Ceiling to Corridors: when enabled, ceilings will be added on corridor tiles
      • Add Ceiling to Rooms: when enabled, ceilings will be added on room tiles

      TileMap Interpreter

      • Fill with Floors: when enabled, will create the correct floor tile (e.g., room floor/corridor floor) under walls, columns, doors
      • Orient Perimeter: if enabled will make the perimeter’s tiles follow the orientation

      Physical Map Behaviour

      The Physical Map Behaviour actually ‘draws’ the map using the data from the virtual map. There are different Physical Map behaviours in Daedalus, each one with its own options and parameters. Some of them share a bunch of options, depending on the map type. Here you can plug in your own Art Assets, their variations and weights.

      Shared Physical Map Options

      • Add Player: when enabled, will instantiate the player’s prefab in the entrance tile (only active if ‘Create Entrance and Exit‘ is enabled)
      • Player Prefab: the prefab to instatiate for the player (only active if ‘Add Player‘ is enabled)
      • Perform Batching: whether to use Static Batching with unmovable objects in the map (Unity Pro only)
      • Orientation: the orientation plane to use for the map creation (XY, XZ, YZ)

      Perform Batching‘ and ‘Orientation‘ are disabled for 2DToolKit maps because they are handled by 2DToolKit itself. Please refer to 2DToolKit documentation to learn more.

      Meshes 3D Physical Map Options

      • Storey separation height: how much space (in height) should the generator leave between two floors of a multi-floor map (only active if ‘Multi-Storey‘ feature is enabled)

      ToolKit2D Sprites Physical Map Options

      • Tile texture size: the size of the sprite used for a tile. Used by the 2DToolKit integration. Please refer to 2DToolKit documentation for more info
      • Sprite Collection Data: used by the 2DToolKit integration. Please refer to 2DToolKit documentation for more info
      • Sprite Prefab: the 2DToolKit sprite prefab to use as one tile

      ToolKit2D Tiles Physical Map Options

      • Tile texture size: the size of the sprite used for a tile. Used by the 2DToolKit integration. Please refer to 2DToolKit documentation for more info
      • Pixels per meter: used by the 2DToolKit integration. Please refer to 2DToolKit documentation for more info

      Sprites 2D Physical Map Options

      • Tile Size: the size of the sprite prefab used for a tile
      • Sprite Prefab: the sprite prefab used for a tile

      Sprites 3D Physical Map Options

      • Tile Prefab: the prefab to use as a tile (usually, a simple 3D plane)

      Shared Tile Variations

      • Corridor Wall: walls delimiting a corridor
      • Corridor Floor: floors in corridor tiles (only active if ‘Use Directional Floors‘ is disabled)
      • Corridor Floor U: U-type floor (only active if ‘Use Directional Floors‘ is enabled)
      • Corridor Floor I: straight floor (only active if ‘Use Directional Floors‘ is enabled)
      • Corridor Floor L: curve (90°) floor (only active if ‘Use Directional Floors‘ is enabled)
      • Corridor Floor T: T-type floor (only active if ‘Use Directional Floors‘ is enabled)
      • Corridor Floor X: cross floor (only active if ‘Use Directional Floors‘ is enabled)
      • Corridor Column: column placed along a corridor’s walls
      • Room Wall: walls delimiting a room
      • Room Floor: floors in room tiles (only active if ‘Use Directional Floors‘ is disabled)
      • Room Floor Inside: the floor on the inner portion of the room (excluded the perimeter) (only active if ‘Use Directional Floors‘ is enabled)
      • Room Floor Border: straight floor on inner room’s perimeter (only active if ‘Use Directional Floors‘ is enabled)
      • Room Floor Corner: Corner floor on inner room’s perimeter (only active if ‘Use Directional Floors‘ is enabled)
      • Room Column: columns placed along a room’s walls
      • Inside Room Column: columns placed inside a room. Only active if ‘Draw Columns in Rooms’ is enabled
      • Door: the prefab to use for the doors
      • Room Door: the prefab to use for the doors
      • Passage Column: the columns to the left and to the right of a ‘passage’
      • Rock: the prefab to use in ‘empty‘ areas of the map. Only active if ‘Draw Rocks‘ is enabled
      • Entrance Prefab: the prefab to use in the entrance tile
      • Exit Prefab: the prefab to use in the exit tile
      • Perimeter Wall: the wall tile on the outer perimeter of a map (only active if ‘Use Perimeter Walls‘ option is enabled)
      • Perimeter Column: the column tile on the outer perimeter of a map (only active if ‘Use Perimeter Walls‘ option is enabled)

      Meshes 3D Tile Variations

      • Corridor Ceiling: ceilings in corridor tiles. Only active if ‘Ceiling on Corridors‘ is enabled
      • Room Ceiling: ceilings in room tiles. Only active if ‘Ceiling on Rooms‘ is enabled
      • Ladder: the ladder (single-tile) to use when connecting two floors of a multi-floor map (only active if ‘Multi-Storey‘ option is enabled)
      • Ladder 2: the ladder (double-tile) to use when connecting two floors of a multi-floor map (only active if ‘Multi-Storey‘ option is enabled)

      Scripting Reference

      Daedalus can be extended via code. We provide full source code within the package, so you are free to improve/extend the generator and all of its features and maybe add some new cool stuff.

      Exposed Methods

      As of now there are a few main methods exposed in the code that you can call to retrieve some useful data. More will come as new features get implemented.


      GameObject GetObjectAtPosition (Vector3 position)

      Returns the GameObject at a certain position, or null if none is found.

      Note that this will return the top-most GameObject at that position, so if there is a wall above a floor, the wall will be returned.

      Usage (example of a MonoBehaviour):


      List<GameObject> GetObjectsOfType(SelectionObjectType type)

      Returns all the GameObjects of a chosen SelectionObjectType in the Physical Map.

      Usage (example of a MonoBehaviour):

      SelectionObject Types

      • All: all objects in the map
      • Ceilings: all ceilings in the map (both rooms’ and corridors’ ceilings)
      • Columns: all columns in the map (corridors’, rooms’, passages’, perimeter’s columns)
      • CorridorCeilings: corridors’ ceilings
      • CorridorColumns: corridors’ columns
      • CorridorFloors: corridors’ floor tiles
      • Corridors: all objects in corridors (floors, walls, columns, ceilings)
      • CorridorWalls: corridors’ walls
      • Doors: all doors in the map
      • Floors: all floors in the map (both rooms’ and corridors’ floors)
      • InsideRoomsColumns: columns inside rooms
      • PassageColumns: columns on the sides of a passage (e.g., doors)
      • Perimeter: all objects in perimeter of a map (walls, columns)
      • Rocks: all rocks (e.g., ‘empty’ tiles) in the map
      • RoomCeilings: rooms’ ceilings
      • RoomColumns: columns on the sides of a room
      • RoomFloors: rooms’ floors
      • Rooms: all objects in the rooms of a map (floors, walls, columns, etc.)
      • RoomWalls: rooms’ walls
      • Unwalkable: all objects representing obstacles in the map (walls, columns, doors, rocks)
      • Walkable: all walkable objects in the map
      • Walls: all walls in the map (both rooms’ and corridors’ walls)


      List<GameObject> GetObjectsOfZone (int zoneNumber)

      Returns all the GameObjects of a given zone.

      Please note that Zones is a feature that is currently in the works; it will be available in next releases of Daedalus. For now, this method will return all the GameObjects in a floor of a multi-floor map.

      Usage (example of a MonoBehaviour):


      Vector3 GetStartPosition()

      Returns the starting position in a map.

      Usage (example of MonoBehaviour):


      Vector3 GetEndPosition()

      Returns the end (exit) position in a map.

      Usage (example of MonoBehaviour):

      Code Documentation

      At this link you can find the full code documentation for Daedalus.

      Please note that the code may change with the implementation of new features.

      Art Assets Creation Guidelines

      We have created a bunch of videos to help artists getting started creating Art Assets for Daedalus. More will be published from time to time following along the implementation of new features, so check back often our Video page.