How To Make a Simple Playing Card Game with Multiplayer and Bluetooth, Part 7

Paying cards

When a player yells “Snap!” when there are no matching cards on the table, he has to pay one card to each of the other players. Because you haven’t built the logic for determining whether there is actually a match on the table, right now the first player to yell “Snap!” is always wrong. That’s OK because it makes it easy to build and test the logic for paying cards.

In GameViewController.m‘s game:playerCalledSnapWithNoMatch:, add the following line:

- (void)game:(Game *)game playerCalledSnapWithNoMatch:(Player *)player
{
	. . .

	[self performSelector:@selector(playerMustPayCards:) withObject:player afterDelay:1.0f];
}

This will call the new method playerMustPayCards: one second after you’ve shown the big red X. Add the implementation for this method next:

- (void)playerMustPayCards:(Player *)player
{
	self.centerLabel.text = [NSString stringWithFormat: NSLocalizedString(@"%@ Must Pay", @"Status text: player must pay cards to the others"), player.name];
	[self.game playerMustPayCards:player];
}

Here you call a new method from Game, playerMustPayCards:, which will move the cards around from one Player to the others in the data model. Add the method signature to Game.h:

- (void)playerMustPayCards:(Player *)player;

And the method itself to Game.m:

- (void)playerMustPayCards:(Player *)player
{
	_mustPayCards = YES;

	int cardsNeeded = 0;
	for (PlayerPosition p = player.position; p < player.position + 4; ++p)
	{
		Player *otherPlayer = [self playerAtPosition:p % 4];
		if (otherPlayer != nil && otherPlayer != player && [otherPlayer totalCardCount] > 0)
			++cardsNeeded;
	}	

	if (cardsNeeded > [player.closedCards cardCount])
	{
		NSArray *recycledCards = [player recycleCards];
		if ([recycledCards count] > 0)
		{
			[self.delegate game:self didRecycleCards:recycledCards forPlayer:player];
			return;
		}
	}

	[self resumeAfterRecyclingCardsForPlayer:player];
}

This method first counts how many cards the player needs to pay. Only other players who have at least one open or closed card will receive a card — players with no cards left do no longer participate in the game. Then you check whether the player actually has enough cards on his closed stack; if not, then you first recycle those cards. The recycling procedure will call resumeAfterRecyclingCardsForPlayer: when it is done, so that’s where you continue (even if no recycling needs to happen).

The new boolean _mustPayCards tells resumeAfterRecyclingCardsForPlayer: that it still has a task to perform after the recycling completes. Replace that method with:

- (void)resumeAfterRecyclingCardsForPlayer:(Player *)player
{
	if (_mustPayCards)
	{
		for (PlayerPosition p = player.position; p < player.position + 4; ++p)
		{
			Player *otherPlayer = [self playerAtPosition:p % 4];
			if (otherPlayer != nil && otherPlayer != player && [otherPlayer totalCardCount] > 0)
			{
				Card *card = [player giveTopmostClosedCardToPlayer:otherPlayer];
				if (card != nil)
					[self.delegate game:self player:player paysCard:card toPlayer:otherPlayer];
			}
		}
	}
}

In the case of a normal recycle you don’t do anything here, only if the player must pay cards. You loop through all the players — based on position, so you see the players in the same order on
both the server and the clients, otherwise the cards get mixed up — and call giveTopmostClosedCardToPlayer: to change the data model. You also call a new delegate method to perform the animation.

Add the _mustPayCards boolean to the instance variables:

@implementation Game
{
	. . .
	BOOL _mustPayCards;
}

Just to make sure you start with a clean slate, you’ll set this variable to NO in beginRound:

- (void)beginRound
{
	_mustPayCards = NO;
	. . .
}

Add the new giveTopmostClosedCardToPlayer: method to both Player.h and Player.m:

- (Card *)giveTopmostClosedCardToPlayer:(Player *)otherPlayer
{
	Card *card = [self.closedCards topmostCard];
	if (card != nil)
	{
		[otherPlayer.closedCards addCardToBottom:card];
		[self.closedCards removeTopmostCard];
	}
	return card;
}

Also add the signature for the new delegate method the GameDelegate protocol in Game.h:

- (void)game:(Game *)game player:(Player *)fromPlayer paysCard:(Card *)card toPlayer:(Player *)toPlayer;

Implement this method in GameViewController.m:

- (void)game:(Game *)game player:(Player *)fromPlayer paysCard:(Card *)card toPlayer:(Player *)toPlayer
{
	CardView *cardView = [self cardViewForCard:card];
	[cardView animatePayCardFromPlayer:fromPlayer toPlayer:toPlayer];
}

And finally add the new animation method to both CardView.h and CardView.m:

