Писане на игра с карти с памет в Swift

Тази статия описва процеса на създаване на проста игра за трениране на паметта, която наистина харесвам. Освен че е добър сам по себе си, ще научите малко повече за класовете и протоколите на Swift, докато вървите. Но преди да започнем, нека разберем самата игра.

Напомняме ви: за всички читатели на "Habr" - отстъпка от 10 000 рубли при записване във всеки курс Skillbox, използвайки промоционалния код на "Habr".

Skillbox препоръчва: Образователен онлайн курс „Професия Java разработчик“.

Как се играе карта с памет

Играта започва с демонстрация на набор от карти. Лежат с лицето надолу (съответно изображението надолу). Когато щракнете върху който и да е, изображението се отваря за няколко секунди.

Задачата на играча е да намери всички карти с еднакви картинки. Ако след като отворите първата карта, обърнете втората и картинките съвпаднат, двете карти остават отворени. Ако не съвпадат, картите се затварят отново. Целта е да се отвори всичко.

Структура на проекта

За да създадете проста версия на тази игра, имате нужда от следните компоненти:

• Един контролер: GameController.swift.
• Един изглед: CardCell.swift.
• Два модела: MemoryGame.swift и Card.swift.
• Main.storyboard, за да се гарантира, че целият набор от компоненти е наличен.

Започваме с най-простия компонент на играта, картите.

Card.swift

Моделът на картата ще има три свойства: id за идентифициране на всяка една, показана булева променлива, за да уточни статуса на картата (скрита или отворена) и artworkURL за изображенията на картите.

class Card {        
    var id: String    
    var shown: Bool = false    
    var artworkURL: UIImage!
}

Ще ви трябват и тези методи, за да контролирате взаимодействието на потребителите с картите:

Метод за показване на изображение върху карта. Тук нулираме всички свойства по подразбиране. За id генерираме случаен id чрез извикване на NSUUIS().uuidString.

init(image: UIImage) {        
    self.id = NSUUID().uuidString        
    self.shown = false        
    self.artworkURL = image    
}

Метод за сравняване на лични карти.

func equals(_ card: Card) -> Bool {
    return (card.id == id)    
}

Метод за създаване на копие на всяка карта - с цел получаване на по-голям брой еднакви. Този метод ще върне карта с подобни стойности.

func copy() -> Card {        
    return Card(card: self)    
}
 
init(card: Card) {        
    self.id = card.id        
    self.shown = card.shown        
    self.artworkURL = card.artworkURL    
}

И още един метод е необходим за разбъркване на картите в началото. Ще го направим разширение на класа Array.

extension Array {    
    mutating func shuffle() {        
        for _ in 0...self.count {            
            sort { (_,_) in arc4random() < arc4random() }        
        }   
    }
}

А ето и имплементацията на кода за модела Card с всички свойства и методи.

class Card {
    
    var id: String
    var shown: Bool = false
    var artworkURL: UIImage!
    
    static var allCards = [Card]()
 
    init(card: Card) {
        self.id = card.id
        self.shown = card.shown
        self.artworkURL = card.artworkURL
    }
    
    init(image: UIImage) {
        self.id = NSUUID().uuidString
        self.shown = false
        self.artworkURL = image
    }
    
    func equals(_ card: Card) -> Bool {
        return (card.id == id)
    }
    
    func copy() -> Card {
        return Card(card: self)
    }
}
 
extension Array {
    mutating func shuffle() {
        for _ in 0...self.count {
            sort { (_,_) in arc4random() < arc4random() }
        }
    }
}

Продължавай.

Вторият модел е MemoryGame, тук сме задали решетка 4*4. Моделът ще има свойства като карти (масив от карти в решетка), масив cardsShown с вече отворени карти и булева променлива isPlaying за проследяване на състоянието на играта.

class MemoryGame {        
    var cards:[Card] = [Card]()    
    var cardsShown:[Card] = [Card]()    
    var isPlaying: Bool = false
}

Ние също трябва да разработим методи за контрол на взаимодействието на потребителите с мрежата.

Метод, който разбърква карти в мрежа.

func shuffleCards(cards:[Card]) -> [Card] {       
    var randomCards = cards        
    randomCards.shuffle()                
 
    return randomCards    
}

Метод за създаване на нова игра. Тук извикваме първия метод за стартиране на първоначалното оформление и инициализиране на променливата isPlaying на true.

