Пишување игра со мемориски картички во Swift

Оваа статија го опишува процесот на создавање едноставна игра за обука на меморија која навистина ми се допаѓа. Освен што е добро само по себе, ќе научите малку повеќе за часовите и протоколите на Swift додека одите. Но, пред да започнеме, да ја разбереме самата игра.

Потсетуваме: за сите читатели на „Хабр“ - попуст од 10 рубли при запишување на кој било курс Skillbox користејќи го промотивниот код „Хабр“.

Skillbox препорачува: Едукативен онлајн курс „Професија Java програмер“.

Како да играте мемориска картичка

Играта започнува со демонстрација на сет на карти. Тие лежат со лицето надолу (соодветно, сликата надолу). Кога ќе кликнете на кој било, сликата се отвора неколку секунди.

Задачата на играчот е да ги пронајде сите карти со исти слики. Ако, по отворањето на првата картичка, ја превртите втората и сликите се совпаѓаат, двете карти остануваат отворени. Доколку не се совпаѓаат, картите повторно се затвораат. Целта е да се отвори се.

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

За да креирате едноставна верзија на оваа игра, потребни ви се следниве компоненти:

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

Започнуваме со наједноставната компонента на играта, картите.

Картичка.свифт

Моделот на картичката ќе има три својства: id за идентификување на секоја од нив, булова променлива прикажана за одредување на статусот на картичката (скриена или отворена) и artworkURL за сликите на картичките.

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

Ќе ви требаат и овие методи за да ја контролирате интеракцијата на корисниците со мапите:

Начин за прикажување слика на картичка. Овде ги ресетираме сите својства на стандардни. За идентификација, генерираме случаен 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. Моделот ќе има својства како што се картички (низа од картички на мрежа), низа од картички прикажани со веќе отворени картички и булова променлива 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 во точно.

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 како root контролер на апликацијата. GameController ќе има collectionView кој ќе го реферираме како IBOoutlet. Друга референца е на копчето IBAction onStartGame(), ова е UIButton, можете да го видите во приказната наречена PLAY.

Малку за имплементацијата на контролорите:

• Прво, ние иницијализираме два главни објекти - мрежата: игра = MemoryGame(), и збир на карти: карти = [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 е непарен). Доколку постои, избраната картичка се споредува со неа. Ако сликите се исти, двете картички се додаваат на картички Прикажани и остануваат свртени нагоре. Ако е различно, картичката остава картички Прикажани и двете се свртени со лицето надолу.

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 веб-развивач“.

Извор: www.habr.com