/// <summary>
/// With match element, clone mock grids to simulate the situation if the match is valid or not.
/// Search mock grids to find a match with specified rules. If there is match, add matches to the explode events, send turn numbe rof the mock grid and bomb events.
/// </summary>
/// <param name="matchElement">Threee coord values for the match.</param>
/// <param name="simulate">If match is valid, make it a valid simulation by changing original grid with the mock one.</param>
/// <returns>Explode event</returns>
public ExplodeEvent Explode(MatchElement?matchElement, bool isTurnClockwise = false, bool simulate = true)
{
// Create mock grid to simulate request
List <HexagonGrid> mockGrids = new List <HexagonGrid>();
for (int i = 0; i < 2; i++)
{
mockGrids.Add((HexagonGrid)this.grid.Clone());
}
// Turn mock grids. First one with 120 degree, secone one with 240 degree.
if (matchElement != null && matchElement?.coords != null)
{
int firstIndex = isTurnClockwise ? 0 : 2;
int lastIndex = isTurnClockwise ? 2 : 0;
for (int mockIndex = 0; mockIndex < 2; mockIndex++)
{
for (int turn = 0; turn < mockIndex + 1; turn++)
{
HexagonElement element = (HexagonElement)mockGrids[mockIndex].GetElement((int)matchElement?.coords[firstIndex].x, (int)matchElement?.coords[firstIndex].y);
mockGrids[mockIndex].grid[(int)matchElement?.coords[firstIndex].x, (int)matchElement?.coords[firstIndex].y] = mockGrids[mockIndex].grid[(int)matchElement?.coords[1].x, (int)matchElement?.coords[1].y];
mockGrids[mockIndex].grid[(int)matchElement?.coords[1].x, (int)matchElement?.coords[1].y] = mockGrids[mockIndex].grid[(int)matchElement?.coords[lastIndex].x, (int)matchElement?.coords[lastIndex].y];
mockGrids[mockIndex].grid[(int)matchElement?.coords[lastIndex].x, (int)matchElement?.coords[lastIndex].y] = element;
}
}
}
// Check explode events on the mock grids to see if the action is valid or not.
// Every rule has to be tried to be sure the match.
List <ExplodeElement> explodeElements = new List <ExplodeElement>();
int selectedMockGridNo = 0;
CheckGridWithrulesToFindMatch(mockGrids, explodeElements, ref selectedMockGridNo);
// If action is valid and not for game over check
if (explodeElements.Count > 0 && simulate)
{
this.grid = mockGrids[selectedMockGridNo];
}
ExplodeEvent explodeEvent = new ExplodeEvent(explodeElements.Count > 0, selectedMockGridNo + 1, explodeElements);
// If action is valid and not for game over check
if (simulate)
{
scoring.SetScore(explodeEvent);
}
// If action is valid and done by user then check for bomb timers and explosion.
if (matchElement != null && matchElement?.coords != null && matchElement?.coords.Count > 0 && simulate)
{
BombEvent bombEvent = scoring.BombCheck(ref this.grid);
explodeEvent.bombEvent = bombEvent;
}
return(explodeEvent);
}
/// <summary>
/// Set bomb texts of the all bombs in the scene.
/// </summary>
/// <param name="explodeEvent"></param>
private void SetBombTexts(ExplodeEvent explodeEvent)
{
if (explodeEvent.bombEvent.bombElements.Count > 0)
{
Debug.Log("There is at least one bomb in the scene and its timer is running out!");
}
foreach (BombElement element in explodeEvent.bombEvent.bombElements)
{
ActivateBombText(element.bombInfo, gridComponentHolder[element.coords]);
}
}
private void Awake()
{
gameOverEvent = new GameOverEvent();
addScoreEvent = new AddScoreEvent();
powerPickupEvent = new PowerPickupEvent();
stickToPaddleEvent = new StickToPaddleEvent();
coinPickUpEvent = new CoinPickUpEvent();
explodeEvent = new ExplodeEvent();
ballHitEvent = new BallHitEvent();
brickDamageEvent = new BrickDamageEvent();
}
/// <summary>
/// Used for non player match element input.
/// First set board untouchable. Send null match element and get explode event.
/// If there wont be any explosion then we can set board touchable and return. If there will be any explosion then set these explosions.
/// </summary>
public void SetMatchElement()
{
SetBoardUnuouchable?.Invoke();
MatchElement matchElement = new MatchElement();
ExplodeEvent explodeEvent = hexagonLogic.Explode(matchElement);
if (!explodeEvent.IsActionValid)
{
SetBoardTouchable?.Invoke();
return;
}
SetExplosion(explodeEvent);
}
/// <summary>
/// Calulates the number of exploded block and the score.
/// </summary>
/// <param name="explodeEvent"></param>
public void SetScore(ExplodeEvent explodeEvent)
{
if (!explodeEvent.IsActionValid)
{
return;
}
int explosionCount = 0;
foreach (ExplodeElement explodeElement in explodeEvent.explodeElements)
{
foreach (Vector2 block in explodeElement.positions)
{
explosionCount++;
}
}
this.score += explosionCount * this.explosionBlockScore;
}
/// <summary>
/// Explodes all the explode element in the explode event, add explodede gameobjects to object pool to reuse them.
/// Invoke increase score after all explosions and start fill event for vacancies of exploded gameobjects.
/// </summary>
/// <param name="explodeEvent"></param>
/// <returns></returns>
private IEnumerator Explode(ExplodeEvent explodeEvent)
{
yield return(new WaitForSeconds(0.3f));
foreach (ExplodeElement explodeElement in explodeEvent.explodeElements)
{
foreach (Vector2 coord in explodeElement.positions)
{
gridComponentHolder[coord].explode.SetExplode();
itemComponentsPool.Add(gridComponentHolder[coord]);
gridComponentHolder[coord] = null;
}
}
yield return(new WaitForSeconds(1f));
IncreaseScore?.Invoke(hexagonLogic.GetCurrentScore());
FillEvent fillEvent = hexagonLogic.Fill();
SetFill(fillEvent);
yield return(null);
}
/// <summary>
/// Player match element input.
/// Set boarch untouchable. create match element with selected coords and send it to the logic to see if match request is available or not.
/// With return explode event set bomb texts. If any bomb explodes then game over.
/// If action is valid turn hexagon gameobjects, explode them and deselect previous selected coords.
/// If action is not valid, calculate the destinations of all hexagon gameobject to make it rotation move.
/// </summary>
/// <param name="isTurnClockWise"></param>
public void SetMacthElement(bool isTurnClockWise)
{
if (selectedCoords == null)
{
return;
}
SetBoardUnuouchable?.Invoke();
MatchElement matchElement = new MatchElement(selectedCoords);
ExplodeEvent explodeEvent = hexagonLogic.Explode(matchElement, isTurnClockwise: isTurnClockWise);
SetBombTexts(explodeEvent);
if (explodeEvent.bombEvent.isBombeExploded)
{
Debug.Log("Bomb exploded! Game Over!");
GameOver?.Invoke();
}
if (explodeEvent.IsActionValid)
{
Debug.Log("Player action is valid. Explosion and fill events are starting.");
ChangeElementsCoordsAndPosiitons(selectedCoords, explodeEvent.turnNo, isTurnClockWise);
SetExplosion(explodeEvent);
DeselectHexagons();
}
else
{
Debug.Log("Player action is not valid. Turn selected coords and return to their coords.");
List <List <Vector2> > destinations = TurnClockwise(selectedCoords, 3, isTurnClockWise);
TurnGridComponents(destinations);
StopAllCoroutines();
StartCoroutine(Move());
}
}
/// <summary>
/// Start explosion coroutine.
/// </summary>
/// <param name="explodeEvent">Explode event</param>
private void SetExplosion(ExplodeEvent explodeEvent)
{
StopAllCoroutines();
StartCoroutine(Explode(explodeEvent));
}
