private Map<BinaryCell> GenerateMap(int width = SOME_EVEN_WIDTH, int height = SOME_EVEN_HEIGHT) { var map = new Map<BinaryCell>(width, height); var mazeGenerator = new MazeGenerator<BinaryCell>(); mazeGenerator.ProcessMap(map, mConfiguration, mRandomizer); return map; }
private void InitialiseMaze(MazeGenerator mazeGenerator, int level) { mazeGrid = mazeGenerator.GenerateMaze(level); nrOfColumns = mazeGenerator.GetColumns(); nrOfRows = mazeGenerator.GetRows(); sizeOfTile = pathTiles[0].GetComponent <Renderer>().bounds.size; }
public MazePositions PostMaze(BoolHelper newMaze) { if (newMaze.isNewMaze) { _context.BlockPositions.RemoveRange(_context.BlockPositions); MazePositions cont = new MazePositions(); MazeGenerator gen = new MazeGenerator(); cont.maze = gen.generateMaze(); foreach (BlockPosition block in cont.maze) { _context.BlockPositions.Add(block); } _context.SaveChanges(); return(cont); } else { MazePositions cont = new MazePositions { maze = new System.Collections.Generic.List <BlockPosition>() }; cont.maze = _context.BlockPositions.ToList(); return(cont); } }
void Start() { Player = GameObject.FindWithTag("Player"); mg = MazeGenerator.GetInstance(); this.GetComponent <SpriteRenderer>().sprite = GetRandomSprite(); this.transform.position = mg.GetSpawnPosition(); }
private void initializeValues() { maze = GameObject.Find("Maze Generator").GetComponent <MazeGenerator>(); maxX = maze.width * maze.scale; maxY = maze.height * maze.scale; minX = Random.value > 0.5f; }
void Update() { if (mGen == null) { mGen = FindObjectOfType <MazeGenerator>(); } else if (m == null) { m = mGen.currentMaze(); } else if (pControl == null) { GameObject g = GameObject.FindGameObjectWithTag("MyPlayer"); if (g != null) { pControl = g.GetComponent <SinglePlayerControl>(); } } else { pOffset = pixelOffset(); cellDim = cellDimenstions(); icon.rectTransform.sizeDelta = new Vector2(cellDimenstions().x, cellDimenstions().y); icon.transform.localEulerAngles = new Vector3(0, 0, -pControl.transform.localEulerAngles.y + 90); Vector2 pPos = pControl.pos(); float x = pixelOffset().x + (cellDimenstions().x *pPos.x) + (cellDimenstions().x / 2); float y = pixelOffset().y + (cellDimenstions().y *pPos.y) + (cellDimenstions().x / 2); Vector2 v = new Vector2(x, y); GetComponent <RectTransform>().anchoredPosition = v; } }
void Start() { MazeGenerator generator = GameObject.Find("MazeGenerate").GetComponent <MazeGenerator> (); _maxFactorX = generator._width - 1; _maxFactorZ = generator._height; }
// Update is called once per frame void Update () { if(mGen == null) mGen = FindObjectOfType<MazeGenerator>(); else if(m == null && mGen != null) { m = mGen.currentMaze(); if(m != null) { Texture2D t = new Texture2D((int)m.Dimensions().x, (int)m.Dimensions().y, TextureFormat.ARGB4444, false); for(int x=0; x<t.width; x++) { for(int y=0; y<t.height; y++) { if(m.GetCell(x,y).isWall) t.SetPixel(x,y,Color.black); else t.SetPixel(x,y,Color.white); } } t.anisoLevel = 0; t.filterMode = FilterMode.Point; t.Apply(); im.sprite = Sprite.Create(t, new Rect(0,0,t.width,t.height), Vector2.one/2); } } }
// ############################################################### // Unity Functions // ############################################################### void Start() { // add sound to the UAV prop = GameObject.Find("propeller_1").GetComponent <PropellerController> (); sound = gameObject.AddComponent <AudioSource> (); AudioClip soundClip = (AudioClip)Resources.Load("Sounds/plane-propeller", typeof(AudioClip)); sound.clip = soundClip; sound.volume = 0f; sound.loop = true; // Get the bounds of he maze for the UAV clamping MazeGenerator maze = GameObject.Find("Maze Generator").GetComponent <MazeGenerator> (); scale = maze.scale; mazeMaxes = new Vector2((maze.height * scale) - (3 * scale), (maze.width * scale) + (3 * scale)); mazeMins = new Vector2(3 * scale, -5); if (GameObject.Find("Max")) { GameObject.Find("Max").transform.position = new Vector3(mazeMaxes.x, 0f, mazeMaxes.y); } if (GameObject.Find("Min")) { GameObject.Find("Min").transform.position = new Vector3(mazeMins.x, 0f, mazeMins.y); } }
private void BG_Worker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e) { try { if (MakeMazeCB.Checked) { MazeGenerator mazeGenerator = new MazeGenerator(new Size((int)ColumnsNUD.Value, (int)RowsNUD.Value)); mazeGenerator.Generate(); mazeGenerator.SaveAsImage(MakeOutputPathTB.Text); mazeGenerator = null; if (!SolveMazeCB.Checked) { System.Diagnostics.Process.Start(MakeOutputPathTB.Text); } } if (SolveMazeCB.Checked) { MazeSolver mazeSolver = new MazeSolver(SolveInputPathTB.Text); mazeSolver.Solve(); mazeSolver.SaveSolutionAsImage(SolveOutputPathTB.Text); mazeSolver = null; System.Diagnostics.Process.Start(SolveOutputPathTB.Text); } GC.Collect(); } catch (Exception ex) { MessageBox.Show(ex.Message); throw; } }
public static void Main(string[] args) { Console.SetWindowSize(240, 80); Random rand = new Random(); SegmentMask maskSet = new SegmentMask(10, 10); while (true) { Console.Clear(); MazeGenerator mazeGen = new MazeGenerator(rand); mazeGen.SetLoopChance(0.1F); mazeGen.SetStraightBias(0.2F); MazeMap mazeMap = mazeGen.Generate(12, 8); CellularGenerator cellGen = new CellularGenerator(rand); cellGen.SetPasses(8); cellGen.SetFillWeight(0.5F); cellGen.SetThresholds(4, 4); CellMap cellMap = cellGen.Generate(mazeMap, maskSet); for (int j = 0; j < cellMap.Height(); j++) { for (int i = 0; i < cellMap.Width(); i++) { Console.Write(GetCharFromCell(cellMap.GetSegment(new MapPos(i, j))) + " "); } } Console.Write("Press enter to regenerate..."); Console.ReadLine(); } }
// Start is called before the first frame update void Start() { MazeGenerator generator = new MazeGenerator(gC.XSize, gC.YSize, gC.ChangeOfTreasure, gC.MaxCoins, gC.ChangeOfCoins); CellObj[,] maze = generator.GenerateMaze(); for (int x = 0; x < maze.GetLength(0); x++) { for (int y = 0; y < maze.GetLength(1); y++) { Cell c = Instantiate(CellPrefab, new Vector2(x * size, y * size), Quaternion.identity) .GetComponent <MazeGen.Cell>(); c.WallLeft.SetActive(maze[x, y].WallLeft); c.WallBottom.SetActive(maze[x, y].WallBottom); c.wallLeftBorder.SetActive(maze[x, y].WallLeftBorder); c.wallBottomBorder.SetActive(maze[x, y].WallBottomBorder); c.Floor.SetActive(maze[x, y].Floor); c.Treasure.SetActive(maze[x, y].Treasure); c.ExitPortal.SetActive(maze[x, y].Exit); if (maze[x, y].CoinCount > 0) { c = generateCoins(maze[x, y], c); } } } }
private static MazeInfo GenerateOrGetExistingMaze(int size) { MazeInfo retVal; if (!mazes.TryGetValue(size, out retVal)) { var generator = new MazeGenerator(); generator.Generate(size, size); generator.Solve(); retVal = new MazeInfo() { GoalPosition = generator.GoalLocation, Grid = generator.TheMazeGrid, Name = $"{size}x{size}", PerfectGameMovesCount = generator.PerfectGameMovesCount, StartingPosition = generator.StartingPosition, Height = size, Width = size }; mazes.Add(size, retVal); } return(retVal); }
public override void OnInspectorGUI() { MazeGenerator mazeGen = (MazeGenerator)target; DrawDefaultInspector(); if (GUILayout.Button("Generate")) { mazeGen.generateMaze(false); } if (GUILayout.Button("Solve")) { mazeGen.solveMaze(); } if (GUILayout.Button("Delete")) { mazeGen.deleteMaze(); } if (GUILayout.Button("Generate Braided")) { mazeGen.generateMaze(true); } }
public void MazeGeneratorCreateMaze() { int rows = 5, columns = 5; int gridSize = rows * columns; Cell[,] c = new Cell[rows, columns]; MazeGenerator.Seed((int)DateTime.Now.Ticks); c = MazeGenerator.GenerateOrthogonal(rows, columns, 0, 0, false); string output = System.Environment.NewLine; for (int j = 0; j < rows; j++) { for (int k = 0; k < columns; k++) { if (c[j, k].ClassState == CLASS_STATE.OPEN) { output += "|O|"; } else { output += "|X|"; } //writer.WriteLine(c[j, k]); } } StreamWriter writer = new StreamWriter(@"C:\temp\mazeGenerator.txt", true); writer.Write(output); writer.Close(); }
// Use this for initialization void Start() { maze = FindObjectOfType <MazeGenerator>(); retries = 0; StartCoroutine(_spawner()); }
public void Setup() { _mazeGenerator = new MazeGenerator(); _defaultGenerator = new DefaultLevelGenerator(); _checkedGenerator = new OpenCheckingGenerator(new DefaultLevelGenerator(), 5); _superCheckedGenerator = new OpenCheckingGenerator(new DefaultLevelGenerator(), 15); }
// Start is called before the first frame update void Start() { var maze = MazeGenerator.Generate(width, height); Draw(maze); TransformObject(); }
// ############################################################### // Unity Functions // ############################################################### void Start() { // default operation is automatic coin spawns automaticCoins = true; // Figure out which mission we are: LTF & LITH | GTP | MTI if (GameController.missionInitials == "MTI") { maze = GameObject.Find("Maze Generator").GetComponent <MazeGenerator>(); MTIMission = true; } else if (GameController.missionInitials == "GTP") { GTPMission = true; } else { scoutMission = true; } // IF tutorial, disable auto-coins if (GameController.isTutorial) { automaticCoinsSetting(false); } // Grab the clock coinSpawnTime = GameController.gameClock; }
void Start() { maze = MazeGenerator.GenerateMaze(width, height, density, complexity); time = Time.time; print($"Generated maze in {time} seconds."); CreateMaze(); }
public Maze GenerateMaze(Coordinate startAt) { _maze.MazeData = MazeGenerator.GetMaze(); _maze.StartAt = startAt; _maze.Refresh(); return(_maze); }
// Maze is created on Awake private void Awake() { // Need to set value of 'maze' here mazeGenerator = new MazeGenerator(); // Need to turn string of hashes and spaces into a maze for (int i = 0; i <= MazeGenerator.mazeSize; i++) { for (int j = MazeGenerator.mazeSize; j >= 0; j--) { // Make a wall if we encounter a '#' if (MazeGenerator.maze[i, j] == '#') { Vector3 wallPos = new Vector3((float)(i + 0.5), (float)(j + 0.37)); Instantiate(wall, wallPos, wall.transform.rotation); } } } // Need to add enemies into maze for (int i = 0; i < enemyCount; i++) { addObject(shootingEnemy); } // Add a torch into the maze addObject(torch); // Add a sword addObject(sword); }
public void SetupMaze(MazeGenerator mazeGenerator, int level) { InitialiseMaze(mazeGenerator, level); if (mazeHolder != null) { DestroyMaze(); } mazeHolder = new GameObject("Maze").transform; for (int x = -1; x < nrOfColumns + 1; x++) { for (int y = -1; y < nrOfRows + 1; y++) { GameObject toInstantiate; if (x > -1 && x < nrOfColumns && y > -1 && y < nrOfRows && mazeGrid[y * nrOfColumns + x]) { toInstantiate = pathTiles[Random.Range(0, pathTiles.Length)]; } else { toInstantiate = wallTiles[Random.Range(0, wallTiles.Length)]; } GameObject instance = Instantiate(toInstantiate, Vector3.Scale(new Vector3(x, y, 0f), sizeOfTile), Quaternion.identity) as GameObject; instance.transform.SetParent(mazeHolder); } } }
public void ProcessMap_ValidInput_SideTypesInAdjacentCellsMatch() { var map = new Map <BinaryCell>(SOME_WIDTH, SOME_HEIGHT); var mazeGenerator = new MazeGenerator <BinaryCell>(); mazeGenerator.ProcessMap(map, new DungeonConfiguration() { Height = SOME_HEIGHT, Width = SOME_WIDTH }, mRandomizer); var sparseness = new SparsenessReducer <BinaryCell>(); sparseness.ProcessMap(map, new DungeonConfiguration() { Sparseness = 0.6 }, mRandomizer); for (int j = 0; j < SOME_HEIGHT; j++) { for (var i = 0; i < SOME_WIDTH; i++) { var currentCell = map.GetCell(i, j); var adjacentCellsByDirection = currentCell.Sides.Keys.ToDictionary(key => key, key => map.GetAdjacentCell(currentCell, key)); foreach (var kvp in adjacentCellsByDirection.Where(kvp => kvp.Value != null)) { Assert.AreEqual(currentCell.Sides[kvp.Key], kvp.Value.Sides[kvp.Key.Opposite()]); } } } }
private void Awake() { _currentLevel = 1; _mazeGenerator = GetComponent <MazeGenerator>(); _minimap = FindObjectOfType <Minimap>(); InitizalizeLevelData(_currentLevel); }
private static void Main(string[] args) { MazeGenerator mazegen = new MazeGenerator(40, 20); mazegen.GenerateMaze(); mazegen.PrintMaze(); }
void Start() { var maze = MazeGenerator.Generate(width, height); //Printing distances /*var distmat = maze.getDistanceMatrix(); * string yolo = ""; * for(int i=0;i<width;i++) * { * for(int j=0;j<height;j++) * { * yolo += "("+i+","+j+")\n"; * for(int k=0;k<width;k++) * { * for(int l=0;l<height;l++) * { * yolo += distmat[i,j].getDistances()[k,l] +"\t"; * } * yolo += "\n"; * } * Debug.Log(yolo); * yolo = ""; * } * }*/ Draw(maze.getMaze()); List <Position> spawn = MazeGenerator.Spawn(width, height, maze.getDistanceMatrix(), noOfPlayers); SpawnPlayers(spawn); SpawnObjective(spawn); }
public override void OnInspectorGUI() { DrawDefaultInspector(); MazeGenerator myGenerator = (MazeGenerator)target; if (GUILayout.Button("Generate Maze")) { myGenerator.GenerateMaze(); } if (GUILayout.Button("Destroy Maze")) { myGenerator.DestroyMaze(); } if (GUILayout.Button("Generar OBJ")) { myGenerator.createOBJ(); } if (GUILayout.Button("Execute Analysis")) { myGenerator.executeAnalysis(); } if (GUILayout.Button("Execute Time Analysis")) { myGenerator.executeTimeAnalysis(); } }
void Awake() { mapData = gameObject.GetComponent <MapData>(); mazeGen = gameObject.GetComponent <MazeGenerator>(); _DoorRoomLookUp = new Dictionary <string, MapPos>(); _DoorRoomLookUp["Door_Bottom_Left"] = new MapPos(0, -1); _DoorRoomLookUp["Door_Left_Bottom"] = new MapPos(-1, 0); _DoorRoomLookUp["Door_Bottom_Right"] = new MapPos(2, -1); _DoorRoomLookUp["Door_Right_Bottom"] = new MapPos(3, 0); _DoorRoomLookUp["Door_Top_Left"] = new MapPos(0, 3); _DoorRoomLookUp["Door_Left_Top"] = new MapPos(-1, 2); _DoorRoomLookUp["Door_Top_Right"] = new MapPos(2, 3); _DoorRoomLookUp["Door_Right_Top"] = new MapPos(3, 2); dirs = new string[4] { "Up", "Down", "Left", "Right" }; _32x32 = new List <string>(); _64x64 = new List <string>(); Items = new List <GameObject>(); mapsGenerated = 0; }
void Update () { if(mGen == null) mGen = FindObjectOfType<MazeGenerator>(); else if(m == null) { m = mGen.currentMaze(); } else if(pControl == null) { GameObject g = GameObject.FindGameObjectWithTag("MyPlayer"); if(g != null) pControl = g.GetComponent<PlayerControl>(); } else { pOffset = pixelOffset(); cellDim = cellDimenstions(); icon.rectTransform.sizeDelta = new Vector2(cellDimenstions().x, cellDimenstions().y); icon.transform.localEulerAngles = new Vector3(0,0,-pControl.transform.localEulerAngles.y + 90); Vector2 pPos = pControl.pos(); float x = pixelOffset().x + (cellDimenstions().x*pPos.x) + (cellDimenstions().x/2); float y = pixelOffset().y + (cellDimenstions().y*pPos.y) + (cellDimenstions().x/2); Vector2 v = new Vector2(x,y); GetComponent<RectTransform>().anchoredPosition = v; } }
public IActionResult Boris() { var mazeGenerator = new MazeGenerator(); var maze = mazeGenerator.GenerateSmart(MazeWidth, MazeHeight); return(View(new MazeViewModel(maze))); }
// Use this for initialization void Awake() { difficulty = GameManager.difficulty; if (difficulty == 1) { mazeSize = 11; turnComplexity = 4; crossroads = 4; randomWalls = 6; } else if (difficulty == 2) { mazeSize = 15; turnComplexity = 6; crossroads = 6; randomWalls = 12; } else if (difficulty == 3) { mazeSize = 19; turnComplexity = 7; crossroads = 9; randomWalls = 20; } maze = MazeGenerator.CreateMaze(mazeSize, turnComplexity, crossroads, randomWalls); GenerateMaze(maze); }
void Start() { MazeGenerator generator = GameObject.Find("MazeGenerate").GetComponent <MazeGenerator> (); _maxFactorX = generator._width - 1; transform.position = new Vector3Int(_cellScale * Random.Range(0, _maxFactorX), 2, 50); }
// Use this for initialization void Start() { mg = GameObject.Find ("Scripts").GetComponent<MazeGenerator> (); player = GameObject.FindGameObjectWithTag ("Player"); point = GameObject.Find ("ref point").transform; currentNode = 0; path = mg.Astar(getNodePosition(transform.position), 0); point.position = new Vector2( mg.cells [0].x, mg.cells[0].y); }
// Use this for initialization void Start () { if (instance == null) instance = this; else { Debug.Log("LevelManager already exists in object: " + instance.gameObject.name); Destroy(this); } mazeGen = GetComponent<MazeGenerator>(); mazeGen.RestartMaze((int)initDimension.x, (int)initDimension.y); }
public void ProcessMap_RemoveAllDeadEnds_AllDeadEndsRemoved() { var map = new Map<BinaryCell>(SOME_WIDTH, SOME_HEIGHT); var mazeGenerator = new MazeGenerator<BinaryCell>(); mazeGenerator.ProcessMap(map, mConfiguration, mRandomizer); var sparsenessReducer = new SparsenessReducer<BinaryCell>(); sparsenessReducer.ProcessMap(map, mConfiguration, mRandomizer); var remover = new DeadendsRemover<BinaryCell>(); remover.ProcessMap(map, mConfiguration, mRandomizer); Assert.AreEqual(0, map.AllCells.Count(cell => cell.Sides.Values.Count(type => type) == 1)); }
public void ProcessMap_ValidInput_SideTypesInAdjacentCellsMatch() { var map = new Map<BinaryCell>(SOME_WIDTH, SOME_HEIGHT); var mazeGenerator = new MazeGenerator<BinaryCell>(); mazeGenerator.ProcessMap(map, new DungeonConfiguration() { Height = SOME_HEIGHT, Width = SOME_WIDTH }, mRandomizer); var sparseness = new SparsenessReducer<BinaryCell>(); sparseness.ProcessMap(map, new DungeonConfiguration() { Sparseness = 0.6 }, mRandomizer); for (int j = 0; j < SOME_HEIGHT; j++) { for (var i = 0; i < SOME_WIDTH; i++) { var currentCell = map.GetCell(i, j); var adjacentCellsByDirection = currentCell.Sides.Keys.ToDictionary(key => key, key => map.GetAdjacentCell(currentCell, key)); foreach (var kvp in adjacentCellsByDirection.Where(kvp => kvp.Value != null)) { Assert.AreEqual(currentCell.Sides[kvp.Key], kvp.Value.Sides[kvp.Key.Opposite()]); } } } }
/// <summary> /// Initializes a new instance of the <see cref="FreezingArcher.Game.MazeTest"/> class. /// </summary> /// <param name="messageProvider">The message provider for this instance.</param> /// <param name="objmnr">The object manager for this instance.</param> /// <param name="rendererContext">The renderer context for the maze scenes.</param> /// <param name="game">The game the maze should be generated in.</param> public MazeTest (MessageProvider messageProvider, ObjectManager objmnr, RendererContext rendererContext, Content.Game game, Application app, CompositorNodeScene sceneNode, CompositorImageOverlayNode healthOverlayNode, CompositorColorCorrectionNode colorCorrectionNode, CompositorNodeOutput outputNode, CompositorWarpingNode warpingNode) { ValidMessages = new[] { (int) MessageId.Input, (int) MessageId.Update, (int) MessageId.HealthChanged, (int) MessageId.CollisionDetected, (int) MessageId.StaminaChanged, (int) MessageId.ItemUse, (int) MessageId.FlashlightToggled }; messageProvider += this; mazeGenerator = new MazeGenerator (objmnr); MazeSceneNode = sceneNode; HealthOverlayNode = healthOverlayNode; ColorCorrectionNode = colorCorrectionNode; OutputNode = outputNode; WarpingNode = warpingNode; this.game = game; application = app; FPS_Text = new Gwen.ControlInternal.Text (app.RendererContext.Canvas); FPS_Text.String = "0 FPS"; FPS_Text.Font = new Gwen.Font (app.RendererContext.GwenRenderer); FPS_Text.SetPosition (5, 5); FPS_Text.Font.Size = 15; FPS_Text.Hide (); HealthOverlayNode.OverlayTexture = rendererContext.CreateTexture2D ("bloodsplatter", true, "Content/bloodsplatter.png"); HealthOverlayNode.Factor = 0; HealthOverlayNode.Blending = OverlayBlendMode.Multiply; warpingNode.WarpTexture = rendererContext.CreateTexture2D ("warp", true, "Content/warp.jpg"); game.SceneNode = MazeSceneNode; game.AddGameState ("maze_overworld", Content.Environment.Default, null); var state = game.GetGameState ("maze_overworld"); state.Scene = new CoreScene (rendererContext, messageProvider); state.Scene.SceneName = "MazeOverworld"; state.Scene.Active = false; state.Scene.BackgroundColor = Color4.Fuchsia; state.Scene.DistanceFogIntensity = 0.07f; state.Scene.AmbientColor = Color4.White; state.Scene.AmbientIntensity = 0.3f; state.Scene.MaxRenderingDistance = 1000.0f; state.AudioContext = new AudioContext (state.MessageProxy); state.MessageProxy.StartProcessing (); loadingScreen = new LoadingScreen (application, messageProvider, "Content/loading.png", "MazeLoadingScreen", new[] { new Tuple<string, GameStateTransition> ("main_menu", GameStateTransition.DefaultTransition) }, new[] { new Tuple<string, GameStateTransition> (state.Name, new GameStateTransition (0)) }); endScreen = new EndScreen (application, rendererContext, new Tuple<string, GameStateTransition>[] { new Tuple<string, GameStateTransition> ("maze_overworld", GameStateTransition.DefaultTransition), new Tuple<string, GameStateTransition> ("maze_underworld", GameStateTransition.DefaultTransition) }); game.SwitchToGameState ("MazeLoadingScreen"); Player = EntityFactory.Instance.CreateWith ("player", state.MessageProxy, new[] { typeof(HealthComponent), typeof(StaminaComponent) }, new[] { typeof(MovementSystem), typeof(KeyboardControllerSystem), typeof(MouseControllerSystem), typeof(SkyboxSystem), typeof(PhysicsSystem) }); inventoryGui = new InventoryGUI (app, state, Player, messageProvider, warpingNode); var inventory = new Inventory (messageProvider, state, Player, new Vector2i (5, 7), 9); inventoryGui.Init (rendererContext.Canvas, inventory); PauseMenu = new PauseMenu (application, ColorCorrectionNode, rendererContext.Canvas, () => maze [currentMaze].AIManager.StartThinking (), () => maze [currentMaze].AIManager.StopThinking ()); AddAudio (state); // embed new maze into game state logic and create a MoveEntityToScene SkyboxSystem.CreateSkybox (state.Scene, Player); Player.GetComponent<TransformComponent> ().Position = new Vector3 (0, 1.85f, 0); var maze_cam_entity = EntityFactory.Instance.CreateWith ("maze_cam_transform", state.MessageProxy, new[] { typeof(TransformComponent) }); var maze_cam_transform = maze_cam_entity.GetComponent<TransformComponent> (); var maze_cam = new BaseCamera (maze_cam_entity, state.MessageProxy, orthographic: true); state.Scene.CameraManager.AddCamera (maze_cam, "maze"); maze_cam_transform.Position = new Vector3 (115, 240, 110); maze_cam_transform.Rotation = Quaternion.FromAxisAngle (Vector3.UnitX, MathHelper.PiOver2); state.Scene.CameraManager.AddCamera (new BaseCamera (Player, state.MessageProxy), "player"); RigidBody playerBody = new RigidBody (new SphereShape (1f)); playerBody.Position = Player.GetComponent<TransformComponent> ().Position.ToJitterVector (); playerBody.AllowDeactivation = false; playerBody.Material.StaticFriction = 0f; playerBody.Material.KineticFriction = 0f; playerBody.Material.Restitution = 0.1f; //playerBody.Mass = 1000000.0f; playerBody.Update (); Player.GetComponent<PhysicsComponent> ().RigidBody = playerBody; Player.GetComponent<PhysicsComponent> ().World = state.PhysicsManager.World; Player.GetComponent<PhysicsComponent> ().PhysicsApplying = AffectedByPhysics.Position; #if PRESENTATION Player.GetComponent<HealthComponent>().MaximumHealth = 500; Player.GetComponent<HealthComponent>().Health = 500; #endif state.PhysicsManager.World.AddBody (playerBody); int seed = new FastRandom ().Next (); var rand = new FastRandom (seed); Logger.Log.AddLogEntry (LogLevel.Debug, "MazeTest", "Seed: {0}", seed); #if PRESENTATION maze [0] = mazeGenerator.CreateMaze<OverworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 10, 10); #else maze [0] = mazeGenerator.CreateMaze<OverworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 30, 30); #endif maze [0].PlayerPosition += Player.GetComponent<TransformComponent> ().Position; maze [0].AIManager.RegisterEntity (Player); for (int i = 0; i < OverworldScobisCount; i++) { ScobisInstances.Add (new Scobis (state, maze [0].AIManager, rendererContext)); } for (int i = 0; i < OverworldCaligoCount; i++) { CaligoInstances.Add (new Caligo (state, maze [0].AIManager, rendererContext, warpingNode)); } for (int i = 0; i < OverworldViridionCount; i++) { ViridionInstances.Add (new Viridion (state, maze [0].AIManager, rendererContext, ColorCorrectionNode)); } for (int i = 0; i < OverworldGhostCount; i++) { GhostInstances.Add (new Ghost (state, maze [0].AIManager, rendererContext, ColorCorrectionNode)); } game.AddGameState ("maze_underworld", Content.Environment.Default, new[] { new Tuple<string, GameStateTransition> ("maze_overworld", new GameStateTransition (0)) }, new[] { new Tuple<string, GameStateTransition> ("maze_overworld", new GameStateTransition (0)), new Tuple<string, GameStateTransition> ("endscreen_state", new GameStateTransition (0)) }); state = game.GetGameState ("maze_underworld"); state.Scene = new CoreScene (rendererContext, messageProvider); state.Scene.SceneName = "MazeUnderworld"; state.Scene.Active = false; state.Scene.BackgroundColor = Color4.AliceBlue; state.Scene.DistanceFogIntensity = 0.07f; state.Scene.AmbientColor = Color4.White; state.Scene.AmbientIntensity = 0.3f; state.Scene.MaxRenderingDistance = 1000.0f; state.AudioContext = new AudioContext (state.MessageProxy); AddAudio (state); state.Scene.CameraManager.AddCamera (new BaseCamera (Player, state.MessageProxy), "player"); #if PRESENTATION maze [1] = mazeGenerator.CreateMaze<UnderworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 10, 10); #else maze [1] = mazeGenerator.CreateMaze<UnderworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 30, 30); #endif maze [1].PlayerPosition += Player.GetComponent<TransformComponent> ().Position; maze [1].AIManager.RegisterEntity (Player); Func<int, int, bool> containsPortalFunc = (x, y) => { foreach (var m in maze) { var cell = m.entities [x, y].GetComponent<PhysicsComponent> ().RigidBody.Tag as MazeCell; if (cell != null && cell.IsPortal) { return true; } } return false; }; mazeWallMover = new MazeWallMover (maze [0], maze [1], game.GetGameState ("maze_overworld"), containsPortalFunc); state.MessageProxy.StopProcessing (); //game.SwitchToGameState("maze_overworld"); for (int i = 0; i < UnderworldCaligoCount; i++) { CaligoInstances.Add (new Caligo (state, maze [1].AIManager, rendererContext, warpingNode)); } for (int i = 0; i < UnderworldPassusCount; i++) { PassusInstances.Add (new Passus (ColorCorrectionNode, state, maze [1].AIManager, rendererContext)); } for (int i = 0; i < UnderworldRoachesCount; i++) { RoachesInstances.Add(new Roaches (state, maze [0].AIManager, rendererContext)); } for (int i = 0; i < UnderworldFenFireCount; i++) { FenFireInstances.Add (new FenFire (state, maze [1].AIManager, rendererContext)); } }
void Start () { gen = FindObjectOfType<MazeGenerator>(); }
private static Map<BinaryCell> GenerateMap() { var map = new Map<BinaryCell>(SOME_WIDTH, SOME_HEIGHT); var mazeGenerator = new MazeGenerator<BinaryCell>(); mazeGenerator.ProcessMap(map, new DungeonConfiguration() { Height = SOME_HEIGHT, Width = SOME_WIDTH }, new Randomizer()); return map; }
//================================================================// // StartNewGame //================================================================// // Create a new game with a different seed and reset appropriate // information. //================================================================// public void StartNewGame() { startSize = 5; currentSquareSize = 5; currentDiversion = 100; ChangeSeed (); currentScore = 0; scoreDisplay.color = Color.white; highScoreMessage.enabled = false; currentScore +=currentSquareSize*(currentSquareSize-1)*10; MazeGenerator maze = new MazeGenerator(seedX, seedY, seedZ); PseudoRandom rnd = new PseudoRandom(seedX, seedY, seedZ); currentStart = maze.CreateRandomPoint(rnd, currentSquareSize, currentSquareSize); CreateNewLevel (currentStart); int[] startPoint = FindStart (currentMap); if (currentPlayer == null) { currentPlayer = (Player) Instantiate (player, gridMaster.GetCoordVect2(startPoint[0], startPoint[1]), Quaternion.identity); } inGame = true; currentPlayer.SetGridMaster (gridMaster); currentPlayer.SetLayout (this); //print (startPoint[0] + " - "+ startPoint[1]); currentPlayer.transform.position = gridMaster.GetCoordVect2 (startPoint [0], startPoint [1]); currentPlayer.currentCoord = startPoint; }
private void Generate() { StopAllCoroutines(); texture = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, false, true) { filterMode = FilterMode.Point }; texture.Clear(Color.black); texture.Apply(); mazeImage.texture = texture; mazeGenerator = new MazeGenerator(textureWidth, textureHeight, cellSize, wallSize); StartCoroutine(GenerateCoroutine()); }
//================================================================// // CreateNewLevel //================================================================// // Destroy all previous parts of the level, then load a level using // MazeGenerator and the current level seed. //================================================================// public void CreateNewLevel(int[] newStart) { while(levelParts.Count != 0) { Destroy(levelParts[0]); levelParts.RemoveAt (0); } MazeGenerator maze = new MazeGenerator(seedX, seedY, seedZ); PseudoRandom rnd = new PseudoRandom(seedX, seedY, seedZ); currentStart = newStart; currentMap = maze.CreateNSEWMap(currentSquareSize, currentSquareSize, currentDiversion, currentStart); currentFinish = FindEnd (currentMap); mainCamera.GetComponent<CameraFollow> ().SetSpotlightSettings (currentSquareSize); MapToLevel (currentMap); CreateBoundries (currentMap); gridMaster = new GridMaster (0.5f, 0.5f, currentMap.GetLength(1), currentMap.GetLength(0), 1f, 1f); GameObject fin = (GameObject)Instantiate (finish, gridMaster.GetCoordVect2(currentFinish[0], currentFinish[1]), Quaternion.identity); levelParts.Add (fin); if (currentSquareSize > startSize) { currentScore +=currentSquareSize*(currentSquareSize-1)*10; currentPlayer.SetGridMaster (gridMaster); currentPlayer.SetLayout (this); } SaveCurrentGame (); }
//================================================================// // ContinueGame //================================================================// // Load in the game settings from a previous game, and create // the level. //================================================================// public void ContinueGame(Game game) { CreateLevelFromGame (game); MazeGenerator maze = new MazeGenerator(seedX, seedY, seedZ); PseudoRandom rnd = new PseudoRandom(seedX, seedY, seedZ); CreateNewLevel (currentStart); int[] startPoint = currentStart; if (currentPlayer == null) { currentPlayer = (Player) Instantiate (player, gridMaster.GetCoordVect2(startPoint[0], startPoint[1]), Quaternion.identity); } inGame = true; currentPlayer.SetGridMaster (gridMaster); currentPlayer.SetLayout (this); //print (startPoint[0] + " - "+ startPoint[1]); currentPlayer.transform.position = gridMaster.GetCoordVect2 (startPoint [0], startPoint [1]); currentPlayer.currentCoord = startPoint; }
void Awake() { instance = this; }
public void practicum() { //panel1.Visible = true; //panel1.Dock = DockStyle.Fill; mg = new MazeGenerator(6, 6); mg.GenerateMaze(); richTextBox1.Visible = true; richTextBox1.Dock = DockStyle.Fill; foreach (MazeGenerator.Edge edge in mg.aPath) { WriteConsole(edge.Edge1 + " - " + edge.Edge2); } //MazeGenerator.EdgeSort es = new MazeGenerator.EdgeSort(); //mg.maze.Sort(es); //foreach (MazeGenerator.Edge edge in mg.maze) //{ // if (edge.Edge1 + 1 == edge.Edge2 || edge.Edge2 + 1 == edge.Edge1) // WriteConsole(" | ", false, false); //} }
void Awake() { mazeGenerator = transform.GetComponent<MazeGenerator>(); }
void Initialize() { // Getting Game system refrecnces: if( _gameData == null ) _gameData = GameData.getInstance(); if( axesInputDelayControl == null ) axesInputDelayControl = AxesInputDelayControl.getInstance(); // Preseting data here since UNITY seems to ignore anything global: MapWidth = (int)MazeGlobals.SMALL_MAP_SIZE.x; MapHeight = (int)MazeGlobals.SMALL_MAP_SIZE.y; // XML/Saving data: isSavable = true; //Globals.defaultIsSavable; xmlElementName = MazeGlobals.mazeXMLlElementNameDefault; xmlNamespace = MazeGlobals.mazeXMLNamespaceDefault; savePathAndName = MazeGlobals.mazeSavePathAndNameDefault; // Initalizing the list to hold the maps: if( _mapList == null ) _mapList = new GenericManager<int, Map>( isSavable, xmlElementName, xmlNamespace, savePathAndName ); // Loading a floor if needed: if( FloorObj == null ) { FloorObj = GameObject.CreatePrimitive( PrimitiveType.Cube ); FloorObj.name = GameGlobals.FLOOR_BLOCK_NAME; FloorObj.tag = GameGlobals.FLOOR_BLOCK_TAG; FloorObj.renderer.material = Resources.Load( GameGlobals.FLOOR_BLOCK_MAT, typeof(Material)) as Material;; FloorObj.renderer.material.shader = Shader.Find( GameGlobals.floorShaderList[ (int) SettingsData.getInstance().GameDifficulty ] ); FloorObj.transform.localScale = GameGlobals.floorSize; } // Loading a wall if needed: if( WallObj == null ) { WallObj = GameObject.CreatePrimitive( PrimitiveType.Cube ); WallObj.name = GameGlobals.WALL_BLOCK_NAME; WallObj.tag = GameGlobals.WALL_BLOCK_TAG; WallObj.renderer.material = Resources.Load( ( GameGlobals.WALL_BLOCK_RANDOM_MAT + Random.Range( 2, 13).ToString() ), typeof(Material)) as Material;; //WallObj.renderer.material.shader = Shader.Find( GameGlobals.wallShaderList[ (int) _gameData.settings.GameDifficulty ] ); WallObj.transform.localScale = GameGlobals.wallSize; } // If the wal or floor are null then exit: if( FloorObj == null || WallObj == null ) { Debug.Log("Error wall and/or floor are not initalized"); return; } #region Creating the light // Creating the light: if( AreaLight == null ) { //AreaLight = new GameObject("The Light"); //AreaLight.AddComponent<Light>(); //AreaLight.light.color = AreaLightColor; //AreaLight.light.type = LightType.Directional; //AreaLight.light.intensity = 0.5f; //AreaLight.transform.localRotation = new Quaternion( 90, 0, 0, 0 ); //AreaLight.transform.position = new Vector3( ( MapWidth * FloorSize.x ) / GameGlobals.HALF, ( FloorSize.y + WallSize.y ) * 10, ( MapHeight * FloorSize.z ) / GameGlobals.HALF ); } #endregion #region Map Loading/Gernerating Generator = new MazeGenerator(); // Attempting to laod an XML file and make the first maze, // If this does not work then we load the default maze: if( !_mapList.loadObjectList( false, Path.Combine( Application.dataPath, savePathAndName ), xmlElementName, xmlNamespace ) ) { // Creating the default raw map data: MainMap = new Map(); MainMap.initalizeDefaultMap(false); // Transforming the default raw map data into Unity objects: Generator.genrate( ref MainMap, ref MapWidth, ref MapHeight, ref FloorObj, ref WallObj ); _mapList.addObject( _mapList.Listcount, MainMap ); // Adding aditional raw map data as needed: AddingMazeHelper.mazeListToAdd( ref _mapList ); // Use this to add lots of maps. // Saving the raw map data to xml: _mapList.saveObjectList( Path.Combine( Application.dataPath, savePathAndName ), xmlElementName, xmlNamespace ); } else { MainMap = _mapList.getObject(0); MainMap.initalizeLoadedMap( false ); Generator.genrate( ref MainMap, ref MapWidth, ref MapHeight, ref FloorObj, ref WallObj ); } #endregion #region Creating Start and End Positions // Creating the Start Position Marker: if( StartPoint == null ) { StartVector = MainMap.playerStartPoint; StartVector.x = (StartVector.x) * FloorObj.transform.localScale.x; StartVector.z = (StartVector.z) * FloorObj.transform.localScale.z; StartPoint = GameObject.CreatePrimitive( PrimitiveType.Cube ); StartPoint.name = GameGlobals.START_POSITION_NAME; StartPoint.tag = GameGlobals.START_POSITION_TAG; StartPoint.transform.localScale = GameGlobals.startAndEndMarkerSize; StartPoint.transform.position = new Vector3( StartVector.x, StartPoint.transform.localScale.y, StartVector.z); StartMat = Resources.Load( GameGlobals.START_BLOCK_MAT, typeof(Material)) as Material; StartPoint.renderer.material = StartMat; } // Creating the End Position Marker: if( EndPoint == null ) { EndVector = MainMap.playerEndPoint; EndVector.x = EndVector.x * FloorObj.transform.localScale.x; EndVector.z = EndVector.z * FloorObj.transform.localScale.z; EndPoint = GameObject.CreatePrimitive( PrimitiveType.Sphere ); EndPoint.name = GameGlobals.END_POSITION_NAME; EndPoint.tag = GameGlobals.END_POSITION_TAG; EndPoint.transform.localScale = GameGlobals.startAndEndMarkerSize; EndPoint.transform.position = new Vector3( EndVector.x, EndPoint.transform.localScale.y, EndVector.z ); ; EndMat = Resources.Load( GameGlobals.END_BLOCK_MAT, typeof(Material)) as Material; EndPoint.renderer.material = EndMat; EndPoint.collider.isTrigger = true; EndPoint.AddComponent<EndPointScript>(); } #endregion #region Creating the Player // Creating the Player and puting it in the game: //Player = Instantiate( Resources.Load( "Player" , typeof(GameObject)) ) as GameObject; Player = Instantiate( Resources.Load( "Prefabs/FPSPlayer" , typeof(GameObject)) ) as GameObject; Player.name = "FPSPlayer"; Player.transform.position = new Vector3 ( StartVector.x, 2, StartVector.z ); playerScript = Player.GetComponent<vp_FPSPlayer>(); #endregion // Setting up gameplay variables: gameState = GameGlobals.GameState.running; // Interface Variables _playTime = 0.0f; _playTimePosition = new Rect( Screen.width - 50, 20, 50, 50 ); #region Pause Button // Seting up the pause Button: //_pauseTextureList = new Texture[ GUIGlobals.numberOfButtonStates ]; //_pauseButtonPosition = new Rect( 0, Screen.height - 50, 100, 50 ); //listCount = _pauseTextureList.Length; //for( i = 0; i < listCount; i++ ) //_pauseTextureList[i] = (Texture2D)Resources.Load( GUIGlobals.pauseButtonPathList[i], typeof(Texture2D)); #endregion #region Pause Menu // Creating the Pause Menu: pauseMenu = new GameObject(); pauseMenu.name = PauseMenuGlobals.PAUSE_MENU_NAME; pauseMenu.tag = PauseMenuGlobals.PAUSE_MENU_TAG; pauseMenu.AddComponent<MenuBase>(); pauseMenu.GetComponent<MenuBase>().initialize( GUIGlobals.menuTypeDefs.PAUSE, PauseMenuGlobals.PAUSE_MENU_BACKGROUND_PATH, PauseMenuGlobals.PAUSE_MENU_BUTTON_TEXTURES, PauseMenuGlobals.PAUSE_MENU_TOOL_TIPS, PauseMenuGlobals.PAUSE_MENU_BUTTON_POSITIONS ); pauseMenu.SetActive( false ); #endregion // Cleaning up the origanal wall and floor objects: Destroy(WallObj); Destroy(FloorObj); }