स्विफ्टमध्ये मेमरी कार्ड गेम लिहिणे

हा लेख एक साधा मेमरी प्रशिक्षण गेम तयार करण्याच्या प्रक्रियेचे वर्णन करतो ज्याचा मला खरोखर आनंद होतो. स्वतः चांगले असण्याव्यतिरिक्त, तुम्ही जाताना स्विफ्ट क्लासेस आणि प्रोटोकॉलबद्दल थोडे अधिक जाणून घ्याल. पण आपण सुरू करण्यापूर्वी, खेळ स्वतः समजून घेऊ.

आम्ही आठवण करून देतो: सर्व Habr वाचकांसाठी - Habr प्रोमो कोड वापरून कोणत्याही स्किलबॉक्स कोर्समध्ये नावनोंदणी करताना 10 रूबल सवलत.

स्किलबॉक्स शिफारस करतो: शैक्षणिक ऑनलाइन अभ्यासक्रम "प्रोफेशन जावा डेव्हलपर".

मेमरी कार्ड कसे खेळायचे

खेळाची सुरुवात पत्त्यांच्या संचाच्या प्रात्यक्षिकाने होते. ते तोंड करून झोपतात (अनुक्रमे, प्रतिमा खाली). जेव्हा तुम्ही कोणत्याही एकावर क्लिक करता तेव्हा प्रतिमा काही सेकंदांसाठी उघडते.

खेळाडूचे कार्य समान चित्रांसह सर्व कार्डे शोधणे आहे. जर, पहिले कार्ड उघडल्यानंतर, तुम्ही दुसरे कार्ड उलटले आणि चित्रे जुळली, तर दोन्ही कार्डे उघडी राहतील. ते जुळत नसल्यास, कार्डे पुन्हा बंद केली जातात. सर्व काही उघडण्याचे ध्येय आहे.

प्रकल्प रचना

या गेमची सोपी आवृत्ती तयार करण्यासाठी तुम्हाला खालील घटकांची आवश्यकता आहे:

• एक नियंत्रक: GameController.swift.
• एक दृश्य: CardCell.swift.
• दोन मॉडेल: MemoryGame.swift आणि Card.swift.
• घटकांचा संपूर्ण संच उपलब्ध असल्याची खात्री करण्यासाठी Main.storyboard.

आम्ही खेळाच्या सर्वात सोप्या घटकापासून सुरुवात करतो, कार्ड्स.

कार्ड.स्विफ्ट

कार्ड मॉडेलमध्ये तीन गुणधर्म असतील: प्रत्येक ओळखण्यासाठी आयडी, कार्डची स्थिती (लपलेले किंवा उघडे) निर्दिष्ट करण्यासाठी दर्शविलेले बुलियन व्हेरिएबल आणि कार्डवरील प्रतिमांसाठी आर्टवर्क URL.

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

नकाशांसह वापरकर्ता परस्परसंवाद नियंत्रित करण्यासाठी तुम्हाला या पद्धतींची देखील आवश्यकता असेल:

कार्डवर प्रतिमा प्रदर्शित करण्याची पद्धत. येथे आम्ही सर्व गुणधर्म डीफॉल्टवर रीसेट करतो. आयडीसाठी, आम्ही 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    
}

आणि सुरुवातीला कार्ड्स शफल करण्यासाठी आणखी एक पद्धत आवश्यक आहे. आम्ही ते अॅरे वर्गाचा विस्तार करू.

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

आणि येथे सर्व गुणधर्म आणि पद्धतींसह कार्ड मॉडेलसाठी कोडची अंमलबजावणी आहे.

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 ग्रिड सेट करतो. मॉडेलमध्ये कार्ड (ग्रिडवरील कार्ड्सचा अॅरे), कार्ड्स आधीच उघडलेले कार्ड दाखवलेले अॅरे आणि गेमच्या स्थितीचा मागोवा घेण्यासाठी एक बुलियन व्हेरिएबल प्लेइंग सारखे गुणधर्म असतील.

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 व्हेरिएबल असत्य वर सेट करतो आणि कार्ड्सचा प्रारंभिक लेआउट काढून टाकतो.

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
}

ही पद्धत **कार्ड दाखवलेल्या** अॅरेमधील शेवटचा घटक वाचते आणि न जुळणारे कार्ड परत करते.

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 कलेक्शन व्ह्यूद्वारे दर्शविले जाईल. आपण अद्याप कलेक्शन व्ह्यूशी परिचित नसल्यास, ते येथे आहे तुम्हाला हवी असलेली माहिती तुम्ही मिळवू शकता.

आम्ही गेमकंट्रोलरला ऍप्लिकेशनचा रूट कंट्रोलर म्हणून कॉन्फिगर करू. गेमकंट्रोलरकडे एक कलेक्शन व्ह्यू असेल ज्याचा आम्ही IBOutlet म्हणून संदर्भ देऊ. दुसरा संदर्भ IBAction onStartGame() बटणाचा आहे, हे UIButton आहे, तुम्ही ते PLAY नावाच्या स्टोरीबोर्डमध्ये पाहू शकता.

नियंत्रकांच्या अंमलबजावणीबद्दल थोडेसे:

