Beispiel #1
0
    public override void OnInspectorGUI()
    {
        MapInterpreterBehaviour t = (MapInterpreterBehaviour)target;

        if (g == null)
        {
            g = t.gameObject.GetComponent <GeneratorBehaviour>();
        }
        if (p == null)
        {
            p = t.gameObject.GetComponent <PhysicalMapBehaviour>();
        }
        if (v == null)
        {
            v = t.gameObject.GetComponent <VirtualMapGeneratorBehaviour>();
        }

        t.drawRocks       = EditorGUILayout.Toggle("Draw Rocks", t.drawRocks);
        t.drawWallCorners = EditorGUILayout.Toggle("Draw Wall Corners", t.drawWallCorners);
        t.drawDoors       = EditorGUILayout.Toggle("Place Doors in Passages", t.drawDoors);

        if (v != null && v.HasRooms)
        {
            t.createColumnsInRooms = EditorGUILayout.Toggle("Draw Columns in Rooms", t.createColumnsInRooms);
        }

        t.useDirectionalFloors = EditorGUILayout.Toggle("Use Directional Floors", t.useDirectionalFloors);

        if (t.useDirectionalFloors)
        {
            t.randomOrientations = false;
        }
        else
        {
            t.randomOrientations = EditorGUILayout.Toggle("Randomize Orientations", t.randomOrientations);
        }

        if (t.useDirectionalFloors)
        {
            t.isolateDirectionalWallsForRooms = EditorGUILayout.Toggle(new GUIContent("Isolate Rooms", "If enabled, room corners will be isolated from the rest of the dungeon."), t.isolateDirectionalWallsForRooms);
        }

        t.usePerimeter = EditorGUILayout.Toggle("Use Perimeter Walls", t.usePerimeter);
//		if (t.usePerimeter) t.internalPerimeter =EditorGUILayout.Toggle("Internal Perimeter",t.internalPerimeter);

        if (g.mapDimensionsType == MapDimensionsType.THREE_DEE)
        {
            t.addCeilingToCorridors = EditorGUILayout.Toggle("Add Ceiling to Corridors", t.addCeilingToCorridors);
            if (v.HasRooms)
            {
                t.addCeilingToRooms = EditorGUILayout.Toggle("Add Ceiling To Rooms", t.addCeilingToRooms);
            }
        }
    }
