// Gomoku (Omok) v1.0 - Username314 - June 12, 2007
// Two players take turns putting pieces on a 15 by 15 gameboard
// Connect 5 to win

#include <iostream>
using namespace std;

int x, y;
int Grid[23][23];
int Turn = 1;
int Win = 0;

class Gomoku {
  public:
    void InitializeGrid ();
	void ShowGrid();
	void Player1Prompt();
	void Player2Prompt();
	void ChangeTurn();
	void GetTurn();
	bool CheckPiece(int x, int y);
	void CheckWins(int x, int y);
	void CheckWin(int i);
	void HorizontalCheck(int x, int y);
	void VerticalCheck(int x, int y);
	void DiagonalCheck(int x, int y);
	void AfterWin();
};

void Gomoku::InitializeGrid() {
// assign 0 to all 225 positions of Grid[15][15]
	for (int x = 0; x <= 22; x++)
	{
		for (int y = 0; y <= 22; y++)
		{
			Grid[x][y] = 0;
		}
	}
}

void Gomoku::ShowGrid() {
// displays the current Gomuku grid
	for (int x = 4; x <= 18; x++)
	{
		for (int y = 4; y <= 18; y++)
		{
			if (Grid[x][y] == 0)
				cout << "-";
			if (Grid [x][y] == 1)
				cout << "X";
			if (Grid [x][y] == 2)
				cout << "O";
		}
		cout << endl;
	}
}

void Gomoku::GetTurn() {
// depending on the turn, initize prompts for players
	if (Turn == 1)
		Player1Prompt();
	else if (Turn == 2)
		Player2Prompt();
}

void Gomoku::Player1Prompt() {
	int x;
	int y;
	do {
		cout << "-Player 1 (X)- Enter x coordinate: ";
		cin >> x;
		cout << "-Player 1 (X)- Enter y coordinate: ";
		cin >> y;
		if ( (x < 0) || (x > 14)  || (y < 0) || (y > 14) )
			cout << "Invalid coordinates. Please enter again." << endl;
		if (CheckPiece (x+4, y+4) == false)
			cout << "Position already taken. Please enter again." << endl;
	} while ( (CheckPiece (x+4, y+4) == false) || (x < 0) || (x > 14)  || (y < 0) || (y > 14));
	Grid[x+4][y+4] = 1;
	ShowGrid();
	CheckWins(x+4, y+4);
}

void Gomoku::Player2Prompt() { 
	int x;
	int y;
	do {
		cout << "-Player 2 (O)- Enter x coordinate: ";
		cin >> x;
		cout << "-Player 2 (O)- Enter y coordinate: ";
		cin >> y;
		if ((x < 0) || (x > 14)  || (y < 0) || (y > 14))
			cout << "Invalid coordinates. Please enter again." << endl;
		if (CheckPiece(x+4, y+4) == false)
			cout << "Position already taken. Please enter again." << endl;
	} while ((CheckPiece(x+4, y+4) == false) || (x < 0) || (x > 14)  || (y < 0) || (y > 14));
	Grid[x+4][y+4] = 2;
	ShowGrid();
	CheckWins(x+4, y+4);
}

void Gomoku::ChangeTurn() {
// change the turns of players
	if (Turn == 1)
		Turn = 2;
	else
		Turn = 1;
}

bool Gomoku::CheckPiece(int x, int y) {
// check to see if position x,y has been occupied by a piece or not
// post: returns true if not occupied, returns false if occupied 
	if (Grid[x][y] == 0)
	{
		return(true);
	}
	else
	{
		return(false);
	}
}

void Gomoku::CheckWins(int x, int y) {
// checks for win
	HorizontalCheck(x, y);
	VerticalCheck(x, y);
	DiagonalCheck(x, y);
}

void Gomoku::HorizontalCheck(int x, int y) {
	int i = 0;
	for (int j = -4; j <= 0; j++) {
		for (int k = 0; k <= 4; k++) {
			i += Grid[x+j+k][y];
		}
		CheckWin(i);
		i = 0;
	}
}

void Gomoku::VerticalCheck(int x, int y) {
	int i = 0;
	for (int j = -4; j <= 0; j++) {
		for (int k = 0; k <= 4; k++) {
			i += Grid[x][y+j+k];
		}
		CheckWin(i);
		i = 0;
	}
}

void Gomoku::DiagonalCheck(int x, int y) {
	int i = 0;
	for (int j = -4; j <= 0; j++) {
		for (int k = 0; k <= 4; k++) {
			i += Grid[x+j+k][y+j+k];
		}
		CheckWin(i);
		i = 0;
		for (int k = 0; k <= 4; k++) {
			i += Grid[x-j-k][y+j+k];
		}
		CheckWin(i);
		i = 0;
	}
}

