Swift တွင် Memory Cards Game ရေးခြင်း။

ဤဆောင်းပါးသည် ကျွန်ုပ်တကယ်နှစ်သက်သော ရိုးရှင်းသော မှတ်ဉာဏ်လေ့ကျင့်ရေးဂိမ်းကို ဖန်တီးသည့် လုပ်ငန်းစဉ်ကို ဖော်ပြသည်။ သူ့ဘာသာသူ ကောင်းကောင်းနေနိုင်တဲ့အပြင်၊ သင်သွားရင်းနဲ့ Swift အတန်းတွေနဲ့ ပရိုတိုကောတွေအကြောင်း နည်းနည်းထပ်လေ့လာမယ်။ ဒါပေမယ့် ကျွန်တော်တို့ မစခင်၊ ဂိမ်းကို ကိုယ်တိုင် နားလည်ကြရအောင်။

ငါတို့မင်းကိုသတိပေးတယ် "Habr" ၏စာဖတ်သူအားလုံးအတွက် - "Habr" ပရိုမိုးရှင်းကုဒ်ကို အသုံးပြု၍ မည်သည့် Skillbox သင်တန်းတွင်စာရင်းသွင်းသည့်အခါ 10 ရူဘယ်လျှော့စျေး။

Skillbox မှ အကြံပြုထားသည်- ပညာရေးအွန်လိုင်းသင်တန်း "Profession Java developer".

Memory Card ကစားနည်း

ဂိမ်းသည် ကတ်အစုံကို သရုပ်ပြခြင်းဖြင့် စတင်သည်။ မှောက်လျက်အိပ်ကြသည် (အသီးသီး၊ ဆင်းတုတော်)။ တစ်ခုခုကို နှိပ်လိုက်သောအခါ၊ ပုံသည် စက္ကန့်အနည်းငယ်ကြာ ပွင့်လာသည်။

ကစားသမား၏တာဝန်မှာ တူညီသောပုံများပါသည့် ကတ်အားလုံးကို ရှာဖွေရန်ဖြစ်သည်။ ပထမကတ်ကိုဖွင့်ပြီးနောက်၊ သင်သည် ဒုတိယမြောက်ကိုလှည့်ပြီး ပုံများကိုက်ညီပါက ကတ်နှစ်ခုစလုံးသည် ဆက်လက်ပွင့်နေမည်ဖြစ်သည်။ မကိုက်ညီပါက ကတ်များကို ထပ်မံပိတ်ပါမည်။ ရည်မှန်းချက်က အရာအားလုံးကို ဖွင့်ဟဖို့ပါ။

စီမံကိန်းဖွဲ့စည်းပုံ

ဤဂိမ်း၏ ရိုးရှင်းသောဗားရှင်းကို ဖန်တီးရန် အောက်ပါ အစိတ်အပိုင်းများ လိုအပ်သည် ။

• ထိန်းချုပ်ကိရိယာတစ်ခု- GameController.swift။
• One View- CardCell.swift။
• မော်ဒယ်နှစ်မျိုး- MemoryGame.swift နှင့် Card.swift။
• အစိတ်အပိုင်းအစုံအလင်ကို ရရှိနိုင်ကြောင်း သေချာစေရန် Main.storyboard

ကျွန်ုပ်တို့သည် ဂိမ်း၏ အရိုးရှင်းဆုံး အစိတ်အပိုင်းဖြစ်သော ကတ်များဖြင့် စတင်ပါသည်။

Card.swift

ကတ်မော်ဒယ်တွင် ဂုဏ်သတ္တိ သုံးခုရှိပါမည်- တစ်ခုစီကို ခွဲခြားရန် id၊ ကတ်၏ အခြေအနေကို သတ်မှတ်ရန် ပြထားသည့် boolean variable တစ်ခုနှင့် ကတ်များရှိ ပုံများအတွက် artworkURL။

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

မြေပုံများနှင့် အသုံးပြုသူ အပြန်အလှန်ဆက်သွယ်မှုကို ထိန်းချုပ်ရန်အတွက် သင်သည် ဤနည်းလမ်းများကို လိုအပ်လိမ့်မည်-

