game_utils.dart

import '../provider/data.dart';
import '../utils/board_animate.dart';
import '../utils/board_utils.dart';

class GameUtils {
  static Future<void> quitGame(Data myProvider) async {
    myProvider.updateGameIsRunning(false);
    if (BoardUtils.checkBoardIsSolved(myProvider)) {
      myProvider.resetCurrentSavedState();
    }
  }

  static Future<void> startNewGame(Data myProvider) async {
    myProvider.updateParameterSize(myProvider.parameterSize);
    myProvider.updateGameIsRunning(true);
    myProvider.resetGivenTipsCount();
    myProvider.shuffleCellValues();
    myProvider.updateCells(BoardUtils.createEmptyBoard(
        myProvider.blockSizeHorizontal * myProvider.blockSizeVertical));
    BoardUtils.pickGrid(myProvider);
    BoardAnimate.startAnimation(myProvider, 'start');
  }

  static void deleteSavedGame(Data myProvider) {
    myProvider.resetCurrentSavedState();
  }

  static void resumeSavedGame(Data myProvider) {
    Map<String, dynamic> savedState = myProvider.getCurrentSavedState();
    if (savedState.isNotEmpty) {
      try {
        myProvider.setParameterValue('level', savedState['level']);
        myProvider.setParameterValue('size', savedState['size']);
        myProvider.setParameterValue('skin', savedState['skin']);

        myProvider.setGivenTipsCount(savedState['tipsCount']);
        myProvider.updateShowConflicts(savedState['showConflicts']);

        myProvider.setShuffleCellValues(savedState['shuffledCellValues']);

        myProvider.updateCells(
            BoardUtils.createBoardFromSavedState(myProvider, savedState['boardValues']));
        myProvider.updateGameIsRunning(true);
      } catch (e) {
        print('Failed to resume game. Will start new one instead.');
        myProvider.resetCurrentSavedState();
        myProvider.initParametersValues();
        startNewGame(myProvider);
      }
    } else {
      myProvider.resetCurrentSavedState();
      myProvider.initParametersValues();
      startNewGame(myProvider);
    }
  }

  static void showTip(Data myProvider) {
    if (myProvider.currentCellCol == null || myProvider.currentCellRow == null) {
      // no selected cell -> pick one
      GameUtils.helpSelectCell(myProvider);
    } else {
      // currently selected cell -> set value
      GameUtils.helpFillCell(myProvider);
    }
    myProvider.increaseGivenTipsCount();
  }

  static void helpSelectCell(Data myProvider) {
    List cells = myProvider.cells;
    int blockSizeHorizontal = myProvider.blockSizeHorizontal;
    int blockSizeVertical = myProvider.blockSizeVertical;

    // pick one of wrong value cells, if found
    List wrongValueCells = BoardUtils.getCellsWithWrongValue(
        cells, myProvider.cellsSolved, blockSizeHorizontal, blockSizeVertical);
    if (wrongValueCells.length != 0) {
      GameUtils.pickRandomFromList(myProvider, wrongValueCells);
      return;
    }

    // pick one of conflicting cells, if found
    List conflictingCells = BoardUtils.getCellsWithUniqueAvailableValue(
        cells, blockSizeHorizontal, blockSizeVertical);
    if (conflictingCells.length != 0) {
      GameUtils.pickRandomFromList(myProvider, conflictingCells);
      return;
    }

    //  pick one form cells with unique non-conflicting candidate value
    List candidateCells = BoardUtils.getCellsWithUniqueAvailableValue(
        cells, blockSizeHorizontal, blockSizeVertical);
    if (candidateCells.length != 0) {
      GameUtils.pickRandomFromList(myProvider, candidateCells);
      return;
    }
  }

  static void pickRandomFromList(Data myProvider, List cellsCoordinates) {
    if (cellsCoordinates.length > 0) {
      cellsCoordinates.shuffle();
      List cell = cellsCoordinates[0];
      myProvider.selectCell(cell[0], cell[1]);
    }
  }

  static void helpFillCell(Data myProvider) {
    List cells = myProvider.cells;
    int blockSizeHorizontal = myProvider.blockSizeHorizontal;
    int blockSizeVertical = myProvider.blockSizeVertical;

    int boardSize = blockSizeHorizontal * blockSizeVertical;

    // Will clean cell if no eligible value found
    int eligibleValue = 0;

    // ensure there is only one eligible value for this cell
    int allowedValuesCount = 0;
    for (var value = 1; value <= boardSize; value++) {
      if (BoardUtils.isValueAllowed(cells, blockSizeHorizontal, blockSizeVertical,
          myProvider.currentCellCol, myProvider.currentCellRow, value)) {
        allowedValuesCount++;
        eligibleValue = value;
      }
    }

    myProvider.updateCellValue(myProvider.currentCellCol, myProvider.currentCellRow,
        allowedValuesCount == 1 ? eligibleValue : 0);
    myProvider.selectCell(null, null);
    if (BoardUtils.checkBoardIsSolved(myProvider)) {
      myProvider.resetCurrentSavedState();
      BoardAnimate.startAnimation(myProvider, 'win');
    }
  }
}