[SOLVED] 代写 data structure algorithm game html software #include “basicdungeon.h”

#include “basicdungeon.h”

using namespace core::dungeon;

/* ——————————————————————————
* BasicDungeon member implementations
* —————————————————————————–*/

BasicDungeon::BasicDungeon()
{

}

/* ——————————————————————————
* RockChamber member implementations
* —————————————————————————–*/

RockChamber::RockChamber()
{

}

/* ——————————————————————————
* QuartzChamber member implementations
* —————————————————————————–*/

QuartzChamber::QuartzChamber()
{

}

/* ——————————————————————————
* BasicWall member implementations
* —————————————————————————–*/

RockWall::RockWall()
{

}
#include “character.h”

using core::Character;

Character::Character(const std::string &name)
: _name{name}
{

}

const std::string& Character::name() const {
return _name;
}

std::ostream& operator<<(std::ostream &stream, const Character &character) {stream << character.name();return stream;}#include “commondungeon.h”using namespace core::dungeon;OpenDoorway::OpenDoorway(){}#include “creatures.h”using namespace core::creatures;/* —————————————————————————— * Creature member implementations * —————————————————————————–*/Creature::Creature(const std::string &name): _name{name}{}const std::string& Creature::name() const {return _name;}#include “csvfile.h”using namespace data;CsvFile::CsvFile(std::istream &input){// TODO: implement the constructor}int CsvFile::numberOfColumns() const{// TODO: implement this method. See header for description.return -10;}int CsvFile::numberOfRows() const{// TODO: implement this method. See header for description.return -10;}std::string CsvFile::at(int row, int column) const{// TODO: implement this method. See header for description.return “not yet implemented”;}std::string CsvFile::headerAt(int column) const{// TODO: implement this method. See header for description.return “not yet implemented”;}int CsvFile::columnIndexOf(const std::string &columnName) const{// TODO: implement this method. See header for description.return -10;}#include “door.h”using namespace core::dungeon;Door::Door(){}#include “dungeon.h”using namespace core::dungeon;Dungeon::Dungeon(): _rooms{}{}// DO NOT modify implementation below this commentstd::shared_ptr Dungeon::retrieveRoom(int id) {
auto roomIterator = _rooms.find(id);
if (roomIterator != _rooms.end()) {
return roomIterator->second;
}
return std::shared_ptr {nullptr};
}

bool Dungeon::addRoom(std::shared_ptr newRoom) {
if (!_rooms.count(newRoom->id())) {
_rooms[newRoom->id()] = newRoom;
return true;
}
return false;
}
#include “game.h”
#include “testingsettings.h”
#include

using namespace core;

// TODO: Add additional implementation here

// Do not change/remove the initialisation of _randomGenerator and _realDistribution, otherwise change as needed.
Game::Game()
: _randomGenerator{uint32_t(time(nullptr))}, _realDistribution{0.0, 1.0}
{

}

// DO NOT modify implementation below this comment

