PA5

main.c

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Author:	Nathan Scott
//Class:	CptS 121, Fall  2015, Section 01, Lab Section 11.
//PA#:		5
//Due:		23OCT2015
//Type:		program entrance file.
//Purpose:	to performance Yahtzee game.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//You may design the Yahtzee game with functions that you see fit.I recommend that you start with a structure chart and determine sub - problems and functions accordingly.You must also take advantage of applying pointers, output parameters, and / or arrays!Your Yahtzee game must also implement the following algorithm :
//
//*(1) (5 pts) Print a game menu for Yahtzee with the following options :
		//1. Print game rules
		//2. Start a game of Yahtzee
		//3. Exit
//*(2) (5 pts) Get a menu option from the user; clear the screen
//*(3) (10 pts) If option 1 is entered, then print the game rules stated above and repeat step(1)
		//otherwise if option 2 is entered, then continue on to step(4); player 1 starts the game
		//otherwise if option 3 is entered, then print a goodbye message and quit the program
		//otherwise repeat step(1)
//*(4) (5 pts) Ask the player to hit any key to continue on to roll the five dice
//*(5) (10 pts) Roll the five dice and display the face values of each die; enumerate each die with
		//a number 1 - 5; add 1 to the total number of rolls for this round
//*(6) (10 pts) If the total number of rolls for this round is less than three,
		//then ask the player(Y / N) if he / she wants to use the roll for one of the game combinations
		//otherwise a combination must be selected
		//1. Sum of 1's        7. Three-of-a-kind
		//2. Sum of 2's        8. Four-of-a-kind
		//3. Sum of 3's        9. Full house
		//4. Sum of 4's        10. Small straight
		//5. Sum of 5's        11. Large straight
		//6. Sum of 6's        12. Yahtzee
		//13. Chance
//**(7) (10 pts) If the number of rolls is three or "yes" is entered, then save the combination and it may not be selected again in the future;
		//continue on to step(8); clear the screen
		//otherwise if "no" is entered, ask the user which dice to re - roll(1 - 5); re - roll the selected die or dice; clear the screen;
		//repeat step(6)
		//otherwise repeat step(6)
//*(8) (5 pts) Alternate players
//*(9) (10 pts) If each player has rolled for the round, then increment the round number
		//if the round number is equal to 14, then continue on to step(10)
		//otherwise repeat step(4)
		//otherwise repeat step(4)
//*(10) (5 pts) If the total score in the upper section is greater than or equal to 63 for a player, then add 35 points to the total score
//*(11) (5 pts) Print the scores for both players and print the winner
//*(12) (5 pts) Repeat step(1)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "header.h"

