Snowball Console Game - Getting Targets to Throw Back

[timmyspan]

So I am doing this project in my online course where it's impossible to collaborate with other students or to get help from the professor. I am hoping some of you who are more seasoned with C++ can help me understand this issue.

I have 3 targets that the player throws a snowball at each turn by picking a row and a column on a grid. Well, the targets need to each throw a snowball back at the player who is on his own grid. I think I have a good starting point, but I just don't know how to get the targets to throw to a random location.

There's also conditional statements but I feel comfortable adding those in the code.

  //**begin #include files************
#include <iostream> // provides access to cin and cout
#include <array>	// provides access to std::array
#include <time.h>	// provides access to time() for srand()
//--end of #include files-----------
//----------------------------------

using namespace std;
//----------------------------------

//**begin global constants**********
// define coordinate structure for target
struct Coords
{
	int x;
	int y;
};

// define coordinate structure for player
struct PCoords
{
	int q;
	int r;
};

// define a struct of the target
struct MyStruct
{
	int ID;				// -- Identification number of the target
	Coords position;	// -- position of target			
	int dist;			// -- distance between target and snowball hit	
	bool hit;			// -- flag indicating target has been hit
};

// define a struct of the player
struct PStruct
{
	int ID;				// -- Identification number of the player
	PCoords location;   // -- position of player
	int between;		// -- distance between player and snowball hit
	bool struck;		// -- flag indicating player has been hit
};

const int gridSize = 5;		// const grid size (i.e. 5x5 grid constant is 5)
const int turns = 20;		// const number of turns
const int targetCount = 3;	// number of targets
const int playerCount = 1;

							//--end of global constants---------
							//----------------------------------

							//**begin function prototypes*******
int throwSnowball(Coords p, MyStruct &Target);
void moveTarget(MyStruct &Target);
void movePlayer(PStruct &Player);
int computerThrowSnowball(PCoords l, PStruct &Player);
//--end of function prototypes------
//----------------------------------

//**begin main program**************
int main()
{
	// initialization
	srand(time(NULL));
	bool allHit = false;
	bool playerHit = false;
	int hitCount = 0;	// number of hits.
	int pHit = 0;
	int dist = 0;		// distance of miss
	int between = 0;
	Coords snowballPos;	// position of snowball hit
	PCoords computerSnowballPos;
	array <MyStruct, targetCount> Targets;
	// Initialize targets
	int idNum = 0;
	for (auto &T : Targets) //**Error 1: add the "&"
	{
		T.ID = idNum++;		// set identification number
							// set target at random location
		T.position.x = rand() % gridSize;
		T.position.y = rand() % gridSize;
		T.hit = false;		// set target hit flag to default: false
	}
	array <PStruct, playerCount> Player;
	int playerId = 0;
	for (auto &P : Player) //**Error 1: add the "&"
	{
		P.ID = playerId++;		// set identification number
							// set target at random location
		P.location.q = rand() % gridSize;
		P.location.r = rand() % gridSize;
		P.struck = false;		// set target hit flag to default: false
	}
	// loop for the specified number of turns
	for (int i = 0; i < turns; i++)
	{
		//   get x and y position for the snowball from player
		cout << "column? ";
		cin >> snowballPos.x;
		cout << "row?    ";
		cin >> snowballPos.y;
		// throw snow ball (see instructions for details)
		for (auto &T : Targets)
		{
			if (!T.hit)
			{
				// check for hit or miss
				dist = throwSnowball(snowballPos, T);
				// report results
				switch (dist)
				{
				case 0:
					cout << "***SPLAT*** You hit target " << T.ID << "!" << endl;
					hitCount++;
					break;
				case 1:
					cout << "target " << T.ID << ": Way too close!" << endl;
					break;
				case 2:
					cout << "target " << T.ID << ": I heard it hit." << endl;
					break;
				default:
					cout << "target " << T.ID << ": Missed by a mile." << endl;
					break;
				}
				//   target moves (see instruction for details
				if (!T.hit) moveTarget(T);
			}
		}
		if (hitCount == 3)
		{
			allHit = true;
			break;
		}
	}
	// throw snow ball (see instructions for details)
	for (int i = 0; i < turns; i++)
	{
		//   get x and y position for the snowball from player
		cin >> computerSnowballPos.q;
		cin >> computerSnowballPos.r;
		for (auto &P : Player)
		{
			if (!P.struck)
			{
				// check for hit or miss
				between = computerThrowSnowball(computerSnowballPos, P);
				// report results
				switch (dist)
				{
				case 0:
					cout << "***SPLAT*** The player, " << P.ID << " has been hit!" << endl;
					hitCount++;
					break;
				case 1:
					cout << "target " << P.ID << ": Way too close!" << endl;
					break;
				case 2:
					cout << "target " << P.ID << ": I heard it hit." << endl;
					break;
				default:
					cout << "target " << P.ID << ": Missed by a mile." << endl;
					break;
				}
				if (!P.struck) movePlayer(P);
			}
		}
		if (pHit == 1)
		{
			playerHit = true;
			break;
		}

		cout << "---Next Turn---" << endl;
	}
	// end of loop
	// report score (number of hits vs turns)
	if (allHit) cout << "All targets have been hit!  Great job!" << endl;
	else cout << "You had " << hitCount << " hits out of " << turns << " throws." << endl;
	cin.get();
	// Wait for user input to close program when debugging.
	cin.get();
	return 0;
}
//--end of main program-------------
//----------------------------------