int Game::randomIntBetweenInc(int min, int max) {
#if INPUT_SCRIPT
return min; // for consistency when using the input script
#else
if (min == max) return max;
if (max < min) std::swap(min, max);int diff{max + 1 – min};return int(_randomGenerator() % unsigned(diff)) + min;#endif}int Game::randomIntBetweenEx(int min, int max) {#if INPUT_SCRIPTreturn max – 1; // for consistency when using the input script#elseif (min == max) return max; // technically invalid for an exclusive rangeif (max < min) std::swap(min, max);int diff{max – min};return int(_randomGenerator() % unsigned(diff)) + min;#endif}double Game::randomDouble() {#if INPUT_SCRIPTreturn 1.0; // for consistency when using the input script.#elsereturn _realDistribution(_randomGenerator);#endif}#include “magicaldungeon.h”using namespace core::dungeon;/* —————————————————————————— * MagicalDungeon member implementations * —————————————————————————–*/MagicalDungeon::MagicalDungeon(){}/* —————————————————————————— * EnchantedLibrary member implementations * —————————————————————————–*/EnchantedLibrary::EnchantedLibrary(){}/* —————————————————————————— * AlchemistsLaboratory member implementations * —————————————————————————–*/AlchemistsLaboratory::AlchemistsLaboratory(){}/* —————————————————————————— * MagicWall member implementations * —————————————————————————–*/MagicWall::MagicWall(){}#include “menuinterface.h”#include
#include

#include “testingsettings.h”

#define AUTHOR “ ”
#define TITLE “ ”

#if INPUT_SCRIPT
#define SCRIPT_PATH “../assignment1-dungeon_crawler/input_script.txt”
#define OUT_FILE_PATH “../assignment1-dungeon_crawler/output_gen.txt”
#endif

/* ——————————————————————————
* NOTE: DO NOT edit this file other than providing your name and game title to the
* `AUTHOR` and `TITLE` macros, respectively.
* Enable testing mode and set options in the testingsettings.h file.
* It may be necessary to change the path to the input script, depending on your
* configuration: see SCRIPT_PATH macro definition above.
* —————————————————————————–*/

/**
* @mainpage
*
* There are three forms of the main function in this file so that it can run in
* three modes: normal, input script, and testing. This is done using conditional
* compilation and is configured through `testingsettings.h`.
*
* In normal mode, the MenuInterface will be run and attached to standard in and
* standard out.
*
* In input script mode, the Menu Interface will be run and attached to a file
* for input and (optionally) a file for output. This will be used as a quick test
* of the general functionality of your implementation. You can use it yourself
* to test as you go to ensure that your implementation conforms to the expected
* commands.
*
* In testing mode, a simple unit testing suite will be executed. A small example
* has been provided, but you are encouraged to implement tests as you go to
* ensure the parts of your implementation are working. This saves time as it makes
* it easier to track down errors for “submodules” this way, rather than having to
* test everything through the menu-driven interface constantly.
*/

using core::MenuInterface;

#if not TESTING

#if not INPUT_SCRIPT

/**
* @brief main Simple main function that runs the MenuInterface until quit.
* @return exit code, 0 is success
*/
int main()
{
MenuInterface m{std::cout, std::cin};

m.displayWelcome(AUTHOR, TITLE);
m.run();

return 0;
}

#else
#include
#include

/**
* @brief main Simple main function runs game using the input script.
* @return
*/
int main()
{
// Using QDir to provide sensible error useful error message
// if the script file cannot be found.
QDir path{SCRIPT_PATH};
std::fstream in{path.absolutePath().toStdString()};
if (in.fail()) {
std::cout << “Unable to find file: ” << path.absolutePath().toStdString() << std::endl<< “Current path: ” << QDir::currentPath().toStdString() << std::endl;return 1;}#if OUTPUT_SCRIPTQDir outPath{OUT_FILE_PATH};std::ofstream out{outPath.absolutePath().toStdString()};if (out.fail()) {std::cout << “Unable to open out file: ” << outPath.absolutePath().toStdString() << std::endl<< “Current path: ” << QDir::currentPath().toStdString() << std::endl;return 1;}#elsestd::ostream& out = std::cout;#endifMenuInterface m{out, in};m.displayWelcome(AUTHOR, TITLE);m.run();return 0;}#endif#else#include “testing.h”/** * @brief main run testing code. * @return */int main() {Testing test{};std::cout << “Running tests …” << std::endl;test.runTests(); // Modify which tests are run in the implementation of runTests()test.printTestResults(std::cout);return 0;}#endif#include “menuinterface.h”#include

using namespace core;

MenuInterface::MenuInterface(std::ostream &display, std::istream &input)
: _display{display}, _input{input}, _currentMenu{Menu::Main} {
}

void MenuInterface::displayWelcome(const std::string &author, const std::string &title) const {
std::string welcomeText{“Welcome to ” + title};
std::string authorText{“Developed by ” + author};
std::string comp3023{“COMP 3023 Software Development with C++”};

unsigned int columns{static_cast (std::max(welcomeText.size(), std::max(authorText.size(), comp3023.size())))};

_display << centre(columns, welcomeText.size()) << welcomeText << std::endl << centre(columns, authorText.size()) << authorText << std::endl << centre(columns, comp3023.size()) << comp3023 << std::endl;}void MenuInterface::run() {displayMenu();while (processSelection(getCharacterInput()) && _input) {displayMenu();}}void MenuInterface::displayMenu() const { waitUntillNewline();switch (_currentMenu) {case Menu::Main:displayMainMenu();break;case Menu::CharacterDetails:characterDetailsMenu();break;case Menu::DungeonSelect:dungeonTypeMenu();break;case Menu::Action:actionMenu();break;case Menu::Combat:combatMenu();break;}}bool MenuInterface::processSelection(char selection) {if (!_input) return false; // graceful exit when input endsswitch (_currentMenu) {case Menu::Main:return processMainMenu(tolower(selection));case Menu::CharacterDetails:processCharacterDetails(tolower(selection));break;case Menu::DungeonSelect:processDungeonType(tolower(selection));break;case Menu::Action:processAction(tolower(selection));break;case Menu::Combat:processCombatAction(tolower(selection));}return true;}char MenuInterface::getCharacterInput() const {char input;_input >> input;
_input.ignore(std::numeric_limits ::max(), ‘
’);
echo(input); // for when running the input script
return input;
}

int MenuInterface::getIntInput() const {
int input;
_input >> input;
_input.ignore(std::numeric_limits ::max(), ‘
’);

while (!_input) {
_input.clear();
warnSelectionInvalid(char(_input.peek()));
_input.ignore(std::numeric_limits ::max(), ‘
’);

_input >> input;
_input.ignore(std::numeric_limits ::max(), ‘
’);
}

echo(input); // for when running the input script

return input;
}

void MenuInterface::warnSelectionInvalid(char selection) const {
_display << “Sorry, ‘” << selection << “‘ is not a valid option, please try again.” << std::endl;}void MenuInterface::setMenu(Menu newMenu) {_currentMenu = newMenu;}void MenuInterface::displayMainMenu() const {_display << “What would you like to do?” << std::endl;_display << ” (p)lay the game” << std::endl;_display << ” (c)haracter details” << std::endl;_display << ” (q)uit” << std::endl;}bool MenuInterface::processMainMenu(char selection) {switch (selection) {case ‘p’:playGame();break;case ‘c’:switchToCharacterMenu();break;case ‘q’:return quitGame();default:warnSelectionInvalid(selection);}return true;}void MenuInterface::playGame() {// TODO: implement this member function.}void MenuInterface::createCharacter() {// TODO: implement this member function.}void MenuInterface::dungeonTypeMenu() const {// TODO: implement this member function._display << “TODO: any key will return to main menu” << std::endl;}void MenuInterface::processDungeonType(char selection) {// TODO: implement this member function.setMenu(Menu::Main);}void MenuInterface::switchToCharacterMenu() {// TODO: implement this member functionsetMenu(Menu::CharacterDetails);}bool MenuInterface::quitGame() const {// TODO: complete implementationreturn !confirm(“Are you sure you want to quit?”);}void MenuInterface::characterDetailsMenu() const {// TODO: implement this member function._display << “TODO: any key will return to main menu” << std::endl;}void MenuInterface::processCharacterDetails(char selection) {// TODO: implement this member function.setMenu(Menu::Main);}void MenuInterface::displayWeaponDetails() {// TODO: implement this member function}void MenuInterface::actionMenu() const {// TODO: implement this member function._display << “TODO: any key will return to main menu” << std::endl;}void MenuInterface::processAction(char selection) {// TODO: implement this member function.setMenu(Menu::Main);}void MenuInterface::combatMenu() const {// TODO: implement this member function._display << “TODO: any key will return to main menu” << std::endl;}void MenuInterface::processCombatAction(char selection) {// TODO: implement this member function.setMenu(Menu::Main);}void MenuInterface::doNavigate() {// TODO: implement this member function}void MenuInterface::pickupWeapon() {// TODO: implement this member function}void MenuInterface::compareWeapons() {// TODO: implement this member function}void MenuInterface::doAttack() {// TODO: implement this member function}void MenuInterface::useSpecialAbility() {// TODO: implement this member function}void MenuInterface::leaveDungeon() {// TODO: implement this member function}bool MenuInterface::confirm(const std::string &confirmationPrompt) const {// TODO: implement this member function.// Do not forget to validate the user’s confirmation selectionreturn true;}#include “room.h”using namespace core::dungeon;Room::Room(int id): _id{id}{}int Room::id() {return _id;}#include “testing.h”#include “basicdungeon.h”#include “character.h”#include “commondungeon.h”#include “creatures.h”#include “csvfile.h”#include “door.h”#include “dungeon.h”#include “game.h”#include “weapons.h”#include “magicaldungeon.h”#include “room.h”#include “wall.h”#include
#include
#include
#include #include
#include

/*
* IMPLEMENT your tests in this file as required.
*
* You may need to edit the original test implementations as you implement your design.
* The original test implementations are just simple examples that do not necessarily
* reflect the final application.
*/

using namespace core;
using namespace data;
using namespace dungeon;
using namespace creatures;
using std::cout;
using std::endl;
using std::setw;

void Testing::runTests() {
cout << std::left << std::setfill(‘.’);csvFileTestSuite(); // Runs all of the CsvFile testscout << setw(72) << “Character class tests ” << testCharacter()<< endl;cout << setw(72) << “Creature class tests “<< testCreature() << endl;cout << setw(72) << “Door class tests “<< testDoor() << endl;cout << setw(72) << “Dungeon class tests ” << testDungeon()<< endl;cout << setw(72) << “Game class tests “<< testGame() << endl;cout << setw(72) << “Weapon class tests “<< testWeapon() << endl;cout << setw(72) << “Room class tests “<< testRoom() << endl;cout << setw(72) << “Wall class tests “<< testWall() << endl;}// This is an example of a simple way of performing your tests.// It is incomplete, so you will need to extend it if you intend to continue with it.std::string Testing::testCharacter() {_failure = false; // ensure this is at the beggining of each teststd::string name{“Character Name”};Character c{name};equal (name, c.name(), “Character .name() does not match constructor value”);

// TODO: complete the testing of the Character class

return passFailText();
}

std::string Testing::testCreature() {
_failure = false; // ensure this is at the beggining of each test

std::string name{“Creature Name”};

Creature c{name};

equal (name, c.name(), “Creature .name() does not match constructor value”);

// TODO: complete the testing of the Creature class(es): can be removed

return passFailText();
}
std::string Testing::testDoor() {
_failure = false; // ensure this is at the beggining of each test

// TODO: complete the testing of the Door class(es): can be removed

//return passFailText();
return “Skipped”;
}
std::string Testing::testDungeon() {
_failure = false; // ensure this is at the beggining of each test

int roomId{1};
std::shared_ptr room{std::make_shared (roomId)};

Dungeon dungeon{};

dungeon.addRoom(room);
equal(room, dungeon.retrieveRoom(roomId), “Dungeon .add/.retrieveRoom() failure, does not return room that was added”);

// TODO: complete the testing of the Dungeon class(es): can be removed

//return passFailText();
return “Skipped”;
}

std::string Testing::testGame() {
_failure = false;

Game game{};

// TODO: implement the testing of the Game class

// The following tests the random number generation.
int value{game.randomIntBetweenInc(5, 0)};
greaterThan(-1, value, “Swapping the min and max (incl.) did not work. Got negative value.”);
lessThan(6, value, “Swapping the min and max (incl.) did not work. value out of range.”);

value = game.randomIntBetweenEx(5, 0);
greaterThan(-1, value, “Swapping the min and max (excl.) did not work. Got negative value.”);
lessThan(5, value, “Swapping the min and max (excl.) did not work. value out of range.”);

for (int i{0}; i < 1000; ++i) {// Not really a good test for this, but just in case.int value = game.randomIntBetweenInc(2, 5);greaterThan(1, value, “Game .randomIntBetweenInc somehow generated a value out of range”);lessThan(6, value, “Game .randomIntBetweenInc somehow generated a value out of range”);}for (int i{0}; i < 1000; ++i) {// Not really a good test for this, but just in case.int value = game.randomIntBetweenEx(2, 5);greaterThan(1, value, “Game .randomIntBetweenEx somehow generated a value out of range”);lessThan(5, value, “Game .randomIntBetweenEx somehow generated a value out of range”);}for (int i{0}; i < 1000; ++i) {// Not really a good test for this, but just in case.double value = game.randomDouble();double tinyValueBelow1{std::nextafter(0.0, std::numeric_limits ::min())};
greaterThan(tinyValueBelow1, value, “Game .randomDouble somehow generated a value out of range”);
lessThan(1.0, value, “Game .randomDouble somehow generated a value out of range”);
}

return passFailText();
}

std::string Testing::testWeapon() {
_failure = false; // ensure this is at the beggining of each test

// TODO: complete the testing of the Item class(es): can be removed

//return passFailText();
return “Skipped”;
}

std::string Testing::testRoom() {
_failure = false;

int roomId{1};

Room room{roomId};

equal(roomId, room.id(), “Room .id() does not match constructor value”);

// TODO: complete the testing of the Character class

return passFailText();
}

std::string Testing::testWall() {
_failure = false; // ensure this is at the beggining of each test

// TODO: complete the testing of the Wall class(es): can be removed

//return passFailText();
return “Skipped”;
}

// TODO: implement the rest of your tests here

// CsvFile tests: Do NOT modify! (except in the following suggestion)
// It is recommended that you perform the following:
// – Comment out all but the first test.
// – Once the first test passes, activate the second while leaving the first
// test active.
// – Once the second test passes, move to the third test, etc.
// Doing it this way will incrementally build up the functionality of your
// CsvFile class while ensuring all of the previous tests still pass as you
// make changes to your implementation.
void Testing::csvFileTestSuite()
{
cout << setw(72) << “CsvFile: Test Empty CSV file ” << testLoadFailureForEmptyCsvFile() << endl;cout << setw(72) << “CsvFile: Test CSV file with Header but no rows ” << testLoadSuccessForHeaderButNoDataCsvFile() << endl;cout << setw(72) << “CsvFile: Test Out of Range Returns Empty string ” << testOutOfRangeReturnsEmptyString() << endl;cout << setw(72) << “CsvFile: Test Correct Header Fields read in ” << testHeaderFieldsCorrectlyRead() << endl;cout << setw(72) << “CsvFile: Test Correct Row data read in and accessible ” << testCommaSeparatedRowDataAccessible() << endl;cout << setw(72) << “CsvFile: Test Multi-Row CSV data is accessible ” << testMultipleRowsOfData() << endl;cout << setw(72) << “CsvFile: Test Load failure for differing number of columns ” << testLoadFailureOnRowWithDifferingNumberOfColumns() << endl;cout << setw(72) << “CsvFile: Test preservation of whitespace in fields ” << testPreservationOfWhitespaceInFields() << endl;cout << setw(72) << “CsvFile: Test line endings of last line ” << testLineEndingOnLastLine() << endl;cout << setw(72) << “CsvFile: Test double quoted fields (no internal quotes) ” << testDoubleQuotedFields() << endl;cout << setw(72) << “CsvFile: Test double quoted fields (mixed some quoted,some not) ” << testDoubleQuotedFieldsMixedWithUnquoted() << endl;cout << setw(72) << “CsvFile: Test replace of ‘\n’ with newline character in quoted fields ” << testReplacementOfBlackslashNInQuotedFieldsWithNewline() << endl;cout << setw(72) << “CsvFile: Test double quotes within fields ” << testDoubleQuotesWithinFields() << endl;cout << setw(72) << “CsvFile: Test putting it all together, load sample creature file ” << testReadingCsvDataFromFile() << endl;}std::string Testing::testLoadFailureForEmptyCsvFile(){std::stringstream data{“”};CsvFile csvFile{data};equal(-1, csvFile.numberOfRows(), “numberOfRows() must indicate load failure for empty input data”);equal(-1, csvFile.numberOfColumns(), “numberOfColumns() must indicate load failure for empty input data”);equal (“”, csvFile.at(1, 1), “at(int,int) must return empty string for empty input data”);
equal (“”, csvFile.headerAt(1), “headerAt(int) must return empty string for empty input data”);
equal(-1, csvFile.columnIndexOf(“Name”), “columnIndexOf(string) must return -1 for empty input data”);

return passFailText();
}

std::string Testing::testLoadSuccessForHeaderButNoDataCsvFile()
{
std::stringstream data{“Header”};
CsvFile csvFile{data};

equal(0, csvFile.numberOfRows(), “numberOfRows() must indicate the number of rows in the data for successful load”);
equal(1, csvFile.numberOfColumns(), “numberOfColumns() must indicate the number of columns for successful load”);
equal (“”, csvFile.at(1, 1), “at(int,int) must return empty string for empty no rows (out of range)”);
equal (“Header”, csvFile.headerAt(1), “headerAt(int) must return the column name for successful load”);
equal(1, csvFile.columnIndexOf(“Header”), “columnIndexOf(string) must return index for for successful load”);

return passFailText();
}

std::string Testing::testOutOfRangeReturnsEmptyString()
{
std::stringstream data{R”:(Header1,Header2
Cell 1,Cell 2
):”};
CsvFile csvFile{data};

equal (“”, csvFile.headerAt(3), “headerAt() must return empty string when index out of range”);
equal (“”, csvFile.headerAt(0), “headerAt() must return empty string when index out of range (zero is out of range)”);
equal (“”, csvFile.at(2,1), “at() must return empty string when row index out of range”);
equal (“”, csvFile.at(0,1), “at() must return empty string when row index out of range (zero is out of range)”);
equal (“”, csvFile.at(1,3), “at() must return empty string when column index out of range”);
equal (“”, csvFile.at(1,0), “at() must return empty string when column index out of range (zero is out of range)”);

returnpassFailText();
}

std::string Testing::testHeaderFieldsCorrectlyRead()
{
std::stringstream data{R”:(Header1,Header2,Header3):”};
CsvFile csvFile{data};

equal(0, csvFile.numberOfRows(), “numberOfRows() must indicate zero, as only the header is present”);
equal(3, csvFile.numberOfColumns(), “numberOfColumns() must indicate 3 columns for the three header fields”);
equal (“Header1”, csvFile.headerAt(1), “headerAt(1) must return the first header field”);
equal (“Header2”, csvFile.headerAt(2), “headerAt(2) must return the second header field”);
equal (“Header3”, csvFile.headerAt(3), “headerAt(3) must return the third header field”);

return passFailText();
}

std::string Testing::testCommaSeparatedRowDataAccessible()
{
std::stringstream data{R”:(Header1,Header2,Header3
Field1,Field2,Field3):”};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must indicate 1, as the header + 1 row is present”);
equal(3, csvFile.numberOfColumns(), “numberOfColumns() must indicate 3 columns for the three fields”);
equal (“Field1”, csvFile.at(1,1), “at(1,1) must return the first field of the first row”);
equal (“Field2”, csvFile.at(1,2), “at(1,2) must return the second field of the first row”);
equal (“Field3”, csvFile.at(1,3), “at(1,3) must return the third field of the first row”);

return passFailText();
}

std::string Testing::testMultipleRowsOfData()
{
std::stringstream data{R”:(Header1,Header2,Header3
Row1Field1,Row1Field2,Row1Field3
Row2Field1,Row2Field2,Row2Field3
Row3Field1,Row3Field2,Row3Field3):”};
CsvFile csvFile{data};

equal(3, csvFile.numberOfRows(), “numberOfRows() must indicate 3, as the header + 3 rows are present”);
equal(3, csvFile.numberOfColumns(), “numberOfColumns() must indicate 3 columns for the three fields”);

equal (“Row1Field1”, csvFile.at(1,1), “at(1,1) must return the first field of the first row”);
equal (“Row1Field2”, csvFile.at(1,2), “at(1,2) must return the second field of the first row”);
equal (“Row1Field3”, csvFile.at(1,3), “at(1,3) must return the third field of the first row”);

equal (“Row2Field1”, csvFile.at(2,1), “at(2,1) must return the first field of the second row”);
equal (“Row2Field2”, csvFile.at(2,2), “at(2,2) must return the second field of the second row”);
equal (“Row2Field3”, csvFile.at(2,3), “at(2,3) must return the third field of the second row”);

equal (“Row3Field1”, csvFile.at(3,1), “at(3,1) must return the first field of the third row”);
equal (“Row3Field2”, csvFile.at(3,2), “at(3,2) must return the second field of the third row”);
equal (“Row3Field3”, csvFile.at(3,3), “at(3,3) must return the third field of the third row”);

return passFailText();
}

std::string Testing::testLoadFailureOnRowWithDifferingNumberOfColumns()
{
std::stringstream dataExtraColumnInRow{R”:(Header1,Header2
Field1,Field2,Field3Error):”};
CsvFile csvFile{dataExtraColumnInRow};

equal(-1, csvFile.numberOfRows(), “numberOfRows() must indicate load failure for row with extra column”);
equal(-1, csvFile.numberOfColumns(), “numberOfColumns() must indicate load failure for row with extra column”);

std::stringstream dataMissingColumnInRow{R”:(Header1,Header2
Field1):”};
csvFile = CsvFile{dataMissingColumnInRow};

equal(-1, csvFile.numberOfRows(), “numberOfRows() must indicate load failure for row with missing column”);
equal(-1, csvFile.numberOfColumns(), “numberOfColumns() must indicate load failure for row with missing column”);

return passFailText();
}

std::string Testing::testPreservationOfWhitespaceInFields()
{
std::stringstream data{”Header1,Header2,Header3,Header4,Header5,Header6
”
”Field1,Field2,Field3,Field4,Field5,Field6“};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must be 1 for whitespace test”);
equal(6, csvFile.numberOfColumns(), “numberOfColumns() must be 6 for whitespace test”);

equal (”Header1″, csvFile.headerAt(1), “headerAt(1) must preserve whitespace at line beginning”);
equal (”Header2″, csvFile.headerAt(2), “headerAt(2) must preserve whitespace after comma”);
equal (“Header3“, csvFile.headerAt(3), “headerAt(3) must preserve whitespace before comma”);
equal (“Header4”, csvFile.headerAt(4), “headerAt(4) must preserve internal whitespace”);
equal (”Header5“, csvFile.headerAt(5), “headerAt(5) must preserve all whitespace”);
equal (“Header6“, csvFile.headerAt(6), “headerAt(6) must preserve whitespace at line end”);

equal (”Field1″, csvFile.at(1,1), “at(1, 1) must preserve whitespace at line beginning”);
equal (”Field2″, csvFile.at(1,2), “at(1, 2) must preserve whitespace after comma”);
equal (“Field3“, csvFile.at(1, 3), “at(1, 3) must preserve whitespace before comma”);
equal (“Field4”, csvFile.at(1, 4), “at(1, 4) must preserve internal whitespace”);
equal (”Field5“, csvFile.at(1, 5), “at(1, 5) must preserve all whitespace”);
equal (“Field6“, csvFile.at(1,6), “at(1, 6) must preserve whitespace at line end”);

return passFailText();
}

std::string Testing::testLineEndingOnLastLine()
{
std::stringstream data{R”:(Header1
Field1):”};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must be 1 for line ending test, without extra CRLF”);
equal(1, csvFile.numberOfColumns(), “numberOfColumns() must be 1 for line ending test, without extra CRLF”);

data = std::stringstream{R”:(Header1
Field1
):”};
csvFile = CsvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must be 1 for line ending test, WITH extra CRLF”);
equal(1, csvFile.numberOfColumns(), “numberOfColumns() must be 1 for line ending test, WITH extra CRLF”);

