cpp-dice-roller/src/roll.cxx

//
//  roll.cxx
//  dice-roll
//
//  Created by Sam Jaffe on 12/1/18.
//  Copyright © 2018 Sam Jaffe. All rights reserved.
//

#include "dice-roll/roll.h"

#include <numeric>

#include "dice-roll/random.h"

namespace dice {
die_roll::operator int() const {
  return sgn(sign) * std::accumulate(rolled.begin(), rolled.end(), 0);
}

dice_roll::operator int() const {
  auto subtotal = std::accumulate(sub_rolls.begin(), sub_rolls.end(), 0) +
                  std::accumulate(modifiers.begin(), modifiers.end(), 0);
  if (dc.comp != difficulty_class::test::None) {
    return static_cast<int>(dc(subtotal));
  } else {
    return subtotal;
  }
}

die_roll roll_impl(die const & d, engine::random & gen) {
  std::vector<int> hits;
  for (int i = 0; i < d.num; ++i) {
    hits.push_back(gen.roll(d.sides));
  }
  switch (d.keep.method) {
  case keep::Highest:
    for (int i = 0; i < d.num - d.keep.amount; ++i) {
      hits.erase(std::min_element(hits.begin(), hits.end()));
    }
    break;
  case keep::Lowest:
    for (int i = 0; i < d.num - d.keep.amount; ++i) {
      hits.erase(std::max_element(hits.begin(), hits.end()));
    }
    break;
  default:
    break;
  }
  return {d.sgn, hits};
}

dice_roll roll_impl(dice const & d, engine::random & gen) {
  std::vector<die_roll> hits;
  for (die const & di : d.of) {
    hits.push_back(roll_impl(di, gen));
  }
  return {hits, d.modifier, d.dc};
}

roller::roller() : gen() {}
roller::roller(engine::random && g) : gen(std::forward<engine::random>(g)) {}

std::vector<dice_roll> roller::operator()(dice const & d) {
  std::vector<dice_roll> out;
  for (int i = 0; i < d.num; ++i) {
    out.emplace_back(roll_impl(d, gen));
  }
  return out;
}
}