ਸਵਿਫਟ ਵਿੱਚ ਇੱਕ ਮੈਮੋਰੀ ਕਾਰਡ ਗੇਮ ਲਿਖਣਾ

ਇਹ ਲੇਖ ਇੱਕ ਸਧਾਰਨ ਮੈਮੋਰੀ ਸਿਖਲਾਈ ਗੇਮ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ ਜਿਸਦਾ ਮੈਂ ਸੱਚਮੁੱਚ ਅਨੰਦ ਲੈਂਦਾ ਹਾਂ. ਆਪਣੇ ਆਪ ਵਿੱਚ ਚੰਗੇ ਹੋਣ ਦੇ ਇਲਾਵਾ, ਤੁਸੀਂ ਜਾਂਦੇ ਸਮੇਂ Swift ਕਲਾਸਾਂ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲ ਬਾਰੇ ਥੋੜਾ ਹੋਰ ਸਿੱਖੋਗੇ। ਪਰ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਸ਼ੁਰੂ ਕਰੀਏ, ਆਓ ਖੇਡ ਨੂੰ ਸਮਝੀਏ।

ਅਸੀਂ ਯਾਦ ਦਿਵਾਉਂਦੇ ਹਾਂ: "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 ਗਰਿੱਡ ਸੈਟ ਕਰਦੇ ਹਾਂ। ਮਾਡਲ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹੋਣਗੀਆਂ ਜਿਵੇਂ ਕਿ ਕਾਰਡ (ਗਰਿੱਡ 'ਤੇ ਕਾਰਡਾਂ ਦੀ ਇੱਕ ਐਰੇ), ਇੱਕ ਕਾਰਡ ਪਹਿਲਾਂ ਤੋਂ ਖੁੱਲ੍ਹੇ ਕਾਰਡਾਂ ਦੇ ਨਾਲ ਦਿਖਾਈ ਗਈ ਐਰੇ, ਅਤੇ ਇੱਕ ਬੁਲੀਅਨ ਵੇਰੀਏਬਲ 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 ਵੇਰੀਏਬਲ ਨੂੰ ਸਹੀ ਵਿੱਚ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਪਹਿਲੀ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਦੇ ਹਾਂ।

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 ਕਲੈਕਸ਼ਨ ਵਿਊ ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ ਅਜੇ ਕਲੈਕਸ਼ਨਵਿਊ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹੋ, ਤਾਂ ਇਹ ਇੱਥੇ ਹੈ ਤੁਸੀਂ ਲੋੜੀਂਦੀ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ.

ਅਸੀਂ GameController ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਰੂਟ ਕੰਟਰੋਲਰ ਵਜੋਂ ਕੌਂਫਿਗਰ ਕਰਾਂਗੇ। ਗੇਮਕੰਟਰੋਲਰ ਕੋਲ ਇੱਕ ਕਲੈਕਸ਼ਨ ਵਿਊ ਹੋਵੇਗਾ ਜਿਸਦਾ ਅਸੀਂ ਇੱਕ 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)
    }
}

ਆਓ ਹੁਣ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰੋਟੋਕੋਲ ਬਾਰੇ ਥੋੜੀ ਗੱਲ ਕਰੀਏ.

ਪ੍ਰੋਟੋਕੋਲ

ਪ੍ਰੋਟੋਕੋਲ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸਵਿਫਟ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਹੈ। ਪ੍ਰੋਟੋਕੋਲ ਇੱਕ ਕਲਾਸ, ਬਣਤਰ, ਜਾਂ ਗਣਨਾ ਲਈ ਨਿਯਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ। ਇਹ ਸਿਧਾਂਤ ਤੁਹਾਨੂੰ ਮਾਡਯੂਲਰ ਅਤੇ ਐਕਸਟੈਂਸੀਬਲ ਕੋਡ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਵਾਸਤਵ ਵਿੱਚ, ਇਹ ਇੱਕ ਪੈਟਰਨ ਹੈ ਜੋ ਅਸੀਂ ਗੇਮਕੰਟਰੋਲਰ ਵਿੱਚ ਕਲੈਕਸ਼ਨਵਿਊ ਲਈ ਪਹਿਲਾਂ ਹੀ ਲਾਗੂ ਕਰ ਰਹੇ ਹਾਂ। ਆਉ ਹੁਣ ਆਪਣਾ ਸੰਸਕਰਣ ਬਣਾਉਂਦੇ ਹਾਂ। ਸੰਟੈਕਸ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਇੱਕ ਪ੍ਰੋਟੋਕੋਲ ਸਾਨੂੰ ਕਲਾਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਨਿਯਮਾਂ ਜਾਂ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਆਓ ਇਸ ਬਾਰੇ ਸੋਚੀਏ ਕਿ ਉਹ ਕੀ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਕੁੱਲ ਚਾਰ ਦੀ ਲੋੜ ਹੈ।

