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

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

हम आपको याद दिलाते हैं: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रोमो कोड का उपयोग करके किसी भी स्किलबॉक्स कोर्स के लिए पंजीकरण करते समय 10,000 रूबल की छूट।

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

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

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

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

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

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

• एक नियंत्रक: GameController.swift।
• एक दृश्य: CardCell.swift।
• दो मॉडल: MemoryGame.swift और Card.swift।
• Main.storyboard ताकि घटकों का पूरा सेट उपलब्ध हो।

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

Card.swift

कार्ड मॉडल में तीन गुण होंगे: प्रत्येक की पहचान करने के लिए आईडी, कार्ड पर चित्रों के लिए कार्ड की स्थिति (छिपे या खुले) और कलाकृति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() } } } } 

आगे बढ़ो।

दूसरा मॉडल मेमोरीगैम है, यहां हम 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 } 

नया गेम बनाने की विधि। यहां हम प्रारंभिक लेआउट को शुरू करने के लिए पहला तरीका कहते हैं और वेरिएबल को इनिशियलाइज़ करना सही है।

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

यदि हम खेल को फिर से शुरू करना चाहते हैं, तो कार्ड को प्रारंभिक लेआउट को गलत और हटाने के लिए आइसप्लिंग चर सेट करें।

 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 संग्रह दृश्य द्वारा दर्शाया जाएगा। यदि आप collectionView से परिचित नहीं हैं, तो यहां आप आवश्यक जानकारी प्राप्त कर सकते हैं ।

हम गेमकंट्रोलर को एप्लिकेशन के रूट कंट्रोलर के रूप में कॉन्फ़िगर करेंगे। GameController में एक संग्रह दृश्य होगा, जिसे हम एक IBOutlet के रूप में संदर्भित करेंगे। एक और लिंक IBAction onStartGame () बटन पर है, यह UIButton है, आप इसे प्लेबोर्ड नामक स्टोरीबोर्ड में देख सकते हैं।

नियंत्रकों के कार्यान्वयन के बारे में थोड़ा सा:

• सबसे पहले, हम दो मुख्य वस्तुओं को शुरू करते हैं - ग्रिड (गेम): गेम = मेमोरीगैम (), और कार्ड के सेट पर: कार्ड = [कार्ड] ()।
• प्रारंभिक चर को viewDidLoad के रूप में सेट करें, यह पहला तरीका है जिसे गेम के दौरान कहा जाता है।
• संग्रह संग्रह को छुपा के रूप में सेट करें, क्योंकि सभी मैप्स तब तक छिपे रहते हैं जब तक उपयोगकर्ता PLAY को दबाता है।
• जैसे ही हम PLAY को दबाते हैं, onStartGame IBAction सेक्शन शुरू हो जाता है, और हमने संग्रह दृश्य isHidden संपत्ति को सेट कर दिया ताकि कार्ड दिखाई दे सकें।
• जब भी कोई उपयोगकर्ता किसी कार्ड का चयन करता है, तो didSelectItemAt विधि कहा जाता है। विधि में, हम गेम के मूल तर्क को लागू करने के लिए डिसलाइक कार्ड कहते हैं।

यहाँ 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) } } 

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

प्रोटोकॉल

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

 protocol MemoryGameProtocol { //protocol definition goes here } 

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

• खेल की शुरुआत: memoryGameDidStart।
• कार्ड फेस को नीचे फ्लिप करने की आवश्यकता है: memoryGameShowCards।
• कार्ड चेहरा नीचे फ्लिप करने की आवश्यकता: मेमोरीगैमहाइडकार्ड्स।
• गेम पूरा करना: memoryGameDidEnd

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

memoryGameDidStart

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

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

memoryGameShowCards

इस विधि को collectionSDViewSelectItemAt से कॉल करें। सबसे पहले, यह चयनित मानचित्र दिखाता है। फिर यह देखने के लिए जांचता है कि क्या कार्डशाउन एरे में एक बेजोड़ कार्ड है (यदि कार्ड्सहोल्ड की संख्या विषम है)। यदि एक है, तो चयनित कार्ड की तुलना इसके साथ की जाती है। यदि चित्र समान हैं, तो दोनों कार्डों को कार्ड्सहाउन में जोड़ा जाता है और खुले रहते हैं। यदि अलग है, तो कार्ड कार्ड को छोड़ देता है, और दोनों उल्टा हो जाते हैं।

memoryGameHideCards

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

दिखाया = झूठा।

memoryGameDidEnd

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

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

अच्छा कोडिंग!

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

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