From 499b4a6644fd2f73871cf493d00adc62e9dda6a6 Mon Sep 17 00:00:00 2001
From: mgorvat <gorvat.michael@gmail.com>
Date: Wed, 13 Apr 2016 02:01:32 +0400
Subject: [PATCH 1/2] Basic labyrinth classes

---
 Labyrinth/Labyrinth/Cell.cs       |  22 ++++
 Labyrinth/Labyrinth/Coordinate.cs |  54 ++++++++
 Labyrinth/Labyrinth/Labyrinth.cs  | 209 ++++++++++++++++++++++++++++++
 3 files changed, 285 insertions(+)
 create mode 100644 Labyrinth/Labyrinth/Cell.cs
 create mode 100644 Labyrinth/Labyrinth/Coordinate.cs
 create mode 100644 Labyrinth/Labyrinth/Labyrinth.cs

diff --git a/Labyrinth/Labyrinth/Cell.cs b/Labyrinth/Labyrinth/Cell.cs
new file mode 100644
index 0000000..4ef26c3
--- /dev/null
+++ b/Labyrinth/Labyrinth/Cell.cs
@@ -0,0 +1,22 @@
+using System;
+
+
+namespace Labyrinth.Labyrinth
+{
+    public class Cell
+    {
+        public enum CellContent { NONE, PLAYER, GOAL }
+
+        public bool down = true,
+                    right = true;
+
+        public CellContent content = CellContent.NONE;
+
+        public Cell() { }
+        public Cell(bool down, bool right)
+        {
+            this.down = down;
+            this.right = right;
+        }
+    }
+}
diff --git a/Labyrinth/Labyrinth/Coordinate.cs b/Labyrinth/Labyrinth/Coordinate.cs
new file mode 100644
index 0000000..1baa20c
--- /dev/null
+++ b/Labyrinth/Labyrinth/Coordinate.cs
@@ -0,0 +1,54 @@
+using System;
+
+namespace Labyrinth.Labyrinth
+{
+    class Coordinate
+    {
+        public enum Direction { UP, RIGHT, DOWN, LEFT }
+
+        private int x, y;
+        public int X
+        {
+            get { return x; }
+            set { x = value; }
+        }
+
+        public int Y
+        {
+            get { return y; }
+            set { y = value; }
+        }
+
+        public Coordinate(int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        public Coordinate(Coordinate from, Direction dir)
+        {
+            switch (dir)
+            {
+                case Direction.UP:
+                    this.x = from.x;
+                    this.y = from.y - 1;
+                    break;
+
+                case Direction.RIGHT:
+                    this.x = from.x + 1;
+                    this.y = from.y;
+                    break;
+
+                case Direction.DOWN:
+                    this.x = from.x;
+                    this.y = from.y + 1;
+                    break;
+
+                case Direction.LEFT:
+                    this.x = from.x - 1;
+                    this.y = from.y;
+                    break;
+            }
+        }
+    }
+}
diff --git a/Labyrinth/Labyrinth/Labyrinth.cs b/Labyrinth/Labyrinth/Labyrinth.cs
new file mode 100644
index 0000000..c752663
--- /dev/null
+++ b/Labyrinth/Labyrinth/Labyrinth.cs
@@ -0,0 +1,209 @@
+using System;
+using Labyrinth.Labyrinth;
+using System.Collections;
+
+namespace Labyrinth.MazeGenerator
+{
+    
+    class Labyrinth
+    {
+        public delegate int GameEndedDelegate();
+
+        private GameEndedDelegate callBack;
+        public GameEndedDelegate CallBack
+        {
+            set { callBack = value; }
+        }
+
+        private int size;
+        public int Size
+        {
+            get { return size; }
+        }
+        private Cell[][] labyrinth;
+        private Coordinate playerCoordinate;
+        private bool gameInProgress = false;
+
+        public Coordinate getPlayerCoordinate()
+        {
+            return playerCoordinate;
+        }
+
+
+        public Labyrinth(int size)
+        {
+            this.size = size;
+            labyrinth = new Cell[size][];
+            for (int i = 0; i < size; i++)
+            {
+                labyrinth[i] = new Cell[size];
+                for (int j = 0; j < size; j++)
+                {
+                    labyrinth[i][j] = new Cell();
+                }
+            }
+        }
+        /*
+        public void initializeGame()
+        {
+            gameInProgress = true;
+            ArrayList<Coordinate> pts = findDiametr();
+            getCell(pts.get(0).x, pts.get(0).y).content = CellContent.PLAYER;
+            playerCoordinate = pts.get(0);
+
+            getCell(pts.get(1).x, pts.get(1).y).content = CellContent.GOAL;
+        }
+        */
+        public void movePlayer(Coordinate.Direction dir)
+        {
+            if (gameInProgress)
+            {
+                //check whether we can move this direction
+                if (!checkWall(playerCoordinate, dir))
+                {
+                    getCell(playerCoordinate).content = Cell.CellContent.NONE;
+
+                    playerCoordinate = new Coordinate(playerCoordinate, dir);
+                    if (getCell(playerCoordinate).content == Cell.CellContent.GOAL)
+                    {
+                        callBack();
+                        gameInProgress = false;
+                    }
+                    getCell(playerCoordinate).content = Cell.CellContent.PLAYER;
+                }
+            }
+        }
+
+        public Cell getCell(int x, int y)
+        {
+            return labyrinth[x][y];
+        }
+
+        public Cell getCell(Coordinate coord)
+        {
+            return labyrinth[coord.X][coord.Y];
+        }
+
+        public void breakWall(int x, int y, Coordinate.Direction dir)
+        {
+            switch (dir)
+            {
+                case Coordinate.Direction.UP:
+                    labyrinth[x][y - 1].down = false;
+                    break;
+
+                case Coordinate.Direction.RIGHT:
+                    labyrinth[x][y].right = false;
+                    break;
+
+                case Coordinate.Direction.DOWN:
+                    labyrinth[x][y].down = false;
+                    break;
+
+                case Coordinate.Direction.LEFT:
+                    labyrinth[x - 1][y].right = false;
+                    break;
+            }
+        }
+
+        public void breakWall(Coordinate coord, Coordinate.Direction dir)
+        {
+            breakWall(coord.X, coord.Y, dir);
+        }
+
+        public bool checkWall(int x, int y, Coordinate.Direction dir)
+        {
+            switch (dir)
+            {
+                case Coordinate.Direction.UP:
+                    if (y > 0 && labyrinth[x][y - 1].down == false) return false;
+                    break;
+
+                case Coordinate.Direction.RIGHT:
+                    if (labyrinth[x][y].right == false) return false;
+                    break;
+
+                case Coordinate.Direction.DOWN:
+                    if (labyrinth[x][y].down == false) return false;
+                    break;
+
+                case Coordinate.Direction.LEFT:
+                    if (x > 0 && labyrinth[x - 1][y].right == false) return false;
+                    break;
+            }
+            return true;
+        }
+
+        public bool checkWall(Coordinate coord, Coordinate.Direction dir)
+        {
+            return checkWall(coord.X, coord.Y, dir);
+        }
+
+        public Coordinate farestCell(Coordinate begin){
+        int [,] length = new int[this.size, this.size];
+        int inf = this.size * this.size + 1;
+        for(int i = 0; i < this.size; i++){
+            for(int j = 0; j < this.size; j++){
+                length[i, j] = inf;
+            }
+        }
+        length[begin.X, begin.Y] = 0;
+        
+        Queue<Coordinate> cells = new Queue<Coordinate>();
+        int maxPath = 0;
+        Coordinate farestPoint = begin;
+        
+        cells.add(begin);
+        while(!cells.isEmpty()){
+            Coordinate curCoord = cells.poll();
+            int x = curCoord.x;
+            int y = curCoord.y;
+            int curLength = length[x][y];
+            if(curLength > maxPath){
+                farestPoint =  curCoord;
+                maxPath = curLength;
+            }
+            if(!checkWall(curCoord, Coordinate.Direction.UP)){
+                if(length[x][y - 1] > curLength + 1){
+                    cells.add(new Coordinate(curCoord, Coordinate.Direction.UP));
+                    length[x][y - 1] = curLength + 1;
+                }
+            }
+            
+            if(!checkWall(curCoord, Coordinate.Direction.RIGHT)){
+                if(length[x + 1][y] > curLength + 1){
+                    cells.add(new Coordinate(curCoord, Coordinate.Direction.RIGHT));
+                    length[x + 1][y] = curLength + 1;
+                }
+            }
+            
+            if(!checkWall(curCoord, Coordinate.Direction.DOWN)){
+                if(length[x][y + 1] > curLength + 1){
+                    cells.add(new Coordinate(curCoord, Coordinate.Direction.DOWN));
+                    length[x][y + 1] = curLength + 1;
+                }
+            }
+            
+            if(!checkWall(curCoord, Coordinate.Direction.LEFT)){
+                if(length[x - 1][y] > curLength + 1){
+                    cells.add(new Coordinate(curCoord, Coordinate.Direction.LEFT));
+                    length[x - 1][y] = curLength + 1;
+                }
+            }
+        }
+        
+        return farestPoint;
+    }
+
+        public ArrayList<Coordinate> findDiametr(){
+        ArrayList<Coordinate> res = new ArrayList<>();
+        Coordinate diamCell1 = farestCell(new Coordinate(0, 0));
+        Coordinate diamCell2 = farestCell(diamCell1);
+        res.add(diamCell1);
+        res.add(diamCell2);
+        return res;
+    }
+        
+
+    }
+}

From b74263ce66e860b40ece2f838ac5ee95a2c883d0 Mon Sep 17 00:00:00 2001
From: mgorvat <gorvat.michael@gmail.com>
Date: Sat, 16 Apr 2016 05:04:54 +0400
Subject: [PATCH 2/2] Maze generation

---
 Labyrinth/Labyrinth.csproj                    |   9 +-
 Labyrinth/Labyrinth/Labyrinth.cs              | 142 ++++++++++--------
 Labyrinth/MazeGenerator/BackTrackGenerator.cs |  36 +++++
 .../MazeGenerator/DivideEtImperaGenerator.cs  |  72 +++++++++
 .../MazeGenerator/HuntAndKillGenerator.cs     |  12 ++
 Labyrinth/MazeGenerator/IMazeGenerator.cs     |  12 ++
 Labyrinth/MazeGenerator/MazeGeneratorUtils.cs |  29 ++++
 7 files changed, 245 insertions(+), 67 deletions(-)
 create mode 100644 Labyrinth/MazeGenerator/BackTrackGenerator.cs
 create mode 100644 Labyrinth/MazeGenerator/DivideEtImperaGenerator.cs
 create mode 100644 Labyrinth/MazeGenerator/HuntAndKillGenerator.cs
 create mode 100644 Labyrinth/MazeGenerator/IMazeGenerator.cs
 create mode 100644 Labyrinth/MazeGenerator/MazeGeneratorUtils.cs

diff --git a/Labyrinth/Labyrinth.csproj b/Labyrinth/Labyrinth.csproj
index 2d2f016..19b4648 100644
--- a/Labyrinth/Labyrinth.csproj
+++ b/Labyrinth/Labyrinth.csproj
@@ -9,11 +9,12 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Labyrinth</RootNamespace>
     <AssemblyName>Labyrinth</AssemblyName>
-    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <WarningLevel>4</WarningLevel>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -63,12 +64,15 @@
       <DependentUpon>App.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Labyrinth\Cell.cs" />
+    <Compile Include="Labyrinth\Coordinate.cs" />
     <Compile Include="MainWindow.xaml.cs">
       <DependentUpon>MainWindow.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Labyrinth\Labyrinth.cs" />
     <Compile Include="Properties\AssemblyInfo.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -95,6 +99,9 @@
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="MazeGenerator\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Labyrinth/Labyrinth/Labyrinth.cs b/Labyrinth/Labyrinth/Labyrinth.cs
index c752663..5dbabb6 100644
--- a/Labyrinth/Labyrinth/Labyrinth.cs
+++ b/Labyrinth/Labyrinth/Labyrinth.cs
@@ -1,10 +1,10 @@
 using System;
 using Labyrinth.Labyrinth;
-using System.Collections;
+using System.Collections.Generic;
 
 namespace Labyrinth.MazeGenerator
 {
-    
+
     class Labyrinth
     {
         public delegate int GameEndedDelegate();
@@ -43,17 +43,17 @@ public Labyrinth(int size)
                 }
             }
         }
