Question
//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**
//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.
*/
Step by Step Solution
There are 3 Steps involved in it
Step: 1
Get Instant Access to Expert-Tailored Solutions
See step-by-step solutions with expert insights and AI powered tools for academic success
Step: 2
Step: 3
Ace Your Homework with AI
Get the answers you need in no time with our AI-driven, step-by-step assistance
Get Started