return passFailText();
}

std::string Testing::testDoubleQuotedFields()
{
std::stringstream data{R”:(“Header,1″,”Header,2″,”Header,3″,”Header4”
“Field,1″,”Field,2″,”Field,3″,”Field4“):”};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must indicate 1, as the header + 1 row is present (double quote test)”);
equal(4, csvFile.numberOfColumns(), “numberOfColumns() must indicate 4 columns for the four fields (double quote test)”);

equal (“Header,1”, csvFile.headerAt(1), “headerAt(1) must return the first header without quotes”);
equal (“Header,2”, csvFile.headerAt(2), “headerAt(2) must return the second header without quotes”);
equal (“Header,3”, csvFile.headerAt(3), “headerAt(3) must return the third header without quotes”);
equal (”Header4“, csvFile.headerAt(4), “headerAt(4) must return the fourth header without quotes, preserving whitespace”);

equal (“Field,1”, csvFile.at(1,1), “at(1,1) must return the first field without quotes”);
equal (“Field,2”, csvFile.at(1,2), “at(1,2) must return the second field without quotes”);
equal (“Field,3”, csvFile.at(1,3), “at(1,3) must return the third field without quotes”);
equal (”Field4“, csvFile.at(1,4), “at(1,4) must return the fourth field without quotes, preserving whitespace”);

