Good Practices for Swift SpriteKit Class Structure - ios

Question

I am developing an iOS card game with Swift and have a question about good practice when it comes to designing the framework for games with SpriteKit and iOS. My basic structure is as follows:
class Card: SpriteKitNode {
cardValue: Int
func action() {}
}
struct Player {
playerName = "Joe"
playerPile = [Card]()
playerStack = [Card]()
}
struct Game {
// Create players and deals out the cards to each player pile.
}
Each player has a few piles of cards and they all come together in the game struct. Most of the cards in my game are independent cards. So, if player 1 plays a card, it has no impact on other players. However, some of the cards in my games have actions which are designed to impact other players decks depending on which card is played.
My question is, a card "action" sounds like it should be defined within the card class. It is a feature of the card itself that it has this ability. However, when I think about how I would implement this, I am not sure how it could impact at the game level to access other player piles. So what is the best practice when it comes to trying to define actions that have upstream impacts when the "Card" does not know how many players there are, which player it belongs to, and how to access another player's pile.
Example of an action I would like to implement: Player 1 can move the top card in any player stack to the top card in any other player's stack. So, player 1 could move the top card from player 2 to 1, 2 to 3, or any other combination based on the number of players on the board. I thought I could be able to do this by passing a lot of parameters to the action function action(moveFrom: Player1, moveTo: Player3), but thought I would come here to find out best practices.
There are also a few other actions which may have different inputs based on the card played. Should these be separate functions, or all built into one "Card Action" function?
// Possibly how this function might look.
func action(moveFrom: Player, moveTo: Player) {
let cardMoved = moveFrom.playerPile[0]
moveTo.playerPile.append(cardMoved)
}
Edit - Follow Up Question
After changing to a POP, I have a few further questions that are stumping me on how to implement.
My action function does not allow me to mutate the player's piles that have been selected. Error = "Cannot use mutating member on immutable value: 'fromPlayer' is a 'let' constant". Does this mean I would have to destroy and create and return new piles for each player each time it was called rather than just modifying the existing ones? This seems pretty inefficient is there a better way to do this?
I get another error when trying to call my action function. I have already checked that my card is indeed a "Slice Card", but I get the error "Value of type 'Card' has no member 'action'".
protocol ActionCard {
func action(fromPlayer: Player, toPlayer: Player)
}
class Card {
}
class SliceCard: Card, ActionCard {
func action(fromPlayer: Player, toPlayer: Player) {
let cardTaken = fromPlayer.stack.removeLast()
toPlayer.stack.append(cardTaken)
}
}
struct Player {
var stack = [Card]()
func playCard(card: Card, fromPlayer: Player, toPlayer: Player) {
if card is SliceCard {
card.action(fromPlayer: fromPlayer, toPlayer: toPlayer)
}
}
}
let player1 = Player()
let player2 = Player()
let cardSelected = SliceCard()
player1.playCard(card: cardSelected, fromPlayer: player1, toPlayer: player2)

Answer 1

Interesting question. I would suggest you a POP (Protocol Oriented Programming) approach.
The Player type
First of all I would suggest using a class for the Player type because you want to pass the same instance to other methods/actions and want these method to be able to mutate the original instance.
You could still use a struct + inout parameters but using a class feels more correct.
class Player {
let name: String
var pile: [Card] = []
var stack: [Card] = []
init(name: String) {
self.name = name
}
}
The ActionError enum
Just create an enum and add a case for every possible error an action can throw
enum ActionError: Error {
case playerHasNoCards
// add more errors here
}
The BaseCard class
You put here all the stuff common to any Card.
class BaseCard: SKSpriteNode {
let cardValue: Int
init(cardValue: Int) {
self.cardValue = cardValue
let texture = SKTexture(imageNamed: "card_image")
super.init(texture: texture, color: .clear, size: texture.size())
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
The Card protocol
Here you required that in order to conform to Card a type must
be a class that inherits from BaseCard
and must have an action(...) method
Here's the code
protocol Card: BaseCard {
func action(currentPlayer: Player, destinatonPlayer: Player, allPlayers: [Player]) throws
}
Please note that the action method should receive all the parameters needed for any action you want to implement.
Your first card
Finally you can implement your first card
class CardToStoleACardFromAnotherPlayer: BaseCard, Card {
func action(currentPlayer: Player, destinatonPlayer: Player, allPlayers: [Player]) throws {
guard destinatonPlayer.pile.isEmpty == false else { throw ActionError.playerHasNoCards }
let card = destinatonPlayer.pile.removeFirst()
currentPlayer.pile.append(card)
}
}
Create as many classes as you want, you will write a different logic into each class.
Examples
class CardToStoleAllCardsFromAllPlayers: BaseCard, Card {
func action(currentPlayer: Player, destinatonPlayer: Player, allPlayers: [Player]) throws {
// ...
}
}
class CardToGiftACardToAnotherPlayer: BaseCard, Card {
func action(currentPlayer: Player, destinatonPlayer: Player, allPlayers: [Player]) throws {
// ...
}
}
Considerations
Now you when you pick a Card and you want to execute its action just call the action method passing all the parameters.
Depending on the type of the instance (CardToStoleACardFromAnotherPlayer, CardToStoleAllCardsFromAllPlayers, CardToGiftACardToAnotherPlayer, ...) contained into that variable a different logic will be executed.