diff --git a/Assets/Scripts/GameController.cs b/Assets/Scripts/GameController.cs
index ffd8047..afde710 100644
--- a/Assets/Scripts/GameController.cs
+++ b/Assets/Scripts/GameController.cs
@@ -11,6 +11,53 @@ public class GameController : MonoBehaviour {
     private Room start;
     private Room finish;
 
+    // Generation Settings
+    [Header("Tile Prefabs")]
+    [SerializeField]
+    GameObject BorderOuter;
+    [SerializeField]
+    GameObject BorderInner;
+    [SerializeField]
+    GameObject BorderSingle;
+    [SerializeField]
+    GameObject Ground;
+    [SerializeField]
+    GameObject Door;
+    [SerializeField]
+    GameObject Rock;
+    [SerializeField]
+    GameObject RockL;
+    [SerializeField]
+    GameObject RockU;
+    [SerializeField]
+    GameObject RockR;
+    [SerializeField]
+    GameObject RockD;
+    [SerializeField]
+    GameObject RockLU;
+    [SerializeField]
+    GameObject RockLR;
+    [SerializeField]
+    GameObject RockLD;
+    [SerializeField]
+    GameObject RockUR;
+    [SerializeField]
+    GameObject RockUD;
+    [SerializeField]
+    GameObject RockRD;
+    [SerializeField]
+    GameObject RockLURD;
+    [SerializeField]
+    GameObject RockLUD;
+    [SerializeField]
+    GameObject RockLUR;
+    [SerializeField]
+    GameObject RockURD;
+    [SerializeField]
+    GameObject RockLRD;
+
+    private Dictionary<GenerationProcessor.ExtendedTileType, GameObject> genPrefabs;
+
     private bool engineInitDone;
 
     public static GameController instance;
@@ -25,8 +72,31 @@ public class GameController : MonoBehaviour {
 
 	// Use this for initialization
 	void Start () {
+        genPrefabs = new Dictionary<GenerationProcessor.ExtendedTileType, GameObject>();
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.BorderOuter, BorderOuter);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.BorderInner, BorderInner);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.BorderSingle, BorderSingle);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.Rock, Rock);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockL, RockL);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockU, RockU);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockR, RockR);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockD, RockD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLU, RockLU);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLR, RockLR);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLD, RockLD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLURD, RockLURD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockRD, RockRD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockUR, RockUR);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockUD, RockUD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLUD, RockLUD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLUR, RockLUR);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockURD, RockURD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.RockLRD, RockLRD);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.Ground, Ground);
+        genPrefabs.Add(GenerationProcessor.ExtendedTileType.Door, Door);
+
         //ChangeState(GameState.INIT);
