स्विफ्ट में मेमोरी कार्ड गेम लिखना

यह आलेख एक सरल मेमोरी प्रशिक्षण गेम बनाने की प्रक्रिया का वर्णन करता है जो मुझे वास्तव में पसंद है। अपने आप में अच्छा होने के अलावा, आप आगे बढ़ते हुए स्विफ्ट कक्षाओं और प्रोटोकॉल के बारे में थोड़ा और सीखेंगे। लेकिन शुरू करने से पहले आइए खेल को समझें।

अनुस्मारक: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रचार कोड का उपयोग करके किसी भी स्किलबॉक्स पाठ्यक्रम में नामांकन करते समय 10 रूबल की छूट।

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

मेमोरी कार्ड कैसे खेलें

खेल ताश के पत्तों के एक सेट के प्रदर्शन के साथ शुरू होता है। वे नीचे की ओर मुंह करके लेटते हैं (क्रमशः, छवि नीचे की ओर)। जब आप किसी पर क्लिक करते हैं तो छवि कुछ सेकंड के लिए खुल जाती है।

खिलाड़ी का कार्य समान चित्रों वाले सभी कार्ड ढूंढना है। यदि, पहला कार्ड खोलने के बाद, आप दूसरा कार्ड पलटते हैं और चित्र मेल खाते हैं, तो दोनों कार्ड खुले रहते हैं। यदि वे मेल नहीं खाते हैं, तो कार्ड फिर से बंद कर दिए जाते हैं। लक्ष्य सब कुछ खोलना है.

परियोजना संरचना

इस गेम का सरल संस्करण बनाने के लिए आपको निम्नलिखित घटकों की आवश्यकता होगी:

• एक नियंत्रक: GameController.swift।
• एक दृश्य: कार्डसेल.स्विफ्ट।
• दो मॉडल: मेमोरीगेम.स्विफ्ट और कार्ड.स्विफ्ट।
• Main.storyboard यह सुनिश्चित करने के लिए कि घटकों का पूरा सेट उपलब्ध है।

हम खेल के सबसे सरल घटक, कार्ड से शुरू करते हैं।

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

कार्ड मॉडल में तीन गुण होंगे: प्रत्येक को पहचानने के लिए आईडी, कार्ड की स्थिति (छिपी या खुली) निर्दिष्ट करने के लिए दिखाया गया एक बूलियन वैरिएबल, और कार्ड पर छवियों के लिए आर्टवर्कयूआरएल।

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

आगे बढ़ें।

दूसरा मॉडल मेमोरीगेम है, यहां हमने 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 वैरिएबल को सत्य पर आरंभ करने के लिए पहली विधि कहते हैं।

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
}

यह विधि **cardsShowed** सरणी में अंतिम तत्व को पढ़ती है और गैर-मिलान वाले कार्ड को वापस कर देती है।

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 नहीं दबाता तब तक सभी कार्ड छिपे रहते हैं।
• जैसे ही हम PLAY दबाते हैं, onStartGame IBAction अनुभाग शुरू हो जाता है, और हम CollectionView isHidden प्रॉपर्टी को गलत पर सेट करते हैं ताकि कार्ड दिखाई दे सकें।
• हर बार जब उपयोगकर्ता कोई कार्ड चुनता है, तो madeSelectItemAt विधि को कॉल किया जाता है। विधि में हम मुख्य गेम लॉजिक को लागू करने के लिए digSelectCard कहते हैं।

यहां अंतिम गेमकंट्रोलर कार्यान्वयन है:

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

अब कुछ महत्वपूर्ण प्रोटोकॉल के बारे में बात करते हैं।

प्रोटोकॉल

प्रोटोकॉल के साथ काम करना स्विफ्ट प्रोग्रामिंग का मूल है। प्रोटोकॉल किसी वर्ग, संरचना या गणना के लिए नियमों को परिभाषित करने की क्षमता प्रदान करते हैं। यह सिद्धांत आपको मॉड्यूलर और एक्स्टेंसिबल कोड लिखने की अनुमति देता है। वास्तव में, यह एक पैटर्न है जिसे हम गेमकंट्रोलर में कलेक्शन व्यू के लिए पहले से ही लागू कर रहे हैं। अब आइए अपना स्वयं का संस्करण बनाएं। सिंटैक्स इस तरह दिखेगा:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

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

• गेम प्रारंभ: मेमोरीगेमडिडस्टार्ट।
• आपको कार्ड को नीचे की ओर करना होगा: मेमोरीगेमशोकार्ड्स।
• आपको कार्ड को नीचे की ओर करना होगा: मेमोरीगेमहाइडकार्ड्स।
• गेम का अंत: मेमोरीगेमडिडएंड।

सभी चार तरीकों को मुख्य वर्ग के लिए लागू किया जा सकता है, जो गेमकंट्रोलर है।

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

जब यह विधि चलाई जाती है, तो गेम शुरू हो जाना चाहिए (उपयोगकर्ता PLAY दबाता है)। यहां हम बस CollectionView.reloadData() को कॉल करके सामग्री को पुनः लोड करेंगे, जो कार्डों को फेरबदल करेगा।

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

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

हम इस विधि को CollectionSDViewSelectItemAt से कहते हैं। सबसे पहले यह चयनित कार्ड दिखाता है. फिर यह देखने के लिए जांच करता है कि कार्ड दिखाए गए सरणी में कोई बेजोड़ कार्ड है (यदि दिखाए गए कार्ड की संख्या विषम है)। यदि कोई है, तो चयनित कार्ड की तुलना उससे की जाती है। यदि चित्र समान हैं, तो दोनों कार्ड दिखाए गए कार्ड में जोड़े जाते हैं और ऊपर की ओर रहते हैं। यदि भिन्न है, तो कार्ड दिखाया गया कार्ड छोड़ देता है और दोनों को नीचे की ओर कर दिया जाता है।

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

यदि कार्ड मेल नहीं खाते हैं, तो इस विधि को बुलाया जाता है और कार्ड की छवियां छिपा दी जाती हैं।

दिखाया गया = झूठा.

मेमोरीगेमडिडएंड

जब इस पद्धति को बुलाया जाता है, तो इसका मतलब है कि सभी कार्ड पहले ही सामने आ चुके हैं और कार्डों की दिखाई गई सूची में हैं: कार्ड्सशोन.काउंट = कार्ड्स.काउंट, इसलिए खेल खत्म हो गया है। विधि को विशेष रूप से तब बुलाया जाता है जब हमने isPlaying var को गलत पर सेट करने के लिए EndGame() को कॉल किया है, जिसके बाद गेम का अंत संदेश दिखाया जाता है। इसके अलावा अलर्टकंट्रोलर का उपयोग नियंत्रक के लिए एक संकेतक के रूप में किया जाता है। 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()
    }
}

दरअसल, बस इतना ही. आप गेम का अपना संस्करण बनाने के लिए इस प्रोजेक्ट का उपयोग कर सकते हैं।

हैप्पी कोडिंग!

स्किलबॉक्स अनुशंसा करता है:

• व्यावहारिक पाठ्यक्रम "मोबाइल डेवलपर प्रो".
• ऑनलाइन पाठ्यक्रम लागू किया "पायथन डेटा विश्लेषक".
• दो वर्षीय व्यावहारिक पाठ्यक्रम "मैं एक PRO वेब डेवलपर हूं".

स्रोत: www.habr.com