//**begin function definitions******
// Determine hit or distance
int throwSnowball(Coords p, MyStruct &Target)
{
	int aDistance;
	//   compare to the target's position
	if (p.x == Target.position.x)
	{
		if (p.y == Target.position.y)
		{
			Target.hit = true;
			return 0;
		}
		else
		{
			return abs(p.y - Target.position.y);
		}
	}
	else
	{
		aDistance = abs(p.x - Target.position.x);
		if (aDistance < abs(p.y - Target.position.y)) aDistance = abs(p.y - Target.position.y);
		return aDistance;
	}
}

//  Move the target
void moveTarget(MyStruct &Target)
{
	enum MyEnum
	{
		North, East, South, West, Stay
	};
	bool moveNotFound = true;
	MyEnum ranNum = MyEnum(rand() % 5);
	if (ranNum == Stay) return;
	while (moveNotFound)
	{
		switch (ranNum)
		{
		case North:
			if (Target.position.y == 0)	break; // can't move North
			Target.position.y--;
			cout << Target.ID << " moving North." << endl;
			return;
		case East:
			if (Target.position.x == gridSize - 1)	break; // can't move East
			Target.position.x++;
			cout << Target.ID << " moving East." << endl;
			return;
		case South:
			if (Target.position.y == gridSize - 1)	break; // can't move South
			Target.position.y++;
			cout << Target.ID << " moving South." << endl;
			return;
		case West:
			if (Target.position.x == 0)	break; // can't move West
			Target.position.x--;
			cout << Target.ID << " moving West." << endl;
			return;
		default:
			break;
		}
		ranNum = MyEnum(int(ranNum + 1) % 4);
	}
}

void movePlayer(PStruct &Player) {
	enum MyEnum
	{
		North, East, South, West, Stay
	};
	bool moveNotFound = true;
	MyEnum ranNum = MyEnum(rand() % 5);
	if (ranNum == Stay) return;
	while (moveNotFound)
	{
		switch (ranNum)
		{
		case North:
			if (Player.location.r == 0)	break; // can't move North
			Player.location.r--;
			cout << Player.ID << " moving North." << endl;
			return;
		case East:
			if (Player.location.q == gridSize - 1)	break; // can't move East
			Player.location.q++;
			cout << Player.ID << " moving East." << endl;
			return;
		case South:
			if (Player.location.r == gridSize - 1)	break; // can't move South
			Player.location.r++;
			cout << Player.ID << " moving South." << endl;
			return;
		case West:
			if (Player.location.q == 0)	break; // can't move West
			Player.location.q--;
			cout << Player.ID << " moving West." << endl;
			return;
		default:
			break;
		}
		ranNum = MyEnum(int(ranNum + 1) % 4);
	}
}

int computerThrowSnowball(PCoords l, PStruct &Player)
{
	int aDistance;
	//   compare to the target's position
	if (l.q == Player.location.q)
	{
		if (l.r== Player.location.r)
		{
			Player.struck = true;
			return 0;
		}
		else
		{
			return abs(l.r - Player.location.r);
		}
	}
	else
	{
		aDistance = abs(l.q - Player.location.q);
		if (aDistance < abs(l.r - Player.location.r)) aDistance = abs(l.r - Player.location.r);
		return aDistance;
	}
}
//--end of function definitions------
//---------------------------------- 

Thanks in advance for any help or suggestions.

[48T7M4Gy]

but I just don't know how to get the targets to throw to a random location.

What about generating a set of two random integers (row,col)? There are many options but rand() would do the job.

/* initialize random seed: */
  srand (time(NULL));

  /* generate 2 numbers within the range of the grid say 1 to 10: */
  random_column = rand() % 10 + 1;
  random_row = rand() % 10 +1;

Then perform a test to see whether grid[random_row][random_column] is occupied.

http://www.cplusplus.com/reference/cstdlib/rand/?kw=rand

[goldenchicken]

Why make 2 different structs for coord and player coord? I think it definitely makes more sense to use one Coord struct.

[timmyspan]

Thanks kemort I will have to try that out.

Goldenchicken, my thought process behind that was using x and y for my player coordinates would overwrite the x and y coordinates for the targets. Please correct me if I am wrong in thinking that.