/*
 * dice.hpp
 *
 *  Created on: Oct 3, 2010
  *  Modified November 7, 2016
 *      Author: Michael J. Fischer
 *      for use in Yale course CPSC 427a, Fall 2010
 */

#include "dice.hpp"

//-----------------------------------------------------------------------------
Dice::Dice(int numDice, int numSides) :
		numDice(numDice), numSides(numSides),
		die(new int[numDice]) {
	for (int k = 0; k < numDice; k++) die[k] = 1; // smallest legal face
	sum = numDice;  // smallest possible sum
}

Dice::~Dice() {
	delete[] die;
	say("deleting die");
}

ostream& Dice::print(ostream& out) const {
	out << ", numDice=" << numDice << ", numSides=" << numSides << ", spots:";
	for (int k = 0; k < numDice; k++) {
		out << " " << die[k];
	}
	return out << ",  sum=" << sum;
}

//==============================================================================
//-----------------------------------------------------------------------------
RandDice::RandDice(int numDice, int numSides, unsigned seed) :
	Dice(numDice, numSides), seed(seed), rnd(numSides, seed) {
	rnd.print(cout);
}

ostream& RandDice::print(ostream& out) const {
	out << "RandDice: seed=" << seed;
	return Dice::print(out);
}

ostream& RandDice::printSummary(ostream& out) const {
	out << "random dice with seed " << seed;
	return out;
}

// Implementation of abstract roll() function from base class
void RandDice::roll() {
	sum = 0;
	for (int k = 0; k < numDice; k++) {
		die[k] = rnd.gen() + 1;
		sum += die[k];
	}
}


//==============================================================================
//-----------------------------------------------------------------------------
FileDice::FileDice(int numDice, int numSides, const char* fileName) :
	Dice(numDice, numSides), fileName(fileName), in(fileName) {
	if (!in)
		throw Fatal("Can't open dice file %s", fileName);
}

FileDice::~FileDice() {
	say("closing %s", fileName);
	in.close();
}

ostream& FileDice::print(ostream& out) const {
	out << "[FileDice: fileName=" << fileName;
	Dice::print(out);
	out << " End FileDice]";
	return out;
}

ostream& FileDice::printSummary(ostream& out) const {
	return out << "simulated dice from file " << fileName;
}

// Implementation of abstract roll() function from base class
void FileDice::roll() {
	sum = 0;
	int k;
	for (k = 0; k < numDice; k++) {
		in >> die[k];
		sum += die[k];
		if (!in.good())
			break;
	}
	if (k < numDice || in.fail() || in.bad())
		throw Fatal("No more dice rolls possible");
}