Nsryjdtyk

I've starting writing the card game Uno the past couple of days and was wondering if you can review my code please. The initialization is done I think, a couple of game functions already exist, please have look.

Please give me feedback concerning, structure, logic, data structures, naming conventions, anything you're noticing!

I want to make sure everything is set until I move on to the View and Controller.

Thanks in advance!

Marcel

import UIKit

import Foundation



// Represents all jokers of the game.

enum Joker: String, CaseIterable {

    // Only four copies of each will be created

    case joker, drawFour, swapCircle

    func points() -> Int {

        switch self {

        case .joker, .drawFour, .swapCircle: return 50

        } // returns points of each card

    }

}



// Represents all "normal" cards.

enum Value: String, CaseIterable {

    // A cartesian product with all colors will be built.

    case one, two, three, four, five, six, seven, eight, nine, drawTwo, skip, turn

    // returns points of each card

    func points() -> Int {

        switch self {

        // THIS DOES NOT LOOK VERY NICE. IS THERE A SMOOTHER WAY?

        case .one: return 1

        case .two: return 2

        case .three: return 3

        case .four: return 4

        case .five: return 5

        case .six: return 6

        case .seven: return 7

        case .eight: return 8

        case .nine: return 9

        case .drawTwo, .skip, .turn: return 20

        }

    }

}



// Represents all colors.

enum Color: String, CaseIterable {

    case red, blue, yellow, green

}



// Represents the structure of a card.

struct Card {

    let value: Value? // is nil when card is a joker

    let color:  Color? // is nil when card is a joker

    let joker:  Joker? // is nil when card has a value and color

}



// Represents the two stacks of the game. Game stack as well as draw stack will be instances of stack, depending on which constructor is called the correct instance will be created.

class Stack {

    public var stack: [Card]



    // Creates the draw when the game is first initalized.

    private static func createDrawStack(with amountOfCards: Int) -> [Card] {

        var cards = [Card]()

        // add 2 cards of each value

        for color in Color.allCases {

            for value in Value.allCases {

                for _ in 0..<amountOfCards { // add two copies

                    cards += [Card(value: value, color: color, joker: nil)]

                }

            }

        }

        for _ in 0..<(amountOfCards * 2) {

            // add 1 swap-circle

            cards += [Card(value: nil, color: nil, joker: .swapCircle)]

            // add 1 draw-four

            cards += [Card(value: nil, color: nil, joker: .drawFour)]

            // add 1 joker

            cards += [Card(value: nil, color: nil, joker: .joker)]

        }

        return cards.shuffled() // TODO: In-place shuffling wouldn't work, maybe not shuffling in here is smoother

    }



    // Creates the game stack when the game is first initalized.

    private static func createGameStack(with drawStack: Stack) -> [Card] {

        return [drawStack.stack.popLast()!]

    }



    init(createDrawStackWith amount: Int) {

        self.stack = Stack.createDrawStack(with: amount)

    }

    init(createGameStackWith drawStack: Stack) {

        self.stack = Stack.createGameStack(with: drawStack)

    }

}



// Represents a player and the actions a player can do.

class Player {

    let id: Int

    var hand = [Card?]()

    var didDraw = false



    // Receives index of button pressed and returns the card selected, so that cardsMatch() can check if it's a valid turn. If so, playCard() will be called.

    public func wantsToPlayCard(at index: Int) -> Card {

        return hand[index]!

    }



    // Moves card requested from user hand to playStack

    public func playCard(at index: Int, onto playStack: Stack) {

        if let card = self.hand.remove(at: index) {

            playStack.stack.append(card)

        }

    }



    // Moves a card from drawStack to user hand

    public func drawCard(from deck: Stack) {

        self.hand.append(deck.stack.popLast()!)

    }



    init(withID id: Int) {

        self.id = id

    }

}



// Represents the whole game. This is the core of the game.

class Uno {



    public var drawStack: Stack // creates a stack to draw from with 2 copies of each color

    public var playStack: Stack // creates a stack where the game will be played

    public var players: [Player] // will be initialized dependent of amount



    // Moves play stack back into draw stack.

    public func resetDrawStack() {

        let topCard = playStack.stack.popLast()! // save top card

        drawStack.stack = playStack.stack // move rest of playStack back into drawStack

        drawStack.stack.shuffle()

        playStack.stack.removeAll()

        playStack.stack += [topCard]

    }



    // Checks if a requested card can be played or not.

    public func cardsMatch(compare topCard: Card, with handCard: Card) -> Bool {

        // if colors match

        if let colorTopCard = topCard.color, let colorHandCard = handCard.color {

            if colorTopCard == colorHandCard {

                return true

            }

        }

        // if values match

        if let valueTopCard = topCard.value, let valueHandCard = handCard.value {

            if valueTopCard == valueHandCard {

                return true

            }

        }

        // if its a joker

        if let _ = handCard.joker {

            return true

        }

        // else

        return false

    }



    // Deals cards to players at the start of round.

    private func dealCards(with amountOfCards: Int) {

        for id in players.indices {

            for _ in 0..<amountOfCards {

                players[id].drawCard(from: drawStack)

            }

        }

    }



    // Creates the players.

    private static func createPlayers(with amountOfPlayers: Int) -> [Player] {

        var players = [Player]()

        for id in 0..<amountOfPlayers {

            players += [Player(withID: id)]

        }

        return players

    }



    // Constructs game dependent on settings.

    init(amountOfPlayers: Int, amountOfCopies: Int, amountOfCards: Int) {

        self.drawStack = Stack(createDrawStackWith: amountOfCopies)

        print(self.drawStack.stack)

        self.playStack = Stack(createGameStackWith: self.drawStack)

        self.players = Uno.createPlayers(with: amountOfPlayers) // creates 2 players

        self.dealCards(with: amountOfCards)

    }

}



var game = Uno(amountOfPlayers: 2, amountOfCopies: 2, amountOfCards: 7)