data = std::stringstream{R”:( “Header1”
“Field1″):”};
csvFile = CsvFile{data};

equal(-1, csvFile.numberOfRows(), “numberOfRows() must indicate load failure for whitespace outside double quotes (before quote)”);
equal(-1, csvFile.numberOfColumns(), “numberOfColumns() must indicate load failure for whitespace outside double quotes (before quote)”);

data = std::stringstream{R”:(“Header1”,Header2
“Field1″,Field2):”};
csvFile = CsvFile{data};

equal(-1, csvFile.numberOfRows(), “numberOfRows() must indicate load failure for whitespace outside double quotes (after quote)”);
equal(-1, csvFile.numberOfColumns(), “numberOfColumns() must indicate load failure for whitespace outside double quotes (after quote)”);

return passFailText();
}

std::string Testing::testDoubleQuotedFieldsMixedWithUnquoted()
{
std::stringstream data{R”:(“Header,1″,Header2,”Header,3”,Header4
“Field,1″,Field2,”Field,3″,Field4):”};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must indicate 1, as the header + 1 row is present (mixed test)”);
equal(4, csvFile.numberOfColumns(), “numberOfColumns() must indicate 4 columns for the three fields (mixed test)”);

equal (“Header,1”, csvFile.headerAt(1), “headerAt(1) must return the first header without quotes (mixed test)”);
equal (“Header2”, csvFile.headerAt(2), “headerAt(2) must return the second header without quotes (mixed test)”);
equal (“Header,3”, csvFile.headerAt(3), “headerAt(3) must return the third header without quotes (mixed test)”);
equal (“Header4”, csvFile.headerAt(4), “headerAt(4) must return the fourth header without quotes (mixed test)”);

