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);
}