-	}
+    }
 	
 	// Update is called once per frame
 	void Update () {
diff --git a/Assets/Scripts/GenerationProcessor.cs b/Assets/Scripts/GenerationProcessor.cs
new file mode 100644
index 0000000..d21119d
--- /dev/null
+++ b/Assets/Scripts/GenerationProcessor.cs
@@ -0,0 +1,171 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class GenerationProcessor {
+    public enum ExtendedTileType
+    {
+        BorderOuter, BorderInner, BorderSingle, Ground, Door, Rock, RockL, RockU, RockR, RockD, RockLU, RockLR, RockLD, RockUR, RockUD, RockRD, RockLURD, RockLUD, RockLUR, RockURD, RockLRD
+    }
+    Dictionary<ExtendedTileType, GameObject> prefabs;
+    public GenerationProcessor(Dictionary<ExtendedTileType, GameObject> prefabs)
+    {
+        this.prefabs = prefabs;
+    }
+
+    public GameObject ProcessRoom(Dictionary<Vector2, Room.TileType> d)
+    {
+        GameObject root = new GameObject
+        {
+            name = "Room"
+        };
+        foreach (Vector2 v in d.Keys)
+        {
+            bool left = false;
+            bool top = false;   
+            bool right = false;
+            bool bottom = false;
+            // left bound
+            if(d.ContainsKey(v + new Vector2(-1, 0)))
+            {
+                if(d[v + new Vector2(-1, 0)] == d[v])
+                {
+                    left = true;
+                }
+            }
+            // top bound
+            if (d.ContainsKey(v + new Vector2(0, 1)))
+            {
+                if (d[v + new Vector2(0, 1)] == d[v])
+                {
+                    top = true;
+                }
+            }
+            // right bound
+            if (d.ContainsKey(v + new Vector2(1, 0)))
+            {
+                if (d[v + new Vector2(1, 0)] == d[v])
+                {
+                    right = true;
+                }
+            }
+            // bottom bound
+            if (d.ContainsKey(v + new Vector2(0, -1)))
+            {
+                if (d[v + new Vector2(0, -1)] == d[v])
+                {
+                    bottom = true;
+                }
+            }
+            ExtendedTileType type = ExtendedTileType.Ground;
+            // ---------------------------------------------------------------------------------------------------------------------------------------------
+            //  ^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~
+            //  
+            //                   ***        W A R N I N G    B A D    C O D E    A H E A D   !  !  !         ***
+            //                      __________________________________________________________________________
+            //
+            //                                  DON'T WATCH, UNLESS YOU WANT TO GET TRAUMATIZED!
+            //  
+            //  ^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~^~!~
+            // ---------------------------------------------------------------------------------------------------------------------------------------------
+            switch (d[v])
+            {
+                case Room.TileType.WALL:
+                    type = ExtendedTileType.BorderSingle;
+                    if(top && left && d.ContainsKey(v + new Vector2(-1, -1)) || top && right && d.ContainsKey(v + new Vector2(1, -1)) || right && bottom && d.ContainsKey(v + new Vector2(1, 1)) || left && bottom && d.ContainsKey(v + new Vector2(-1, 1)))
+                    {
+                        type = ExtendedTileType.BorderOuter;
+                    } else if(top && left || top && right || right && bottom || left && bottom)
+                    {
+                        type = ExtendedTileType.BorderInner;
+                    }
+                    break;
+                case Room.TileType.GROUND:
+                    type = ExtendedTileType.Ground;
+                    break;
+                case Room.TileType.DOOR:
+                    type = ExtendedTileType.Door;
+                    break;
+                case Room.TileType.ROCK:
+                    type = ExtendedTileType.Rock;
+                    if (top && !right && !left && !bottom)
+                    {
+                        type = ExtendedTileType.RockU;
+                    }
+                    if (left && !right && !bottom && !top)
+                    {
+                        type = ExtendedTileType.RockL;
+                    }
+                    if (right && !bottom && !left && !top)
+                    {
+                        type = ExtendedTileType.RockR;
+                    }
+                    if (bottom && !right && !left && !top)
+                    {
+                        type = ExtendedTileType.RockD;
+                    }
+                    if (left && top && !bottom && !right)
+                    {
+                        type = ExtendedTileType.RockLU;
+                    }
+                    if (left && right && !top && !bottom)
+                    {
+                        type = ExtendedTileType.RockLR;
+                    }
+                    if (left && bottom && !right && !top)
+                    {
+                        type = ExtendedTileType.RockLD;
+                    }
+                    if (top && right && !left && !bottom)
+                    {
+                        type = ExtendedTileType.RockUR;
+                    }
+                    if (top && bottom && !left && !right)
+                    {
+                        type = ExtendedTileType.RockUD;
+                    }
+                    if (right && bottom && !top && !left)
+                    {
+                        type = ExtendedTileType.RockRD;
+                    }
+
+                    if (left && top && bottom && !right)
+                    {
+                        type = ExtendedTileType.RockLUD;
+                    }
+                    if (left && top && right && !bottom)
+                    {
+                        type = ExtendedTileType.RockLUR;
+                    }
+                    if (top && right && bottom && !left)
+                    {
+                        type = ExtendedTileType.RockURD;
+                    }
+                    if (left && right && bottom && !top)
+                    {
+                        type = ExtendedTileType.RockLRD;
+                    }
+                    if (left && top && right && bottom)
+                    {
+                        type = ExtendedTileType.RockLURD;
+                    }
+                    break;
+            }
+
+            CreateGOFromType(v, type, root);
+        } 
+
+        return root;
+    }
+
+    private GameObject CreateGOFromType(Vector2 v, ExtendedTileType t, GameObject root)
+    {
+        GameObject tmp = null;
+        if (prefabs.ContainsKey(t) && root != null)
+        {
+            tmp = GameObject.Instantiate(prefabs[t], root.transform);
+            tmp.transform.position = v;
+        }
+        return tmp;
+    }
+}
diff --git a/Assets/Scripts/GenerationProcessor.cs.meta b/Assets/Scripts/GenerationProcessor.cs.meta
new file mode 100644
index 0000000..0e5b82f
--- /dev/null
+++ b/Assets/Scripts/GenerationProcessor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff430f09ad5abe842954d226715a96aa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/Room.cs b/Assets/Scripts/Room.cs
index 924ebbe..dcfc36a 100644
--- a/Assets/Scripts/Room.cs
+++ b/Assets/Scripts/Room.cs
@@ -5,11 +5,11 @@ using UnityEngine;
 public class Room : MonoBehaviour {
 
 	public enum TileType {
-		GROUND, WALL, DOOR
+		GROUND, WALL, DOOR, ROCK
 	}
 
 	Vector2 position;
-	Map<Vector2, TileType> tiles;
+	Dictionary<Vector2, TileType> tiles;
 
     List<Door> doors;
     List<Transform> spawnpoints;