759 lines
20 KiB
Dart
759 lines
20 KiB
Dart
import 'dart:math';
|
|
import 'package:flame/components.dart';
|
|
import 'package:flame/effects.dart';
|
|
import 'package:flame/game.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:match_magic/db/main_db.dart';
|
|
import 'package:match_magic/game/game_mode_manager.dart';
|
|
import 'package:match_magic/game/sprite_loader.dart';
|
|
import 'package:match_magic/screens/game_over_screen.dart';
|
|
import 'package:match_magic/utilities/audio_manager.dart';
|
|
import 'package:match_magic/widgets/overlays/game_overlay/hint_button.dart';
|
|
import 'package:match_magic/widgets/overlays/game_overlay/pause_button.dart';
|
|
import 'package:match_magic/widgets/overlays/game_overlay/restart_button.dart';
|
|
import 'tile.dart';
|
|
|
|
class Board extends FlameGame {
|
|
BuildContext context;
|
|
final bool gameMode;
|
|
late GameModeManager gameModeManager;
|
|
|
|
static const int rows = 8;
|
|
static const int cols = 8;
|
|
late double tileSize;
|
|
Tile? selectedTile;
|
|
List<List<Tile?>> tiles = [];
|
|
int? selectedRow;
|
|
int? selectedCol;
|
|
bool animating = false;
|
|
bool isGridInitialized = false;
|
|
Tile? lastMovedTile;
|
|
Tile? lastMovedByGravity;
|
|
|
|
static int score = 0;
|
|
late TextComponent _playerScore;
|
|
late TextComponent _playerMoves;
|
|
late TextComponent _remainingTime;
|
|
bool isFirstLaunch = true;
|
|
|
|
bool isGameOver = false;
|
|
static bool isSoundPlaying = true;
|
|
|
|
Board(
|
|
this.context, {
|
|
required this.gameMode,
|
|
}) {
|
|
gameModeManager = GameModeManager(
|
|
currentMode: gameMode,
|
|
onGameOver: _onGameOver,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<void> onLoad() async {
|
|
super.onLoad();
|
|
await loadImages();
|
|
gameModeManager.initializeMode();
|
|
|
|
newGame();
|
|
}
|
|
|
|
void newGame() {
|
|
isFirstLaunch = true;
|
|
resetGame();
|
|
gameModeManager.initializeMode();
|
|
tiles.clear();
|
|
selectedRow = null;
|
|
selectedCol = null;
|
|
animating = false;
|
|
tileSize = size.x / cols;
|
|
_initializeGrid(isFirstLaunch);
|
|
_removeInitialMatches();
|
|
|
|
isFirstLaunch = false;
|
|
_playerScore = TextComponent(
|
|
text: 'Score: ',
|
|
position: Vector2(60, 70),
|
|
anchor: Anchor.centerLeft,
|
|
);
|
|
add(_playerScore);
|
|
if (gameModeManager.currentMode) {
|
|
_playerMoves = TextComponent(
|
|
text: 'Moves: ',
|
|
position: Vector2(200, 70),
|
|
anchor: Anchor.centerLeft,
|
|
);
|
|
add(_playerMoves);
|
|
} else {
|
|
_remainingTime = TextComponent(
|
|
text: 'Time: ',
|
|
position: Vector2(200, 70),
|
|
anchor: Anchor.centerLeft,
|
|
);
|
|
add(_remainingTime);
|
|
}
|
|
}
|
|
|
|
void resetGame() {
|
|
isGameOver = false;
|
|
this.overlays.remove(GameOverMenu.id);
|
|
|
|
score = 0;
|
|
gameModeManager.resetMode();
|
|
selectedTile = null;
|
|
final List<Component> tilesToRemove = [];
|
|
for (final component in children) {
|
|
if (component is Tile) {
|
|
tilesToRemove.add(component);
|
|
}
|
|
}
|
|
for (final tile in tilesToRemove) {
|
|
remove(tile);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void render(Canvas canvas) {
|
|
super.render(canvas);
|
|
|
|
// Progress bar renderer in level mode
|
|
if (gameModeManager.currentMode == GameMode.levelProgression) {
|
|
final progressBarWidth = size.x * (score / gameModeManager.targetScore);
|
|
final progressBarHeight = 20.0;
|
|
final rect = Rect.fromLTWH(10, size.y - progressBarHeight - 10,
|
|
progressBarWidth, progressBarHeight);
|
|
final paint = Paint()..color = Colors.green;
|
|
canvas.drawRect(rect, paint);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void update(double dt) {
|
|
_playerScore.text = 'Score: $score';
|
|
if (gameModeManager.currentMode) {
|
|
_playerMoves.text = 'Moves: ${GameModeManager.movesLeft}';
|
|
} else {
|
|
_remainingTime.text = 'Time: ${gameModeManager.remainingTime}';
|
|
}
|
|
if (!isGameOver && gameModeManager.isGameOverCondition()) {
|
|
_onGameOver();
|
|
}
|
|
|
|
super.update(dt);
|
|
}
|
|
|
|
void _initializeGrid(bool animate) {
|
|
int totalTiles = rows * cols;
|
|
int completedTiles = 0;
|
|
for (int row = 0; row < rows; row++) {
|
|
List<Tile?> rowTiles = [];
|
|
for (int col = 0; col < cols; col++) {
|
|
int spriteIndex = _randomElement();
|
|
|
|
var initialPosition = animate
|
|
? Vector2(col * tileSize, -tileSize * rows)
|
|
: Vector2(col * tileSize, row * tileSize);
|
|
|
|
var tile = Tile(
|
|
sprite: Tile.crystals[spriteIndex],
|
|
spriteIndex: spriteIndex,
|
|
size: Vector2.all(tileSize),
|
|
position: initialPosition,
|
|
row: row,
|
|
col: col,
|
|
onSwipe: handleTileSwipe,
|
|
);
|
|
rowTiles.add(tile);
|
|
add(tile);
|
|
|
|
if (animate) {
|
|
double delay = 0.04 * ((rows - 1 - row) * cols + col);
|
|
|
|
tile.add(
|
|
MoveEffect.to(
|
|
Vector2(col * tileSize, row * tileSize + 200),
|
|
EffectController(
|
|
duration: 0.5,
|
|
startDelay: delay,
|
|
curve: Curves.bounceOut,
|
|
),
|
|
onComplete: () {
|
|
completedTiles++;
|
|
if (completedTiles == totalTiles) {
|
|
isGridInitialized = true;
|
|
}
|
|
},
|
|
),
|
|
);
|
|
}
|
|
}
|
|
tiles.add(rowTiles);
|
|
}
|
|
if (!animate) {
|
|
isGridInitialized = true;
|
|
}
|
|
}
|
|
|
|
int _randomElement() {
|
|
return Random().nextInt(Tile.crystals.length);
|
|
}
|
|
|
|
void _removeInitialMatches() {
|
|
bool hasMatches;
|
|
do {
|
|
hasMatches = false;
|
|
for (int row = 0; row < rows; row++) {
|
|
for (int col = 0; col < cols; col++) {
|
|
if (_hasMatch(row, col)) {
|
|
int spriteIndex = _randomElement();
|
|
tiles[row][col]!.sprite = Tile.crystals[spriteIndex];
|
|
tiles[row][col]!.spriteIndex = spriteIndex;
|
|
hasMatches = true;
|
|
}
|
|
}
|
|
}
|
|
} while (hasMatches);
|
|
}
|
|
|
|
int _calculateScore(int matchLength) {
|
|
if (matchLength == 3) {
|
|
return 50;
|
|
} else if (matchLength == 4) {
|
|
return 400;
|
|
} else if (matchLength == 5) {
|
|
return 200;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Moving elements
|
|
|
|
void selectTile(Tile tile) {
|
|
if (selectedTile == null) {
|
|
selectedTile = tile;
|
|
tile.select();
|
|
} else {
|
|
if (_isNeighbor(selectedTile!, tile) || selectedTile!.isMagicCube) {
|
|
} else {
|
|
selectedTile?.deselect();
|
|
selectedTile = tile;
|
|
tile.select();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool _isNeighbor(Tile tile1, Tile tile2) {
|
|
return (tile1.row == tile2.row && (tile1.col - tile2.col).abs() == 1) ||
|
|
(tile1.col == tile2.col && (tile1.row - tile2.row).abs() == 1);
|
|
}
|
|
|
|
Future<void> handleTileSwipe(Tile tile, Vector2 delta) async {
|
|
if (!isGridInitialized || animating) return;
|
|
Tile? targetTile;
|
|
|
|
if (tile.isMagicCube) {
|
|
targetTile = _getTileBySwipeDirection(tile, delta);
|
|
if (targetTile != null) {
|
|
_removeAllOfType(targetTile.spriteIndex);
|
|
_animateRemoveTile(tile);
|
|
isSoundPlaying = await MainDB.instance.getSoundEnabled();
|
|
if (isSoundPlaying) {
|
|
AudioManager.playExplosionSound();
|
|
}
|
|
|
|
tiles[tile.row][tile.col] = null;
|
|
}
|
|
return;
|
|
}
|
|
|
|
targetTile = _getTileBySwipeDirection(tile, delta);
|
|
|
|
if (targetTile != null) {
|
|
animating = true;
|
|
lastMovedTile = tile;
|
|
swapTiles(tile, targetTile, true);
|
|
|
|
await Future.delayed(const Duration(milliseconds: 300));
|
|
bool matchesFound = await checkMatches();
|
|
if (!matchesFound) {
|
|
swapTiles(tile, targetTile, true);
|
|
} else {
|
|
GameModeManager.movesLeft--;
|
|
}
|
|
selectedRow = null;
|
|
selectedCol = null;
|
|
animating = false;
|
|
}
|
|
}
|
|
|
|
Tile? _getTileBySwipeDirection(Tile tile, Vector2 delta) {
|
|
int row = tile.row;
|
|
int col = tile.col;
|
|
Tile? targetTile;
|
|
|
|
if (delta.x.abs() > delta.y.abs()) {
|
|
if (delta.x > 0 && col < cols - 1) {
|
|
targetTile = tiles[row][col + 1];
|
|
} else if (delta.x < 0 && col > 0) {
|
|
targetTile = tiles[row][col - 1];
|
|
}
|
|
} else {
|
|
if (delta.y > 0 && row < rows - 1) {
|
|
targetTile = tiles[row + 1][col];
|
|
} else if (delta.y < 0 && row > 0) {
|
|
targetTile = tiles[row - 1][col];
|
|
}
|
|
}
|
|
return targetTile;
|
|
}
|
|
|
|
void swapTiles(Tile tile1, Tile tile2, bool animate) {
|
|
final tempRow1 = tile1.row;
|
|
final tempCol1 = tile1.col;
|
|
final tempRow2 = tile2.row;
|
|
final tempCol2 = tile2.col;
|
|
|
|
tile1.row = tempRow2;
|
|
tile1.col = tempCol2;
|
|
tile2.row = tempRow1;
|
|
tile2.col = tempCol1;
|
|
|
|
tiles[tile1.row][tile1.col] = tile1;
|
|
tiles[tile2.row][tile2.col] = tile2;
|
|
|
|
if (animate) {
|
|
final tempPosition1 = tile1.position.clone();
|
|
final tempPosition2 = tile2.position.clone();
|
|
tile1.animateMoveTo(tempPosition2, () {});
|
|
tile2.animateMoveTo(tempPosition1, () {});
|
|
}
|
|
tile1.deselect();
|
|
tile1.deselect();
|
|
}
|
|
|
|
// Hint button
|
|
|
|
Future<Tile?> findHint() async {
|
|
for (int row = 0; row < rows; row++) {
|
|
for (int col = 0; col < cols; col++) {
|
|
Tile? tile = tiles[row][col];
|
|
|
|
if (col < cols - 1 && await _canSwap(row, col, row, col + 1)) {
|
|
return tile;
|
|
}
|
|
if (row < rows - 1 && await _canSwap(row, col, row + 1, col)) {
|
|
return tile;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Future<bool> _canSwap(int row1, int col1, int row2, int col2) async {
|
|
Tile tempTile1 = tiles[row1][col1]!;
|
|
Tile tempTile2 = tiles[row2][col2]!;
|
|
|
|
tiles[row1][col1] = tempTile2;
|
|
tiles[row2][col2] = tempTile1;
|
|
|
|
bool matchFound = await checkMatches(simulate: true);
|
|
|
|
tiles[row1][col1] = tempTile1;
|
|
tiles[row2][col2] = tempTile2;
|
|
|
|
return matchFound;
|
|
}
|
|
|
|
void showHint() async {
|
|
Tile? hintTile = await findHint();
|
|
if (hintTile != null) {
|
|
hintTile.select();
|
|
}
|
|
}
|
|
|
|
// Match checks
|
|
|
|
Future<bool> checkMatches({bool simulate = false}) async {
|
|
if (simulate) {
|
|
for (int row = 0; row < rows; row++) {
|
|
for (int col = 0; col < cols; col++) {
|
|
if (_hasMatch(row, col)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
animating = true;
|
|
|
|
final matches = <List<int>>[];
|
|
for (int row = 0; row < rows; row++) {
|
|
for (int col = 0; col < cols; col++) {
|
|
if (_hasMatch(row, col)) {
|
|
matches.add([row, col]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (matches.isNotEmpty) {
|
|
int points = 0;
|
|
for (final match in matches) {
|
|
points += _removeMatchedElements(match[0], match[1]);
|
|
}
|
|
isSoundPlaying = await MainDB.instance.getSoundEnabled();
|
|
if (isSoundPlaying) {
|
|
AudioManager.playSelectSound();
|
|
}
|
|
Future.delayed(const Duration(milliseconds: 300), () {
|
|
_applyGravity();
|
|
Future.delayed(const Duration(milliseconds: 300), () {
|
|
_fillEmptySpaces();
|
|
Future.delayed(const Duration(milliseconds: 300), () {
|
|
animating = false;
|
|
checkMatches();
|
|
});
|
|
});
|
|
});
|
|
score += points;
|
|
|
|
return true;
|
|
}
|
|
animating = false;
|
|
return false;
|
|
}
|
|
|
|
bool _hasMatch(int row, int col) {
|
|
final value = tiles[row][col]?.spriteIndex;
|
|
|
|
int count = 1;
|
|
for (int i = col + 1;
|
|
i < cols && tiles[row][i]?.spriteIndex == value;
|
|
i++) {
|
|
count++;
|
|
}
|
|
for (int i = col - 1; i >= 0 && tiles[row][i]?.spriteIndex == value; i--) {
|
|
count++;
|
|
}
|
|
if (count >= 3) return true;
|
|
|
|
count = 1;
|
|
for (int i = row + 1;
|
|
i < rows && tiles[i][col]?.spriteIndex == value;
|
|
i++) {
|
|
count++;
|
|
}
|
|
for (int i = row - 1; i >= 0 && tiles[i][col]?.spriteIndex == value; i--) {
|
|
count++;
|
|
}
|
|
return count >= 3;
|
|
}
|
|
|
|
// Removing items
|
|
|
|
void _removeAllOfType(int spriteIndex) {
|
|
int removedCount = 0;
|
|
for (int row = 0; row < rows; row++) {
|
|
for (int col = 0; col < cols; col++) {
|
|
if (tiles[row][col]?.spriteIndex == spriteIndex) {
|
|
_animateRemoveTile(tiles[row][col]!);
|
|
tiles[row][col] = null;
|
|
removedCount++;
|
|
}
|
|
}
|
|
}
|
|
score += removedCount * 100;
|
|
Future.delayed(const Duration(milliseconds: 300), () {
|
|
_applyGravity();
|
|
Future.delayed(const Duration(milliseconds: 300), () {
|
|
_fillEmptySpaces();
|
|
});
|
|
});
|
|
}
|
|
|
|
int _removeMatchedElements(int row, int col) {
|
|
int score = 0;
|
|
final int? value = tiles[row][col]?.spriteIndex;
|
|
bool specialTriggered = false;
|
|
Tile? tileToTransformIntoSpecial;
|
|
|
|
int left = col;
|
|
while (left > 0 && tiles[row][left - 1]?.spriteIndex == value) {
|
|
left--;
|
|
}
|
|
int right = col;
|
|
while (right < cols - 1 && tiles[row][right + 1]?.spriteIndex == value) {
|
|
right++;
|
|
}
|
|
|
|
if (right - left + 1 >= 3) {
|
|
score += _calculateScore(right - left + 1);
|
|
|
|
if (right - left + 1 == 4) {
|
|
tileToTransformIntoSpecial = lastMovedTile ?? lastMovedByGravity;
|
|
} else if (right - left + 1 >= 5) {
|
|
tileToTransformIntoSpecial = lastMovedTile ?? lastMovedByGravity;
|
|
}
|
|
|
|
for (int i = left; i <= right; i++) {
|
|
if (tiles[row][i] != null) {
|
|
if (tiles[row][i]!.isBomb) {
|
|
specialTriggered = true;
|
|
_triggerBomb(row, i);
|
|
}
|
|
if (tiles[row][i] != tileToTransformIntoSpecial) {
|
|
_animateRemoveTile(tiles[row][i]!);
|
|
tiles[row][i] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int top = row;
|
|
while (top > 0 && tiles[top - 1][col]?.spriteIndex == value) {
|
|
top--;
|
|
}
|
|
int bottom = row;
|
|
while (bottom < rows - 1 && tiles[bottom + 1][col]?.spriteIndex == value) {
|
|
bottom++;
|
|
}
|
|
|
|
if (bottom - top + 1 >= 3) {
|
|
score += _calculateScore(bottom - top + 1);
|
|
|
|
if (bottom - top + 1 == 4) {
|
|
tileToTransformIntoSpecial = lastMovedTile ?? lastMovedByGravity;
|
|
} else if (bottom - top + 1 >= 5) {
|
|
tileToTransformIntoSpecial = lastMovedTile ?? lastMovedByGravity;
|
|
}
|
|
|
|
for (int i = top; i <= bottom; i++) {
|
|
if (tiles[i][col] != null) {
|
|
if (tiles[i][col]!.isBomb) {
|
|
specialTriggered = true;
|
|
_triggerBomb(i, col);
|
|
}
|
|
if (tiles[i][col] != tileToTransformIntoSpecial) {
|
|
_animateRemoveTile(tiles[i][col]!);
|
|
tiles[i][col] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tileToTransformIntoSpecial != null) {
|
|
if ((right - left + 1 >= 5) || (bottom - top + 1 >= 5)) {
|
|
_createMagicCube(
|
|
tileToTransformIntoSpecial.row, tileToTransformIntoSpecial.col);
|
|
} else {
|
|
_createBomb(
|
|
tileToTransformIntoSpecial.row, tileToTransformIntoSpecial.col);
|
|
}
|
|
}
|
|
|
|
if (specialTriggered) {
|
|
_triggerBomb(row, col);
|
|
}
|
|
|
|
return score;
|
|
}
|
|
|
|
void _animateRemoveTile(Tile tile) {
|
|
tile.add(ScaleEffect.to(
|
|
Vector2.zero(),
|
|
EffectController(
|
|
duration: 0.2,
|
|
curve: Curves.easeInBack,
|
|
),
|
|
onComplete: () => tile.removeFromParent(),
|
|
));
|
|
}
|
|
|
|
// The emergence of new elements
|
|
|
|
void _applyGravity() {
|
|
for (int col = 0; col < cols; col++) {
|
|
for (int row = rows - 1; row >= 0; row--) {
|
|
if (tiles[row][col] == null) {
|
|
for (int k = row - 1; k >= 0; k--) {
|
|
if (tiles[k][col] != null) {
|
|
tiles[row][col] = tiles[k][col]!;
|
|
tiles[k][col] = null;
|
|
tiles[row][col]!.row = row;
|
|
tiles[row][col]!.animateMoveTo(
|
|
Vector2(col * tileSize, row * tileSize + 200), () {});
|
|
lastMovedByGravity = tiles[row][col];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void _fillEmptySpaces() {
|
|
for (int col = 0; col < cols; col++) {
|
|
for (int row = rows - 1; row >= 0; row--) {
|
|
if (tiles[row][col] == null) {
|
|
int spriteIndex = _randomElement();
|
|
var tile = Tile(
|
|
sprite: Tile.crystals[spriteIndex],
|
|
spriteIndex: spriteIndex,
|
|
size: Vector2.all(tileSize),
|
|
position: Vector2(col * tileSize, -tileSize),
|
|
row: row,
|
|
col: col,
|
|
onSwipe: handleTileSwipe,
|
|
);
|
|
tiles[row][col] = tile;
|
|
add(tile);
|
|
tile.animateMoveTo(
|
|
Vector2(col * tileSize, row * tileSize + 200), () {});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bomb
|
|
|
|
void _triggerBomb(int row, int col) async {
|
|
final tile = tiles[row][col];
|
|
if (tile == null || !tile.isBomb) return;
|
|
|
|
final bombPosition = tile.position.clone();
|
|
|
|
for (int i = max(0, row - 1); i <= min(rows - 1, row + 1); i++) {
|
|
for (int j = max(0, col - 1); j <= min(cols - 1, col + 1); j++) {
|
|
if (tiles[i][j] != null) {
|
|
if (tiles[i][j]!.isBomb && !(i == row && j == col)) {
|
|
tiles[i][j]!.isBomb = false;
|
|
_triggerBomb(i, j);
|
|
} else {
|
|
_animateRemoveTile(tiles[i][j]!);
|
|
tiles[i][j] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_animateBombExplosion(bombPosition);
|
|
|
|
_animateRemoveTile(tile);
|
|
tiles[row][col] = null;
|
|
isSoundPlaying = await MainDB.instance.getSoundEnabled();
|
|
if (isSoundPlaying) {
|
|
AudioManager.playExplosionSound();
|
|
}
|
|
}
|
|
|
|
void _animateBombExplosion(Vector2 position) {
|
|
final explosion = CircleComponent(
|
|
radius: tileSize / 2,
|
|
paint: Paint()..color = Colors.orange.withOpacity(0.7),
|
|
position: position - Vector2.all(tileSize / 2),
|
|
);
|
|
|
|
add(explosion);
|
|
|
|
explosion.add(
|
|
ScaleEffect.to(
|
|
Vector2.all(3),
|
|
EffectController(duration: 0.5),
|
|
onComplete: () => explosion.removeFromParent(),
|
|
),
|
|
);
|
|
}
|
|
|
|
void _createBomb(int row, int col) async {
|
|
isSoundPlaying = await MainDB.instance.getSoundEnabled();
|
|
if (isSoundPlaying) {
|
|
AudioManager.playFourElementsSound();
|
|
}
|
|
final tile = tiles[row][col];
|
|
if (tile != null) {
|
|
tile.isBomb = true;
|
|
|
|
tile.add(
|
|
OpacityEffect.to(
|
|
0.5,
|
|
EffectController(
|
|
duration: 0.5,
|
|
infinite: true,
|
|
reverseDuration: 0.5,
|
|
),
|
|
),
|
|
);
|
|
|
|
tile.add(
|
|
ColorEffect(
|
|
Colors.orange,
|
|
EffectController(
|
|
duration: 0.5,
|
|
infinite: true,
|
|
reverseDuration: 0.5,
|
|
),
|
|
opacityFrom: 0.5,
|
|
opacityTo: 1.0,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
void explodeBomb(Tile bombTile) {
|
|
final bombPosition = bombTile.position.clone();
|
|
final bombRow = bombTile.row;
|
|
final bombCol = bombTile.col;
|
|
|
|
for (int i = max(0, bombRow - 1); i <= min(rows - 1, bombRow + 1); i++) {
|
|
for (int j = max(0, bombCol - 1); j <= min(cols - 1, bombCol + 1); j++) {
|
|
if (tiles[i][j] != null) {
|
|
if (tiles[i][j]!.isBomb && (i != bombRow || j != bombCol)) {
|
|
_triggerBomb(i, j);
|
|
} else {
|
|
_animateRemoveTile(tiles[i][j]!);
|
|
tiles[i][j] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_animateBombExplosion(bombPosition);
|
|
tiles[bombRow][bombCol] = null;
|
|
}
|
|
|
|
// Magic cube
|
|
|
|
void _createMagicCube(int row, int col) async {
|
|
isSoundPlaying = await MainDB.instance.getSoundEnabled();
|
|
if (isSoundPlaying) {
|
|
AudioManager.playFourElementsSound();
|
|
}
|
|
var tile = tiles[row][col];
|
|
tile?.sprite = Tile.magicCubeSprite;
|
|
tile?.isMagicCube = true;
|
|
}
|
|
|
|
// Game over
|
|
|
|
void _onGameOver() {
|
|
print("Game Over! Score: ${score}");
|
|
showGameOverScreen();
|
|
}
|
|
|
|
void showGameOverScreen() {
|
|
isGameOver = true;
|
|
remove(_playerScore);
|
|
if (gameModeManager.currentMode) {
|
|
remove(_playerMoves);
|
|
} else {
|
|
remove(_remainingTime);
|
|
}
|
|
|
|
this.overlays.remove(PauseButton.id);
|
|
this.overlays.remove(RestartButton.id);
|
|
this.overlays.remove(HintButton.id);
|
|
MainDB.instance.addHighScore(score, () {
|
|
this.overlays.add(GameOverMenu.id);
|
|
});
|
|
}
|
|
}
|