Public feed
#890645
#include "fleet.h"
// HEADERS -- one for each function
// include the definitions for each of the non-template functions
// declared in fleet.h
const char* shipNames[7] =
{"No Ship","Mine Sweeper","Submarine","Frigate","Battleship","Aircraft Carrier"};
const int TOTALPIECES = 17; // total pieces in all ships
//---------------------------------------------------------------------------------
// Function: setShipInfo()
// File: fleet.cpp
// Title: Set ShipInfo
// Description:
// Sets struct ShipInfo fields
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls:
//
// Called By:
//
// Parameters: ShipInfo * shipInfoPtr: pointer to the ShipInfo to be set
// Ship name: enumerated name of type of ship
// Direction orientation: enumerated direction
// unsigned short row: row-coordinate in grid
// unsigned short col: column-coordinate in grid
//
// Returns: void
//
// History Log:
//
//
//---------------------------------------------------------------------------------
void setShipInfo(ShipInfo * shipInfoPtr, Ship name, Direction orientation,
unsigned short row, unsigned short col)
{
shipInfoPtr->m_name = name;
shipInfoPtr->m_bowLocation.m_col = col;
shipInfoPtr->m_bowLocation.m_row = row;
shipInfoPtr->m_orientation = orientation;
shipInfoPtr->m_piecesLeft = shipSize[name];
}
//---------------------------------------------------------------------------------
// Function: allocMem()
// File: fleet.cpp
// Title: Allocate Memory
// Description:
// allocates memory for current grids
// Programmer: Paul Bladek
// modified by:
//
// Date: 9/13/06
//
// Version: 1.01
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls:
//
// Called By: main()
//
// Parameters: Player players[]: the array of 2 players in the game
// char size: : 'S' or 'L' (small or large)
//
// Returns: void
//
// History Log:
// 12/20/05 PB completed v 1.0
// 9/13/06 PB completed v 1.01
//
//---------------------------------------------------------------------------------
void allocMem(Player players[], char size)
{
short row = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short col = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
try
{
for(short i = 0; i < NUMPLAYERS; ++i)
{
players[i].m_gameGrid[0] = new Ship*[row];
players[i].m_gameGrid[1] = new Ship*[row];
for(short j = 0; j < row; ++j)
{
players[i].m_gameGrid[0][j] = new Ship[col];
players[i].m_gameGrid[1][j] = new Ship[col];
for(short k = 0; k <= col; ++k)
{
players[i].m_gameGrid[0][j][k] = NOSHIP;
players[i].m_gameGrid[1][j][k] = NOSHIP;
} // end for k
} // end for j
} // end for i
}
catch(exception e)
{
cerr << "exception: " << e.what()<< endl;
cout << "shutting down" << endl;
cin.ignore(256,'\n');
exit(EXIT_FAILURE);
}
}
//---------------------------------------------------------------------------------
// Function: deleteMem()
// File: fleet.cpp
// Title: Delete Memory
// Description:
// Deletes memory for grids
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls:
//
// Called By: main()
//
// Parameters: Player players[]: the array of the 2 Players
// char size: 'S' or 'L'
//
// Returns: void
//
// History Log:
//
//
//---------------------------------------------------------------------------------
void deleteMem(Player players[], char size)
{
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
// your code goes here ...
// delete in reverse order of allocMem()
}
//---------------------------------------------------------------------------------
// Function: printShip()
// File: fleet.cpp
// Title: Print Ship
// Description:
// Print grid element for the proper ship
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: three characters representing one ship to sout
//
// Calls:
//
// Called By: printGrid()
//
// Parameters: ostream & sout: the stream to print to
// Ship thisShip: the Ship to be brinted in the grid format
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void printShip(ostream & sout, Ship thisShip)
{
sout << ' ' ;
switch(thisShip)
{
case NOSHIP: sout << ' ';
break;
case MINESWEEPER: sout << 'M';
break;
case SUB: sout << 'S';
break;
case FRIGATE: sout << 'F';
break;
case BATTLESHIP: sout << 'B';
break;
case CARRIER: sout << 'C';
break;
case HIT: sout << 'H';
break;
case MISSED: sout << MISS;
break;
default: sout << 'X';
}
sout << VERT ;
}
//---------------------------------------------------------------------------------
// Function: printGrid()
// File: fleet.cpp
// Title: Print Ship
// Description:
// Print grid element for the proper ship
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: a single grid to sout
//
// Calls: printShip()
//
// Called By: main()
// setShips()
// saveGrid()
//
// Parameters: ostream & sout: the stream to print to
// Ship** grid: the 2-D array of Ships
// char size: 'S' or 'L'
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void printGrid(ostream& sout, Ship** grid, char size)
{
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short numberOfCols = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
for(short j = 1; j <= numberOfCols; ++j)
sout << setw(3) << j;
sout << endl;
char letter = 'A';
for(short i = 0; i < numberOfRows; ++i)
{
sout << letter;
for (short j = 0; j < numberOfCols; ++j)
printShip(sout, grid[i][j]);
sout << endl;
sout << HORIZ;
for(short j = 1; j <= (numberOfCols - 1); ++j)
sout << HORIZ << HORIZ << CROSS ;
sout << HORIZ << HORIZ << CROSS << endl;
letter++;
}
sout << endl;
// your code goes here ...
// use printShip for each element in the grid
}
//---------------------------------------------------------------------------------
// Function: initializePlayer()
// File: fleet.cpp
// Title: Initialize Player
// Description:
// sets initial values for m_ships and m_piecesLeft
// Programmer: Paul Bladek
//
// Date:
//
// Version: 1.0
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls:
//
// Called By: main()
//
// Parameters: Player* playerPtr: a pointer to rhe current Player
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void initializePlayer(Player* playerPtr)
{
for(short i = 0; i < SHIP_SIZE_ARRAYSIZE; i++)
setShipInfo(playerPtr->m_ships+i, static_cast<Ship>(i));
playerPtr->m_piecesLeft = TOTALPIECES;
}
//---------------------------------------------------------------------------------
// Function: setships()
// File: fleet.cpp
// Title: Set Ships
// Description:
// Allows user to put ships in grid
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: location and orientation using getCoord from cin
//
// Output: prompts to cout
//
// Calls: printGrid()
// safeChoice()
// getCoord()
// saveGrid()
//
// Called By: main()
//
// Parameters: Player players[]: the array of 2 players
// char size: 'S' or 'L'
// short whichPlayer: the player number (0 or 1)
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void setShips(Player players[], char size, short whichPlayer)
{
char input = 'V';
char ok = 'Y';
char save = 'N';
ostringstream outSStream;
Cell location = {0, 0};
for(short j = 1; j < SHIP_SIZE_ARRAYSIZE; j++)
{
system("cls");
printGrid(cout, players[whichPlayer].m_gameGrid[0], size);
outSStream.str("");
outSStream << "Player " << whichPlayer + 1 << " Enter "
<< shipNames[j] << " orientation";
input = safeChoice(outSStream.str(),'V','H');
players[whichPlayer].m_ships[j].m_orientation = (input == 'V')?VERTICAL:HORIZONTAL;
cout << "Player " << whichPlayer + 1 << " Enter " << shipNames[j] <<
" bow coordinates <row letter><col #>: ";
location = getCoord(cin,size);
// if ok
if(!validLocation(players[whichPlayer], j, size))
{
cout << "invalid location. Press <enter>" ;
cin.get();
j--; // redo
continue;
}
if(players[whichPlayer].m_ships[j].m_orientation == VERTICAL)
{
for(int k = 0; k < shipSize[j]; k++)
{
players[whichPlayer].m_gameGrid[0][location.m_row + k][location.m_col] = (Ship)j;
}
}
else
{
for(int k = 0; k < shipSize[j]; k++)
{
players[whichPlayer].m_gameGrid[0][location.m_row][location.m_col + k] = (Ship)j;
}
}
// your code goes here ...
} // end for j
save = safeChoice("\nSave starting grid?",'Y','N');
if(save=='Y')saveGrid(players, whichPlayer, size);
}
//---------------------------------------------------------------------------------
// Function: saveGrid()
// File: fleet.cpp
// Title: Save Grid
// Description:
// Saves the ship grid to a file
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: grid to specified file
//
// Calls: printGrid()
//
// Called By: setships()
//
// Parameters: Player players[]: the array of 2 players
// short whichPlayer: the player number (0 or 1)
// char size: 'S' or 'L'
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void saveGrid(Player players[], short whichPlayer, char size)
{
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short numberOfCols = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
// your code goes here ...
}
//---------------------------------------------------------------------------------
// Function: getGrid()
// File: fleet.cpp
// Title: GetGrid
// Description:
// Reads grid from a file
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: grid from specified file
//
// Output: prompts to cout
//
// Calls:
//
// Called By: main()
//
// Parameters: Player players[]: the array of 2 players
// short whichPlayer: the player number (0 or 1)
// char size: 'S' or 'L'
// string fileName: the name of the file to be openned for reading
//
// Returns: bool -- true if the file is openned and read;
// false otherwise
//
// History Log:
//
//---------------------------------------------------------------------------------
bool getGrid(Player players[], short whichPlayer, char size, string fileName)
{
string line;
ifstream ifs;
Ship ship;
short shipCount[6] = {0};
char cell = ' ';
char fsize = 'S';
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short numberOfCols = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
try
{
ifs.open(fileName.c_str());
if(!ifs)
{
cout << "could not open file " << fileName << endl
<< " press <enter> to continue" << endl;
cin.ignore(256,'\n');
return false;
}
}
catch(...)
{
cout << "could not open file " << fileName << endl
<< " press <enter> to continue" << endl;
cin.ignore(256,'\n');
return false;
}
// your code goes here ...
return true;
}
//---------------------------------------------------------------------------------
// Function: getCoord()
// File: fleet.cpp
// Title: Get Coordinates
// Description:
// Returns a cell with coordinates set by user
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: cell coordinates (in the form "A13" from sin
//
// Output: prompts to cout
//
// Calls:
//
// Called By: main()
// setships()
//
// Parameters: istream& sin: the stream to read from
// char size: 'S' or 'L'
//
// Returns: Cell location -- a cell containing the input coordinates
//
// History Log:
//
//---------------------------------------------------------------------------------
Cell getCoord(istream& sin, char size)
{
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short numberOfCols = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
char highChar = static_cast<char>(numberOfRows - 1) + 'A';
char row = 'A';
short col = 0;
Cell location = {0, 0};
do
{
col = 0;
cout << "Row must be a letter from A to " << highChar
<< " and column must be from 1 to " << numberOfCols << ": ";
while((row = toupper(sin.get())) < 'A' || row > highChar)
{
sin.ignore(256, '\n');
cout << "Row must be a letter from A to " << highChar
<< " and column must be from 1 to " << numberOfCols << ": ";
}
sin >> col;
if(!sin)
sin.clear();
sin.ignore(256, '\n');
}
while(col < 1 || col > numberOfCols);
location.m_col = col - 1;
location.m_row = static_cast<short>(row - 'A');
return location;
}
//---------------------------------------------------------------------------------
// Function: validLocation()
// File: fleet.cpp
// Title: Valid Location
// Description:
// Can the ship legitinately go there?
// Programmer:
//
// Date:
//
// Version:
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls:
//
// Called By:
//
// Parameters: const Player& player: a reference to the specific Player
// short shipNumber: the number of the ship (1 - 5) in the array player.m_ships[]
// char size: 'S' or 'L'
//
// Returns: bool -- true if the ship would not go off the edge
// or cross another ship;
// false otherwise
//
// History Log:
//
//---------------------------------------------------------------------------------
bool validLocation(const Player& player, short shipNumber, char size)
{
short numberOfRows = (toupper(size)=='L')?LARGEROWS:SMALLROWS;
short numberOfCols = (toupper(size)=='L')?LARGECOLS:SMALLCOLS;
// your code goes here ...
// replace the return value
return true;
}
//---------------------------------------------------------------------------------
// Function: header()
// File: fleet.cpp
// Title: header
// Description:
// Prints opening graphic
// Programmer: Paul Bladek
//
// Date:
//
// Version: 1.0
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls: boxTop()
// boxLine()
// boxBottom()
//
// Called By: main()
//
// Parameters: ostream & sout: the stream to print to
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void header(ostream& sout)
{
const string empty;
const string sink("SINK THE FLEET!");
// your name goes here!
const string by(" Edmonds Community College Cmpsc 143");
boxTop(sout, BOXWIDTH);
boxLine(sout, empty, BOXWIDTH);
boxLine(sout, sink , BOXWIDTH, 'C');
boxLine(sout, empty, BOXWIDTH);
boxLine(sout, by, BOXWIDTH, 'C');
boxLine(sout, empty, BOXWIDTH);
boxBottom(sout, BOXWIDTH);
}
//---------------------------------------------------------------------------------
// Function: endBox()
// File: fleet.cpp
// Title: End Box
// Description:
// prints closinging graphic
// Programmer: Paul Bladek
//
// Date:
//
// Version: 1.0
//
// Environment: Hardware:IBM Pentium+
// Software: Windows XP or 98+ with .NET framework for execution;
// Compiles under Microsoft Visual C++ 2005
//
// Input: None
//
// Output: None
//
// Calls: boxTop()
// boxLine()
// boxBottom()
//
// Called By: main()
//
// Parameters: short player: the number of the winner (0 or 1)
//
// Returns: void
//
// History Log:
//
//---------------------------------------------------------------------------------
void endBox(short player)
{
const string empty;
ostringstream msg;
msg << "Congratulations player " << player + 1 << "!";
boxTop(cout, BOXWIDTH);
boxLine(cout, empty, BOXWIDTH);
boxLine(cout, msg.str() , BOXWIDTH, 'C');
boxLine(cout, empty, BOXWIDTH);
boxBottom(cout, BOXWIDTH);
}