• प्रथम, आम्ही दोन मुख्य ऑब्जेक्ट्स सुरू करतो - ग्रिड: गेम = मेमरी गेम(), आणि कार्ड्सचा संच: कार्ड्स = [कार्ड]().
• आम्ही प्रारंभिक व्हेरिएबल्स viewDidLoad म्हणून सेट करतो, ही पहिली पद्धत आहे जी गेम चालू असताना कॉल केली जाते.
• संग्रह दृश्य लपविलेले वर सेट केले आहे कारण वापरकर्ता प्ले दाबेपर्यंत सर्व कार्ड लपवले जातात.
• आम्ही PLAY दाबताच, onStartGame IBAction विभाग सुरू होतो आणि आम्ही collectionView isHidden प्रॉपर्टी खोट्यावर सेट करतो जेणेकरून कार्ड दृश्यमान होतील.
• प्रत्येक वेळी वापरकर्ता कार्ड निवडतो तेव्हा didSelectItemAt पद्धत कॉल केली जाते. मुख्य गेम लॉजिक लागू करण्यासाठी आम्ही didSelectCard म्हणतो त्या पद्धतीमध्ये.

येथे अंतिम गेमकंट्रोलर अंमलबजावणी आहे:

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)
    }
}

आता महत्त्वाच्या प्रोटोकॉलबद्दल थोडे बोलूया.

प्रोटोकॉल

प्रोटोकॉलसह कार्य करणे हा स्विफ्ट प्रोग्रामिंगचा मुख्य भाग आहे. प्रोटोकॉल वर्ग, रचना किंवा गणनेसाठी नियम परिभाषित करण्याची क्षमता प्रदान करतात. हे तत्त्व तुम्हाला मॉड्यूलर आणि एक्स्टेंसिबल कोड लिहिण्याची परवानगी देते. खरं तर, हा एक नमुना आहे जो आम्ही आधीच GameController मध्ये collectionView साठी लागू करत आहोत. आता आपली स्वतःची आवृत्ती बनवूया. वाक्यरचना असे दिसेल:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

आम्हाला माहित आहे की प्रोटोकॉल आम्हाला वर्ग लागू करण्यासाठी नियम किंवा सूचना परिभाषित करण्याची परवानगी देतो, म्हणून ते काय असावेत याचा विचार करूया. तुम्हाला एकूण चारची गरज आहे.

• गेम प्रारंभ: memoryGameDidStart.
• तुम्हाला कार्डचा चेहरा खाली करणे आवश्यक आहे: memoryGameShowCards.
• तुम्हाला कार्डचा चेहरा खाली करणे आवश्यक आहे: memoryGameHideCards.
• गेमचा शेवट: memoryGameDidEnd.

सर्व चार पद्धती मुख्य वर्गासाठी लागू केल्या जाऊ शकतात, जे गेमकंट्रोलर आहे.

मेमरीगेमडिडस्टार्ट

जेव्हा ही पद्धत चालवली जाते, तेव्हा गेम सुरू झाला पाहिजे (वापरकर्ता प्ले दाबतो). येथे आम्ही फक्त collectionView.reloadData() वर कॉल करून सामग्री रीलोड करू, जे कार्ड्स शफल करेल.

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

मेमरीगेमशोकार्ड्स

आम्ही या पद्धतीला संग्रह SDViewSelectItemAt वरून कॉल करतो. प्रथम ते निवडलेले कार्ड दाखवते. नंतर कार्ड दाखवलेल्या अॅरेमध्ये न जुळणारे कार्ड आहे का ते तपासा (कार्डांची संख्या विषम असल्यास) एक असल्यास, निवडलेल्या कार्डची त्याच्याशी तुलना केली जाते. जर चित्रे सारखी असतील, तर दोन्ही कार्डे कार्ड्समध्ये जोडली जातात आणि समोरासमोर राहतात. भिन्न असल्यास, कार्ड सोडले कार्ड दाखवले आणि दोन्ही तोंड खाली केले.

मेमरीगेमहाइडकार्ड्स

कार्ड जुळत नसल्यास, ही पद्धत कॉल केली जाते आणि कार्ड प्रतिमा लपवल्या जातात.

दर्शविलेले = खोटे.

memoryGameDidEnd

जेव्हा ही पद्धत कॉल केली जाते, तेव्हा याचा अर्थ असा होतो की सर्व कार्ड आधीच उघड झाले आहेत आणि कार्ड दर्शविलेल्या सूचीमध्ये आहेत: cardsShown.count = cards.count, त्यामुळे गेम संपला आहे. isPlaying var खोट्यावर सेट करण्यासाठी आम्ही endGame() ला कॉल केल्यानंतर ही पद्धत विशेषतः कॉल केली जाते, त्यानंतर गेम समाप्तीचा संदेश दर्शविला जातो. तसेच alertController चा वापर नियंत्रकासाठी सूचक म्हणून केला जातो. viewDidDisappear म्हणतात आणि गेम रीसेट केला जातो.

गेमकंट्रोलरमध्ये हे सर्व कसे दिसते ते येथे आहे:

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()
    }
}

वास्तविक, ते सर्व आहे. तुम्ही गेमची तुमची स्वतःची आवृत्ती तयार करण्यासाठी हा प्रकल्प वापरू शकता.

आनंदी कोडिंग!

स्किलबॉक्स शिफारस करतो:

• प्रॅक्टिकल कोर्स "मोबाइल डेव्हलपर प्रो".
• ऑनलाईन कोर्स लागू केला "पायथन डेटा विश्लेषक".
• दोन वर्षांचा प्रॅक्टिकल कोर्स "मी प्रो वेब डेव्हलपर आहे".

स्त्रोत: www.habr.com