equal (“Field,1”, csvFile.at(1,1), “at(1,1) must return the first field without quotes (mixed test)”);
equal (“Field2”, csvFile.at(1,2), “at(1,2) must return the second field without quotes (mixed test)”);
equal (“Field,3”, csvFile.at(1,3), “at(1,3) must return the third field without quotes (mixed test)”);
equal (“Field4”, csvFile.at(1,4), “at(1,4) must return the fourth field without quotes (mixed test)”);

return passFailText();
}

std::string Testing::testReplacementOfBlackslashNInQuotedFieldsWithNewline()
{
std::stringstream data{R”:(“Header
1″,”He
ader
2”,Header
3
“Field
1″,”Fi
eld
2″,Field
3):”};
CsvFile csvFile{data};

equal (“Header
1”, csvFile.headerAt(1), “headerAt(1) must return the first header with ‘\n’ replaced with newline”);
equal (“He
ader
2”, csvFile.headerAt(2), “headerAt(2) must return the second header with ‘\n’ replaced with newline”);
equal (“Header\n3”, csvFile.headerAt(3), “headerAt(3) must return the thord header WITHOUT ‘\n’ replaced with newline, since it is unquoted”);

equal (“Field
1”, csvFile.at(1,1), “at(1,1) must return the first field with ‘\n’ replaced with newline”);
equal (“Fi
eld
2”, csvFile.at(1,2), “at(1,2) must return the second field with ‘\n’ replaced with newline”);
equal (“Field\n3”, csvFile.at(1,3), “at(1,3) must return the third field WITHOUT ‘\n’ replaced with newline, since it is unquoted”);

return passFailText();
}