int main(void){
	srand((unsigned)time(0));//generate seed for rand().
	//declare variables.
	int menu = 0;
	int counter = 0;
	int dice[5] = { 0 };
	int hold[5] = { 0 };
	int repeatValue[7] = { 0 };
	int contValue[3] = { 0 };
	int score[2][14] = { 0 };//[0/1]: two players, [0-12/13]: 13 is the sum of 0-12.
	int finalScore[2][14] = { 0 };
	int input = 0;
	int playerNum = 0;
	int player[2][26] = { { 0 }, { 0 } };

	system("mode con cols=140 lines=50");//define window size.
	system("color 5f");//change window color.

	do{//do while loop start.
		system("cls");

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		//1.0. Prints out the menu.
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		printMenu();
		//END OF 1.0.//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		fflush(stdin);//clear scanf buffer.
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		//3.0. If option 1 is entered, then print the game rules stated above and repeat step (1)
		//otherwise if option 2 is entered, then continue on to step(4); player 1 starts the game
		//otherwise if option 3 is entered, then print a goodbye message and quit the program
		//otherwise repeat step(1)
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		if (scanf("%d", &menu) != 1 || menu > 2){//determine user enter is valid or not.
			system("cls");
			printf("\n***************************************\nError: please enter a valid choice!\n***************************************\n\n");
			system("pause");
		}
		else//if user input is valid then enter else clause.
		{
			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			//1.1. Prints out the rules of the game.
			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			if (menu == 1){
				printGameRules();
			}
			//END OF 1.1.//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			//1.2. Start a game of Yahtzee
			///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			if (menu == 2){
				for (int i = 0; i < 26; i++){
					playerNum = i % 2;
					system("cls");
					printf("Player: %d\n", playerNum + 1);
					printf("Round = %d\n\n", i + 1);//13 times for each player, total 26 times.
					system("pause");
					system("cls");

					printf("Player: %d\n\n", playerNum + 1);
					printf("1. Rolling dice.\n0. Exit.\n\nEnter: ");
					if (scanf("%d", &input) == 1){
						while (input != 0 && counter < 3){
							rollDice(dice, hold, playerNum);//get 5 dices' values.
							repeat(dice, repeatValue, playerNum);//get value from repeat function, then assign to repeatValue.
							cont(dice, contValue, playerNum);//get value from repeat function then, assign to contValue.
							one2six(dice, playerNum, score);
							a3ok(dice, repeatValue, playerNum, score);
							a4ok(dice, repeatValue, playerNum, score);
							fullHouse(dice, repeatValue, playerNum, score);
							smallStr8(dice, contValue, playerNum, score);
							largeStr8(dice, contValue, playerNum, score);
							yahtzee(dice, repeatValue, playerNum, score);
							chance(dice, playerNum, score);
							playerScore(playerNum, score, finalScore);
							system("cls");
							fflush(stdin);
							printf("Player: %d\n\n", playerNum + 1);
							printf("Keep rolling: \n1. Yes\n0. No\n\nEnter: ");
							scanf("%d", &input);
							counter++;
						}
					}
					else{
						system("cls");
						printf("\n***************************************\nError: please enter a valid choice!\n***************************************\n\n");
						system("pause");
						system("cls");
					}
					for (int i = 0; i < 13; i++){
						finalScore[playerNum][13] += finalScore[playerNum][i];
						printf("Player%d score[%d] is: %d\n", playerNum + 1, i, finalScore[playerNum][i]);
					}
					if (finalScore[playerNum][13] > 65){
						finalScore[playerNum][13] += 35;
					}
					system("pause");
				}
				if (finalScore[0][13] > finalScore[1][13]){
					printf("The winner is: player1!\n\n");
					system("pause");
				}
				else{
					printf("The winner is: player2!\n\n");
					system("pause");
				}
				
			}
		}
		//END OF 1.2.//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	} while (menu != 0);//end do while loop when menu == 0.
	system("cls");
	printf("\n\nGood Bye!\n\n");
	//END OF 3.0.//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	system("pause");
	return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//THE END
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

header.h

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Author:	Nathan Scott
//Class:	CptS 121, Fall  2015, Section 01, Lab Section 11.
//PA#:		5
//Due:		23OCT2015
//Type:		header file.
//Purpose:	include lib and pre-define functions.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#ifndef _HEADERNAME_H 
#define _HEADERNAME_H
#define _CRT_SECURE_NO_WARNINGS
#define SIZE 5

void printMenu(void);
void printGameRules(void);

void rollDice(int dice[],int hold[], int playerNum);
void repeat(int dice[], int repeatValue[], int playerNum);
void cont(int dice[], int repeatValue[], int playerNum);

void one2six(int dice[], int playerNum, int score[][12]);
void a3ok(int dice[], int repeatValue[], int playerNum, int score[][12]);
void a4ok(int dice[], int repeatValue[], int playerNum, int score[][12]);
void fullHouse(int dice[], int repeatValue[], int playerNum, int score[][12]);
void smallStr8(int dice[], int contValue[], int playerNum, int score[][12]);
void largeStr8(int dice[], int contValue[], int playerNum, int score[][12]);
void yahtzee(int dice[], int repeatValue[], int playerNum, int score[][12]);
void chance(int dice[], int playerNum, int score[][12]);

void playerScore(int playerNum, int score[][12], int finalScore[][12]);

#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//THE END
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func.c

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Author:	Nathan Scott
//Class:	CptS 121, Fall  2015, Section 01, Lab Section 11.
//PA#:		5
//Due:		23OCT2015
//Type:		source file.
//Purpose:	define functions and logics.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "header.h"

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Prints out the menu.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void printMenu(void){
	printf("\n\n    .  .  .  .  .      .  .  .  .  .      .  .  .  .  .      .  .  .  .  .      .  .  .  .  .\
\n   .           ..     .           ..     .           ..     .           ..     .           ..\
\n  .     6     . .    .     5     . .    .     2     . .    .     4     . .    .     3     . .\
\n .           .  .   .           .  .   .           .  .   .           .  .   .           .  .\
\n.  .  .  .  .   .  .  .  .  .  .   .  .  .  .  .  .   .  .  .  .  .  .   .  .  .  .  .  .   .\
\n.           . 1 .  .           . 3 .  .           . 5 .  .           . 3 .  .           . 4 .\
\n.     2     .  .   .     4     .  .   .     3     .  .   .     2     .  .   .     1     .  .\
\n.           . .    .           . .    .           . .    .           . .    .           . .\
\n.  .  .  .  .      .  .  .  .  .      .  .  .  .  .      .  .  .  .  .      .  .  .  .  .\n\n\
\n\nAuthor: Nathan Scott\n\
Version: 5.18\n\n\
-------------------------------------MENU-------------------------------------\n\
1. Print game rules\n\
2. Start a game of Yahtzee\n\
0. Exit\n\
------------------------------------------------------------------------------\n\n\
Enter: ");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Prints out the rules of the game.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void printGameRules(void){
	system("cls");
	printf("Function: printGameRules()\n\
		   \nThe Rules of Yahtzee\n\
		   \n\
		   The scorecard used for Yahtzee is composed of two sections.A upper section and a lower section.\n\
		   A total of thirteen boxes or thirteen scoring combinations are divided amongst the sections.\n\
		   The upper section consists of boxes that are scored by summing the value of the dice\n\
		   matching the faces of the box. If a player rolls four 3's, then the score placed in the 3's box\n\
		   is the sum of the dice which is 12. Once a player has chosen to score a box, it may not be changed\n\
		   and the combination is no longer in play for future rounds. If the sum of the scores in\n\
		   the upper section is greater than or equal to 63, then 35 more points are added to the players\n\
		   overall score as a bonus. The lower section contains a number of poker like combinations.\n\
		   \n\
		   See the table provided below :\n\
		   \n\
		   +-------------------------------------------------------------------------------------------------------+\n\
		   | NAME			| COMBINATION				| SCORE						|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | 3 of kind		| Three dice with the same face		| Sum of all face values on the 5 dice	|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | 4 of kind		| Four dice with the same face		| Sum of all face values on the 5 dice	|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | Full house		| One pair and a three-of-a-kind	| 25						|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | Small straight	| A sequence of four dice		| 30						|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | Large straight	| A sequence of five dice		| 40						|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | Yahtzee (5 of kind)	| Five dice with the same face		| 50						|\n\
		   |-------------------------------------------------------------------------------------------------------|\n\
		   | Chance		| This is the catch all combination	| Sum of all face values on the 5 dice	|\n\
		   +-------------------------------------------------------------------------------------------------------+\n\
		   \n");
	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//roll dice.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void rollDice(int dice[], int hold[], int playerNum){
	int debug = 0, counter = 0, input = 0;
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: rollDice()\n");
	//debug switch.
	printf("debug = %d\n\n", debug);

	//////////////////////////////////////////////////////////////////////////
	//debug begin.
	//////////////////////////////////////////////////////////////////////////
	//debug mode is off.
	if (debug == 0){
		printf("Hit any key to continue on to roll the five dice:\n\n");
		system("pause");
		system("cls");
		printf("Player: %d\n\n", playerNum + 1);
		while (counter < 3){
			for (int i = 0; i < SIZE; i++){
				if (hold[i] >= 1){
					printf("Hold dice%d = %d\n", hold[i] + 1, dice[i]);

				}
				else{
					dice[i] = rand() % 6 + 1;
					printf("dice%d = %d\n", i + 1, dice[i]);
				}
			}
			system("pause");
			printf("Player: %d\n\n", playerNum + 1);
			printf("Which dice would you like to hold (1-5): \n0. Done\n\nEnter: ");
			while (scanf("%d", input) == 1 && input != 0 && input < 5){
				if (input - 1 == 0){
					hold[0] = 0;
				}
				if (input - 1 == 1){
					hold[1] = 1;
				}
				if (input - 1 == 2){
					hold[2] = 2;
				}
				if (input - 1 == 3){
					hold[3] = 3;
				}
				if (input - 1 == 4){
					hold[4] = 4;
				}
			}
			counter++;
		}
		
	}

	//test a3ok and a4ok.
	if (debug == 1){
		dice[0] = 2, dice[1] = 2, dice[2] = 2, dice[3] = 2, dice[4] = 4;
		for (int i = 0; i < SIZE; i++){
			printf("dice%d = %d\n", i + 1, dice[i]);
		}
	}
	//test fullHouse.
	if (debug == 2){
		dice[0] = 4, dice[1] = 2, dice[2] = 4, dice[3] = 2, dice[4] = 4;
		for (int i = 0; i < SIZE; i++){
			printf("dice%d = %d\n", i + 1, dice[i]);
		}
	}
	//test smallStr8.
	if (debug == 3){
		dice[0] = 2, dice[1] = 1, dice[2] = 3, dice[3] = 4, dice[4] = 4;
		for (int i = 0; i < SIZE; i++){
			printf("dice%d = %d\n", i + 1, dice[i]);
		}
	}
	//test largeStr8.
	if (debug == 4){
		for (int i = 0; i < SIZE; i++){
			dice[i] = i + 2;
			printf("dice%d = %d\n", i + 1, dice[i]);
		}
	}
	//test yahtzee.
	if (debug == 5){
		for (int i = 0; i < SIZE; i++){
			dice[i] = 3;
			printf("dice%d = %d\n", i + 1, dice[i]);
		}
	}
	//////////////////////////////////////////////////////////////////////////
	//debug end.
	//////////////////////////////////////////////////////////////////////////

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//repeating test.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void repeat(int dice[], int repeatValue[], int playerNum){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: repeat()\n");

	for (int i = 0; i < SIZE; i++){
		for (int j = i + 1; j < SIZE; j++){
			if (dice[i] == dice[j]){
				printf("dice%d = %d <-> dice%d = %d <repeated>\n", i + 1, dice[i], j + 1, dice[j]);
				repeatValue[0]++;
			}
		}
	}

	for (int k = 0; k < SIZE; k++){
		for (int l = 1; l < 7; l++){
			if (dice[k] == l){
				repeatValue[l]++;
			}
		}
	}

	for (int m = 0; m < 7; m++){
		if (m == 0){
			printf("total repeat = %d\n", repeatValue[m]);
		}
		else{
			printf("dice%d = repeat %d time(s)\n", m, repeatValue[m]);
		}
	}

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//continuous test.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void cont(int dice[], int contValue[], int playerNum){
	int low = 0, high = SIZE - 1; //setup initial value.  
	int swap, i;
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: cont()\n");

	//bubble sort algorithm, I derived from http://www.cricode.com/3212.html.
	while (low < high) {
		for (i = low; i < high; ++i){ //ascending, find max. 
			if (dice[i]> dice[i + 1]) {
				swap = dice[i];
				dice[i] = dice[i + 1];
				dice[i + 1] = swap;
			}
		}
		--high;//change high's value and move forward 1.
		for (i = high; i > low; --i){ //descending, find min.
			if (dice[i] < dice[i - 1]) {
				swap = dice[i];
				dice[i] = dice[i - 1];
				dice[i - 1] = swap;
			}
		}
		++low;//change low's value and move backward 1.
	}
	//end of sort.

	contValue[1] = dice[0];//assign min value to result[0].
	contValue[2] = dice[sizeof(dice)];//assign max value to result[1].

	for (int j = 0; j < SIZE - 1; j++){
		if (dice[j] + 1 != dice[j + 1]){
			contValue[0] = 0;//result[0] = 0 (false).
		}
		else{
			contValue[0] = 1;//result[0] = 1 (true).
		}
	}

	for (int k = 0; k < SIZE; k++){
		printf("dice%d = %d\n", k + 1, dice[k]);
	}

	printf("cont = %d\nmin = %d\nmax = %d\n", contValue[0], contValue[1], contValue[2]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//calculate 1-6 dice point(s) (score[0-5]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void one2six(int dice[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: one2six()\n");

	for (int i = 0; i < 6; i++){
		if (dice[i] == 1){
			score[playerNum][0] += 1;
		}
		if (dice[i] == 2){
			score[playerNum][1] += 2;
		}
		if (dice[i] == 3){
			score[playerNum][2] += 3;
		}
		if (dice[i] == 4){
			score[playerNum][3] += 4;
		}
		if (dice[i] == 5){
			score[playerNum][4] += 5;
		}
		if (dice[i] == 6){
			score[playerNum][5] += 6;
		}
	}

	for (int i = 0; i < 6; i++){
		printf("%d's score = %d\n", i + 1, score[playerNum][i]);
	}
	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//a 3 of kind (score[6]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void a3ok(int dice[], int repeatValue[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: a3ok()\n");

	if (repeatValue[0] >= 3){
		for (int i = 0; i < SIZE; i++){
			score[playerNum][6] += dice[i];
		}
	}
	else{
		score[playerNum][6] = 0;
	}
	printf("score = %d\n", score[playerNum][6]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//a 4 of kind (score[7]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void a4ok(int dice[], int repeatValue[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: a4ok()\n");

	if (repeatValue[0] >= 6){
		for (int i = 0; i < SIZE; i++){
			score[playerNum][7] += dice[i];
		}
	}
	else{
		score[playerNum][7] = 0;
	}
	printf("score = %d\n", score[playerNum][7]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//full house (score[8]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void fullHouse(int dice[], int repeatValue[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: fullHouse()\n");

	if (repeatValue[0] >= 3 && dice[0] == dice[1] && dice[3] == dice[4]){
		if (dice[1] == dice[2] || dice[2] == dice[3]){
			score[playerNum][8] = 25;
		}
	}
	else {
		score[playerNum][8] = 0;
	}
	printf("score = %d\n", score[playerNum][8]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//small straight (score[9]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void smallStr8(int dice[], int cont[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: smallStr8()\n");

	if (cont[0] == 1){
		score[playerNum][9] = 30;
	}
	else{
		score[playerNum][9] = 0;
	}
	printf("cont[0] = %d\ncont[1] = %d\ncont[2] = %d\nscore = %d\n", cont[0], cont[1], cont[2], score[playerNum][9]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//large straight (score[10]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void largeStr8(int dice[], int cont[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: largeStr8()\n");

	if (cont[0] == 1){
		score[playerNum][10] = 40;
	}
	else{
		score[playerNum][10] = 0;
	}
	printf("cont[0] = %d\ncont[1] = %d\ncont[2] = %d\nscore = %d\n", cont[0], cont[1], cont[2], score[playerNum][10]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//yahtzee (5 of kind (score[11])).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void yahtzee(int dice[], int repeatValue[], int playerNum, int score[][12]){
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: yahtzee()\n");

	if (repeatValue[0] == 10){
		score[playerNum][11] = 50;
	}
	else{
		score[playerNum][11] = 0;
	}
	printf("score = %d\n", score[playerNum][11]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//chance (score[12]).
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chance(int dice[], int playerNum, int score[][12]){
	int result = 0;
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: chance()\n");

	for (int i = 0; i < SIZE; i++){
		score[playerNum][12] += dice[i];
	}
	printf("score = %d\n", score[playerNum][12]);

	system("pause");
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//player score.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void playerScore(int playerNum, int score[][12], int finalScore[][12]){
	int input = 0, i = 0;
	system("cls");
	printf("Player: %d\n\n", playerNum + 1);
	printf("Function: playerScore()\n");
	printf("\n1. Sum of 1's (%d)        7. Three-of-a-kind (%d)\n\
		   2. Sum of 2's (%d)        8. Four-of-a-kind (%d)\n\
		   3. Sum of 3's (%d)        9. Full house (%d)\n\
		   4. Sum of 4's (%d)        10. Small straight (%d)\n\
		   5. Sum of 5's (%d)        11. Large straight (%d)\n\
		   6. Sum of 6's (%d)        12. Yahtzee (%d)\n\
		   13. Chance (%d)\n\
		   \n", score[playerNum][0], score[playerNum][6], score[playerNum][1], score[playerNum][7], score[playerNum][2], score[playerNum][8], score[playerNum][3], score[playerNum][9], score[playerNum][4], score[playerNum][10], score[playerNum][5], score[playerNum][11], score[playerNum][12]);
	printf("Which score would you like to keep it:\n\nEnter: ");
	if (scanf("%d", &input) == 1 && input < 14){
		finalScore[playerNum][input - 1] = score[playerNum][input - 1];
		printf("finalScore[%d][%d] = %d\n\n", playerNum + 1, input - 1, finalScore[playerNum][input - 1]);
		system("pause");
	}
	else {
		printf("\n***************************************\nError: please enter a valid choice!\n***************************************\n\n");
		system("pause");
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//THE END
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////