Esempio n. 1
0
// How quickly can you find the hidden string?
void playGame()
{
	string toHide;
	string difficulty;
	int guessRow, guessCol;
	int start, finish;
	char guessDirection;

	cout << "Provide a string to hide in the puzzle, all lower case: ";
	cin >> toHide;
	cout << "\nChoose your difficulty level: \"easy\", \"medium\" or \"hard\": ";
	cin >> difficulty;

	JumblePuzzle* jp;
	try
	{
		jp = new JumblePuzzle(toHide, difficulty);
	}
	catch (BadJumbleException& e)
	{
		cerr << e.what();
		return;
	}

	showJumble(jp->getJumble(), jp->getSize());

	start = static_cast<int>(time(NULL));
	cout << "Enter row location: ";
	cin >> guessRow;
	cout << "Enter column location: ";
	cin >> guessCol;
	cout << "Enter direction (\"n\", \"e\", \"s\" or \"w\"): ";
	cin >> guessDirection;
	finish = static_cast<int>(time(NULL));
	if (guessRow == jp->getRowPos() && guessCol == jp->getColPos() &&
			guessDirection == jp->getDirection())
		cout << "You found it!" << endl;
	else
	{
		cout << "Wrong location..." << endl;
		cout << "The location is row: " << jp->getRowPos() << " col: " << jp->getColPos()
																		<< ", direction: " << jp->getDirection() << endl;
	}
	cout << "You took " << (finish - start) << " seconds." << endl;
	delete jp;
	jp = NULL;

} // end playGame
Esempio n. 2
0
// Copy constructor
JumblePuzzle::JumblePuzzle(const JumblePuzzle& right)
{
	strLen = right.getSize();
	row = right.getRowPos();
	col = right.getColPos();
	direction = right.getDirection();

	puzzle = new char*[strLen];

	// individual arrays
	for (int i = 0; i < strLen; i++)
		puzzle[i] = new char[strLen];

	charArrayPtr* rightJumble = right.getJumble();

	for (int i = 0; i < strLen; i++)
	{
		for (int j = 0; j < strLen; j++)
			puzzle[i][j] = rightJumble[i][j];
	}
}
Esempio n. 3
0
//copy constructor
JumblePuzzle::JumblePuzzle(const JumblePuzzle& jumble)
{
	rowPos = jumble.getRowPos();
	colPos = jumble.getColPos();
	size = jumble.getSize();
	direction = jumble.getDirection();

	if (jumble.getJumble())
	{
		jumbleArray = new char*[size];
			for (int i = 0; i < size; i++)
				jumbleArray[i] = new char[size];
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					jumbleArray[i][j] = jumble.getJumble()[i][j];
				}
			}
	}
}
Esempio n. 4
0
// Copy Constructor
JumblePuzzle::JumblePuzzle(const JumblePuzzle& right)
{
	size = right.getSize();
	row = right.getRowPos();
	col = right.getColPos();
	direction = right.getDirection();

	jumble = new char*[size];

	// Create individual arrays on the heap
	for (int i = 0; i < size; i++)
		jumble[i] = new char[size];

	charArrayPtr* rightJumble = right.getJumble();

	for (int i = 0; i < size; i++)
	{
		for (int j = 0; j < size; j++)
			jumble[i][j] = rightJumble[i][j];
	}
}
Esempio n. 5
0
// Add unit tests to this function.  A few unit tests are provided to test your copy constructor,
// your assignment overloading and aliasing.  You need to write some more tests before these ones.
// Test the public members only ("Black Box Testing").  Test to make sure that exceptions are
// thrown when they should be, that the puzzle is the correct size and is formed properly, and
// that the accessors return what they should.  You can add these unit tests as you develop your
// code ("TDD") and comment out the supplied tests until you are ready for them.
void testJumble() {
	JumblePuzzle* jp;
	string hiddenWord = "HIDDEN";

	// Testing Accessors
	cout << "Testing Accessors: " << endl;
	jp = new JumblePuzzle(hiddenWord, "hard");

	char dir = jp->getDirection();
	if (dir != 'n' &&  dir != 'e' && dir != 's' && dir != 'w')
		cerr << "Direction Accessor returned invalid value." << endl;

	int size = jp->getSize();
	int correctSize = hiddenWord.size() * 4;
	if (correctSize != size)
		cerr << "Size Accessor returned invalid value." << endl;

	int row = jp->getRowPos();
	int col = jp->getColPos();

	if (row < 0 || row >= size)
		cerr << "Row Accessor returned invalid value." << endl;

	if (col < 0 || col >= size )
		cerr << "Column Accessor returned invalud value." << endl;

	cout << "Jumble Accessors working correctly." << endl;

	// Test puzzle is correct size
	cout << "\nTesting for correct puzzle size: " << endl;
	hiddenWord = "pie";
	correctSize = hiddenWord.size() * 2;
	jp = new JumblePuzzle(hiddenWord, "easy");

	if (jp->getSize() == correctSize)
		cout << "Correct puzzle size for easy difficulty." << endl;
	else
		cerr << "Invalid puzzle size for easy difficulty." << endl;

	correctSize = hiddenWord.size() * 3;
	jp = new JumblePuzzle(hiddenWord, "medium");

	if (jp->getSize() == correctSize)
		cout << "Correct puzzle size for medium difficulty." << endl;
	else
		cerr << "Invalid puzzle size for medium difficulty." << endl;

	correctSize = hiddenWord.size() * 4;
	jp = new JumblePuzzle(hiddenWord, "hard");

	if (jp->getSize() == correctSize)
		cout << "Correct puzzle size for hard difficulty." << endl;
	else
		cerr << "Invalid puzzle size for hard difficulty." << endl;

	// Puzzle Formed properly
	cout << "\nTesting for properly formed puzzle: " << endl;
	hiddenWord = "HIDDEN";
	jp = new JumblePuzzle(hiddenWord, "medium");
	row = jp->getRowPos();
	col = jp->getColPos();
	dir = jp->getDirection();
	charArrayPtr* jumble = jp->getJumble();

	if (jumble[row][col] != hiddenWord.at(0))
		cerr << "Invalid formation of puzzle. At row: " << row << ", col: " << col << ", direction: " << dir << endl;

	for (int i = 1; i < hiddenWord.size(); i++)
	{
		if (dir == 'n')
			row--;
		else if (dir == 'e')
			col++;
		else if (dir == 's')
			row++;
		else // dir == 'w'
			col--;

		if (jumble[row][col] != hiddenWord.at(i))
			cerr << "Invalid formation of puzzle. At row: " << row << ", col: " << col << ", direction: " << dir << endl;
	}

	cout << "Puzzle formed correctly." << endl;

	// Testing exceptions
	cout << "\nTesting Exceptions: " << endl;

	// Invalid word length
	try
	{
		jp = new JumblePuzzle("to", "easy");
	}
	catch (BadJumbleException& e)
	{
		cerr << e.what() << endl;
	}

	try
	{
		jp = new JumblePuzzle("aaaaaaaaaaa", "easy");
	}
	catch (BadJumbleException& e)
	{
		cerr << e.what() << endl;
	}

	// Invalid Difficulty
	try
	{
		jp = new JumblePuzzle("word", "Easy"); // Must be lower-case
	}
	catch (BadJumbleException& e)
	{
		cerr << e.what() << endl;
	}
	try
	{
		jp = new JumblePuzzle("word", "beginner"); // Must be easy, medium, or hard
	}
	catch (BadJumbleException& e)
	{
		cerr << e.what() << endl;
	}

	/*
	// Test copy constructor for proper operation
	cout << "Testing copy constructor:" << endl;
	// While debugging, you can use capital letters to make the hidden string easier to locate
	JumblePuzzle jp1("HELLO", "easy");
	showJumble(jp1.getJumble(), jp1.getSize());
	JumblePuzzle jp2(jp1);
	cout << "Should look the same:" << endl;
	showJumble(jp2.getJumble(), jp2.getSize());

	// Test aliasing from copy constructor
	charArrayPtr* puzzle = jp2.getJumble();
	int sz = jp2.getSize();
	for (int i = 0; i < sz; i++)
		puzzle[i][i] = '.';
	cout << "Dotted diagonal:" << endl;
	showJumble(puzzle, sz);
	cout << "Should be same as original 1:" << endl;
	showJumble(jp1.getJumble(), sz);
	cout << "Should be same as original 2:" << endl;
	showJumble(jp2.getJumble(), sz);

	// Test assignment operator for proper operation
	cout << "Testing assignment operator:" << endl;
	JumblePuzzle jp3("BYE", "easy");
	showJumble(jp3.getJumble(), jp3.getSize());
	JumblePuzzle jp4 = jp3;
	cout << "Should look the same:" << endl;
	showJumble(jp4.getJumble(), jp4.getSize());

	// Test aliasing from assignment operator
	puzzle = jp4.getJumble();
	sz = jp4.getSize();
	for (int i = 0; i < sz; i++)
		puzzle[i][i] = '*';
	cout << "Star diagonal:" << endl;
	showJumble(puzzle, sz);
	cout << "Should be same as original 3:" << endl;
	showJumble(jp3.getJumble(), sz);
	cout << "Should be same as original 4:" << endl;
	showJumble(jp4.getJumble(), sz);


	// Test self-assignment
	jp4 = jp4;
	cout << "Should be same as original 4:" << endl;
	showJumble(jp4.getJumble(), sz);
	*/
} // end testJumble