ကတ်ပေါ်တွင် ပုံတစ်ပုံကို ပြသရန် နည်းလမ်း။ ဤတွင် ကျွန်ုပ်တို့သည် ဂုဏ်သတ္တိအားလုံးကို ပုံသေအဖြစ် ပြန်လည်သတ်မှတ်သည်။ id အတွက်၊ ကျွန်ုပ်တို့သည် NSUUIS(.uuidString) ကိုခေါ်ဆိုခြင်းဖြင့် ကျပန်း id ကိုထုတ်ပေးပါသည်။

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

ID ကတ်များကို နှိုင်းယှဉ်နည်း။

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 class ရဲ့ extension တစ်ခုဖြစ်အောင် လုပ်မယ်။

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 ဇယားကွက်ကို သတ်မှတ်သည်။ မော်ဒယ်တွင် ကတ်များ (ဂရစ်တစ်ခုပေါ်ရှိ ကတ်များ အခင်းအကျင်းတစ်ခု)၊ ဖွင့်ထားပြီးသော ကတ်များဖြင့် ပြသထားသည့် ခင်းကျင်းတစ်ခု၊ ဂိမ်း၏ အခြေအနေကို ခြေရာခံရန် boolean variable 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 variable ကို true အဖြစ် စတင်ရန် ပထမနည်းလမ်းကို ခေါ်သည်။

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

ဂိမ်းကို ပြန်လည်စတင်လိုပါက၊ ထို့နောက်ကျွန်ုပ်တို့သည် isPlaying variable ကို 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 controller အဖြစ် သတ်မှတ်ပေးပါမည်။ GameController တွင် ကျွန်ုပ်တို့ IBOoutlet အဖြစ် ရည်ညွှန်းမည့် collectionView တစ်ခုရှိပါမည်။ နောက်ထပ်ရည်ညွှန်းချက်မှာ IBAction onStartGame() ခလုတ်အတွက်၊ ၎င်းသည် UIButton ဖြစ်ပြီး၊ ၎င်းကို PLAY ဟုခေါ်သော ဇတ်လမ်းဘုတ်တွင် သင်တွေ့နိုင်ပါသည်။

ထိန်းချုပ်ကိရိယာများ အကောင်အထည်ဖော်ခြင်းအကြောင်း အနည်းငယ်။

• ပထမဦးစွာ ကျွန်ုပ်တို့သည် အဓိက အရာဝတ္ထု နှစ်ခု - ဇယားကွက်- ဂိမ်း = MemoryGame(), နှင့် ကတ်များ- ကတ်များ = [ကတ်]().
• ကျွန်ုပ်တို့သည် ကနဦး variable များကို 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)
    }
}

အခု အရေးကြီးတဲ့ ပရိုတိုကောတွေအကြောင်း နည်းနည်းပြောရအောင်။

Protocols များ

ပရိုတိုကောများနှင့် အလုပ်လုပ်ခြင်းသည် Swift ပရိုဂရမ်းမင်း၏ အဓိကအချက်ဖြစ်သည်။ ပရိုတိုကောများသည် အတန်း၊ ဖွဲ့စည်းပုံ သို့မဟုတ် စာရင်းကောက်ခြင်းအတွက် စည်းမျဉ်းများကို သတ်မှတ်ရန် စွမ်းရည်ကို ပေးသည်။ ဤနိယာမသည် သင့်အား modular နှင့် extensible code ရေးနိုင်သည်။ တကယ်တော့၊ ဒါက GameController ရှိ collectionView အတွက် အကောင်အထည်ဖော်ပြီးသား ပုံစံတစ်ခုပါ။ ယခုကျွန်ုပ်တို့၏ကိုယ်ပိုင်ဗားရှင်းကိုလုပ်ကြပါစို့။ syntax သည် ဤကဲ့သို့ဖြစ်နေလိမ့်မည်-

protocol MemoryGameProtocol {
    //protocol definition goes here
}