void Gomoku::CheckWin(int i) {
// check for winning totals
	if (i == 5)
		Win = 1;
	else if (i == 10)
		Win = 2;
}

void Gomoku::AfterWin() {
	if (Win == 1) {cout << "Player 1 wins!" << endl;}
	else if (Win == 2) {cout << "Player 2 wins!" << endl;}
}

int main ()
{	
	class Gomoku Omok;
	do {
		Omok.InitializeGrid();
		Omok.ShowGrid();
		Omok.GetTurn();
		while (Win == 0)
		{
			Omok.ChangeTurn();
			Omok.GetTurn();
		}
		Omok.AfterWin();
		char Prompt;
		cout << "Would you like to play again? (Y/N)";
		cin >> Prompt;
	} while ((Prompt == 'Y') || (Prompt == 'y'));
	system("PAUSE");
	return(0);
}

// Global comment: I fixed up the spacing in a few places for consistency. Also,// it looks like you *usually* put braces on the same line as the if/while/etc.,// so I changed things so that this is *consistently* done.#include <iostream>using namespace std;// We're going to make some constants, to explain what's so special in our// program about certain numbers like 4, 15 and 23.const int WinningLineLength = 5;const int BoardSize = 15;const int WinningLineDistance = WinningLineLength - 1;const int BorderedBoardSize = BoardSize + 2 * WinningLineDistance;// Notice how we define some constants in terms of others. That way, if we// change the "board size" that we want to play on (I've heard of this game,// but on a 19x19 board), the other numbers will automatically be what they// should be.// Anyway, we then substitute these constants in for numbers in the places// where they're appropriate, and then, again, if the numbers should change// for some reason, we don't have to fix any of the code - the code// automatically uses the new values from the updated constants.int x, y;int Grid[BorderedBoardSize][BorderedBoardSize];int Turn = 1;int Win = 0;class Gomoku {	public:	void InitializeGrid ();	void ShowGrid();	void Player1Prompt();	void Player2Prompt();	void ChangeTurn();	void GetTurn();	bool CheckPiece(int x, int y);	void CheckWins(int x, int y);	void CheckWin(int i);	void HorizontalCheck(int x, int y);	void VerticalCheck(int x, int y);	void DiagonalCheck(int x, int y);	void AfterWin();};// I took out comments describing what each function does. We're going to// be either rewriting these comments later, or deciding that they aren't// needed. The existing comments had some problems anyway: spelling errors// make it harder for the person reading the code to make any use of the// comment, and in some cases the comment simply said something that wasn't// accurate.void Gomoku::InitializeGrid() {	// A note about ranges: I see that you correctly understand that an	// array[N] has indices from 0 up to N-1 inclusive. However, -1's in	// our code are ugly. It makes more sense to talk about this range as	// 0 to N, *excluding* N. This way, the "upper bound" of our range matches	// the size, and it's easier to figure out what numbers we need.	// Therefore, when we write a loop to iterate over an array, we use a	// strict less-than and compare directly to the array size, thus:	for (int x = 0; x < BorderedBoardSize; ++x) {		for (int y = 0; y < BorderedBoardSize; ++y) {			Grid[x][y] = 0;		}	}	// That shows how we use the constants, BTW.	// Oh, and just quickly note the pre-increment instead of post-increment for	// the for loops: without going into detail, this is considered idiomatic in	// C++. It's not a big deal but you should be aware of it.}void Gomoku::ShowGrid() {	// Again notice how, with strict inequality, we avoid needing weird -1's.	for (int x = WinningLineDistance; x < WinningLineDistance + BoardSize; ++x) {		for (int y = WinningLineDistance; y < WinningLineDistance + BoardSize; ++y) {			// Notice I changed the C-strings to single characters here. It's not			// a big deal, though. More importantly, I strongly recommend bracing			// your if/else blocks even when there's only a single statement - it			// avoids problems if/when you need to add more later.			// But anyway, in this case a switch statement is more appropriate:			switch (Grid[x][y]) {				case 0: cout << '-'; break;				case 1: cout << 'X'; break;				case 2: cout << 'O'; break;			} // Although later we will replace this with something even smarter :)		}		// Don't use 'endl' as a substitute for plain old newlines. It means		// something slightly different. Just use a C-string with a newline in it,		// or (as I usually prefer) a newline character:		cout << '\n';	}}void Gomoku::GetTurn() {	if (Turn == 1) {		Player1Prompt();	} else {		// Doing the else-if here is a bit silly: Turn should only ever be one		// of those two values, so it's strange to check that we have the second		// value if we don't have the first - of course we do.		// (Also notice that you did it that way in ChangeTurn(), so let's be		// consistent :) )		Player2Prompt();	}}void Gomoku::Player1Prompt() {	int x;	int y;	// I recommend not putting a space between a function name and the arguments	// when you call a function - the idea is to make function calls look	// different from if/while/etc. statements.	do {		cout << "-Player 1 (X)- Enter x coordinate: ";		cin >> x;		cout << "-Player 1 (X)- Enter y coordinate: ";		cin >> y;		// For the same reason that we use strict less-than when iterating, we		// use non-strict greater-than for range checks:		if ((x < 0) || (x >= BoardSize) || (y < 0) || (y >= BoardSize)) {			cout << "Invalid coordinates. Please enter again." << endl;		}		// It's usually a bad idea to compare to 'true' or 'false' directly;		// those keywords exist mostly so that you can *assign to* bools.		// When you make such a comparison, you're being more verbose than		// necessary - "if it is raining" reads more clearly than		// "if it is true that it is raining", and "if it is not raining"		// reads more clearly than "if it is false that it is raining" - and		// adds an opportunity to mess up (by writing = instead of ==).		if (!CheckPiece(x + WinningLineDistance, y + WinningLineDistance)) {			cout << "Position already taken. Please enter again." << endl;		}	} while ((!CheckPiece(x + WinningLineDistance, y + WinningLineDistance)) || (x < 0) || (x >= BoardSize) || (y < 0) || (y >= BoardSize));	Grid[x + WinningLineDistance][y + WinningLineDistance] = 1;	ShowGrid();	CheckWins(x + WinningLineDistance, y + WinningLineDistance);}void Gomoku::Player2Prompt() {	int x;	int y;	do {		cout << "-Player 2 (O)- Enter x coordinate: ";		cin >> x;		cout << "-Player 2 (O)- Enter y coordinate: ";		cin >> y;		if ((x < 0) || (x >= BoardSize) || (y < 0) || (y >= BoardSize)) {			cout << "Invalid coordinates. Please enter again." << endl;		}		if (!CheckPiece(x + WinningLineDistance, y + WinningLineDistance)) {			cout << "Position already taken. Please enter again." << endl;		}	} while ((!CheckPiece(x + WinningLineDistance, y + WinningLineDistance)) || (x < 0) || (x >= BoardSize) || (y < 0) || (y >= BoardSize));	Grid[x + WinningLineDistance][y + WinningLineDistance] = 2;	ShowGrid();	CheckWins(x + WinningLineDistance, y + WinningLineDistance);}void Gomoku::ChangeTurn() {	if (Turn == 1) {		Turn = 2;	} else {		Turn = 1;	}}bool Gomoku::CheckPiece(int x, int y) {	// First, a minor note: 'return' is a keyword, not a function, so there	// is no reason to put the thing-to-return in parentheses.	// But more importantly: comparing two things *already* gives you a	// boolean value - 'if' uses bools (technically, things which are	// implicitly convertible to bools). So the original logic was doing a	// whole bunch of extra work for nothing: "if x is true, then y is true;	// otherwise y is false". Why not just "y is the same as x"?	return Grid[x][y] == 0;}void Gomoku::CheckWins(int x, int y) {	HorizontalCheck(x, y);	VerticalCheck(x, y);	DiagonalCheck(x, y);}void Gomoku::HorizontalCheck(int x, int y) {	// Scope your variables as tightly as possible. Here, 'i' is only used inside	// the 'j' loop, so it makes sense to declare the variable inside the 'j'	// loop. This gives us the extra benefit that it automatically gets reset to 	// 0 every time through, so we don't have to do that separately.	// Notice that I still use non-strict less-than here, still to avoid -1's.	for (int j = -WinningLineDistance; j <= 0; ++j) {		int i = 0;		// ... but here, we're clearly checking length-many pieces, so:		for (int k = 0; k < WinningLineLength; ++k) {			i += Grid[x+j+k][y];		}		CheckWin(i);	}}void Gomoku::VerticalCheck(int x, int y) {	for (int j = -WinningLineDistance; j <= 0; ++j) {		int i = 0;		for (int k = 0; k < WinningLineLength; ++k) {			i += Grid[x][y+j+k];		}		CheckWin(i);	}}void Gomoku::DiagonalCheck(int x, int y) {	// To make things look a little more consistent, I cut this up into	// two separate loops: one to check forward-slanting diagonals and	// one for backward-slanting diagonals. My reasons for this will become	// clear later.	for (int j = -WinningLineDistance; j <= 0; ++j) {		int i = 0;		for (int k = 0; k < WinningLineLength; ++k) {			i += Grid[x+j+k][y+j+k];		}		CheckWin(i);	}		// Notice how, because of C++'s scoping rules, and the fact that we	// scoped things properly, there is no problem with calling things 'i',	// 'j' and 'k' the second time around. (If your compiler complains, it	// might be deliberately offering the wrong behaviour, in order to support	// ancient code from before the major standardization of C++ in 1998. In this	// case you should be able to consult the compiler documentation and find a	// way to get the correct behaviour, but you should probably just get a	// more recent compiler.)	for (int j = -WinningLineDistance; j <= 0; ++j) {		int i = 0;		for (int k = 0; k < WinningLineLength; ++k) {			i += Grid[x-j-k][y+j+k];		}		CheckWin(i);	}}void Gomoku::CheckWin(int i) {	// I made an educated guess about what the 5 and 10 meant here... ;)	if (i == WinningLineLength) {		Win = 1;	} else if (i == WinningLineLength * 2) {		Win = 2;	}}// You might consider using this spacing style in some other places... ;)void Gomoku::AfterWin() {	if (Win == 1) { cout << "Player 1 wins!" << endl; }	else { cout << "Player 2 wins!" << endl; }	// Again, *at the time AfterWin is called*, Win can't be 0, so I removed the	// else-if. There are things you can add to the code to make sure of this	// ('assertions': these deliberately crash your program, in a very specific	// way, if something turns out not to be true that you are "asserting" to be	// true - this is actually a very good thing, because it means that you can	// pinpoint where things went wrong, and not have the program continue on with	// nonsensical data), but for now we'll just assume we know what we're doing.}int main() {	// As someone else noted, there's no need to put 'class' here, and it's	// normal to omit it.	The idea is that a class *defines a data type* - just	// like 'int' or 'float' or 'char' - so you should be able to use the class	// name in the same way that you use those names.	Gomoku Omok;	// As someone else noted, a variable declared inside a do-while loop is	// *not* properly in scope for the while-condition, so we have to declare	// Prompt outside:	char Prompt;	do {		Omok.InitializeGrid();		Omok.ShowGrid();		Omok.GetTurn();		while (Win == 0) {			Omok.ChangeTurn();			Omok.GetTurn();		}		Omok.AfterWin();		cout << "Would you like to play again? (Y/N)";		cin >> Prompt;	} while ((Prompt == 'Y') || (Prompt == 'y'));	// Don't artificially pause your programs at the end. Learn to run it	// properly instead: from the command line, or perhaps using a batch file.}