Beispiel #2
0
    public override void OnInspectorGUI()
    {
        DiggingVirtualMapGeneratorBehaviour t = (DiggingVirtualMapGeneratorBehaviour)target;
        MapInterpreterBehaviour             interpreterBehaviour = t.gameObject.GetComponent <MapInterpreterBehaviour>();

        // Entrance/Exit (COMMON)
        EditorGUILayout.BeginHorizontal();
        t.createStartAndEnd = EditorGUILayout.Toggle("Create Entrance and Exit", t.createStartAndEnd);
        if (t.HasRooms && t.createStartAndEnd)
        {
            t.forceStartAndEndInRooms = EditorGUILayout.Toggle("Force in Room", t.forceStartAndEndInRooms);
        }
        EditorGUILayout.EndHorizontal();
        if (t.createStartAndEnd)
        {
            EditorGUILayout.MinMaxSlider(new GUIContent("Min & Max distance % between entrance and exit"), ref t.minimumDistanceBetweenStartAndEnd, ref t.maximumDistanceBetweenStartAndEnd, 0, 100);
        }


        t.algorithmChoice = (DiggingMapGeneratorAlgorithmChoice)EditorGUILayout.EnumPopup("Generation Algorithm: ", t.algorithmChoice);

        t.directionChangeModifier = EditorGUILayout.IntSlider(new GUIContent("Non-Linearity %", "The higher this is, the more winding the dungeon will be."), t.directionChangeModifier, 0, 100);
        t.sparsenessModifier      = EditorGUILayout.IntSlider(new GUIContent("Sparseness %", "The higher this is, the less branching and the shorter the dungeon will be."), t.sparsenessModifier, 0, 90); // Sparseness cannot be too high!
        t.openDeadEndModifier     = EditorGUILayout.IntSlider(new GUIContent("Link Dead Ends %", "The higher this is, the more the dungeon will not end abruptly."), t.openDeadEndModifier, 0, 100);

        if (interpreterBehaviour != null && interpreterBehaviour.SupportsRooms)
        {
            t.createRooms = EditorGUILayout.Toggle("Create Rooms", t.createRooms);
            if (t.createRooms)
            {
                EditorGUILayout.BeginHorizontal();
                t.minRooms = EditorGUILayout.IntSlider("Min Rooms", t.minRooms, 0, 10);
                t.maxRooms = EditorGUILayout.IntSlider("Max Rooms", t.maxRooms, 0, 10);
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                t.minRoomWidth = EditorGUILayout.IntSlider("Min Room Width", t.minRoomWidth, 2, 10);
                t.maxRoomWidth = EditorGUILayout.IntSlider("Max Room Width", t.maxRoomWidth, 2, 10);
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                t.minRoomHeight = EditorGUILayout.IntSlider("Min Room Length", t.minRoomHeight, 2, 10);
                t.maxRoomHeight = EditorGUILayout.IntSlider("Max Room Length", t.maxRoomHeight, 2, 10);
                EditorGUILayout.EndHorizontal();

                t.doorsDensityModifier = EditorGUILayout.IntSlider("Passage Density %", t.doorsDensityModifier, 0, 100);
                t.forceRoomTransversal = EditorGUILayout.Toggle(new GUIContent("Force Room Transversal", "If enabled, rooms will be placed such as to force their transversal from one end to the other of the dungeon."), t.forceRoomTransversal);
            }
        }
        else
        {
            t.createRooms = false;
        }
    }
    public override void OnInspectorGUI()
    {
        PhysicalMapBehaviour t = (PhysicalMapBehaviour)target;

        if (g == null)
        {
            g = t.gameObject.GetComponent <GeneratorBehaviour>();
        }
        if (i == null)
        {
            i = t.gameObject.GetComponent <MapInterpreterBehaviour>();
        }
        if (v == null)
        {
            v = t.gameObject.GetComponent <VirtualMapGeneratorBehaviour>();
        }

        if (v.createStartAndEnd)
        {
            t.createEntranceAndExit = EditorGUILayout.Toggle("Add Entrance and Exit", t.createEntranceAndExit);

            if (t.createEntranceAndExit)
            {
                //			EditorGUILayout.BeginHorizontal();
                t.createPlayer = EditorGUILayout.Toggle("Add Player", t.createPlayer);
                if (t.createPlayer)
                {
                    t.playerPrefab = EditorGUILayout.ObjectField("Player Prefab", t.playerPrefab, typeof(GameObject), true) as GameObject;
                }
                //			EditorGUILayout.EndHorizontal();
            }
        }

        if (!t.AutomaticBatching)
        {
            t.enabledBatching = EditorGUILayout.Toggle("Perform Batching", t.enabledBatching);
        }
        if (!t.AutomaticOrientation && !t.ForcedOrientation)
        {
            t.mapPlaneOrientation = (MapPlaneOrientation)EditorGUILayout.EnumPopup("Orientation", t.mapPlaneOrientation);
        }
    }