-        /*
+        
         public void initializeGame()
         {
             gameInProgress = true;
-            ArrayList<Coordinate> pts = findDiametr();
-            getCell(pts.get(0).x, pts.get(0).y).content = CellContent.PLAYER;
-            playerCoordinate = pts.get(0);
+            Tuple<Coordinate, Coordinate> pts = findDiametr();
+            getCell(pts.Item1).content = Cell.CellContent.PLAYER;
+            playerCoordinate = pts.Item1;
 
-            getCell(pts.get(1).x, pts.get(1).y).content = CellContent.GOAL;
+            getCell(pts.Item2).content = Cell.CellContent.GOAL;
         }
-        */
+        
         public void movePlayer(Coordinate.Direction dir)
         {
             if (gameInProgress)
@@ -139,71 +139,81 @@ public bool checkWall(Coordinate coord, Coordinate.Direction dir)
             return checkWall(coord.X, coord.Y, dir);
         }
 
-        public Coordinate farestCell(Coordinate begin){
-        int [,] length = new int[this.size, this.size];
-        int inf = this.size * this.size + 1;
-        for(int i = 0; i < this.size; i++){
-            for(int j = 0; j < this.size; j++){
-                length[i, j] = inf;
-            }
-        }
-        length[begin.X, begin.Y] = 0;
-        
-        Queue<Coordinate> cells = new Queue<Coordinate>();
-        int maxPath = 0;
-        Coordinate farestPoint = begin;
-        
-        cells.add(begin);
-        while(!cells.isEmpty()){
-            Coordinate curCoord = cells.poll();
-            int x = curCoord.x;
-            int y = curCoord.y;
-            int curLength = length[x][y];
-            if(curLength > maxPath){
-                farestPoint =  curCoord;
-                maxPath = curLength;
-            }
-            if(!checkWall(curCoord, Coordinate.Direction.UP)){
-                if(length[x][y - 1] > curLength + 1){
-                    cells.add(new Coordinate(curCoord, Coordinate.Direction.UP));
-                    length[x][y - 1] = curLength + 1;
+        public Coordinate farestCell(Coordinate begin)
+        {
+            int[,] length = new int[this.size, this.size];
+            int inf = this.size * this.size + 1;
+            for (int i = 0; i < this.size; i++)
+            {
+                for (int j = 0; j < this.size; j++)
+                {
+                    length[i, j] = inf;
                 }
             }
-            
-            if(!checkWall(curCoord, Coordinate.Direction.RIGHT)){
-                if(length[x + 1][y] > curLength + 1){
-                    cells.add(new Coordinate(curCoord, Coordinate.Direction.RIGHT));
-                    length[x + 1][y] = curLength + 1;
+            length[begin.X, begin.Y] = 0;
+
+            Queue<Coordinate> cells = new Queue<Coordinate>();
+            int maxPath = 0;
+            Coordinate farestPoint = begin;
+
+            cells.Enqueue(begin);
+            while (cells.Count != 0)
+            {
+                Coordinate curCoord = cells.Dequeue();
+                int x = curCoord.X;
+                int y = curCoord.Y;
+                int curLength = length[x, y];
+                if (curLength > maxPath)
+                {
+                    farestPoint = curCoord;
+                    maxPath = curLength;
                 }
-            }
-            
-            if(!checkWall(curCoord, Coordinate.Direction.DOWN)){
-                if(length[x][y + 1] > curLength + 1){
-                    cells.add(new Coordinate(curCoord, Coordinate.Direction.DOWN));
-                    length[x][y + 1] = curLength + 1;
+                if (!checkWall(curCoord, Coordinate.Direction.UP))
+                {
+                    if (length[x, y - 1] > curLength + 1)
+                    {
+                        cells.Enqueue(new Coordinate(curCoord, Coordinate.Direction.UP));
+                        length[x, y - 1] = curLength + 1;
+                    }
                 }
-            }
-            
-            if(!checkWall(curCoord, Coordinate.Direction.LEFT)){
-                if(length[x - 1][y] > curLength + 1){
-                    cells.add(new Coordinate(curCoord, Coordinate.Direction.LEFT));
-                    length[x - 1][y] = curLength + 1;
+
+                if (!checkWall(curCoord, Coordinate.Direction.RIGHT))
+                {
+                    if (length[x + 1, y] > curLength + 1)
+                    {
+                        cells.Enqueue(new Coordinate(curCoord, Coordinate.Direction.RIGHT));
+                        length[x + 1, y] = curLength + 1;
+                    }
+                }
+
+                if (!checkWall(curCoord, Coordinate.Direction.DOWN))
+                {
+                    if (length[x, y + 1] > curLength + 1)
+                    {
+                        cells.Enqueue(new Coordinate(curCoord, Coordinate.Direction.DOWN));
+                        length[x, y + 1] = curLength + 1;
+                    }
+                }
+
+                if (!checkWall(curCoord, Coordinate.Direction.LEFT))
+                {
+                    if (length[x - 1, y] > curLength + 1)
+                    {
+                        cells.Enqueue(new Coordinate(curCoord, Coordinate.Direction.LEFT));
+                        length[x - 1, y] = curLength + 1;
+                    }
                 }
             }
-        }
-        
-        return farestPoint;
-    }
 
-        public ArrayList<Coordinate> findDiametr(){
-        ArrayList<Coordinate> res = new ArrayList<>();
-        Coordinate diamCell1 = farestCell(new Coordinate(0, 0));
-        Coordinate diamCell2 = farestCell(diamCell1);
-        res.add(diamCell1);
-        res.add(diamCell2);
-        return res;
-    }
-        
+            return farestPoint;
+        }
 
+        public Tuple<Coordinate, Coordinate> findDiametr()
+        {
+            Coordinate diamCell1 = farestCell(new Coordinate(0, 0));
+            Coordinate diamCell2 = farestCell(diamCell1);
+            Tuple<Coordinate, Coordinate> res = new Tuple<Coordinate, Coordinate>(diamCell1, diamCell2);
+            return res;
+        }
     }
 }
diff --git a/Labyrinth/MazeGenerator/BackTrackGenerator.cs b/Labyrinth/MazeGenerator/BackTrackGenerator.cs
new file mode 100644
index 0000000..4c50e3c
--- /dev/null
+++ b/Labyrinth/MazeGenerator/BackTrackGenerator.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+using Labyrinth.Labyrinth;
+
+namespace Labyrinth.MazeGenerator
+{
+    class BackTrackGenerator : IMazeGenerator
+    {
+        public Labyrinth generate(int size)
+        {
+            Labyrinth lab = new Labyrinth(size);
+            bool[,] visited = new bool[size, size];
+            Stack<Coordinate> stack = new Stack<Coordinate>();
+            Random rnd = new Random();
+        
+            stack.Push(new Coordinate(rnd.Next(size), rnd.Next(size)));
+        
+            while(stack.Count > 0){
+                Coordinate coord = stack.Peek();
+                visited[coord.X, coord.Y] = true;
+            
+                List<Coordinate.Direction> dirs = MazeGeneratorUtils.getUnvisitedWays(visited, coord);
+                if(dirs.Count > 0){
+                    int ind = rnd.Next(dirs.Count);
+                    Coordinate.Direction dir = dirs[ind];
+                    lab.breakWall(coord, dir);
+                    stack.Push(new Coordinate(coord, dir));
+                }else{
+                    stack.Pop();
+                } 
+            }
+            return lab;
+        }
+    }
+}
diff --git a/Labyrinth/MazeGenerator/DivideEtImperaGenerator.cs b/Labyrinth/MazeGenerator/DivideEtImperaGenerator.cs
new file mode 100644
index 0000000..6004320
--- /dev/null
+++ b/Labyrinth/MazeGenerator/DivideEtImperaGenerator.cs
@@ -0,0 +1,72 @@
+using System;
+
+using Labyrinth.Labyrinth;
+
+namespace Labyrinth.MazeGenerator
+{
+    class DivideEtImperaGenerator
+    {
+        public Labyrinth generate(int size)
+        {
+            Labyrinth lab = new Labyrinth(size);
+            divideEtImpera(lab, 0, 0, size - 1, size - 1, new Random());
+            return lab;
+        }
+
+        private static void divideEtImpera(Labyrinth lab, int x1, int y1, int x2, int y2, Random rnd)
+        {
+            if (x2 - x1 == 0)
+            {
+                for (int i = y1; i < y2; i++)
+                {
+                    lab.breakWall(x1, i, Coordinate.Direction.DOWN);
+                }
+                return;
+            }
+
+            if (y2 - y1 == 0)
+            {
+                for (int i = x1; i < x2; i++)
+                {
+                    lab.breakWall(i, y1, Coordinate.Direction.RIGHT);
+                }
+                return;
+            }
+
+            int xLine, yLine;
+            xLine = rnd.Next(x2 - x1) + x1;
+            yLine = rnd.Next(y2 - y1) + y1;
+
+            int wallInd = rnd.Next(4);
+            
+            if (wallInd != 0)
+            {
+                int portY = rnd.Next(yLine - y1 + 1) + y1;
+                lab.breakWall(xLine, portY, Coordinate.Direction.RIGHT);
+            }
+ 
+            if (wallInd != 1)
+            {
+                int portX = rnd.Next(x2 - xLine) + xLine + 1;
+                lab.breakWall(portX, yLine, Coordinate.Direction.DOWN);
+            }
+            
+            if (wallInd != 2)
+            {
+                int portY = rnd.Next(y2 - yLine) + yLine + 1;
+                lab.breakWall(xLine, portY, Coordinate.Direction.RIGHT);
+            }
+            
+            if (wallInd != 3)
+            {
+                int portX = rnd.Next(xLine - x1 + 1) + x1;
+                lab.breakWall(portX, yLine, Coordinate.Direction.DOWN);
+            }
+
+            divideEtImpera(lab, x1, y1, xLine, yLine, rnd);
+            divideEtImpera(lab, xLine + 1, y1, x2, yLine, rnd);
+            divideEtImpera(lab, x1, yLine + 1, xLine, y2, rnd);
+            divideEtImpera(lab, xLine + 1, yLine + 1, x2, y2, rnd);
+        }
+    }
+}
diff --git a/Labyrinth/MazeGenerator/HuntAndKillGenerator.cs b/Labyrinth/MazeGenerator/HuntAndKillGenerator.cs
new file mode 100644
index 0000000..01e0a10
--- /dev/null
+++ b/Labyrinth/MazeGenerator/HuntAndKillGenerator.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Labyrinth.MazeGenerator
+{
+    class HuntAndKillGenerator
+    {
+    }
+}
diff --git a/Labyrinth/MazeGenerator/IMazeGenerator.cs b/Labyrinth/MazeGenerator/IMazeGenerator.cs
new file mode 100644
index 0000000..2205cf5
--- /dev/null
+++ b/Labyrinth/MazeGenerator/IMazeGenerator.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Labyrinth.MazeGenerator
+{
+    interface IMazeGenerator
+    {
+    }
+}
diff --git a/Labyrinth/MazeGenerator/MazeGeneratorUtils.cs b/Labyrinth/MazeGenerator/MazeGeneratorUtils.cs
new file mode 100644
index 0000000..fd0df07
--- /dev/null
+++ b/Labyrinth/MazeGenerator/MazeGeneratorUtils.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+using Labyrinth.Labyrinth;
+
+namespace Labyrinth.MazeGenerator
+{
+    public class MazeGeneratorUtils
+    {
+        public static List<Coordinate.Direction> getUnvisitedWays(bool[,] vis, Coordinate coord)
+        {
+            int x = coord.X;
+            int y = coord.Y;
+            List<Coordinate.Direction> res = new List<Coordinate.Direction>();
+
+            if (x > 0 && vis[x - 1, y] == false) res.Add(Coordinate.Direction.LEFT);
+            if (y > 0 && vis[x, y - 1] == false) res.Add(Coordinate.Direction.UP);
+            if (x < vis.GetLength(0) - 1 && vis[x + 1, y] == false) res.Add(Coordinate.Direction.RIGHT);
+            if (y < vis.GetLength(1) - 1 && vis[x, y + 1] == false) res.Add(Coordinate.Direction.DOWN);
+            return res;
+        }
+
+        public static bool isVisited(bool[,] vis, int x, int y)
+        {
+            if (x < 0 || y < 0 || x >= vis.GetLength(0) || y >= vis.GetLength(1)) return false;
+            return vis[x, y];
+        }
+    }
+}