Changed GameBoard pointers in Player and DevelopmentCard to references and initialized them. Made the GameBoard initialize the player vector

Databean · Databean · commit 99c8cd5463bf · 2014-04-08T18:57:02.000-05:00
diff --git a/include/Deck.h b/include/Deck.h
@@ -27,7 +27,7 @@ class Deck {
     void reshuffleDeck();
 
 public:
-	Deck();
+	Deck(GameBoard& board);
 	virtual ~Deck();
 
 	int getSize();
diff --git a/include/DevelopmentCard.h b/include/DevelopmentCard.h
@@ -25,9 +25,9 @@ class DevelopmentCard {
 
 protected:
     DevCardType type;
-    GameBoard *board;
+    GameBoard& board;
 public:
-    DevelopmentCard();
+    DevelopmentCard(GameBoard& board);
     virtual ~DevelopmentCard();
 
     virtual DevCardType getType() const = 0;
@@ -42,7 +42,7 @@ class KnightCard : public DevelopmentCard {
 private:
 
 public:
-	KnightCard();
+	KnightCard(GameBoard& board);
 //	virtual ~KnightCard();
 
     virtual DevCardType getType() const;
@@ -54,7 +54,7 @@ class KnightCard : public DevelopmentCard {
 
 class VictoryPointCard : public DevelopmentCard {
 public:
-    VictoryPointCard();
+    VictoryPointCard(GameBoard& board);
 //    virtual ~VictoryPointCard();
 
     virtual DevCardType getType() const;
@@ -64,7 +64,7 @@ class VictoryPointCard : public DevelopmentCard {
 
 class YearOfPlentyCard : public DevelopmentCard {
 public:
-    YearOfPlentyCard();
+    YearOfPlentyCard(GameBoard& board);
 //    virtual ~YearOfPlentyCard();
 
     virtual DevCardType getType() const;
@@ -77,7 +77,7 @@ class YearOfPlentyCard : public DevelopmentCard {
 
 class MonopolyCard : public DevelopmentCard {
 public:
-    MonopolyCard();
+    MonopolyCard(GameBoard& board);
 //    virtual ~MonopolyCard();
 
     virtual DevCardType getType() const;
@@ -91,7 +91,7 @@ class RoadBuildingCard : public DevelopmentCard {
 private:
 
 public:
-	RoadBuildingCard();
+	RoadBuildingCard(GameBoard& board);
 //	virtual ~RoadBuildingCard();
 
     virtual DevCardType getType() const;
diff --git a/include/GameBoard.h b/include/GameBoard.h
@@ -61,8 +61,8 @@ class GameBoard {
     void payoutResources(int roll);
     
 public:
-	GameBoard(std::vector<std::unique_ptr<Player>>&& players);
-	GameBoard(std::vector<std::unique_ptr<Player>>&& players, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations);
+	GameBoard(const std::vector<std::string>& playerNames);
+	GameBoard(const std::vector<std::string>& playerNames, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations);
 	GameBoard(std::istream& in);
 	GameBoard(GameBoard&) = delete;
 	~GameBoard();
diff --git a/include/Player.h b/include/Player.h
@@ -40,7 +40,7 @@ class Player {
     int armySize;
     int longestRoad;
     int victoryPoints;
-    GameBoard *board;
+    GameBoard& board;
     int resources[5];
     int tradeModifiers[5];
 
@@ -49,8 +49,8 @@ class Player {
 
 public:
 
-	Player(std::string playerName);
-	Player(tinyxml2::XMLElement*);
+	Player(GameBoard& board, std::string playerName);
+	Player(GameBoard& board, tinyxml2::XMLElement*);
 	~Player();
 
     int getVictoryPoints();
@@ -64,9 +64,6 @@ class Player {
     void buyCard(std::unique_ptr<DevelopmentCard> card);
     std::string getName() const;
 
-    GameBoard* getBoard();
-    void setBoard(GameBoard* newboard);
-
 //    void playCard(int index);
 //    void playCard(DevelopmentCard* card);
 
diff --git a/src/Deck.cpp b/src/Deck.cpp
@@ -11,32 +11,32 @@
 /**
  * Construct a Deck with the standard cards available in the Settlers of Catan game.
  */
-Deck::Deck()
+Deck::Deck(GameBoard& board)
 {
 	// TODO Auto-generated constructor stub
 	for(int i = 0; i < 15; i++)
 	{
-		DevelopmentCard* card = new KnightCard();
+		DevelopmentCard* card = new KnightCard(board);
 		this->deck.push_back(card);
 	}
 	for(int i = 0; i < 4; i++)
 	{
-		DevelopmentCard* card = new VictoryPointCard();
+		DevelopmentCard* card = new VictoryPointCard(board);
 		this->deck.push_back(card);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new YearOfPlentyCard();
+		DevelopmentCard* card = new YearOfPlentyCard(board);
 		this->deck.push_back(card);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new MonopolyCard();
+		DevelopmentCard* card = new MonopolyCard(board);
 		this->deck.push_back(card);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new RoadBuildingCard();
+		DevelopmentCard* card = new RoadBuildingCard(board);
 		this->deck.push_back(card);
 	}
     
diff --git a/src/DevelopmentCard.cpp b/src/DevelopmentCard.cpp
@@ -12,7 +12,7 @@
 
 
 //Base Class
-DevelopmentCard::DevelopmentCard()
+DevelopmentCard::DevelopmentCard(GameBoard& board) : board(board)
 {
 
 }
@@ -31,7 +31,7 @@ bool DevelopmentCard::operator==(const DevelopmentCard& other) {
 	return getType() == other.getType();
 }
 
-KnightCard::KnightCard():DevelopmentCard()
+KnightCard::KnightCard(GameBoard& board) : DevelopmentCard(board)
 {
 
 }
@@ -43,11 +43,11 @@ DevCardType KnightCard::getType() const {
 void KnightCard::playCard(Player *player, Coordinate target)
 {
     //Call function to play card
-	board->moveRobber(target);
+	board.moveRobber(target);
 }
 
 
-VictoryPointCard::VictoryPointCard():DevelopmentCard()
+VictoryPointCard::VictoryPointCard(GameBoard& board) : DevelopmentCard(board)
 {
 
 }
@@ -58,7 +58,7 @@ DevCardType VictoryPointCard::getType() const {
 
 
 
-YearOfPlentyCard::YearOfPlentyCard():DevelopmentCard()
+YearOfPlentyCard::YearOfPlentyCard(GameBoard& board) : DevelopmentCard(board)
 {
 
 }
@@ -77,7 +77,7 @@ void YearOfPlentyCard::playCard(Player *player, int rType1, int rType2)
 
 
 
-MonopolyCard::MonopolyCard():DevelopmentCard()
+MonopolyCard::MonopolyCard(GameBoard& board) : DevelopmentCard(board)
 {
 
 }
@@ -90,9 +90,9 @@ void MonopolyCard::playCard(Player *player, int rType)
 {
 	int totalResourceCount = 0;
 
-	for(int i=0; i<board->getNoOfPlayers(); i++)
+	for(int i=0; i<board.getNoOfPlayers(); i++)
 	{
-		Player& p = board->getPlayer(i);
+		Player& p = board.getPlayer(i);
 		totalResourceCount += p.getResource(rType);
 		p.addResource(rType, (-1*p.getResource(rType)) );
 	}
@@ -101,7 +101,9 @@ void MonopolyCard::playCard(Player *player, int rType)
 
 
 
-RoadBuildingCard::RoadBuildingCard():DevelopmentCard(){};
+RoadBuildingCard::RoadBuildingCard(GameBoard& board) : DevelopmentCard(board) {
+	
+};
 
 DevCardType RoadBuildingCard::getType() const
 {
@@ -111,10 +113,10 @@ DevCardType RoadBuildingCard::getType() const
 
 
 void RoadBuildingCard::playCard(Player* player, Coordinate start1, Coordinate end1, Coordinate start2, Coordinate end2){
-	if (!board->PlaceRoad(start1, end1, *player)){
+	if (!board.PlaceRoad(start1, end1, *player)){
 		throw std::invalid_argument("The first road passed was not valid, no roads placed");
 	}
-	if ((!board->PlaceRoad(start2, end2, *player))){
+	if ((!board.PlaceRoad(start2, end2, *player))){
 		throw std::invalid_argument("The second road passed was not valid, only the first road was placed");
 	}
 }
diff --git a/src/GameBoard.cpp b/src/GameBoard.cpp
@@ -32,7 +32,11 @@ using std::vector;
  * Board tiles and roll numbers are randomized.
  * @param players A vector of the players playing the game.
  */
-GameBoard::GameBoard(vector<unique_ptr<Player>>&& players) : players(std::move(players)) {
+GameBoard::GameBoard(const vector<std::string>& playerNames) {
+	for(auto& name : playerNames) {
+		players.push_back(std::unique_ptr<Player>(new Player(*this, name)));
+	}
+	
 	std::srand(std::time(0));
 	
 	const static vector<resourceType> boardResources {BRICK, BRICK, BRICK, STONE, STONE, STONE, WHEAT, WHEAT, WHEAT, WHEAT, WOOD, WOOD, WOOD, WOOD, SHEEP, SHEEP, SHEEP, SHEEP};
@@ -104,7 +108,11 @@ void GameBoard::insertTile(Coordinate location, vector<resourceType>& resources,
  * @param resourceLocations A mapping from coordinates to resource types and dice values, representing the tiles.
  * @throws std::runtime_error When the configuration is invalid.
  */
-GameBoard::GameBoard(std::vector<std::unique_ptr<Player>>&& players, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations) : players(std::move(players)) {
+GameBoard::GameBoard(const std::vector<std::string>& playerNames, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations) {
+	for(auto& name : playerNames) {
+		players.push_back(std::unique_ptr<Player>(new Player(*this, name)));
+	}
+	
 	for(auto& resource : resourceLocations) {
 		resources[resource.first] = std::unique_ptr<ResourceTile>(new ResourceTile(*this, resource.first, resource.second.first, resource.second.second));
 	}
@@ -152,7 +160,7 @@ GameBoard::GameBoard(istream& in) {
 	auto playerElements = doc.RootElement()->FirstChildElement("players");
 	if(playerElements) {
 		for(auto playerElement = playerElements->FirstChildElement(); playerElement; playerElement = playerElement->NextSiblingElement()) {
-			unique_ptr<Player> player(new Player(playerElement));
+			unique_ptr<Player> player(new Player(*this, playerElement));
 			players.emplace_back(std::move(player));
 		}
 	}
diff --git a/src/Player.cpp b/src/Player.cpp
@@ -25,9 +25,10 @@ using std::runtime_error;
 
 /**
  * Initialize a player.
+ * @param board The board the player is playing on.
  * @param playerName The name of the player. Should be unique.
  */
-Player::Player(std::string playerName) : name(playerName)
+Player::Player(GameBoard& board, std::string playerName) : name(playerName), board(board)
 {
 	armySize = 0;
 	longestRoad = 0;
@@ -42,9 +43,10 @@ Player::Player(std::string playerName) : name(playerName)
 
 /**
  * Construct a player from a serialized tinyxml2::XMLElement.
+ * @param board The board the player is playing on.
  * @param elem The XMLElement to read data from.
  */
-Player::Player(XMLElement* elem)
+Player::Player(GameBoard& board, XMLElement* elem) : board(board)
 {
 	for(auto& r : resources) {
 		r = 0;
@@ -58,11 +60,11 @@ Player::Player(XMLElement* elem)
 	XMLElement* cardsElement = elem->FirstChildElement("cards");
 	for(auto cardElem = cardsElement->FirstChildElement("card"); cardElem; cardElem = cardElem->NextSiblingElement("card")) {
 		static const map<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>> typeToCard = {
-			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("knight", [this]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new KnightCard()); }),
-			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("victorypoint", [this]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new VictoryPointCard()); }),
-			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("yearofplenty", [this]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new YearOfPlentyCard()); }),
-			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("monopoly", [this]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new MonopolyCard()); }),
-			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("roadbuilding", [this]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new RoadBuildingCard()); }),
+			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("knight", [&board]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new KnightCard(board)); }),
+			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("victorypoint", [&board]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new VictoryPointCard(board)); }),
+			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("yearofplenty", [&board]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new YearOfPlentyCard(board)); }),
+			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("monopoly", [&board]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new MonopolyCard(board)); }),
+			std::pair<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>>("roadbuilding", [&board]() -> std::unique_ptr<DevelopmentCard> { return std::unique_ptr<DevelopmentCard>(new RoadBuildingCard(board)); }),
 		};
 		auto typeIt = typeToCard.find(std::string(cardElem->FirstChildElement("type")->FirstChild()->Value()));
 		if(typeIt == typeToCard.end()) {
@@ -162,23 +164,6 @@ int Player::getVictoryPoints()
     return victoryPoints;
 }
 
-/**
- * The GameBoard that a player is playing on.
- * @return The board.
- */
-GameBoard* Player::getBoard(){
-	return board;
-}
-
-/**
- * Assign the Player to a particular GameBoard.
- * @param newboard The new board they are playing on.
- */
-void Player::setBoard(GameBoard * newboard){
-	board = newboard;
-}
-
-
 /**
  * Acquire a development card.
  * @param card An owning pointer to the card the player acquired.
@@ -206,7 +191,7 @@ void Player::buyCard(std::unique_ptr<DevelopmentCard> card)
 //    if(!std::any_of(developmentCards.begin(), developmentCards.end(), cardTester)) {
 //        return;
 //    }
-//    card->playCard();
+//    card->playCard(board);
 //    if (card->getType() == KNIGHT) {
 //        armySize++;
 //	}
diff --git a/src/main.cpp b/src/main.cpp
@@ -76,15 +76,13 @@ int main(int argc, char *argv[]) {
 
 	updateViewport(windowWidth, windowHeight);
 	
-	vector<unique_ptr<Player>> players;
-	players.emplace_back(unique_ptr<Player>(new Player("test")));
 	
-	Player& firstPlayer = *players[0];
-	
-	GameBoard model(std::move(players));
+	GameBoard model({"testPlayer"});
 	GameView view(model);
 	GameController controller(model, view);
 	
+	Player& firstPlayer = model.getPlayer(0);
+	
 	model.PlaceSettlement(Coordinate{0, 0}, firstPlayer);
 	model.PlaceRoad(Coordinate{0, 0}, Coordinate{1, 0}, firstPlayer);
 	model.PlaceRoad(Coordinate{1, 0}, Coordinate{1, 1}, firstPlayer);
diff --git a/tests/testSerialization.cpp b/tests/testSerialization.cpp
@@ -47,11 +47,11 @@ TEST(multiplePlayerSerialization) {
 TEST(testCardSerialization) {
 	vector<unique_ptr<Player>> players;
 	players.emplace_back(unique_ptr<Player>(new Player("test")));
-	players[0]->buyCard(unique_ptr<DevelopmentCard>(new KnightCard(players[0].get())));
-	players[0]->buyCard(unique_ptr<DevelopmentCard>(new VictoryPointCard(players[0].get())));
-	players[0]->buyCard(unique_ptr<DevelopmentCard>(new YearOfPlentyCard(players[0].get())));
-	players[0]->buyCard(unique_ptr<DevelopmentCard>(new MonopolyCard(players[0].get())));
-	players[0]->buyCard(unique_ptr<DevelopmentCard>(new RoadBuildingCard(players[0].get())));
+	players[0]->buyCard(unique_ptr<DevelopmentCard>(new KnightCard()));
+	players[0]->buyCard(unique_ptr<DevelopmentCard>(new VictoryPointCard()));
+	players[0]->buyCard(unique_ptr<DevelopmentCard>(new YearOfPlentyCard()));
+	players[0]->buyCard(unique_ptr<DevelopmentCard>(new MonopolyCard()));
+	players[0]->buyCard(unique_ptr<DevelopmentCard>(new RoadBuildingCard()));
 	
 	GameBoard testBoard(std::move(players));
 	
diff --git a/tests/test_DevelopmentCards.cpp b/tests/test_DevelopmentCards.cpp

Original file line number	Diff line number	Diff line change
`@@ -11,32 +11,32 @@`
`11`	`11`	`/**`
`12`	`12`	`* Construct a Deck with the standard cards available in the Settlers of Catan game.`
`13`	`13`	`*/`
`14`		`-Deck::Deck()`
	`14`	`+Deck::Deck(GameBoard& board)`
`15`	`15`	`{`
`16`	`16`	`// TODO Auto-generated constructor stub`
`17`	`17`	`for(int i = 0; i < 15; i++)`
`18`	`18`	`{`
`19`		`- DevelopmentCard* card = new KnightCard();`
	`19`	`+ DevelopmentCard* card = new KnightCard(board);`
`20`	`20`	`this->deck.push_back(card);`
`21`	`21`	`}`
`22`	`22`	`for(int i = 0; i < 4; i++)`
`23`	`23`	`{`
`24`		`- DevelopmentCard* card = new VictoryPointCard();`
	`24`	`+ DevelopmentCard* card = new VictoryPointCard(board);`
`25`	`25`	`this->deck.push_back(card);`
`26`	`26`	`}`
`27`	`27`	`for(int i = 0; i < 2; i++)`
`28`	`28`	`{`
`29`		`- DevelopmentCard* card = new YearOfPlentyCard();`
	`29`	`+ DevelopmentCard* card = new YearOfPlentyCard(board);`
`30`	`30`	`this->deck.push_back(card);`
`31`	`31`	`}`
`32`	`32`	`for(int i = 0; i < 2; i++)`
`33`	`33`	`{`
`34`		`- DevelopmentCard* card = new MonopolyCard();`
	`34`	`+ DevelopmentCard* card = new MonopolyCard(board);`
`35`	`35`	`this->deck.push_back(card);`
`36`	`36`	`}`
`37`	`37`	`for(int i = 0; i < 2; i++)`
`38`	`38`	`{`
`39`		`- DevelopmentCard* card = new RoadBuildingCard();`
	`39`	`+ DevelopmentCard* card = new RoadBuildingCard(board);`
`40`	`40`	`this->deck.push_back(card);`
`41`	`41`	`}`
`42`	`42`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`
`13`	`13`
`14`	`14`	`//Base Class`
`15`		`-DevelopmentCard::DevelopmentCard()`
	`15`	`+DevelopmentCard::DevelopmentCard(GameBoard& board) : board(board)`
`16`	`16`	`{`
`17`	`17`
`18`	`18`	`}`
`@@ -31,7 +31,7 @@ bool DevelopmentCard::operator==(const DevelopmentCard& other) {`
`31`	`31`	`return getType() == other.getType();`
`32`	`32`	`}`
`33`	`33`
`34`		`-KnightCard::KnightCard():DevelopmentCard()`
	`34`	`+KnightCard::KnightCard(GameBoard& board) : DevelopmentCard(board)`
`35`	`35`	`{`
`36`	`36`
`37`	`37`	`}`
`@@ -43,11 +43,11 @@ DevCardType KnightCard::getType() const {`
`43`	`43`	`void KnightCard::playCard(Player *player, Coordinate target)`
`44`	`44`	`{`
`45`	`45`	`//Call function to play card`
`46`		`- board->moveRobber(target);`
	`46`	`+ board.moveRobber(target);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`
`50`		`-VictoryPointCard::VictoryPointCard():DevelopmentCard()`
	`50`	`+VictoryPointCard::VictoryPointCard(GameBoard& board) : DevelopmentCard(board)`
`51`	`51`	`{`
`52`	`52`
`53`	`53`	`}`
`@@ -58,7 +58,7 @@ DevCardType VictoryPointCard::getType() const {`
`58`	`58`
`59`	`59`
`60`	`60`
`61`		`-YearOfPlentyCard::YearOfPlentyCard():DevelopmentCard()`
	`61`	`+YearOfPlentyCard::YearOfPlentyCard(GameBoard& board) : DevelopmentCard(board)`
`62`	`62`	`{`
`63`	`63`
`64`	`64`	`}`
`@@ -77,7 +77,7 @@ void YearOfPlentyCard::playCard(Player *player, int rType1, int rType2)`
`77`	`77`
`78`	`78`
`79`	`79`
`80`		`-MonopolyCard::MonopolyCard():DevelopmentCard()`
	`80`	`+MonopolyCard::MonopolyCard(GameBoard& board) : DevelopmentCard(board)`
`81`	`81`	`{`
`82`	`82`
`83`	`83`	`}`
`@@ -90,9 +90,9 @@ void MonopolyCard::playCard(Player *player, int rType)`
`90`	`90`	`{`
`91`	`91`	`int totalResourceCount = 0;`
`92`	`92`
`93`		`- for(int i=0; i<board->getNoOfPlayers(); i++)`
	`93`	`+ for(int i=0; i<board.getNoOfPlayers(); i++)`
`94`	`94`	`{`
`95`		`- Player& p = board->getPlayer(i);`
	`95`	`+ Player& p = board.getPlayer(i);`
`96`	`96`	`totalResourceCount += p.getResource(rType);`
`97`	`97`	`p.addResource(rType, (-1*p.getResource(rType)) );`
`98`	`98`	`}`
`@@ -101,7 +101,9 @@ void MonopolyCard::playCard(Player *player, int rType)`
`101`	`101`
`102`	`102`
`103`	`103`
`104`		`-RoadBuildingCard::RoadBuildingCard():DevelopmentCard(){};`
	`104`	`+RoadBuildingCard::RoadBuildingCard(GameBoard& board) : DevelopmentCard(board) {`
	`105`	`+`
	`106`	`+};`
`105`	`107`
`106`	`108`	`DevCardType RoadBuildingCard::getType() const`
`107`	`109`	`{`
`@@ -111,10 +113,10 @@ DevCardType RoadBuildingCard::getType() const`
`111`	`113`
`112`	`114`
`113`	`115`	`void RoadBuildingCard::playCard(Player* player, Coordinate start1, Coordinate end1, Coordinate start2, Coordinate end2){`
`114`		`- if (!board->PlaceRoad(start1, end1, *player)){`
	`116`	`+ if (!board.PlaceRoad(start1, end1, *player)){`
`115`	`117`	`throw std::invalid_argument("The first road passed was not valid, no roads placed");`
`116`	`118`	`}`
`117`		`- if ((!board->PlaceRoad(start2, end2, *player))){`
	`119`	`+ if ((!board.PlaceRoad(start2, end2, *player))){`
`118`	`120`	`throw std::invalid_argument("The second road passed was not valid, only the first road was placed");`
`119`	`121`	`}`
`120`	`122`	`}`