std::string Testing::testDoubleQuotesWithinFields()
{
std::stringstream data{R”:(“Header””1”
“Field””1″):”};
CsvFile csvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must indicate 1, as the header + 1 row is present (double quote test)”);
equal(1, csvFile.numberOfColumns(), “numberOfColumns() must indicate 4 columns for the three fields (double quote test)”);

equal (“Header”1”, csvFile.headerAt(1), “headerAt(1) must return the first header with internal quotes maintained, no outer quotes”);
equal (“Field”1”, csvFile.at(1,1), “at(1,1) must return the first field with internal quotes maintained, no outer quotes”);

data = std::stringstream{R”:(“Header””,””1″
“Field””,””1″):”};
csvFile = CsvFile{data};

equal(1, csvFile.numberOfRows(), “numberOfRows() must indicate 1, as the header + 1 row is present (double quote test with comma)”);
equal(1, csvFile.numberOfColumns(), “numberOfColumns() must indicate 4 columns for the three fields (double quote test with comma)”);

equal (“Header”,”1″, csvFile.headerAt(1), “headerAt(1) must return the first header with internal quotes maintained, no outer quotes, and internal commas preserved”);
equal (“Field”,”1″, csvFile.at(1,1), “at(1,1) must return the first field with internal quotes maintained, no outer quotes, and internal commas preserved”);