Beispiel #4
0
    public override void OnInspectorGUI()
    {
        errorStyle = new GUIStyle();
        errorStyle.normal.textColor = Color.red;

        GeneratorBehaviour           t = (GeneratorBehaviour)target;
        PhysicalMapBehaviour         physicalMapBehaviour   = t.gameObject.GetComponent <PhysicalMapBehaviour>();
        MapInterpreterBehaviour      interpreterBehaviour   = t.gameObject.GetComponent <MapInterpreterBehaviour>();
        VirtualMapGeneratorBehaviour vmapGeneratorBehaviour = t.gameObject.GetComponent <VirtualMapGeneratorBehaviour>();

        targetInstance = t;

        t.mapDimensionsType = (MapDimensionsType)EditorGUILayout.EnumPopup("Map Dimensions Type", t.mapDimensionsType);

        t.MapWidth  = EditorGUILayout.IntSlider("Map Width", t.MapWidth, 2, GeneratorBehaviour.MAX_SIZE);
        t.MapHeight = EditorGUILayout.IntSlider("Map Length", t.MapHeight, 2, GeneratorBehaviour.MAX_SIZE);

        EditorGUILayout.BeginHorizontal();
        t.useSeed = EditorGUILayout.Toggle("Use seed", t.useSeed);
        EditorGUI.BeginDisabledGroup(t.useSeed == false);
        t.seed = EditorGUILayout.IntSlider("Seed", t.seed, 0, 10000);
        EditorGUI.EndDisabledGroup();
        EditorGUILayout.EndHorizontal();

        if (t.mapDimensionsType == MapDimensionsType.THREE_DEE)
        {
            t.multiStorey = EditorGUILayout.Toggle("Multi-Storey", t.multiStorey);
            if (t.multiStorey)
            {
                t.numberOfStoreys = EditorGUILayout.IntSlider("Number of Storeys", t.numberOfStoreys, 1, 10);
            }
            else
            {
                t.numberOfStoreys = 1;
            }
        }
        else
        {
            t.multiStorey     = false;
            t.numberOfStoreys = 1;
        }

        this.showAdvanced = EditorGUILayout.Foldout(this.showAdvanced, "Advanced Options");
        if (this.showAdvanced)
        {
            GUILayout.BeginHorizontal();
            t.printTimings = EditorGUILayout.Toggle("Print Timings", t.printTimings);
            GUILayout.EndHorizontal();
            EditorGUILayout.LabelField("Last used seed: " + t.lastUsedSeed);
            showDebugCoordinates = EditorGUILayout.Toggle("Show Debug Coordinates", showDebugCoordinates);
            showDebugConnections = EditorGUILayout.Toggle("Show Debug Connections", showDebugConnections);
        }

        EditorGUI.BeginDisabledGroup(Application.isPlaying == true);
        bool canGenerate = true;

        if (vmapGeneratorBehaviour == null)
        {
            GUILayout.Label("Attach a Virtual Map Generator Behaviour to enable generation!", errorStyle);
            canGenerate = false;
        }
        if (physicalMapBehaviour == null)
        {
            GUILayout.Label("Attach a Physical Map Behaviour to enable generation!", errorStyle);
            canGenerate = false;
        }
        else if (t.mapDimensionsType == MapDimensionsType.THREE_DEE && !physicalMapBehaviour.SupportsThreeDeeMap)
        {
            GUILayout.Label("The attached Physical Map Behaviour does not support a 3D map!", errorStyle);
            canGenerate = false;
        }
        if (interpreterBehaviour == null)
        {
            GUILayout.Label("Attach a Map Interpreter Behaviour to enable generation!", errorStyle);
            canGenerate = false;
        }

        EditorGUI.BeginDisabledGroup(!canGenerate);
        if (GUILayout.Button("Generate!"))
        {
            t.Generate();
        }
        EditorGUI.EndDisabledGroup();

        #region Save/Load buttons
        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Save"))
        {
            SavePrefab();
        }
        EditorGUILayout.EndHorizontal();
        #endregion
        EditorGUI.EndDisabledGroup();
    }
    public void Generate()
    {
        isCurrentlyGenerating = true;

        // Make sure we have a VirtualMapGeneratorBheaviour component
        virtualMapGeneratorBehaviour = gameObject.GetComponent <VirtualMapGeneratorBehaviour>();
        if (virtualMapGeneratorBehaviour == null)
        {
            Debug.LogError("You need to attach a VirtualMapGeneratorBehaviour to this gameObject to enable generation!", this);
            return;
        }

        // Make sure we have a PhysicalMapBehaviour component
        physicalMapBehaviour = gameObject.GetComponent <PhysicalMapBehaviour>();
        if (physicalMapBehaviour == null)
        {
            Debug.LogError("You need to attach a PhysicalMapBehaviour to this gameObject to enable generation!", this);
            return;
        }

        // Make sure we have a MapInterpreterBehaviour component
        interpreterBehaviour = gameObject.GetComponent <MapInterpreterBehaviour>();
        if (interpreterBehaviour == null)
        {
            Debug.LogError("You need to attach a MapInterpreterBehaviour to this gameObject to enable generation!", this);
            return;
        }

        // Remove the existing map
        if (rootMapGo != null)
        {
            if (physicalMap != null)
            {
                physicalMap.CleanUp();
                DestroyImmediate(physicalMap);
            }

            if (Application.isPlaying)
            {
                Destroy(rootMapGo);
            }
            else
            {
                DestroyImmediate(rootMapGo);
            }
            virtualMaps = null;
            physicalMap = null;
        }

        // Remove any other existing children as well
        foreach (Transform childTr in this.transform)
        {
            DestroyImmediate(childTr.gameObject);
        }


        if (printTimings)
        {
            preDate = System.DateTime.Now;
        }

        if (!ForceCommonSenseOptions())
        {
            return;
        }

        physicalMapBehaviour.MeasureSizes();
        SetGeneratorValues();

        virtualMapGeneratorBehaviour.Initialise();
        lastUsedSeed = virtualMapGeneratorBehaviour.InitialiseSeed(useSeed, seed);
        virtualMaps  = virtualMapGeneratorBehaviour.GenerateAllMaps(MapWidth, MapHeight, numberOfStoreys);

        mapInterpreter = interpreterBehaviour.Generate();

        physicalMap = physicalMapBehaviour.Generate(virtualMaps, this, mapInterpreter);

        this.rootMapGo = physicalMap.rootMapGo;

        if (printTimings)
        {
            postDate = System.DateTime.Now;
            TimeSpan timeDifference = postDate.Subtract(preDate);
            Debug.Log("Generated in " + timeDifference.TotalMilliseconds.ToString() + " ms");
        }

        BroadcastMessage("DungeonGenerated", SendMessageOptions.DontRequireReceiver);
        isCurrentlyGenerating = false;
    }
