void step()

in csrc/liars_dice/subgame_solving.cc [421:463]

• 40 lines of code
• 10 McCabe index (conditional complexity)

  void step(int traverser) override {
    const TreeStrategy& br_strategy =
        br_solver.compute_br(traverser, average_strategies, initial_beliefs,
                             &root_values[traverser]);

    // How many updates done for the valeus and strategy of the traverser
    // assuming alternating pattern.
    const int num_update = num_strategies / 2 + 1;
    {
      const double alpha =
          params.linear_update ? 2. / (num_update + 1) : 1. / (num_update);
      root_values_means[traverser].resize(root_values[traverser].size());
      for (size_t i = 0; i < root_values[traverser].size(); ++i) {
        root_values_means[traverser][i] +=
            (root_values[traverser][i] - root_values_means[traverser][i]) *
            alpha;
      }
    }
    update_sum_strat(/*public_node=*/0, traverser, br_strategy,
                     initial_beliefs[traverser]);
    for (size_t node = 0; node < tree.size(); ++node) {
      if (!tree[node].num_children() ||
          tree[node].state.player_id != traverser) {
        continue;
      }
      for (int i = 0; i < game.num_hands(); i++) {
        if (params.linear_update) {
          for (auto& v : sum_strategies[node][i]) {
            v *= static_cast<double>(num_update + 1) / (num_update + 2);
          }
        }
        if (params.optimistic) {
          normalize_probabilities(sum_strategies[node][i],
                                  last_strategies[node][i],
                                  &average_strategies[node][i]);
        } else {
          normalize_probabilities(sum_strategies[node][i],
                                  &average_strategies[node][i]);
        }
      }
    }
    ++num_strategies;
  }