return passFailText();
}

std::string Testing::testReadingCsvDataFromFile()
{
std::ifstream dataFile{“creature_types_sample.csv”};
CsvFile csvFile{dataFile};
dataFile.close(); // Ensure you close the file stream after loading the data

equal(3, csvFile.numberOfRows(), “numberOfRows() the example file contains three rows”);
equal(8, csvFile.numberOfColumns(), “numberOfColumns() the example file contains 8 columns”);

equal (“Maximum Health”, csvFile.headerAt(1), “First column of creature file must be Maximum Health”);
equal (“Name”, csvFile.headerAt(2), “Second column of creature file must be Name”);
equal (“Description”, csvFile.headerAt(3), “Third column of creature file must be Description”);
equal (“Strength”, csvFile.headerAt(4), “Fourth column of creature file must be Strength”);
equal (“Dexterity”, csvFile.headerAt(5), “Fifth column of creature file must be Dexterity”);
equal (“Wisdom”, csvFile.headerAt(6), “Sixth column of creature file must be Wisdom”);
equal (“Weapon”, csvFile.headerAt(7), “Seventh column of creature file must be Weapon”);
equal (“Dungeon Type”, csvFile.headerAt(8), “Eighth column of creature file must be Dungeon Type”);

equal (“20”, csvFile.at(1,1), “First creature must have 20 Maximum Health”);
equal (“Goblin”, csvFile.at(1,2), “First creature must be named Goblin”);
equal (“a small nimble creature who favours the short sword”, csvFile.at(1,3), “First creature has the wrong Description”);
equal (“2”, csvFile.at(1,4), “First creature must have 2 Strength”);
equal (“4”, csvFile.at(1,5), “First creature must have 4 Dexterity”);
equal (“1”, csvFile.at(1,6), “First creature must have 1 Wisdom”);
equal (“ShortSword”, csvFile.at(1,7), “First creature must have a ShortSword Weopn”);
equal (“All”, csvFile.at(1,8), “First creature must have be for All Dungeon Type”);

equal (“30”, csvFile.at(2,1), “Second creature must have 20 Maximum Health”);
equal (“Werewolf”, csvFile.at(2,2), “Second creature must be named Werewolf”);
equal (“glowing red eyes peer our from behind a long nose and sharp teeth”, csvFile.at(2,3), “Second creature has the wrong Description”);
equal (“5”, csvFile.at(2,4), “Second creature must have 5 Strength”);
equal (“2”, csvFile.at(2,5), “Second creature must have 2 Dexterity”);
equal (“1”, csvFile.at(2,6), “Second creature must have 1 Wisdom”);
equal (“Fists”, csvFile.at(2,7), “Second creature must have a Fists Weapon”);
equal (“BasicDungeon”, csvFile.at(2,8), “Second creature must have be for Basic Dungeon Type”);

equal (“20”, csvFile.at(3,1), “Third creature must have 20 Maximum Health”);
equal (“Evil Wizard”, csvFile.at(3,2), “Third creature must be named Evil Wizard”);
equal (“cackling over an old tome, this wizard seems insanely evil;
or maybe just insane? it is hard to tell”, csvFile.at(3,3), “Third creature has the wrong Description”);
equal (“1”, csvFile.at(3,4), “Third creature must have 1 Strength”);
equal (“2”, csvFile.at(3,5), “Third creature must have 2 Dexterity”);
equal (“5”, csvFile.at(3,6), “Third creature must have 5 Wisdom”);
equal (“WizardsStaff”, csvFile.at(3,7), “Third creature must have a WizardsStaff”);
equal (“MagicalDungeon”, csvFile.at(3,8), “Third creature must have be for Magical Dungeon Type”);

return passFailText();
}
#include “wall.h”

using namespace core::dungeon;

Wall::Wall()
{

}
#include “game.h”
#include “weapons.h”
#include
#include

using namespace core::weapons;

/* ——————————————————————————
* Weapon member implementations
* —————————————————————————–*/

Weapon::Weapon()
{

}

Fists::Fists()
{

}

Boomerang::Boomerang()
{

}

ShortSword::ShortSword()
{

}

BattleAxe::BattleAxe()
{

}