• ਗੇਮ ਸ਼ੁਰੂ: memoryGameDidStart.
• ਤੁਹਾਨੂੰ ਕਾਰਡ ਨੂੰ ਹੇਠਾਂ ਵੱਲ ਮੋੜਨ ਦੀ ਲੋੜ ਹੈ: memoryGameShowCards।
• ਤੁਹਾਨੂੰ ਕਾਰਡ ਨੂੰ ਹੇਠਾਂ ਵੱਲ ਮੋੜਨ ਦੀ ਲੋੜ ਹੈ: memoryGameHideCards।
• ਗੇਮ ਦਾ ਅੰਤ: memoryGameDidEnd।

ਸਾਰੇ ਚਾਰ ਤਰੀਕਿਆਂ ਨੂੰ ਮੁੱਖ ਕਲਾਸ ਲਈ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਗੇਮ ਕੰਟਰੋਲਰ ਹੈ।

memoryGameDidStart

ਜਦੋਂ ਇਹ ਵਿਧੀ ਚਲਾਈ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਗੇਮ ਸ਼ੁਰੂ ਹੋ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ (ਉਪਭੋਗਤਾ PLAY ਨੂੰ ਦਬਾਉਦਾ ਹੈ)। ਇੱਥੇ ਅਸੀਂ collectionView.reloadData() ਨੂੰ ਕਾਲ ਕਰਕੇ ਸਮੱਗਰੀ ਨੂੰ ਮੁੜ ਲੋਡ ਕਰਾਂਗੇ, ਜੋ ਕਾਰਡਾਂ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ।

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

ਮੈਮੋਰੀ ਗੇਮਸ਼ੋਕਾਰਡਸ

ਅਸੀਂ ਇਸ ਵਿਧੀ ਨੂੰ collectionSDViewSelectItemAt ਤੋਂ ਕਾਲ ਕਰਦੇ ਹਾਂ। ਪਹਿਲਾਂ ਇਹ ਚੁਣਿਆ ਕਾਰਡ ਦਿਖਾਉਂਦਾ ਹੈ। ਫਿਰ ਇਹ ਦੇਖਣ ਲਈ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕਾਰਡ ਦਿਖਾਏ ਗਏ ਐਰੇ ਵਿੱਚ ਕੋਈ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਕਾਰਡ ਹੈ (ਜੇਕਰ ਦਿਖਾਏ ਗਏ ਕਾਰਡਾਂ ਦੀ ਗਿਣਤੀ ਅਜੀਬ ਹੈ)। ਜੇਕਰ ਇੱਕ ਹੈ, ਤਾਂ ਚੁਣੇ ਹੋਏ ਕਾਰਡ ਦੀ ਤੁਲਨਾ ਇਸ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਤਸਵੀਰਾਂ ਇੱਕੋ ਜਿਹੀਆਂ ਹਨ, ਤਾਂ ਦੋਵੇਂ ਕਾਰਡ ਦਿਖਾਏ ਗਏ ਕਾਰਡਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸਾਹਮਣੇ ਰਹਿੰਦੇ ਹਨ। ਜੇਕਰ ਵੱਖੋ-ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਕਾਰਡ ਛੱਡੇ ਕਾਰਡ ਦਿਖਾਏ ਜਾਂਦੇ ਹਨ ਅਤੇ ਦੋਵੇਂ ਮੂੰਹ ਹੇਠਾਂ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

MemoryGameHideCards

ਜੇਕਰ ਕਾਰਡ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ, ਤਾਂ ਇਸ ਵਿਧੀ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਾਰਡ ਚਿੱਤਰਾਂ ਨੂੰ ਲੁਕਾਇਆ ਜਾਂਦਾ ਹੈ।

ਦਿਖਾਇਆ = ਝੂਠਾ।

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