public void InitNewGrid() { RemoveGrid(); ThisGrid = new GridTile[SizeX, SizeY]; Vector2 currentPosition = new Vector2(0, 0); Sprite sprite = TilePrefab.GetComponent <SpriteRenderer>().sprite; float spriteWidth = sprite.bounds.extents.x; float spriteHeight = sprite.bounds.extents.y; for (int y = 0; y < SizeY; y++) { for (int x = 0; x < SizeX; x++) { GridTile newTile = Instantiate(TilePrefab); newTile.transform.position = new Vector2(currentPosition.x, currentPosition.y); newTile.transform.SetParent(transform); newTile.PositionIndex = new Index(x, y); newTile.name = String.Format("GridTile_{0}_{1}", x, y); ThisGrid[x, y] = newTile; GridList.Add(newTile); currentPosition.x += spriteWidth; currentPosition.y -= spriteHeight; } currentPosition.x = (y + 1) * spriteWidth; currentPosition.y = (y + 1) * spriteHeight; } }
public void AddTileToPatch(GridTile newTile) { _allTiles.Add(newTile); GridTile_StaticAnomaly anomaly = newTile.GetComponent <GridTile_StaticAnomaly>(); anomaly.anomalyTileDestroyed += OnTileDestroyed; }
public void BuildConnectionFrom(GridTile from) { if (points.Count > 0) { return; //already built, building or collapsing a connection. } if (a == null || b == null) { return; } if (a != from && b != from) { return; } if (a.state == TileState.NULL || b.state == TileState.NULL) { return; } GridTile target = a == from ? b: a; Bullet bullet = Bullet.FireBulletFromTo(from.gameObject, target.gameObject); //jitter start position out by srite radius units from center of the origin sprite. bullet.transform.position += (bullet.Trajectory * from.GetComponent <SpriteRenderer>().size.x / 2); bullet.buildTrail = true; bullet.HandleNewPoint += HoldTrail; }
private void CheckForClients() { TileCoordinates currentTile = GridCoords.FromWorldToTilePosition(transform.position); GridTile tile = GridCoords.CurrentGridInfo.gameGridTiles[currentTile.tileX, currentTile.tileY]; GridTile_Planet planet = tile.GetComponent <GridTile_Planet>(); if (planet != null) { CheckForClients(planet); } }
private void OnSpawningAnomalyTileLifeOver(GridTile tile) { tile.tileLifeOver -= OnSpawningAnomalyTileLifeOver; GridTile_SpawningStaticAnomaly anomalyTile = tile.GetComponent <GridTile_SpawningStaticAnomaly>(); AnomalyPatch parentPatch = anomalyTile.ParentPatch; int tileX = tile.tileX; int tileY = tile.tileY; ReplaceTile(tile, 4); parentPatch.AddTileToPatch(_currentGridInfo.gameGridTiles[tileX, tileY]); }
private IEnumerator AnomalySpreadingTimer() { while (true) { if (!GameManager.GameStarted) { yield return(new WaitForEndOfFrame()); continue; } if (_allAnomalyPatches.Count == 0) { break; } yield return(new WaitForSeconds(anomalySpreadTime)); int randomIndex = UnityEngine.Random.Range(0, _allAnomalyPatches.Count); AnomalyPatch targetPatch = _allAnomalyPatches[randomIndex]; GridTile randomTile = targetPatch.GetRandomNewTile(); if (randomTile == null) { continue; } int tileX = randomTile.tileX; int tileY = randomTile.tileY; ReplaceTile(randomTile, 5); GridTile newTile = _currentGridInfo.gameGridTiles[tileX, tileY]; GridTile_SpawningStaticAnomaly anomalyTile = newTile.GetComponent <GridTile_SpawningStaticAnomaly>(); anomalyTile.ParentPatch = targetPatch; newTile.tileLifeOver += OnSpawningAnomalyTileLifeOver; } }
private void CreateObstacleRow() { TileStates[] RowLayout = new TileStates[TilesX]; RowObstacleData Data = new RowObstacleData(); Data.HasObstacles = true; RowObstacleData PrevData = Rows[0]; int ObstacleCount = 0; int ObstacleTarget = Random.Range(MinObstacleCountH, MaxObstacleCountH); //at least one gap has to line up with the row below this one List <int> GapIndices = new List <int>(); for (int i = 0; i < TilesX; i++) { if (PrevData.HasObstacles == false || PrevData.States[i] == TileStates.PathGap) { GapIndices.Add(i); } } int StartIndex = GapIndices[Random.Range(0, GapIndices.Count)]; int EndIndex = StartIndex; RowLayout[StartIndex] = TileStates.PathGap; //the gap should be forced to the min gap width, randomly add gap tiles left and right int GapWidth = 1; while (GapWidth < MinObstacleGapH) { int Dir = Random.Range(0, 2); if (Dir == 0) { if (StartIndex == 0) { continue; } StartIndex--; RowLayout[StartIndex] = TileStates.PathGap; GapWidth++; } else { if (EndIndex == TilesX - 1) { continue; } EndIndex++; RowLayout[EndIndex] = TileStates.PathGap; GapWidth++; } } for (int i = 0; i < TilesX; i++) { if (RowLayout[i] == TileStates.Unset) { RowLayout[i] = TileStates.Gap; } } //add obstacles at random until the obstacle count is met while (ObstacleCount < ObstacleTarget) { int a = Random.Range(0, TilesX); if (RowLayout[a] == TileStates.Gap) { RowLayout[a] = TileStates.Block; ObstacleCount++; } } for (int x = 0; x < TilesX; x++) { Data.States[x] = RowLayout[x]; if (RowLayout[x] != TileStates.Block) { continue; } GameObject GridTile; SpriteRenderer Renderer; if (RemovedFGTiles.Count > 0) { GridTile = RemovedFGTiles.Dequeue(); Renderer = GridTile.GetComponent <SpriteRenderer>(); } else { GridTile = new GameObject("FG Tile" + FGTileIndex++); Renderer = GridTile.AddComponent <SpriteRenderer>(); } Renderer.sprite = Resources.Load <Sprite>("Wall"); GridTile.transform.position = new Vector3(FirstTileX + x, TopLine, -1); //if (RowLayout[x] == TileStates.PathGap) Renderer.color = new Color(0, 1, 0, 0.5f); //else Renderer.color = new Color(1, 1, 1, 1); FGTiles.Add(GridTile); } Rows.Insert(0, Data); if (Rows.Count > 5) { Rows.RemoveAt(Rows.Count - 1); } }
void AddTileRow() { if (State == GameStates.ThumbActive || State == GameStates.ThumbLifted) { Score++; } bool EvenTile = EvenRow; EvenRow = !EvenRow; //add the background tiles for (int x = 0; x < TilesX; x++) { GameObject GridTile; SpriteRenderer Renderer; if (RemovedBGTiles.Count > 0) { GridTile = RemovedBGTiles.Dequeue(); Renderer = GridTile.GetComponent <SpriteRenderer>(); } else { GridTile = new GameObject("BG Tile" + BGTileIndex++); Renderer = GridTile.AddComponent <SpriteRenderer>(); } string TileName; if (EvenTile) { TileName = "WhiteTile"; } else { TileName = "BlackTile"; } if (Random.Range(1, 100) < 10) { TileName = "Cracked" + TileName; if (Random.Range(1, 100) < 50) { TileName += "1"; } else { TileName += "2"; } } else { TileName = "Clean" + TileName; } Renderer.sprite = Resources.Load <Sprite>("Tiles/" + TileName); GridTile.transform.position = new Vector3(FirstTileX + x, TopLine, 0); EvenTile = !EvenTile; BGTiles.Add(GridTile); } if (RowCounter > 6) { if (RowCounter % 60 == 0) { IncreaseDifficulty(); } if (CreatingObstacle) { CreateObstacleRow(); LinesToGo--; if (LinesToGo == 0) { CreatingObstacle = false; LinesToGo = Random.Range(MinObstacleGapV, MaxObstacleGapV + 1); print("" + LinesToGo); } } else { RowObstacleData Data = new RowObstacleData(); Rows.Insert(0, Data); if (Rows.Count > 5) { Rows.RemoveAt(Rows.Count - 1); } LinesToGo--; if (LinesToGo == 0) { CreatingObstacle = true; LinesToGo = Random.Range(MinObstacleSizeV, MaxObstacleSizeV + 1); } } } DemoLinesCleared++; RowCounter++; TopLine++; if (State == GameStates.ThumbActive || State == GameStates.ThumbLifted) { CurrentScrollSpeed += ScrollSpeedIncrease; if (CurrentScrollSpeed > MaxScrollSpeed) { CurrentScrollSpeed = MaxScrollSpeed; } } }
// Use this for initialization public void Init() { int x; if (Int32.TryParse(Regex.Match(gameObject.name, "\\d+").Value, out x)) { this.x = x; } else { Debug.Log("Error parsing x position from column name: " + gameObject.name); } TilePlaceholder[] gridspaces = GetComponentsInChildren <TilePlaceholder>(); if (gridHeight == -1) { gridHeight = gridspaces.Length; } else { if (gridHeight != gridspaces.Length) { throw new Exception(String.Format("BUG! Verify that each column has equivalent ACTIVE placeholders. " + "Column {0} has {1} placeholders. " + "Set the SPRITE RENDERER of the placeholders to 'inactive' instead!", gameObject.name, gridspaces.Length)); } } for (int i = 0; i < gridspaces.Length; i++) { TilePlaceholder placeholder = gridspaces[i]; GridTile tile = (Instantiate(Resources.Load("Prefabs/Tile", typeof(GameObject))) as GameObject).GetComponent <GridTile>(); tile.gameObject.name = x + "" + i; tile.gameObject.transform.position = placeholder.gameObject.transform.position; tile.y = i; tile.x = this.x; tile.directions = placeholder.GetDirections(); tile.column = this; SpriteRenderer sr = placeholder.GetComponent <SpriteRenderer>(); tile.GetComponent <SpriteRenderer>().sprite = sr.sprite; //set state at the end tile.SetState(placeholder.state); tiles.Add(tile); Destroy(sr); } //save reference to self to columns list; update the grid width allColumns.Add(this); gridWidth = allColumns.Count; }
//returns the number of tiles that were toggled. private bool ToggleAdjacent(GridTile clicked, Direction direction) { GridTile adjacent = clicked.GetAdjacentTile(direction); if (adjacent == null) { return(false); } if (adjacent.state == TileState.NULL) { return(false); } //depending on current direction, if tile doesn't contain opposite direction, then break //since it doesn't connect switch (direction) { case Direction.EAST: if (!adjacent.directions.Contains(Direction.WEST)) { return(false); } break; case Direction.NORTH: if (!adjacent.directions.Contains(Direction.SOUTH)) { return(false); } break; case Direction.WEST: if (!adjacent.directions.Contains(Direction.EAST)) { return(false); } break; case Direction.SOUTH: if (!adjacent.directions.Contains(Direction.NORTH)) { return(false); } break; } //when any tile turns off, we need to collapse ALL the connections between it and any other tile. adjacent.Toggle(); //fire bullet between clicked and adjacent. //state of clicked tile won't update until after loop finishes (since toggling state of clicked conditonal //on toggling state of at least one other grid tile) so we just preview the next state here. //(i.e., we know that clicked will toggle state, since if we're here then clicked toggled something) TileState clickedTileNextState = clicked.state == TileState.OFF ? TileState.ON : TileState.OFF; Bullet fired = null; if (adjacent.state == TileState.ON) { fired = Bullet.FireBulletFromTo(clicked.gameObject, adjacent.gameObject); } if (adjacent.state == TileState.OFF && clickedTileNextState == TileState.ON) { fired = Bullet.FireBulletFromTo(adjacent.gameObject, clicked.gameObject); } if (fired != null) { fired.transform.position += (fired.Trajectory * clicked.GetComponent <SpriteRenderer>().size.x / 2); } return(true); }