WizardsStaff::WizardsStaff()
{

}

MagicWand::MagicWand()
{

}

/* ——————————————————————————
* Enchantment member implementations
* —————————————————————————–*/

Enchantment::Enchantment()
{

}

FlameEnchantment::FlameEnchantment()
{

}

ElectricityEnchantment::ElectricityEnchantment()
{

}

HealingEnchantment::HealingEnchantment()
{

}

VampirismEnchantment::VampirismEnchantment()
{

}
#ifndef BASICDUNGEON_H
#define BASICDUNGEON_H
#include “commondungeon.h”

namespace core {
namespace dungeon {

// TODO: define component classes spcific to the BasicDungeon type

/**
* @brief TODO The BasicDungeon class
*/
class BasicDungeon
{
public:
BasicDungeon();
};

/**
* @brief TODO The RockChamber class
*/
class RockChamber
{
public:
RockChamber();
};

/**
* @brief TODO The QuartzChamber class
*/
class QuartzChamber
{
public:
QuartzChamber();
};

/**
* @brief TODO The BasicWall class
*/
class RockWall
{
public:
RockWall();
};

} // namespace dungeon
} // namespace core

#endif // BASICDUNGEON_H
#ifndef CHARACTER_H
#define CHARACTER_H
#include

namespace core {

// TODO: define Character class.
// There is some example code in here, but it can be modified if desired.

/**
* @brief TODO The Complete the Character class, following is just a small example
*/
class Character
{
public:
Character(const std::string &name);

const std::string& name() const;

private:
std::string _name;
};

} // namespace core

std::ostream& operator<<(std::ostream &stream, const core::Character &character);#endif // CHARACTER_H#ifndef COMMONDUNGEON_H#define COMMONDUNGEON_H#include “dungeon.h”#include “room.h”#include “wall.h”#include “door.h”namespace core {namespace dungeon {// TODO: define concrete components classes common to all dungeon types/** * @brief TODO The OpenDoorway class */class OpenDoorway{public:OpenDoorway();};} // namespace dungeon} // namespace core#endif // COMMONDUNGEON_H#ifndef CREATURE_H#define CREATURE_H#include

namespace core {
namespace creatures {

// TODO: define Creature class and the its concrete subclasses.
// There is some example code in here, but it can be modified if desired.

/**
* @brief TODO The Creature class
*/
class Creature
{
public:
Creature(const std::string &name);

const std::string& name() const;

private:
std::string _name;
};

} // namespace creatures
} // namespace core

#endif // CREATURE_H
#ifndef CSVFILE_H
#define CSVFILE_H

#include
#include

namespace data {

/**
* @brief The CsvFile class reads CSV data from a stream and makes it
* available to the application on a read-only basis.
*
* CSV Files contain tabular data in rows and columns according to the
* format defined by RFC 4180 [https://tools.ietf.org/html/rfc4180].
* (Ignore the requirement for fields contianign CRLF. We can assume
* that there are no CRLF in the input files.)
*
* The data is accessed through a simple inteface using row and column
* indices, both of which start at 1 (not zero). The interface also
* provides access to the header data, i.e., the column names.
*
* The CSV data is loaded in the constructor, from an input stream.
* This allows the data to be read from file or any other source connected
* to a stream.
*
* You will need to implement this class according to the provided interface.
* There is a set of tests provided in ‘testing.cpp’ for you to check that
* your implementation conforms. Be sure to enable testing in ‘testingsettings.h’
* to run the test suite and check your implementation.
*/
class CsvFile
{
public:
/**
* @brief CsvFile constructor, initialises internal data structures
* with CSV content from the input stream.
*
* Assumes the first row is a header row. If the input contains no
* content, the CsvFile is considered to have failed to load.
*
* @param input the stream from which to read the data
*/
CsvFile(std::istream &input);

/**
* @brief numberOfColumns Returns the number of columns in the CSV file,
* or -1 if the data failed to load.
*
* @return number of columns or -1
*/
int numberOfColumns() const;

/**
* @brief numberOfRows returns the number of rows in the CSV file,
* or -1 if the data failed to load.
*
* The header row is NOT included in the count of rows.
*
* @return number of rows or -1
*/
int numberOfRows() const;

/**
* @brief at Returns the content of the cell at the given row, column.
*
* Row indices start at 1, column indices start at 1.
* Returns an empty string if the CSV file failed to load or if row/column
* is out of range.
*
* @param row the row from which to retrieve the data
* @param column the column from whcih to retrieve the data
* @return the cell data at row, column
*/
std::string at(int row, int column) const;

/**
* @brief headerAt Returns the column name at the given index.
*
* Column indices start at 1.
* Returns an empty string if the CSV file failed to load or if column
* is out of range.
*
* @param column the index of the column
* @return the column name
*/
std::string headerAt(int column) const;

/**
* @brief columnIndexOf Returns the column index for the given column name.
*
* Returns -1 if the CSV file faild to load.
* Column indices start at 1.
*
* @param columnName the name of the column
* @return the index of the named column, or -1
*/
int columnIndexOf(const std::string &columnName) const;
};

} // namespace data

#endif // CSVFILE_H
#ifndef DOOR_H
#define DOOR_H

namespace core {
namespace dungeon {

/**
* @brief TODO The Door class
*/
class Door
{
public:
Door();
};

} // namespace dungeon
} // namespace core

#endif // DOOR_H
#ifndef DUNGEON_H
#define DUNGEON_H
#include “room.h”
#include