GameState<MoveType?, PlayerType?> game);
  double getValue(GameState<MoveType?, PlayerType?> game);

      GameState<MoveType, PlayerType?> game);
  double getValue(GameState<MoveType, PlayerType?> game);

  double? valueThreshold;
  int? useValueAfterDepth;

    this.valueThreshold,
    this.useValueAfterDepth,

  backProp() {
    var winner = gameState!.winner;

  backProp(PlayerType? winner) {

    int? useValueAfterDepth,
    double? valueThreshold,

    Config config = Config(
        c: c,
        backpropObserver: backpropObserver,
        nnpv: nnpv,
        useValueAfterDepth: useValueAfterDepth,
        valueThreshold: valueThreshold);

        config: Config(c: c, backpropObserver: backpropObserver, nnpv: nnpv),

        config: config,

    rootNode.config = config;

    var currentDepth = 0;

      PlayerType? winner;

        if (currentNode.gameState?.winner != null) {
          winner = currentNode.gameState?.winner;
          break;
        }
        winner = getShortcutWinner(currentDepth, config, currentNode);
        if (config.useValueAfterDepth != null &&
            currentDepth >= config.useValueAfterDepth!) {
          break;
        }
        currentDepth += 1;

      currentNode.backProp();

      currentNode.backProp(winner);

  }
  PlayerType? getShortcutWinner(int currentDepth, Config config,
      Node<MoveType, PlayerType?> currentNode) {
    if (config.nnpv != null &&
        config.useValueAfterDepth != null &&
        config.valueThreshold != null) {
      if (currentDepth > config.useValueAfterDepth!) {
        double currentValue = config.nnpv!.getValue(
            currentNode.gameState as GameState<MoveType, PlayerType?>);
        if (currentValue >= config.valueThreshold!) {
          return currentNode.gameState!.currentPlayer;
        }
      }
    }
    return null;