Beispiel #6
0
    override public bool CheckDefaults()
    {
        MapInterpreterBehaviour interpreterBehaviour = GetComponent <MapInterpreterBehaviour>();

        if (interpreterBehaviour is TileMapInterpreterBehaviour)
        {
            corridorWallVariations   = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWall", corridorWallVariations);
            corridorFloorVariations  = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloor", corridorFloorVariations);
            corridorColumnVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorColumn", corridorColumnVariations);

            roomWallVariations         = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWall", roomWallVariations);
            roomFloorVariations        = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomFloor", roomFloorVariations);
            roomColumnVariations       = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomColumn", roomColumnVariations);
            insideRoomColumnVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomInsideColumn", insideRoomColumnVariations);

            corridorFloorUVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloorU", corridorFloorUVariations);
            corridorFloorIVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloorI", corridorFloorIVariations);
            corridorFloorLVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloorL", corridorFloorLVariations);
            corridorFloorTVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloorT", corridorFloorTVariations);
            corridorFloorXVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorFloorX", corridorFloorXVariations);

            roomFloorInsideVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomFloor", roomFloorInsideVariations);
            roomFloorCornerVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomFloorCorner", roomFloorCornerVariations);
            roomFloorBorderVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomFloorBorder", roomFloorBorderVariations);

            perimeterWallVariations   = CheckDefault("Daedalus_Resources/2D/Prefabs2D/PerimeterWall", perimeterWallVariations);
            perimeterColumnVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/PerimeterColumn", perimeterColumnVariations);

            corridorWallOVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallO", corridorWallOVariations);
            corridorWallUVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallU", corridorWallUVariations);
            corridorWallIVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallI", corridorWallIVariations);
            corridorWallLVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallL", corridorWallLVariations);
            corridorWallTVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallT", corridorWallTVariations);
            corridorWallXVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/CorridorWallX", corridorWallXVariations);

            roomWallOVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallO", roomWallOVariations);
            roomWallUVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallU", roomWallUVariations);
            roomWallIVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallI", roomWallIVariations);
            roomWallLVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallL", roomWallLVariations);
            roomWallTVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallT", roomWallTVariations);
            roomWallXVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomWallX", roomWallXVariations);

            doorVariations          = CheckDefault("Daedalus_Resources/2D/Prefabs2D/Door", doorVariations);
            roomDoorVariations      = CheckDefault("Daedalus_Resources/2D/Prefabs2D/RoomDoor", roomDoorVariations);
            passageColumnVariations = CheckDefault("Daedalus_Resources/2D/Prefabs2D/DoorColumn", passageColumnVariations);
            rockVariations          = CheckDefault("Daedalus_Resources/2D/Prefabs2D/Rock", rockVariations);
        }

        if (!entrancePrefab)
        {
            entrancePrefab = Resources.Load("Daedalus_Resources/Shared/Prefabs/DefaultEntrance", typeof(GameObject)) as GameObject;
        }
        if (!exitPrefab)
        {
            exitPrefab = Resources.Load("Daedalus_Resources/Shared/Prefabs/DefaultExit", typeof(GameObject)) as GameObject;
        }
        if (!playerPrefab)
        {
            playerPrefab = Resources.Load("Daedalus_Resources/Shared/Prefabs/Player2D", typeof(GameObject)) as GameObject;
        }

        mapPlaneOrientation = MapPlaneOrientation.XY;

        return(true);
    }
