public Map2dAStar(Func <bool> canJump, MazeLevel maze, VisionMapping vision, Transform transform, GameObject prefab_debug_astar)
{
this.maze = maze;
this.prefab_debug_astar = prefab_debug_astar;
SetAstarSourceData(vision, () => maze.Map, canJump, ResetCalcSpace,
(Coord c, out Coord n) => {
AStarData a = calcSpace.At(c);
Coord f = a.from; //e = a._edge;
n = f != Coord.NegativeOne ? f : c;
return(a._edge);
},
(c, f, e) => {
AStarData a = calcSpace.At(c);
a._edge = e; a.from = f;
},
c => calcSpace.At(c).f, (c, f) => { calcSpace.At(c).f = f; },
c => calcSpace.At(c).g, (c, f) => { calcSpace.At(c).g = f; });
ResetCalcSpace(Map.GetSize());
Vector3 p = transform.position;
Coord here = maze.GetCoord(p);
Start(here, here);
if (prefab_debug_astar != null)
{
maze.seen.onChange += RefreshVision;
vision.onChange += RefreshVision;
}
}
public Maze(int w, int h, MazeLevel mazeMode)
{
width = w;
height = h;
this.mazeMode = mazeMode;
maze = new Elements[height, width];
randomNumber = new Random();
}
public Score(MazeLevel mazeLevel)
{
currentScore = NEWSCORE;
this.mazeLevel = mazeLevel.ToString();
db = new Database();
currentScore = NEWSCORE;
sound = new GameSound();
}
public void SetDiscovered(bool discovered, Discovery d, MazeLevel maze)
{
_discovered = discovered;
this.maze = maze;
maze.seen[coord] = discovered;
this.d = d;
t = transform;
started = 0;
DoAnimate();
}
void ResetLevel()
{
ClearLevel();
// When resetting the level, levelIndex will be set to the next level.
int currentLevel = levelIndex == 0 ? LevelCollection.levels.Count - 1 : levelIndex - 1;
MazeLevel level = LevelCollection.levels[currentLevel];
visibilityController.SetupLevel(level);
mazeState = MazeState.Starting;
}
public void Draw(MazeLevel mazeLevel)
{
if (prevCells == null)
{
FirstDraw(mazeLevel);
}
else
{
ReDraw(mazeLevel);
}
prevCells = mazeLevel.Cells.ToList();
}
public Engine(gameMode mode, MazeLevel mazeMode, int length = mazeRenderLength, int width = mazeRenderWidth)
{
mazeLength = length;
mazeWidth = width;
currentGameMode = mode;
gameSound = new GameSound();
this.mazeMode = mazeMode;
score = new Score(this.mazeMode);
foodGenerator = new FoodGenerator();
newAI = new AI(new Random());
newSmartAI = new AI(new Random());
}
private void MazeLevelToViewModel(MazeLevel mazeLevel, MazeViewModel viewModel)
{
viewModel.Cells = new CellType[mazeLevel.Height, mazeLevel.Width];
foreach (var cell in mazeLevel.Cells
.OrderBy(x => x.Y)
.ThenBy(x => x.X))
{
viewModel.Cells[cell.Y, cell.X] = CellTypeMapper(cell);
//viewModel.Cells[cell.Y, cell.X].X = cell.X;
//viewModel.Cells[cell.Y, cell.X].Y = cell.Y;
}
}
private void ReDraw(MazeLevel mazeLevel)
{
foreach (var cell in mazeLevel.Cells)
{
var prevCell = prevCells.Single(x => x.IsSameCoordinate(cell));
if (prevCell.GetType() != cell.GetType())
{
Console.SetCursorPosition(cell.X, cell.Y);
DrawCell(cell);
}
}
}
private void FirstDraw(MazeLevel mazeLevel)
{
Console.Clear();
for (int y = 0; y < mazeLevel.Height; y++)
{
for (int x = 0; x < mazeLevel.Width; x++)
{
var cell = mazeLevel.Cells.Single(cell => cell.X == x &&
cell.Y == y);
DrawCell(cell);
}
Console.WriteLine();
}
}
public LevelState(string name, int startLevel)
: base(name)
{
Camera = new FirstPersonCamera();
Camera.BoundingRadius = 2.0f;
Camera.UpdateBoundingVolumes();
YnG.ShowMouse = (GameConfiguration.EnabledMouse ? true : false);
YnG.AudioManager.SoundEnabled = GameConfiguration.EnabledSound;
YnG.AudioManager.MusicVolume = GameConfiguration.MusicVolume;
groundPlayerBoundingSphere = new BoundingSphere(Camera.Position, Camera.BoundingRadius);
_mazeLevel = new MazeLevel(startLevel);
Add(_mazeLevel);
_gameHUD = new GameHUD();
timeTimer = new MazeTimer();
score = new Score(startLevel);
gameState = MazeGameState.Playing;
elapsedPartyTime = 0;
soundTimer = new YnTimer(1000, 0);
if (YnG.AudioManager.SoundEnabled)
{
soundTimer.Completed += (s, e) => YnG.AudioManager.SoundEnabled = true;
}
else
{
soundTimer.Completed += (s, e) => { }
};
control = new MazeController(Camera);
Scene.SceneLight.AmbientIntensity = 0.85f;
Scene.SceneLight.DirectionalLights[0].Enabled = true;
Scene.SceneLight.DirectionalLights[0].Direction = new Vector3(-1, 0.75f, -1);
Scene.SceneLight.DirectionalLights[0].DiffuseColor = Color.WhiteSmoke.ToVector3();
Scene.SceneLight.DirectionalLights[0].DiffuseIntensity = 1.0f;
Scene.SceneLight.DirectionalLights[0].SpecularColor = new Vector3(233, 33, 33);
}
void LoadNextLevel()
{
ClearLevel();
if (UDLRCameraController.Instance != null)
{
UDLRCameraController.Instance.ResetCameraPositions();
}
if (levelIndex < LevelCollection.levels.Count)
{
MazeLevel level = LevelCollection.levels[levelIndex];
visibilityController.SetupLevel(level);
levelIndex = (levelIndex + 1) % LevelCollection.levels.Count;
// This happens before Start() is called on some components, so we have to force their
// MazeStateChanged callback whenever they register themselves. Which isn't ideal.
mazeState = MazeState.Starting;
}
}
public void InitializeMinimap(MazeLevel mazeLevel)
{
itemsCount = mazeLevel.Items.Count;
itemsCounter.Text = String.Format("{0} / {1}", new object[] { 0, itemsCount });
miniMap = new MiniMap(mazeLevel.Tiles, mazeLevel.Level.BlockSizes.Width, mazeLevel.Level.BlockSizes.Depth);
miniMap.LoadContent();
miniMap.Enabled = GameConfiguration.EnabledMinimapUpdate;
miniMap.Visible = GameConfiguration.EnabledMinimap;
Add(miniMap);
miniMapLeftBorder.Active = GameConfiguration.EnabledMinimap;
miniMapBottomBorder.Active = GameConfiguration.EnabledMinimap;
miniMapBottomBorder.Width = (int)(miniMap.Width);
miniMapBottomBorder.Position = new Vector2(miniMap.X, miniMap.Y + miniMap.Height);
miniMapLeftBorder.Height = (int)(miniMap.Height + miniMapBottomBorder.ScaledHeight);
miniMapLeftBorder.Position = new Vector2(miniMap.X - miniMapLeftBorder.ScaledWidth, miniMap.Y);
}
private void Start()
{
if (maze == null)
{
maze = FindObjectOfType <MazeLevel>();
}
CharacterMove cm = transform.parent.GetComponent <CharacterMove>();
if (cm == null)
{
Debug.Log(transform.HierarchyPath());
}
sc = GetComponent <SphereCollider>();
cm.callbacks.jumped.AddListener(v => Blink());
//cm.callbacks.stand.AddListener(v => Blink());
cm.callbacks.fall.AddListener(() => Blink());
if (playerLayer == -1)
{
LayerMask.NameToLayer("player");
}
ResetCalc();
}
public void ClaimPlayer(Command.Exec e)
{
GameObject npc = DialogManager.Instance.dialogWithWho;
Global.GetComponent <Team>().AddMember(npc);
MazeLevel ml = Global.GetComponent <MazeLevel>();
Discovery d = EnsureExplorer(npc);
ParticleSystem ps = npc.GetComponentInChildren <ParticleSystem>();
Color color = ps.main.startColor.color;
d.discoveredFloor = Color.Lerp(d.discoveredFloor, color, 0.25f);
d.discoveredWall = Color.Lerp(d.discoveredWall, color, 0.25f);
d.discoveredRamp = Color.Lerp(d.discoveredRamp, color, 0.25f);
d.maze = ml;
Global.GetComponent <ConditionCheck>().DoActivateTest();
InventoryCollector inv = npc.GetComponentInChildren <InventoryCollector>();
inv.inventory = InventoryManager.main;
inv.autoPickup = true;
ScriptedDictionary dict = npc.GetComponent <ScriptedDictionary>();
dict["cooperative"] = true;
}
public Gold(int x, int y, MazeLevel mazeLevel, int goldCount)
: base(x, y, mazeLevel)
{
GoldCount = goldCount;
}
private static int FindMinimumDistanceBfsPlutonian(PortalMaze maze, int maxDepth)
{
var graph = BuildSimpleGraph(maze);
var toplevel = new MazeLevel()
{
Level = 0
};
var entry = graph.Vertices[maze.Entry];
var exit = graph.Vertices[maze.Exit];
var root = graph.Root;
toplevel.Visited[root.Pos] = true;
var queue = new Queue <(MazeLevel, PortalGraph.Vertex, int)>();
queue.Enqueue((toplevel, root, 0));
while (queue.Any())
{
var(level, node, distance) = queue.Dequeue();
if (node.Pos == exit.Pos && level.Level == 0)
{
return(distance);
}
foreach (var e in node.Edges)
{
var nextnode = e.Key;
var nextlevel = level;
if (e.Value != 0)
{
if (e.Value == -1)
{
if (level.Level > maxDepth)
{
continue;
}
if (level.Inner == null)
{
level.Inner = new MazeLevel()
{
Level = level.Level + 1,
Outer = level
};
}
nextlevel = level.Inner;
}
else
{
nextlevel = level.Outer;
if (nextlevel == null)
{
continue;
}
}
nextnode = graph.Vertices[nextnode.Pos];
}
if (nextlevel.Visited[nextnode.Pos])
{
continue;
}
nextlevel.Visited[nextnode.Pos] = true;
queue.Enqueue((nextlevel, nextnode, distance + 1));
}
}
return(Infinite);
}
static void Main(string[] args)
{
initialMenuLoad();
currentGameMode = gameMode.basic;
MazeLevel mazeMode = ChooseMazeMode();
using (Engine gameEngine = new Engine(gameMode.basic, mazeMode))
{
Elements[,] Maze = gameEngine.initializeGame();
Elements[,] updateMaze = Maze;
Draw(Maze);
do
{
int score = gameEngine.getScore();
drawScore(score);
ConsoleKeyInfo keyInfo = keyListner.ReadKey(GameStepMilliseconds);
switch (keyInfo.Key)
{
case ConsoleKey.UpArrow:
updateMaze = gameEngine.updateGame(Direction.Up);
break;
case ConsoleKey.DownArrow:
updateMaze = gameEngine.updateGame(Direction.Down);
break;
case ConsoleKey.RightArrow:
updateMaze = gameEngine.updateGame(Direction.Right);
break;
case ConsoleKey.LeftArrow:
updateMaze = gameEngine.updateGame(Direction.Left);
break;
case ConsoleKey.Q:
ExitGame = true;
break;
default:
updateMaze = gameEngine.updateGame(Direction.Unchanged);
break;
}
if (updateMaze[0, 0] == Elements.snakeDeath)
{
ExitGame = true;
}
Console.Clear();
Draw(updateMaze);
}while (ExitGame == false);
Console.Write("Please enter your name: ");
string highScoreName = keyListner.ReadKey(Int32.MaxValue).KeyChar.ToString() + Console.ReadLine();
gameEngine.setName(highScoreName);
gameEngine.handleHighSCore();
EndGame(gameEngine.getScore(), gameEngine.getHighScoreList());
}
}
public void SetupLevel(MazeLevel levelData)
{
objectRevealTimer.Clear();
objectRevealTimer.AddObjectList(new SerialObjectTaskTimer.ObjectTaskList(blocksInitialRevealDelay));
objectRevealTimer.AddObjectList(new SerialObjectTaskTimer.ObjectTaskList(camRevealDelay));
objectRevealTimer.AddObjectList(new SerialObjectTaskTimer.ObjectTaskList(panelRevealDelay));
if (UDLRCameraController.Instance != null)
{
CamAnimator[] animators = UDLRCameraController.Instance.GetCameraAnimators();
CameraPanel.DisplayPosition[] camRevealOrder = { CameraPanel.DisplayPosition.TopLeft, CameraPanel.DisplayPosition.TopRight,
CameraPanel.DisplayPosition.BottomRight, CameraPanel.DisplayPosition.BottomLeft };
for (int i = 0; i < camRevealOrder.Length; ++i)
{
if (LevelController.Instance.LevelCollection.levels[LevelController.Instance.levelIndex].cameraToggles[(int)camRevealOrder[i]])
{
foreach (CamAnimator camAnim in animators)
{
if (camAnim != null && camAnim.CameraPanel.camPosition == camRevealOrder[i])
{
HideObjectAndAddToRevealList(camAnim.gameObject, (int)VisibilityState.RevealingCameras);
break;
}
}
}
}
}
foreach (RotatorTriggerData rotator in levelData.rotators)
{
GameObject rotatorTriggerObj = Instantiate(rotatorCubePrefab, rotator.position, Quaternion.identity);
CameraRotatorTrigger rotatorTrigger = rotatorTriggerObj.GetComponent <CameraRotatorTrigger>();
if (rotatorTrigger != null)
{
rotatorTrigger.arcType = rotator.arcType;
}
HideObjectAndAddToRevealList(rotatorTriggerObj, (int)VisibilityState.RevealingObjects);
}
if (InputHandler.Instance != null)
{
for (int panelPos = 0; panelPos < (int)CameraPanel.DisplayPosition.NumPositions; ++panelPos)
{
if (LevelController.Instance.LevelCollection.levels[LevelController.Instance.levelIndex].cameraToggles[panelPos])
{
GameObject cube = Instantiate(playerCubePrefab, levelData.cubeStartPositions[panelPos], Quaternion.identity);
CubeController cubeController = cube.GetComponent <CubeController>();
Assert.IsNotNull(cubeController);
InputHandler.Instance.SetCubeController(panelPos, cubeController);
cubeController.associatedPanelPosition = (CameraPanel.DisplayPosition)panelPos;
cube.layer = LayerMask.NameToLayer(CameraPanel.PositionLayerNames[panelPos]);
HideObjectAndAddToRevealList(cube, (int)VisibilityState.RevealingObjects);
GameObject goal = Instantiate(goalCubePrefab, levelData.goalPositions[panelPos], Quaternion.identity);
MazeGoal goalController = goal.GetComponent <MazeGoal>();
Assert.IsNotNull(goalController);
goal.layer = LayerMask.NameToLayer(CameraPanel.PositionLayerNames[panelPos]);
HideObjectAndAddToRevealList(goal, (int)VisibilityState.RevealingObjects);
goalController.associatedDisplayPosition = (CameraPanel.DisplayPosition)panelPos;
if (UDLRCameraController.Instance != null)
{
MeshRenderer meshRenderer = cube.GetComponent <MeshRenderer>();
if (meshRenderer != null)
{
meshRenderer.material.SetColor("_EmissionColor", UDLRCameraController.Instance.GetCameraAnimators()[panelPos].GetCamObjColour());
}
MeshRenderer goalMeshRenderer = goal.GetComponent <MeshRenderer>();
if (goalMeshRenderer != null)
{
goalMeshRenderer.material.SetColor("_EmissionColor", UDLRCameraController.Instance.GetCameraAnimators()[panelPos].GetCamObjColour());
}
}
}
}
}
if (UDLRCameraController.Instance != null)
{
UDLRCameraController.Instance.panelController.enabled = false;
objectRevealTimer.AddObjectToObjectsList(UDLRCameraController.Instance.gameObject, (int)VisibilityState.RevealingPanel);
}
objectRevealTimer.BeginObjectTasks();
}
public Wall(int x, int y, MazeLevel mazeLevel)
: base(x, y, mazeLevel)
{
}
protected BaseCell(int x, int y, MazeLevel mazeLevel)
{
X = x;
Y = y;
MazeLevel = mazeLevel;
}
public Ground(int x, int y, MazeLevel mazeLevel)
: base(x, y, mazeLevel)
{
}
