//Ifgqueue.h

#ifndef LFGQUEUE_H #define LFGQUEUE_H

#include "player.h"

class LFGQueue { public: LFGQueue(); void add_player(Player* p); bool remove_next_party(Player** players); int player_count(); int position(Player* p);

private: Player** players; int count; int capacity; };

#endif

//*******************************************************************************************

//main.cpp

#include #include #include #include "lfgqueue.h"

using namespace std;

int main() { Player* group[3]; Player daria("Daria", Player::Defender); Player daniela("Daniela", Player::Defender); Player hector("Hector", Player::Hunter); Player hugo("Hugo", Player::Hunter); Player berta("Berta", Player::Bard); Player bernardo("Bernardo", Player::Bard);

LFGQueue q; cout << "5\% earned." << endl;

// Test when queue contains a single complete party // in the desired order (Defender, Hunter, Bard) q.add_player(&daniela); assert(q.position(&daniela) == 1); assert(q.position(&hector) == -1); assert(q.position(&berta) == -1); assert(q.player_count() == 1); cout << "10\% earned." << endl;

q.add_player(&hector); assert(q.position(&daniela) == 1); assert(q.position(&hector) == 2); assert(q.position(&berta) == -1); assert(q.player_count() == 2); q.add_player(&berta); assert(q.position(&daniela) == 1); assert(q.position(&hector) == 2); assert(q.position(&berta) == 3); assert(q.player_count() == 3); cout << "20\% earned." << endl;

group[0] = group[1] = group[2] = 0; assert(q.remove_next_party(group)); cout << "25\% earned." << endl;

assert(group[0] == &daniela); assert(group[0]->name == "Daniela"); assert(group[0]->role == Player::Defender); assert(group[1] == &hector); assert(group[1]->name == "Hector"); assert(group[1]->role == Player::Hunter); assert(group[2] == &berta); assert(group[2]->name == "Berta"); assert(group[2]->role == Player::Bard); assert(q.player_count() == 0); cout << "35\% earned." << endl;

// Test when queue contains a single complete party in // in an undesired order (Bard, Hunter, Defender) q.add_player(&bernardo); q.add_player(&hugo); q.add_player(&daria); assert(q.player_count() == 3); assert(q.position(&bernardo) == 1); assert(q.position(&hugo) == 2); assert(q.position(&daria) == 3);

group[0] = group[1] = group[2] = 0; assert(q.remove_next_party(group));

assert(group[0] == &daria); assert(group[0]->name == "Daria"); assert(group[0]->role == Player::Defender); assert(group[1] == &hugo); assert(group[1]->name == "Hugo"); assert(group[1]->role == Player::Hunter); assert(group[2] == &bernardo); assert(group[2]->name == "Bernardo"); assert(group[2]->role == Player::Bard); assert(q.player_count() == 0); cout << "40\% earned." << endl;

// Test what happens when not enough plaers for a group group[0] = group[1] = group[2] = 0; assert(!q.remove_next_party(group)); assert(group[0] == 0); assert(group[1] == 0); assert(group[2] == 0); cout << "50\% earned." << endl; // Test what happens when two full groups of players // in an undesired order (Def, Hunt, Hunt, Bard, Bard, Def) q.add_player(&daria); q.add_player(&hector); q.add_player(&hugo); q.add_player(&bernardo); q.add_player(&berta); q.add_player(&daniela); assert(q.player_count() == 6); assert(q.position(&daria) == 1); assert(q.position(&hector) == 2); assert(q.position(&hugo) == 3); assert(q.position(&bernardo) == 4); assert(q.position(&berta) == 5); assert(q.position(&daniela) == 6);

group[0] = group[1] = group[2] = 0; assert(q.remove_next_party(group)); assert(group[0] == &daria); assert(group[1] == &hector); assert(group[2] == &bernardo); assert(q.player_count() == 3); assert(q.position(&hugo) == 1); assert(q.position(&berta) == 2); assert(q.position(&daniela) == 3);

group[0] = group[1] = group[2] = 0; assert(q.remove_next_party(group)); assert(group[0] == &daniela); assert(group[1] == &hugo); assert(group[2] == &berta); assert(q.player_count() == 0); group[0] = group[1] = group[2] = 0; assert(!q.remove_next_party(group)); assert(group[0] == 0); assert(group[1] == 0); assert(group[2] == 0); cout << "65\% earned." << endl;

// Stress test 1: make a queue with 3000 group. // 1000xBard, 1000xDefender, 1000xHunter. ostringstream oss; for (int i = 0; i < 1000; ++i) { oss.str(""); oss << "Bard_" << i+1; q.add_player(new Player(oss.str(), Player::Bard)); } assert(q.player_count() == 1000); group[0] = group[1] = group[2] = 0; assert(!q.remove_next_party(group)); assert(group[0] == 0); assert(group[1] == 0); assert(group[2] == 0);

for (int i = 0; i < 1000; ++i) { oss.str(""); oss << "Hunter_" << i+1; q.add_player(new Player(oss.str(), Player::Hunter)); } assert(q.player_count() == 2000); group[0] = group[1] = group[2] = 0; assert(!q.remove_next_party(group)); assert(group[0] == 0); assert(group[1] == 0); assert(group[2] == 0);

for (int i = 0; i < 1000; ++i) { oss.str(""); oss << "Defender_" << i+1; q.add_player(new Player(oss.str(), Player::Defender)); } assert(q.player_count() == 3000);

for (int i = 0; i < 1000; ++i) { group[0] = group[1] = group[2] = 0; assert(q.remove_next_party(group));

oss.str(""); oss << "Defender_" << i+1; assert(group[0]->name == oss.str()); assert(group[0]->role == Player::Defender);

oss.str(""); oss << "Hunter_" << i+1; assert(group[1]->name == oss.str()); assert(group[1]->role == Player::Hunter);

oss.str(""); oss << "Bard_" << i+1; assert(group[2]->name == oss.str()); assert(group[2]->role == Player::Bard);

delete group[0]; delete group[1]; delete group[2];

assert(q.player_count() == 3000 - (i + 1) * 3); } cout << "85\% earned." << endl; // Stress test 2: make a queue with 1000001 group. // 999999xHunter, 1xBard, 1xDefender. for (int i = 0; i < 999999; ++i) { oss.str(""); oss << "AnonHunter_" << i+1; q.add_player(new Player(oss.str(), Player::Hunter)); } assert(q.player_count() == 999999); assert(!q.remove_next_party(group));

q.add_player(new Player("SadBard", Player::Bard)); assert(q.player_count() == 1000000); assert(!q.remove_next_party(group)); q.add_player(new Player("BusyTank", Player::Defender)); assert(q.player_count() == 1000001); assert(q.remove_next_party(group)); assert(q.player_count() == 999998); assert(group[0]->name == "BusyTank"); assert(group[1]->name == "AnonHunter_1"); assert(group[2]->name == "SadBard"); cout << "100\% earned." << endl; }

//************************************************************************

//player.h

#ifndef PLAYER_H #define PLAYER_H

#include

using namespace std;

class Player { public: enum Role {Defender, Hunter, Bard}; Player(string name, Role role) { this->name = name; this->role = role; } string name; Role role; };

#endif

//***************************************************************************

/*

In many multiplayer online games, theres a looking for group feature for being automatically matched with other players. Such a feature behaves like a queue: players join the queue and removed in complete groups, and players who join the queue first are the first to be grouped.

Implement a looking-for-group queue for a game where players can be one of three roles (Defender, Hunter, and Bard) and each group consists of one Defender, one Hunter, and one Bard.

Create a new C++ source file named lfgqueue.cpp that implements the LFGQueue class declared in lfgqueue.h such that main.cpp and lfgqueue.cpp compile into a program that runs with no failed assertions.

*/