Beispiel #7
0
    override public bool CheckDefaults()
    {
        // TODO: Instead of checking the type, we should use inheritance: there should be a PhysicalMap-MapInterpreter pair class that defines the default
        MapInterpreterBehaviour interpreterBehaviour = GetComponent <MapInterpreterBehaviour>();

        if (interpreterBehaviour is StandardMapInterpreterBehaviour)
        {
            corridorWallVariations    = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorWall", corridorWallVariations);
            corridorFloorVariations   = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorFloor", corridorFloorVariations);
            corridorColumnVariations  = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumn", corridorColumnVariations);
            corridorCeilingVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorCeiling", corridorCeilingVariations);

            roomWallVariations         = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomWall", roomWallVariations);
            roomFloorVariations        = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomFloor", roomFloorVariations);
            roomColumnVariations       = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumn", roomColumnVariations);
            insideRoomColumnVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumn", insideRoomColumnVariations);
            roomCeilingVariations      = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomCeiling", roomCeilingVariations);

            corridorFloorUVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorU", corridorFloorUVariations);
            corridorFloorIVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorI", corridorFloorIVariations);
            corridorFloorLVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorL", corridorFloorLVariations);
            corridorFloorTVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorT", corridorFloorTVariations);
            corridorFloorXVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorX", corridorFloorXVariations);

            roomFloorInsideVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomFloor", roomFloorInsideVariations);
            roomFloorCornerVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomFloorCorner", roomFloorCornerVariations);
            roomFloorBorderVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomFloorBorder", roomFloorBorderVariations);

            corridorWallOVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnO", corridorWallOVariations);
            corridorWallUVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnU", corridorWallUVariations);
            corridorWallIVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnI", corridorWallIVariations);
            corridorWallLVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnL", corridorWallLVariations);
            corridorWallTVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnT", corridorWallTVariations);
            corridorWallXVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultCorridorColumnX", corridorWallXVariations);

            roomWallOVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnO", roomWallOVariations);
            roomWallUVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnU", roomWallUVariations);
            roomWallIVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnI", roomWallIVariations);
            roomWallLVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnL", roomWallLVariations);
            roomWallTVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnT", roomWallTVariations);
            roomWallXVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomColumnX", roomWallXVariations);

            doorVariations          = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultDoor", doorVariations);
            roomDoorVariations      = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRoomDoor", roomDoorVariations);
            passageColumnVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultDoorColumn", passageColumnVariations);
            rockVariations          = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultRock", rockVariations);

            perimeterWallVariations   = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultPerimeter", perimeterWallVariations);
            perimeterColumnVariations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultPerimeterColumn", perimeterColumnVariations);

            ladderVariations  = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultLadder1", ladderVariations);
            ladder2Variations = CheckDefault("Daedalus_Resources/3D/StandardMap/DefaultLadder2", ladder2Variations);
        }
        else if (interpreterBehaviour is TileMapInterpreterBehaviour)
        {
            corridorWallVariations    = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWall", corridorWallVariations);
            corridorFloorVariations   = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorFloor", corridorFloorVariations);
            corridorColumnVariations  = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorColumn", corridorColumnVariations);
            corridorCeilingVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorCeiling", corridorCeilingVariations);

            roomWallVariations         = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWall", roomWallVariations);
            roomFloorVariations        = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomFloor", roomFloorVariations);
            roomColumnVariations       = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomColumn", roomColumnVariations);
            insideRoomColumnVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomInsideColumn", insideRoomColumnVariations);
            roomCeilingVariations      = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomCeiling", roomCeilingVariations);

            corridorFloorUVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorU", corridorFloorUVariations);
            corridorFloorIVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorI", corridorFloorIVariations);
            corridorFloorLVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorL", corridorFloorLVariations);
            corridorFloorTVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorT", corridorFloorTVariations);
            corridorFloorXVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorX", corridorFloorXVariations);

            roomFloorInsideVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomFloor", roomFloorInsideVariations);
            roomFloorCornerVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomFloorCorner", roomFloorCornerVariations);
            roomFloorBorderVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomFloorBorder", roomFloorBorderVariations);

            corridorWallOVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallO", corridorWallOVariations);
            corridorWallUVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallU", corridorWallUVariations);
            corridorWallIVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallI", corridorWallIVariations);
            corridorWallLVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallL", corridorWallLVariations);
            corridorWallTVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallT", corridorWallTVariations);
            corridorWallXVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockCorridorWallX", corridorWallXVariations);

            roomWallOVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallO", roomWallOVariations);
            roomWallUVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallU", roomWallUVariations);
            roomWallIVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallI", roomWallIVariations);
            roomWallLVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallL", roomWallLVariations);
            roomWallTVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallT", roomWallTVariations);
            roomWallXVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomWallX", roomWallXVariations);

            perimeterWallVariations   = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockPerimeterWall", perimeterWallVariations);
            perimeterColumnVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockPerimeterColumn", perimeterColumnVariations);

            doorVariations          = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockDoor", doorVariations);
            roomDoorVariations      = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRoomDoor", roomDoorVariations);
            passageColumnVariations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockDoorColumn", passageColumnVariations);
            rockVariations          = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockRock", rockVariations);

            ladderVariations  = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockLadder1", ladderVariations);
            ladder2Variations = CheckDefault("Daedalus_Resources/3D/Tiles3D/DefaultBlockLadder2", ladder2Variations);
        }

        if (!entrancePrefab)
        {
            entrancePrefab = Resources.Load("Daedalus_Resources/Shared/Prefabs/DefaultEntrance", typeof(GameObject)) as GameObject;
        }
        if (!exitPrefab)
        {
            exitPrefab = Resources.Load("Daedalus_Resources/Shared/Prefabs/DefaultExit", typeof(GameObject)) as GameObject;
        }

        return(true);
    }