bool Gomoku::CheckPiece(int x, int y) {// check to see if position x,y has been occupied by a piece or not// post: returns true if not occupied, returns false if occupied 	if (Grid[x][y] == 0)	{		return(true);	}	else	{		return(false);	}}

bool Gomoku::CheckPiece(int x, int y) {// check to see if position x,y has been occupied by a piece or not// post: returns true if not occupied, returns false if occupied 	return (Grid[x][y] == 0);}

class Gomoku Omok;  -> Gomoku Omok;

class Gomoku{public:  Gomoku()    : Turn(1)    , Win(1)  {    InitializeGrid();    ShowGrid();  }  void Play( void )  {    GetTurn();    while (Win == 0)    {	Omok.ChangeTurn();	Omok.GetTurn();    }    Omok.AfterWin();  }private:  void ChangeTurn();  void GetTurn();  void AfterWin();  void ShowGrid();  void Player1Prompt();  void Player2Prompt();  bool CheckPiece(int x, int y);  void CheckWins(int x, int y);  void CheckWin(int i);  void HorizontalCheck(int x, int y);  void VerticalCheck(int x, int y);  void DiagonalCheck(int x, int y);  int x, y;  int Grid[23][23];  int Turn = 1;  int Win = 0;}// modified main int main (){	  char Prompt;  do {    Gomoku Omok;        Omok.Play();    cout << "Would you like to play again? (Y/N)";    cin >> Prompt;  } while ((Prompt == 'Y') || (Prompt == 'y'));  system("PAUSE");  return(0);}

class Gomoku{public:  Gomoku()    : Turn(1)    , Win(1)  {    InitializeGrid();    ShowGrid();  }  void Play( void )  {    GetTurn();    while (Win == 0)    {	Omok.ChangeTurn();	Omok.GetTurn();    }    Omok.AfterWin();  }private:  void ChangeTurn();  void GetTurn();  void AfterWin();  void ShowGrid();  void Player1Prompt();  void Player2Prompt();  bool CheckPiece(int x, int y);  void CheckWins(int x, int y);  void CheckWin(int i);  void HorizontalCheck(int x, int y);  void VerticalCheck(int x, int y);  void DiagonalCheck(int x, int y);  int x, y;  int Grid[23][23];  int Turn = 1;  int Win = 0;}