ပရိုတိုကောတစ်ခုသည် အတန်းတစ်ခုကို အကောင်အထည်ဖော်ရန်အတွက် စည်းမျဉ်းများ သို့မဟုတ် ညွှန်ကြားချက်များကို သတ်မှတ်ရန် သင့်အား ခွင့်ပြုကြောင်း ကျွန်ုပ်တို့သိသည်၊ ထို့ကြောင့် ၎င်းတို့သည် အဘယ်အရာဖြစ်သင့်သည်ကို စဉ်းစားကြည့်ကြပါစို့။ စုစုပေါင်း လေးခုလိုပါတယ်။

• ဂိမ်းစတင်ခြင်း- memoryGameDidStart။
• သင်သည် ကတ်ကို အောက်သို့လှည့်ရန် လိုအပ်သည်- memoryGameShowCards။
• သင်သည် ကတ်ကို အောက်သို့လှည့်ရန် လိုအပ်သည်- memoryGameHideCards။
• ဂိမ်းအဆုံး- memoryGameDidEnd။

GameController ဖြစ်သည့် main class အတွက် နည်းလမ်းလေးခုလုံးကို အကောင်အထည်ဖော်နိုင်ပါသည်။

memoryGameDidStart

ဤနည်းလမ်းကိုလုပ်ဆောင်သောအခါ၊ ဂိမ်းစတင်သင့်သည် (အသုံးပြုသူသည် PLAY ကိုနှိပ်သည်)။ ဤတွင် ကျွန်ုပ်တို့သည် collectionView.reloadData() ကိုခေါ်ဆိုခြင်းဖြင့် အကြောင်းအရာကို ကတ်များကို shuffle လုပ်ပါမည်။

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

memoryGameShowCards

ဤနည်းလမ်းကို collectionSDViewSelectItemAt မှခေါ်ဆိုပါသည်။ ပထမဦးစွာ ရွေးချယ်ထားသော ကတ်ကို ပြပါ။ ထို့နောက် cardsShown array တွင် မယှဉ်နိုင်သော ကတ်တစ်ခု ရှိမရှိ (ပြသထားသော ကတ်အရေအတွက် ထူးဆန်းပါက) စစ်ဆေးပါ။ တစ်ခုရှိလျှင် ရွေးချယ်ထားသောကတ်ကို ၎င်းနှင့် နှိုင်းယှဉ်ပါသည်။ ပုံများသည် တူညီပါက၊ ကတ်နှစ်ခုလုံးကို ပြသထားသော ကတ်များထဲသို့ ပေါင်းထည့်ကာ မျက်နှာပေါ်တွင် ရှိနေမည်ဖြစ်သည်။ မတူညီပါက၊ ကတ်သည် ကတ်များကိုပြသပြီး နှစ်ခုလုံးကို မှောက်လျက်လှန်ထားသည်။

memoryGameHideCards

ကတ်များနှင့် မကိုက်ညီပါက၊ ဤနည်းလမ်းကို ခေါ်ပြီး ကတ်ပုံများကို ဝှက်ထားသည်။

ပြသည် = မှားသော။

memoryGameDidEnd

ဤနည်းလမ်းကို ခေါ်သောအခါ၊ ကတ်များအားလုံးကို ထုတ်ဖော်ပြီးဖြစ်ကြောင်း ဆိုလိုသည်မှာ cardsShown list ထဲတွင် ရှိနေသည်- cardsShown.count = cards.count, ထို့ကြောင့် ဂိမ်းပြီးသွားပါပြီ။ isPlaying var ကို false ဟုသတ်မှတ်ရန် endGame() ကိုခေါ်ပြီးနောက်၊ ဂိမ်းအဆုံးသတ်မက်ဆေ့ချ်ကိုပြသပြီးနောက် အဆိုပါနည်းလမ်းကို အတိအကျခေါ်သည်။ ထို့အပြင် alertController ကို controller အတွက်ညွှန်ပြချက်အဖြစ်အသုံးပြုသည်။ 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 မှ အကြံပြုထားသည်-

• လက်တွေ့သင်တန်း "မိုဘိုင်း Developer PRO".
• အသုံးချ အွန်လိုင်းသင်တန်း "Python Data Analyst".
• နှစ်နှစ်စာလက်တွေ့သင်တန်း "ကျွန်တော်က PRO ဝဘ် developer တစ်ယောက်ပါ".

source: www.habr.com