func newGame(cardsArray:[Card]) -> [Card] {       
    cards = shuffleCards(cards: cardsArray)        
    isPlaying = true            
 
    return cards    
}

Ако искаме да рестартираме играта, след това задаваме променливата isPlaying на false и премахваме първоначалното оформление на картите.

func restartGame() {        
    isPlaying = false                
    cards.removeAll()        
    cardsShown.removeAll()    
}

Метод за проверка на кликнати карти. Повече за него по-късно.

func cardAtIndex(_ index: Int) -> Card? {        
    if cards.count > index {            
        return cards[index]        
    } else {            
        return nil        
    }    
}

Метод, който връща позицията на конкретна карта.

func indexForCard(_ card: Card) -> Int? {        
    for index in 0...cards.count-1 {            
        if card === cards[index] {                
            return index            
        }      
    }
        
    return nil    
}

Проверка на съответствието на избраната карта със стандарта.

func unmatchedCardShown() -> Bool {
    return cardsShown.count % 2 != 0
}

Този метод чете последния елемент в масива **cardsShown** и връща несъответстващата карта.

func didSelectCard(_ card: Card?) {        
    guard let card = card else { return }                
    
    if unmatchedCardShown() {            
        let unmatched = unmatchedCard()!                        
        
        if card.equals(unmatched) {          
            cardsShown.append(card)            
        } else {                
            let secondCard = cardsShown.removeLast()      
        }                    
    } else {            
        cardsShown.append(card)        
    }                
    
    if cardsShown.count == cards.count {            
        endGame()        
    }    
}

Main.storyboard и GameController.swift

Main.storyboard изглежда по следния начин:

Първоначално трябва да зададете новата игра като viewDidLoad в контролера, включително изображенията за мрежата. В играта всичко това ще бъде представено от 4*4 collectionView. Ако все още не сте запознати с collectionView, ето го можете да получите необходимата информация.

Ние ще конфигурираме GameController като основен контролер на приложението. GameController ще има collectionView, който ще наричаме IBOutlet. Друга препратка е към бутона IBAction onStartGame(), това е UIButton, можете да го видите в сценария, наречен PLAY.

Малко за внедряването на контролери:

• Първо инициализираме два основни обекта - мрежата: game = MemoryGame() и набор от карти: cards = [Card]().
• Задаваме първоначалните променливи като viewDidLoad, това е първият метод, който се извиква, докато играта работи.
• collectionView е настроен на скрит, защото всички карти са скрити, докато потребителят не натисне PLAY.
• Веднага след като натиснем PLAY, секцията onStartGame IBAction започва и ние задаваме свойството collectionView isHidden на false, така че картите да могат да станат видими.
• Всеки път, когато потребителят избере карта, се извиква методът didSelectItemAt. В метода, който извикваме didSelectCard, за да реализираме основната логика на играта.

Ето окончателното внедряване на GameController:

class GameController: UIViewController {
 
    @IBOutlet weak var collectionView: UICollectionView!
    
    let game = MemoryGame()
    var cards = [Card]()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        game.delegate = self
        
        collectionView.dataSource = self
        collectionView.delegate = self
        collectionView.isHidden = true
        
        APIClient.shared.getCardImages { (cardsArray, error) in
            if let _ = error {
                // show alert
            }
            
            self.cards = cardsArray!
            self.setupNewGame()
        }
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        
        if game.isPlaying {
            resetGame()
        }
    }
    
    func setupNewGame() {
        cards = game.newGame(cardsArray: self.cards)
        collectionView.reloadData()
    }
    
    func resetGame() {
        game.restartGame()
        setupNewGame()
    }
    
    @IBAction func onStartGame(_ sender: Any) {
        collectionView.isHidden = false
    }
}
 
// MARK: - CollectionView Delegate Methods
extension GameController: UICollectionViewDelegate, UICollectionViewDataSource {
    
    func numberOfSections(in collectionView: UICollectionView) -> Int {
        return 1
    }
    
    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return cards.count
    }
    
    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "CardCell", for: indexPath) as! CardCell
        cell.showCard(false, animted: false)
        
        guard let card = game.cardAtIndex(indexPath.item) else { return cell }
        cell.card = card
        
        return cell
    }
    
    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        let cell = collectionView.cellForItem(at: indexPath) as! CardCell
        
        if cell.shown { return }
        game.didSelectCard(cell.card)
        
        collectionView.deselectItem(at: indexPath, animated:true)
    }
}