- (void)animatePayCardFromPlayer:(Player *)fromPlayer toPlayer:(Player *)toPlayer
{
	[self.superview sendSubviewToBack:self];

	CGPoint point = [self centerForPlayer:toPlayer];
	_angle = [self angleForPlayer:toPlayer];

	[UIView animateWithDuration:0.4f
		delay:0.0f
		options:UIViewAnimationOptionCurveEaseOut
		animations:^
		{
			self.center = point;
			self.transform = CGAffineTransformMakeRotation(_angle);
		}
		completion:nil];
}

That’s quite a few changes, but now when a player yells “Snap!” when there is no match, the GameViewController says to Game, “that player has to pay the cards”, and then Game tells GameViewController to move those cards around. The reason that the controller tells Game what to do next has to do with timing. Game doesn’t know when its delegate is done performing the animations, so it depends on its delegate to tell it to perform the next step.

You should be able to run the app now. Tap the Snap! button for one of the players and on both the client and the server you should see a card fly from that player to each of the others.

Note: Recall that when a client disconnects, the server sends a list of redistributed cards to each of the other clients. After someone yells “Snap!”, cards also have to move from one player to another but this time the PlayerCalledSnap packet does not include such a list of cards. Instead, the clients figure out for themselves what the cards are. Both approaches are equally valid, although in the latter case it is vital that all clients and the server agree on the game state, otherwise one client may show different cards from the others, which sort-of spoils the game.

There is still that pesky issue that the game no longer lets you turn over cards after you’ve tapped Snap!. Change playerMustPayCards: in GameViewController.m to:

- (void)playerMustPayCards:(Player *)player
{
	self.centerLabel.text = [NSString stringWithFormat: NSLocalizedString(@"%@ Must Pay", @"Status text: player must pay cards to the others"), player.name];
	[self.game playerMustPayCards:player];
	[self performSelector:@selector(afterMovingCardsForPlayer:) withObject:player afterDelay:1.0f];
}

This now calls a new method, afterMovingCardsForPlayer:, one second after the cards have been moved around. Add this method to GameViewController.m:

- (void)afterMovingCardsForPlayer:(Player *)player
{
	self.snapButton.enabled = YES;
	self.turnOverButton.enabled = YES;

	if ([[self.game playerAtPosition:PlayerPositionBottom] totalCardCount] == 0)
		self.snapButton.hidden = YES;
}

Here you re-enable the buttons, but if the local player has no more cards available, he no longer participates and you hide his Snap! button.

Try it out, now turning over cards works again after someone yells “Snap!”. Also do this: flip over all the cards until there are none left on the closed stack — this is quicker if you limit the number of cards on the deck — and then press the Snap! button for that player. His cards should now first be recycled.

While testing this, you’ll probably run into some situations that aren’t handled properly yet. For example, a player yells “Snap!” in a two-player game while he has one closed card left and it is his turn. The closed card gets paid but now there are no cards left for him to turn over. His open stack should be recycled, but that currently doesn’t happen — you only check whether recycling needs to happen at the moment a player is activated. So you need to add some extra logic that should happen after the player paid his cards.

In GameViewController.m, change afterMovingCardsForPlayer: to:

- (void)afterMovingCardsForPlayer:(Player *)player
{
	BOOL changedPlayer = [self.game resumeAfterMovingCardsForPlayer:player];

	self.snapButton.enabled = YES;
	self.turnOverButton.enabled = YES;

	if ([[self.game playerAtPosition:PlayerPositionBottom] totalCardCount] == 0)
		self.snapButton.hidden = YES;

	if (!changedPlayer)
		[self showIndicatorForActivePlayer];
}

You now call the resumeAfterMovingCardsForPlayer: method on Game. This will perform a number of checks — should the active player recycle his cards, and so on — and returns YES if a new player will be made active, which can happen if the active player no longer has any cards left. If the active player didn’t change, you call showIndicatorForActivePlayer again in other to change the text on the center label back to “Player X’s turn”.

Add the resumeAfterMovingCardsForPlayer: method to Game.h and Game.m:

- (BOOL)resumeAfterMovingCardsForPlayer:(Player *)player
{
	_mustPayCards = NO;

	if ([[self activePlayer] totalCardCount] == 0 || _hasTurnedCard)
	{
		if (self.isServer)
			[self activateNextPlayer];

		return YES;
	}
	else if ([[self activePlayer] shouldRecycle])
	{
		[self recycleCardsForActivePlayer];
		return NO;
	}

	return NO;
}

If the active player has no more cards — he has just paid them all to the other players — then the server needs to activate the next player. Otherwise, if the active player no longer has any closed cards left, they should be recycled first.