public void Reset() { //Debug.Log("Reset"); goalExists = false; goal = null; GetComponent <Pathfinding>().Reset(); }
public bool ImproveMap(IMap map, IRandomProvider random) { // Let's reuse directions, but let them represent quadrants // So north-> north-west var quadrant = ChooseQuadrant(random); var goaltile = new GoalTile(); (var success, var location, var openDir) = PlaceTileInQuadrant(quadrant, map, goaltile); if (!success) { return(success); } goaltile.Direction = openDir; map.Goal = location; var startTile = new StartTile(); (success, location, openDir) = PlaceTileInQuadrant(Directions.GetOpposite(quadrant), map, startTile); if (success) { startTile.Direction = openDir; map.Start = location; } return(success); }
public void SetTile(Tile tile) { this.tile = tile as GoalTile; if (this.tile != null) { CorrectRotation(); } }
//this is a meme name, i'm a nets fan //one connection succeeded private void JubilationInNewark(List <Tile> pathToSuccess, GoalTile goalThatWasFound) { switch (goalThatWasFound.typeOfGoal) { case GoalType.gt_bomb: goalThatWasFound.Jubilation(); AudioSource.PlayClipAtPoint(explosionEffects[Random.Range(0, explosionEffects.Length)], transform.position); //this should actually come from removeOnUse Vector2Int tilePos = goalThatWasFound.GetTilePosition(); _currentLevelTiles[tilePos.x, tilePos.y] = null; break; case GoalType.gt_score: AudioSource.PlayClipAtPoint(successEffects[Random.Range(0, successEffects.Length)], transform.position); foreach (Tile t in pathToSuccess) { t.Jubilation(); } break; case GoalType.gt_timeBonus: goalThatWasFound.Jubilation(); AudioSource.PlayClipAtPoint(timeLimitEffects[Random.Range(0, timeLimitEffects.Length)], transform.position); _currentLevelTimeLimit += goalThatWasFound.timeBonus; UpdateTimeLimitText(); ApplyMoveLimitVisualEffects(Color.white, Color.blue); break; default: break; } bool allGoalsDone = true; foreach (StartTile st in _startTiles) { if (!st.IsUsedUp()) { allGoalsDone = false; } } if (allGoalsDone) { nextLevelButton.interactable = true; nextLevelButton.GetComponent <Image>().color = Color.green; } }
public void SetPath(Tile lastTile) { //Debug.Log("SET"); if (currentPath.Count > 0) { GoalTile pathStart = currentPath.Pop(); NetworkServer.Destroy(pathStart.gameObject); } if (pathStart != null) { NetworkServer.Destroy(pathStart.gameObject); pathStart = null; } Tile previousTile = placedTiles.Count > 0 ? placedTiles.Peek() : null; Point start = GetComponent <Goals>().StartPoint(lastTile, previousTile); GoalTile startTile = new GoalTile(start.x, start.y, start.z); pathStart = startTile; startTile.gameObject = GetComponent <Goals>().Create(start.x, start.y, start.z, false, GameScene.Instance.Path); int[,,] array = MapToArray(placedTiles, start); int center = array.GetLength(0) / 2; EmptyPath(currentPath); Queue <Point> pointQueue = Dijkstra.Solve(array, center, center, center, center); placedTiles.Push(lastTile); while (pointQueue.Count > 0) { Point point = pointQueue.Dequeue(); GoalTile path = new GoalTile(point.x * blockSize + start.x, point.y * blockSize + start.y, point.z * blockSize + start.z); path.gameObject = GetComponent <Goals>().Create(point.x * blockSize + start.x, point.y * blockSize + start.y, point.z * blockSize + start.z, false, GameScene.Instance.Path); currentPath.Push(path); } }
public void SetGoal(Tile lastTile) { if (goalExists) { return; } goalExists = true; int x = lastTile.x + blockSize * rng.Next(-5, 6); int y = lastTile.y; int z = lastTile.z + blockSize * rng.Next(2, 10); //calculate time for chronometer goal = new GoalTile(x, y, z); goal.gameObject = Create(x, y, z, true, GameScene.Instance.Goal); }
public bool Place() { if (lastGoal != null) { lastGoal = null; } lastPlaced += 1; bool output = Random.Next(0, 5) > 3; if (output) { lastPlaced = 1; } //output = true; return(output); }
public Point StartPoint(Tile lastTile, Tile previousTile) { Point output = new Point(lastTile.x, lastTile.y, lastTile.z); if (!lastTile.init && !missedGoal && lastTile.gameObject.name == "CrossTile") { GoalTile pathStart = GetComponent <Pathfinding>().currentPath.Peek(); return(new Point(pathStart.x, pathStart.y, pathStart.z)); } try { Quaternion next = new Quaternion(1, 0, 0, 0); Quaternion i = new Quaternion(0, 1, 0, 0); if (lastTile.gameObject.name == "CornerTile") { next *= i * i; } int rotation = (int)lastTile.gameObject.transform.rotation.eulerAngles.y + ArchitectAI.tileCompensation[lastTile.gameObject.name]; while (rotation > 0) { rotation -= 90; next *= i; } output.x += (int)next.x * blockSize; output.z += (int)next.y * blockSize; if (Array.Exists(ArchitectAI.linearTiles, element => element == lastTile.gameObject.name) && previousTile != null && output.x == previousTile.x && output.y == previousTile.y) { output.x -= 2 * (int)next.x * blockSize; output.z -= 2 * (int)next.y * blockSize; } } catch (Exception) { } return(output); }
private void CheckForConnectivity() { bool connectionFound = false; foreach (StartTile st in _startTiles) { if (st.IsUsedUp()) { continue; } //check if this tile reaches any goal tiles by connecting via the pipes List <Tile> pathToSuccess = new List <Tile>(); GoalTile goalThatWasFound = null; connectionFound = CheckTileConnections(st, Vector2Int.zero, st, pathToSuccess, out goalThatWasFound); if (connectionFound) { JubilationInNewark(pathToSuccess, goalThatWasFound); break; } } }
public int Position(Tile currentTile, Tile lastTile) { GoalTile position = GetComponent <Pathfinding>().currentPath.Peek(); GoalTile nextPath; try { nextPath = GetComponent <Pathfinding>().currentPath.Skip(1).First(); } catch (Exception e) { Debug.Log("path too short"); nextPath = new GoalTile(Goals.goal.x, Goals.goal.y, Goals.goal.z); } //unset crosstiles to avoid weird bugs if (currentTile.gameObject.name == "CrossTile") { NetworkServer.Destroy(currentTile.gameObject); currentTile.gameObject = Instantiate(GameScene.Instance.tiles[0].tile, new Vector3(currentTile.x, GameScene.Instance.tiles[0].tile.transform.position.y, currentTile.z), Quaternion.identity); currentTile.gameObject.name = GameScene.Instance.tiles[0].tile.name; } //set corner when needed //yes, the ai is basically cheating (but for the greater good) if ((nextPath.x - lastTile.x == 16 || nextPath.x - lastTile.x == -16) && (nextPath.z - lastTile.z == 16 || nextPath.z - lastTile.z == -16)) { NetworkServer.Destroy(currentTile.gameObject); currentTile.gameObject = Instantiate(GameScene.Instance.tiles[2].tile, new Vector3(currentTile.x, GameScene.Instance.tiles[2].tile.transform.position.y, currentTile.z), Quaternion.identity); currentTile.gameObject.name = GameScene.Instance.tiles[2].tile.name; } else if (currentTile.gameObject.name == "CornerTile") { NetworkServer.Destroy(currentTile.gameObject); currentTile.gameObject = Instantiate(GameScene.Instance.tiles[0].tile, new Vector3(currentTile.x, GameScene.Instance.tiles[0].tile.transform.position.y, currentTile.z), Quaternion.identity); currentTile.gameObject.name = GameScene.Instance.tiles[0].tile.name; } int direction = 0; Vector3 delta = new Vector3(position.x - lastTile.x, 0, position.z - lastTile.z); if (delta.x > 0) { direction = 2; } if (delta.x < 0) { direction = 1; } return(direction); }
public int Rotation(Tile currentTile, Tile lastTile) { int lastCompensate = -90; try { lastCompensate = tileCompensation[lastTile.gameObject.name]; if (lastTile.gameObject.name == "CornerTile") { switch (((int)lastTile.gameObject.transform.rotation.eulerAngles.y) + 360 % 360) { case 0: case 90: lastCompensate = 270; break; case 270: case -90: lastCompensate = 270; break; default: lastCompensate = 0; break; } } } catch (Exception e) { }; int compensate = tileCompensation[currentTile.gameObject.name] - lastCompensate; int delta = 0; if (currentTile.gameObject.name == "CornerTile") { GoalTile goal = Goals.goal; delta = goal.x - currentTile.x; if (delta == 0) { delta = lastTile.x - currentTile.x > 0 ? 90 : 180;//z increases } else { delta = (delta > 0 ? 90 : 180); //x modifies } } try { if (lastTile != null && lastTile.gameObject.name == "JumpTile" && currentTile.gameObject.name == "JumpTile") { compensate += 180; } if (lastTile != null && lastTile.gameObject.name == "CrossTile" && (lastTile.x != currentTile.x || lastTile.z != currentTile.z)) { if (lastTile.x - currentTile.x == 0) { return(90 + compensate); } else if (lastTile.x - currentTile.x > 0) { return(180 + compensate); } return(0 + compensate); } //Debug.Log(currentTile.gameObject.name + ": " + new Vector3((int)lastTile.gameObject.transform.rotation.eulerAngles.y, compensate, delta)); //Debug.Log(lastTile.gameObject.name); return((int)lastTile.gameObject.transform.rotation.eulerAngles.y + compensate + delta); } catch (Exception e) { Debug.Log(e); } return(compensate + delta); }
private bool CheckTileConnections(Tile tile, Vector2Int incomingDir, Tile lastEncounteredStartTile, List <Tile> pathToSuccess, out GoalTile goalThatWasFound) { if (tile is StartTile) { lastEncounteredStartTile = tile; pathToSuccess.Clear(); } bool goalFound = tile is GoalTile && !tile.IsUsedUp(); goalThatWasFound = goalFound ? (GoalTile)tile : null; bool linkedToPreviousTile = (tile == lastEncounteredStartTile); foreach (Vector2Int cd in tile.ConnectionDirs) { if (cd == incomingDir) { //this is where the line comes from, no need to take this into account for future //but we need to assure we have connection here linkedToPreviousTile = true; break; } } if (!linkedToPreviousTile) { return(false); } else { pathToSuccess.Add(tile); } foreach (Vector2Int cd in tile.ConnectionDirs) { if (cd != incomingDir && !goalFound) { Vector2Int targetPosition = tile.GetTilePosition() + cd; if (IsWithinBounds(targetPosition)) { //recursive call, what's important is reversing the direction so that incoming tile is properly controlled //we should be afraid of loops! Tile targetTile = _currentLevelTiles[targetPosition.x, targetPosition.y]; if (targetTile) //space could be empty altogether { goalFound = CheckTileConnections(targetTile, new Vector2Int(-cd.x, -cd.y), lastEncounteredStartTile, pathToSuccess, out goalThatWasFound); } } } } return(goalFound); }