Scribens Memoria Card Ludus in Celeri

Hoc articulum describit processus faciendi simplex memoria disciplinae ludum quod ego vere amo. Praeterquam quod in se bonum sit, paulo plura de Celeribus generibus et protocollis abeuntes disces. Sed priusquam incipiamus, ipsum ludum intelligamus.

admonemus; omnibus legentibus "Habr" - discount 10 rublorum cum scribendo in quavis Skillbox utens "Habr" codice promotivo.

Skillbox commendat: Educational online course "Professio Java Developer".

Quomodo ludere Memoria Card

Ludus incipit cum demonstratione actuum chartarum. In faciem iacent (respective, imaginem deorsum). Cum aliquem premes, imago brevi tempore aperit.

Ludii munus est omnes chartas iisdem imaginibus invenire. Si, post primum schedulam aperiendam, in secundum et tabulas inserere, ambae chartae apertae manent. Si non concordant, chartae iterum clauduntur. Propositum est omnia aperire.

Project structure

Ad simplicem huius ludi versionem creare debes sequentium partium:

• One Controller: GameController.swift.
• One View: CardCell.swift.
• Duo exempla: MemoriaGame.swift et Card.swift.
• Main.storyboard ut tota copia partium praesto sit.

Committitur simplicissima pars ludi, chartae.

Card.swift

Exemplar chartae tres proprietates habebit: id ad unumquemque cognoscendum, variabilis booleana ostensa ad statum chartae (absconditum vel apertum), et artworkURL pro imaginibus in chartis.

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

His quoque methodis opus erit ut commercium cum mappis usoris contineas:

Methodus imaginem exhibendi in charta. Hic omnes proprietates ad defaltam exponimus. Id enim temere id generamus vocando NSUUIS().uuidString.

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

Methodus ID pecto comparet.

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

Modus quisque creare exemplum card — ut maiorem numerum identicorum acciperent. Haec methodus chartam cum similibus valoribus reddet.

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

Plusque una methodus opus est ad chartas in initio versandas. Prorogationem classis ordinatae dabimus.

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

Atque hic exsecutio est Codicis exemplar cum omnibus proprietatibus et methodis 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() }
        }
    }
}

Perge.

Secundum exemplar est MemoriaGame, hic 4*4 eget. Exemplar proprietates habebunt ut chartae (inclusio chartarum in craticulae), chartarum instructarum cum chartis iam apertis, et boolean variabilis indagat ut statum ludi indagat.

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

Etiam methodos evolvere debemus ut user commercium cum malesuada euismod moderari.

Methodus quae chartas terit in malesuada euismod.

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

Modus creandi novum ludum. Hic primam methodum vocamus ut inceptandi initialis extensionis et initializet lusus variabilis ad verum.

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

Si ludum sileo velimus, tunc isPlaying variabilis ad falsas et falsas ponemus et initialem chartarum intentionem removemus.

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

Modum examinandi clicked pecto. Plura de eo postea.

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

Methodus quae redit positionem certae card.

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

Reperiens obsequium delectae card cum vexillum.

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

Haec methodus ultimum elementum in cardsShown ordinata legit et cardo non-aequante redit.

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 et GameController.swift

Main.storyboard aliquid simile hoc spectat:

Initio, debes novum ludum constituere sicut in moderatoris viewDidLoad, etiam imagines pro malesuada euismod. In ludo, haec omnia repraesentabuntur per 4*4 collectionView. Si nondum nota cum collectionView, hic est vos can adepto vos postulo indicium.

GameController applicationem radicis moderatoris configurabimus. GameController collectionem habebit quam ut IBOutlet referemus. Alia relatio ad conjunctionem IBAction onStartGame, hoc est UIButton, videre potes in fabula fabula quae vocatur.

Paulo de exsecutione moderatoris:

• Primum initializemus duas res principales - eget: ludus = MemoriaGame(), et tabulae chartarum: chartarum = [Card]().
• Initiales variabiles pro viewDidLoad constituimus, primus modus est qui vocatur dum ludus currit.
• collectionView in occulto positum est quia omnes chartae occultae sunt donec usor urget PLAY.
• Cum primum LUDO premamus, sectionem inStartGame IBAction incipit, et collectionem View occultam rem falsam constituimus ut chartae visibiles fieri possint.
• Quoties usor deligit schedulam, modus didSelectItemAt appellatur. In methodo didSelectCard appellamus ad efficiendum logicam principalem ludum.

Hic est exsecutio finalis 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)
    }
}

Nunc pauca de momentis protocollis loquamur.

Protocols

Protocolla laborat nucleus Celeri programmatio. Protocolla praebent facultatem regulas definiendi genus, structuram, vel enumerationem. Hoc principium tibi permittit ut codicem modularem et extensum scribere. Re vera, hoc exemplum est quod iam in collectione View in GameController exsequuntur. Nunc versionem nostram faciamus. Syntaxis similis haec erit:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

Scimus protocollum nos permittere ut regulas vel instructiones definiamus ad genus exsequendum, ut cogitemus quid debeant. Quattuor opus est summa.

• Ludus initium: memoryGameDidStart.
• Opus est ut card faciem tuam convertas: memoryGameShowCards.
• Opus est ut card faciem tuam convertas: memoryGameHideCards.
• Ludus finis: memoryGameDidEnd.

Omnes quattuor modi effici possunt pro genere principali, quod est GameController.

memoryGameDidStart

Cum haec methodus currit, ludus debet incipere (utentis LUDO pressit). Simpliciter hic materiam explicabimus appellando collectioneView.reloadData(), quae chartulas miscebit.

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

memoryGameShowCards

Hanc methodum vocamus ex collectionSDViewSelectItemAt. Primo ostendit electum card. Deinde impedit ut videam an cardo singularis sit in schedulis instructis (si numerus cardsShown est impar). Si adsit, chartae selectae cum ea comparantur. Si picturae eaedem sunt, ambae chartae ad chartas Shown accedunt et faciem sursum manent. Si diversum est, chartae folia chartae monstrantur et utraque facies deflexa est.

memoryGameHideCards

Si schedae non concordant, haec methodus appellatur et imagines schedae occultantur.

ostensum est = falsum.

memoryGameDidEnd

Cum haec methodus appellatur, significat omnes chartas iam revelatas esse et in indice chartarum Shown: pectoShown.count = cards.count, praeludio finito. Methodus speciatim appellatur postquam finem Ludus() appellavimus ut isPlaying var ad falsum exponeret, post quem nuntius ludus finis ostenditur. Etiam alertController index pro moderatoris adhibetur. viewDidDisappear dicitur ac ludus reset.

Ecce id quod totum spectat sicut in 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()
    }
}

Profecto id omne. Hoc consilio uti potes ad versionem tuam ludum creare.

Felix coding!

Skillbox commendat:

• Cursus practicus "Mobile Developer PRO".
• De online cursum "Python Data Analyst".
• Duo annorum cursum "Pro elit sum".

Source: www.habr.com