/// <summary> /// Generates the maze. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <returns>maze</returns> public Maze GenerateMaze(string name, int rows, int cols) { Maze maze = mazeGenerator.Generate(rows, cols); singleplayerMazesDictionary.Add(name, maze); singleplayerMazesAndGamesNames.Add(name); return(maze); }
/// <summary> /// Generates the maze. /// </summary> /// <param name="name">The maze name.</param> /// <param name="row">number of rows.</param> /// <param name="col">number of cols.</param> /// <returns> /// maze /// </returns> public Maze GenerateMaze(string name, int row, int col) { if (_mazes.ContainsKey(name)) { return(null); } Maze maze = _generator.Generate(col, row); maze.Name = name; //save the maze _mazes.Add(name, maze); return(maze); }
/// <summary> /// Defines the entry point of the application. /// </summary> /// <param name="args">The arguments.</param> static void Main(string[] args) { //generate the maze. DFSMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(30, 30); //adapt the maze. SearchableMazeAdapter searchableMaze = new SearchableMazeAdapter(maze); //printing the maze. Console.Write(searchableMaze.MyMaze.ToString()); Solution <Position> BFSSolution; Solution <Position> DFSSolution; //solving by BFS. ISearcher <Position> searcher = new BFS <Position>(); BFSSolution = searcher.Search(searchableMaze); BFSSolution.Name = searchableMaze.MyMaze.Name; searchableMaze.Clean(); //solving by DFS. searcher = new DFS <Position>(); DFSSolution = searcher.Search(searchableMaze); DFSSolution.Name = searchableMaze.MyMaze.Name; //printing the solutions. Console.WriteLine(BFSSolution.EvaluatedNodes); Console.WriteLine(DFSSolution.EvaluatedNodes); }
/// <summary> /// Function Compares Bfs and Dfs algorithm functions. /// </summary> public void CompareSolvers() { IMazeGenerator dfsMaze = new DFSMazeGenerator(); // Print the maze. //Console.WriteLine(dfsMaze.ToString()); StatePool <Position> spDfs = new StatePool <Position>(); //Adapter adDfs = new Adapter(2, 2, 0, 0, 1, 1, "test Dfs", spDfs); Maze maze = dfsMaze.Generate(500, 500); Console.WriteLine(maze.ToString()); Adapter adDfs = new Adapter(maze, spDfs); ISearcher <Position> dfs = new Dfs <Position>(); Solution <Position> solDfs = dfs.Search(adDfs); Console.WriteLine(Adapter.ToJson(solDfs, "test")); // Creates the solution in Json format. /* * StatePool<Position> spBfs = new StatePool<Position>(); * // Adapter adBfs = new Adapter(10, 10, 0, 0, 8, 1, "test Bfs", spBfs); * Maze maze = dfsMaze.Generate(500, 500); * Console.WriteLine(maze.ToString()); * Adapter adBfs = new Adapter(maze, spBfs); * ISearcher<Position> bfs = new Bfs<Position>(); * Solution<Position> solBfs = bfs.search(adBfs); * //Console.WriteLine(adBfs.ToJson(solBfs)); */ }
/// <summary> /// Compares the solvers. /// </summary> /// <param name="row">The row.</param> /// <param name="col">The col.</param> public static void CompareSolvers(int row, int col) { // create maze DFSMazeGenerator myMazeGen = new DFSMazeGenerator(); Maze maze = myMazeGen.Generate(row, col); Console.WriteLine(maze); ObjectAdapter mazeAdapter = new ObjectAdapter(maze); // BFS solution ISearcher <Position> sbfs = new BFS <Position>(); sbfs.Search(mazeAdapter); // print num of stages Console.WriteLine("BFS: " + sbfs.GetNumberOfNodesEvaluated()); // DFS solution ISearcher <Position> sdfs = new DFS <Position>(); sdfs.Search(mazeAdapter); // print num of stages Console.WriteLine("DFS: " + sdfs.GetNumberOfNodesEvaluated()); }
/// <summary> /// constructor /// </summary> /// <param name="name">the name of the game</param> /// <param name="row">num of rows</param> /// <param name="col">num of columns</param> public Game(string name, int row, int col) { DFSMazeGenerator dfs = new DFSMazeGenerator(); myMaze = dfs.Generate(row, col); myMaze.Name = name; }
private static void Main(string[] args) { // the maze size 100x100 int col = 100; int row = 100; // create maze with DFSMazeGenerator DFSMazeGenerator generator = new DFSMazeGenerator(); Maze maze = generator.Generate(col, row); // print the maze Console.Write(maze.ToString()); // adapt the maze and solve it with BFS ISearchable <Position> adapter = new MazeAdapter(maze); ISearcher <Position> bfsSearcher = new BestFirstSearch <Position>(); bfsSearcher.Search(adapter); int bfsNumOfStases = bfsSearcher.GetNumberOfNodesEvaluated(); // solve the maze with DFS ISearcher <Position> dfsSearcher = new DepthFirstSearch <Position>(); dfsSearcher.Search(adapter); int dfsNumOfStases = dfsSearcher.GetNumberOfNodesEvaluated(); // print the num of evalueted nodes for BFS and DFS Console.WriteLine("number of BFS states:" + bfsNumOfStases); Console.WriteLine("number of DFS states:" + dfsNumOfStases); Console.Read(); }
/// <summary> /// Starts the game. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <param name="client">The client.</param> /// <returns></returns> public bool StartGame(string name, int rows, int cols, TcpClient client) { // if the game doesn't exist if (MultiplayerMazeList.ContainsKey(name)) { return(true); } // generate DFSMazeGenerator dfsMazeGenerator = new DFSMazeGenerator(); Maze maze = dfsMazeGenerator.Generate(rows, cols); maze.Name = name; // add to games MazeGame game = new MazeGame(maze); MultiplayerMazeList[name] = game; game.AddPlayer(client, name); if (MultiplayerMazeList.ContainsKey(name)) { MultiplayerMazeList.Remove(name); } return(false); }
/// <summary> /// Gets the maze. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <returns></returns> public Maze GetMaze(string name, int rows, int cols) { DFSMazeGenerator generatorMaze = new DFSMazeGenerator(); Maze maze = generatorMaze.Generate(rows, cols); maze.Name = name; return(maze); }
/// <summary> /// generates a maze with the maze adapter /// </summary> /// <param name="name"></param> /// <param name="rows"></param> /// <param name="cols"></param> /// <returns></returns> public Maze Generate(string name, int rows, int cols) { DFSMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze m = mazeGenerator.Generate(rows, cols); m.Name = name; return(m); }
/// <summary> /// Generates the specified maze. /// </summary> /// <param name="name">The name of maze.</param> /// <param name="rows">The rows of maze.</param> /// <param name="cols">The cols of maze.</param> /// <returns></returns> private Maze Generate(string name, int rows, int cols) { IMazeGenerator g = new DFSMazeGenerator(); Maze maze = g.Generate(rows, cols); maze.Name = name; return(maze); }
/// <summary> /// generate maze /// </summary> /// <param name="name">name</param> /// <param name="rows">rows</param> /// <param name="cols">cols</param> /// <returns></returns> public Maze generateMaze(string name, int rows, int cols) { DFSMazeGenerator mazeCreator = new DFSMazeGenerator(); Maze maze = mazeCreator.Generate(rows, cols); maze.Name = name; poolMaze.Add(maze.Name, maze); return(maze); }
/// <summary> /// Generates the specified name. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <returns>Maze.</returns> public Maze generate(string name, int rows, int cols) { var dfsMazeGenerator = new DFSMazeGenerator(); var MyMaze = dfsMazeGenerator.Generate(rows, cols); MyMaze.Name = name; DictionaryOfMazes[name] = MyMaze; return(MyMaze); }
public Maze GenerateMaze(string name, int rows, int cols) { MazeGeneratorLib.IMazeGenerator generator = new DFSMazeGenerator(); Maze maze = generator.Generate(rows, cols); maze.Name = name; mazes.Add(name, maze); return(maze); }
/// <summary> /// Generates a maze with a name that is given, size according the parameters /// </summary> /// <param name="name">The name of the maze.</param> /// <param name="rows">num of rows.</param> /// <param name="cols">num of cols.</param> /// <returns> /// a new maze /// </returns> public Maze generate(string name, int rows, int cols) { DFSMazeGenerator maze = new DFSMazeGenerator(); Maze currentMaze = maze.Generate(rows, cols); currentMaze.Name = name; //this is the way? allMazes.Add(name, currentMaze); return(currentMaze); }
public Maze GenerateMaze(string name, int rows, int cols) { DFSMazeGenerator mazeGen = new DFSMazeGenerator(); Maze maze = mazeGen.Generate(rows, cols); maze.Name = name; mazes.Add(name, new Pair <Maze, Solution>(maze, null)); return(maze); }
/// <summary> /// Main class. /// Generates a Maze. /// Sends it CompareSolvers to compare two solvers and draw it. /// </summary> /// <param name="args"></param> static void Main(string[] args) { var generator = new DFSMazeGenerator(); Maze maze = generator.Generate(30, 30); CompareSolvers(maze); Console.Read(); }
/// <summary> /// Generates the maze. /// </summary> /// <param name="name">The maze's name.</param> /// <param name="rows">The number of rows.</param> /// <param name="cols">The number of cols.</param> /// <returns></returns> public Maze GenerateMaze(string name, int rows, int cols) { // create maze DFSMazeGenerator myMazeGen = new DFSMazeGenerator(); Maze myMaze = myMazeGen.Generate(rows, cols); myMaze.Name = name; mazes.Add(name, myMaze); return(this.mazes[name]); }
/* * The generate command creates a single player maze, which is added to the database * and then returned to the user */ public SearchableMaze GenerateMaze(string name, int rows, int cols) { Maze m = mazeMaker.Generate(rows, cols); SearchableMaze maze = new SearchableMaze(m, name); // The maze is saved in the database if (!singlePlayerMazes.ContainsKey(name)) { singlePlayerMazes.Add(name, maze); } else { singlePlayerMazes[name] = maze; if (singlePlayerSolutions.ContainsKey(name)) { singlePlayerSolutions.Remove(name); } } return(maze); }
public Maze GenerateMaze(string name, int rows, int cols) { if (!mazes.ContainsKey(name)) { DFSMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(rows, cols); maze.Name = name; mazes.Add(name, maze); return(maze); } return(null); }
/// <summary> /// Generates the maze. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <returns></returns> public Maze GenerateMaze(string name, int rows, int cols) { IMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(rows, cols); maze.Name = name; cash.AddSingleGame(name, new SingleGame(name, maze, null)); //cash.AddMaze(name, maze); return(maze); }
public Maze GenerateMaze(string name, int rows, int cols) { IMazeGenerator mg = new DFSMazeGenerator(); Maze m = mg.Generate(rows, cols); m.Name = name; if (mazeCache.ContainsKey(name)) { return(null); } mazeCache.Add(m.Name, m); return(m); }
/// <summary> /// Generates the maze. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <returns>Maze</returns> public Maze GenerateMaze(string name, int rows, int cols) { modelData.mutexMazes.WaitOne(); IMazeGenerator newMaze = new DFSMazeGenerator(); Maze maze = null; // Generate the maze. maze = newMaze.Generate(rows, cols); modelData.Mazes.Add(name, maze); // Unlock. modelData.mutexMazes.ReleaseMutex(); return(maze); }
static void Main(string[] args) { Program pg = new Program(); IMazeGenerator dfsMaze = new DFSMazeGenerator(); Maze maze = dfsMaze.Generate(100, 100); //pg.CompareSolvers(); // Example of Usage: // The following gets 2 rows, 2 coloms and 0 (Bfs algorithm), Runs the bfs algorithm // and returns the solution to the algorithm. Solution <Position> pos = pg.Solve(maze, 0); }
/// <summary> /// Starts the maze. /// </summary> /// <param name="name">The maze's name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <param name="client">The client's connection.</param> public void StartMaze(string name, int rows, int cols, TcpClient client) { // create maze DFSMazeGenerator myMazeGen = new DFSMazeGenerator(); Maze myMaze = myMazeGen.Generate(rows, cols); myMaze.Name = name; // create game Game myGame = new Game(myMaze, client); this.games.Add(name, myGame); }
static void Main(string[] args) { DFSMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(5, 5); Console.WriteLine(maze.ToString()); SearchableMaze searchableMaze = new SearchableMaze(maze); BFS <Position> bfsSolver = new BFS <Position>(); DFS <Position> dfsSolver = new DFS <Position>(); Console.WriteLine("BFS:"); Console.WriteLine(bfsSolver.search(searchableMaze)); Console.WriteLine(bfsSolver.getNumberOfNodesEvaluated()); Console.WriteLine("DFS:"); Console.WriteLine(dfsSolver.search(searchableMaze)); Console.WriteLine(dfsSolver.getNumberOfNodesEvaluated()); //string json = @"{ // 'Name': 'mymaze', // 'Maze': // '0001010001010101110101010000010111111101000001000111010101110001010001011111110100000000011111111111', // 'Rows': 10, // 'Cols': 10, // 'Start': { // 'Row': 0, // 'Col': 4 // }, // 'End': { // 'Row': 0, // 'Col': 0 // } //}"; //Maze maze = Maze.FromJSON(json); //Console.Write(maze.ToString()); //SearchableMaze searchableMaze = new SearchableMaze(maze); //BFS<Position> bfsSolver = new BFS<Position>(); //DFS<Position> dfsSolver = new DFS<Position>(); //Console.WriteLine("BFS:"); //Console.WriteLine(bfsSolver.search(searchableMaze)); //Console.WriteLine(bfsSolver.getNumberOfNodesEvaluated()); //Console.WriteLine("DFS:"); //Console.WriteLine(dfsSolver.search(searchableMaze)); //Console.WriteLine(dfsSolver.getNumberOfNodesEvaluated()); Console.Read(); }
/// <summary> /// Starts the game. /// </summary> /// <param name="name">The name.</param> /// <param name="rows">The rows.</param> /// <param name="cols">The cols.</param> /// <param name="gamer">The gamer.</param> /// <returns></returns> public Maze StartGame(string name, int rows, int cols, string player /*, ClientNotifier gamer*/) { //Maze maze = GenerateMaze(name, rows, cols); IMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(rows, cols); maze.Name = name; MultiGame game = new MultiGame(name, maze, player); //game.AddGamer(gamer); //cash.AddGame(name, game); cash.AddMultiGame(name, game); return(maze); }
/// <summary> /// Compare the solvers we created by using the adapter desing pattern between /// the maze and searchable. /// </summary> static void CompareSolvers() { DFSMazeGenerator dfsMaze = new DFSMazeGenerator(); Maze maze = dfsMaze.Generate(100, 100); ISearchable <Position> adapt = new MazeToSearchableAdapter(maze); BFSSearcher <Position> bfs = new BFSSearcher <Position>(); DFSSearcher <Position> dfs = new DFSSearcher <Position>(); //Console.WriteLine(maze); bfs.Search(adapt); Console.WriteLine("Best First Search evaluated {0} nodes.", bfs.GetNumberOfNodesEvaluated()); dfs.Search(adapt); Console.WriteLine("DFS evaluated {0} nodes.", dfs.GetNumberOfNodesEvaluated()); }
public Maze GenerateMaze(string nameOfGame, int rows, int cols) { if (SPGames.ContainsKey(nameOfGame)) { // The game is already exist in the system. throw new Exception($"The game '{nameOfGame}' already exists"); } // Generate a maze with the given size. IMazeGenerator mazeGenerator = new DFSMazeGenerator(); Maze maze = mazeGenerator.Generate(rows, cols); maze.Name = nameOfGame; SPGames.Add(nameOfGame, new SinglePlayerGame(maze)); return(maze); }
public static void CompareSolvers() { DFSMazeGenerator generator = new DFSMazeGenerator(); Maze m = generator.Generate(5, 6); Console.WriteLine(m.ToString()); BestFirstSearch <CellType> bfs = new BestFirstSearch <CellType>(); DFS <CellType> dfs = new DFS <CellType>(); Solution <CellType> SolBFS = bfs.search(m); Solution <CellType> SolDFS = dfs.search(m); Console.ReadLine(); }