Сега нека поговорим малко за важните протоколи.

протоколи

Работата с протоколи е ядрото на програмирането на Swift. Протоколите предоставят възможност за дефиниране на правила за клас, структура или изброяване. Този принцип ви позволява да пишете модулен и разширяем код. Всъщност това е модел, който вече прилагаме за collectionView в GameController. Сега нека направим наша собствена версия. Синтаксисът ще изглежда така:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

Знаем, че протоколът ни позволява да дефинираме правила или инструкции за внедряване на клас, така че нека помислим какви трябва да бъдат те. Трябват ви общо четири.

• Начало на играта: memoryGameDidStart.
• Трябва да обърнете картата с лицето надолу: memoryGameShowCards.
• Трябва да обърнете картата с лицето надолу: memoryGameHideCards.
• Край на играта: memoryGameDidEnd.

И четирите метода могат да бъдат реализирани за основния клас, който е GameController.

memoryGameDidStart

Когато този метод се изпълни, играта трябва да започне (потребителят натиска PLAY). Тук просто ще презаредим съдържанието, като извикаме collectionView.reloadData(), което ще разбърка картите.

func memoryGameDidStart(_ game: MemoryGame) {
    collectionView.reloadData()
}

memoryGameShowCards

Извикваме този метод от collectionSDViewSelectItemAt. Първо показва избраната карта. След това проверява дали има несъвпадаща карта в масива cardsShown (ако броят на cardsShown е нечетен). Ако има такава, избраната карта се сравнява с нея. Ако снимките са еднакви, двете карти се добавят към cardsShown и остават с лицето нагоре. Ако е различна, картата оставя картите Показани и двете се обръщат с лицето надолу.

memoryGameHideCards

Ако картите не съвпадат, този метод се извиква и изображенията на картите се скриват.

показано = невярно.

memoryGameDidEnd

Когато този метод бъде извикан, това означава, че всички карти вече са разкрити и са в списъка cardsShown: cardsShown.count = cards.count, така че играта е приключила. Методът се извиква специално, след като сме извикали endGame(), за да зададем isPlaying var на false, след което се показва съобщението за край на играта. Също така alertController се използва като индикатор за контролера. viewDidDisappear се извиква и играта се нулира.

Ето как изглежда всичко това в GameController:

extension GameController: MemoryGameProtocol {
    func memoryGameDidStart(_ game: MemoryGame) {
        collectionView.reloadData()
    }
 
 
    func memoryGame(_ game: MemoryGame, showCards cards: [Card]) {
        for card in cards {
            guard let index = game.indexForCard(card)
                else { continue
            }        
            
            let cell = collectionView.cellForItem(
                at: IndexPath(item: index, section:0)
            ) as! CardCell
 
            cell.showCard(true, animted: true)
        }
    }
 
    func memoryGame(_ game: MemoryGame, hideCards cards: [Card]) {
        for card in cards {
            guard let index = game.indexForCard(card)
                else { continue
            }
            
            let cell = collectionView.cellForItem(
                at: IndexPath(item: index, section:0)
            ) as! CardCell
    
            cell.showCard(false, animted: true)
        }
    }
 
    func memoryGameDidEnd(_ game: MemoryGame) {
        let alertController = UIAlertController(
            title: defaultAlertTitle,
            message: defaultAlertMessage,
            preferredStyle: .alert
        )
 
        let cancelAction = UIAlertAction(
            title: "Nah", style: .cancel) {
            [weak self] (action) in
            self?.collectionView.isHidden = true
        }
 
        let playAgainAction = UIAlertAction(
            title: "Dale!", style: .default) {
            [weak self] (action) in
            self?.collectionView.isHidden = true
 
            self?.resetGame()
        }
 
        alertController.addAction(cancelAction)
        alertController.addAction(playAgainAction)
        
        self.present(alertController, animated: true) { }
    
        resetGame()
    }
}

Всъщност това е всичко. Можете да използвате този проект, за да създадете своя собствена версия на играта.

Приятно кодиране!

Skillbox препоръчва:

• Практически курс „Мобилен разработчик PRO“.
• Приложен онлайн курс „Анализатор на данни на Python“.
• Двугодишен практически курс „Аз съм PRO уеб разработчик“.

Източник: www.habr.com