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