ಸ್ವಿಫ್ಟ್‌ನಲ್ಲಿ ಮೆಮೊರಿ ಕಾರ್ಡ್‌ಗಳ ಆಟವನ್ನು ಬರೆಯುವುದು

ಈ ಲೇಖನವು ನಾನು ನಿಜವಾಗಿಯೂ ಇಷ್ಟಪಡುವ ಸರಳ ಮೆಮೊರಿ ತರಬೇತಿ ಆಟವನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಸ್ವತಃ ಉತ್ತಮವಾಗಿರುವುದರ ಜೊತೆಗೆ, ನೀವು ಹೋದಂತೆ ಸ್ವಿಫ್ಟ್ ತರಗತಿಗಳು ಮತ್ತು ಪ್ರೋಟೋಕಾಲ್‌ಗಳ ಕುರಿತು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಕಲಿಯುವಿರಿ. ಆದರೆ ನಾವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಆಟವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.

ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಶೈಕ್ಷಣಿಕ ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "ವೃತ್ತಿ ಜಾವಾ ಡೆವಲಪರ್".

ಮೆಮೊರಿ ಕಾರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಆಡುವುದು

ಆಟವು ಕಾರ್ಡ್‌ಗಳ ಸೆಟ್‌ಗಳ ಪ್ರದರ್ಶನದೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಅವರು ಮುಖಾಮುಖಿಯಾಗಿ ಮಲಗುತ್ತಾರೆ (ಕ್ರಮವಾಗಿ, ಚಿತ್ರ ಕೆಳಗೆ). ನೀವು ಯಾವುದನ್ನಾದರೂ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಚಿತ್ರವು ಕೆಲವು ಸೆಕೆಂಡುಗಳವರೆಗೆ ತೆರೆಯುತ್ತದೆ.

ಒಂದೇ ಚಿತ್ರಗಳೊಂದಿಗೆ ಎಲ್ಲಾ ಕಾರ್ಡ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಆಟಗಾರನ ಕಾರ್ಯವಾಗಿದೆ. ಮೊದಲ ಕಾರ್ಡ್ ಅನ್ನು ತೆರೆದ ನಂತರ, ನೀವು ಎರಡನೆಯದನ್ನು ತಿರುಗಿಸಿದರೆ ಮತ್ತು ಚಿತ್ರಗಳು ಹೊಂದಾಣಿಕೆಯಾದರೆ, ಎರಡೂ ಕಾರ್ಡ್‌ಗಳು ತೆರೆದಿರುತ್ತವೆ. ಅವು ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಕಾರ್ಡ್‌ಗಳನ್ನು ಮತ್ತೆ ಮುಚ್ಚಲಾಗುತ್ತದೆ. ಎಲ್ಲವನ್ನೂ ತೆರೆಯುವುದು ಗುರಿಯಾಗಿದೆ.

ಯೋಜನೆಯ ರಚನೆ

ಈ ಆಟದ ಸರಳ ಆವೃತ್ತಿಯನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಈ ಕೆಳಗಿನ ಘಟಕಗಳು ಬೇಕಾಗುತ್ತವೆ:

• ಒಂದು ನಿಯಂತ್ರಕ: 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() }
        }
    }
}

ಮುಂದುವರಿಯಿರಿ.

ಎರಡನೇ ಮಾದರಿ 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 ಸಂಗ್ರಹ ವೀಕ್ಷಣೆಯಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಸಂಗ್ರಹ ವೀಕ್ಷಣೆಯ ಕುರಿತು ನಿಮಗೆ ಇನ್ನೂ ಪರಿಚಯವಿಲ್ಲದಿದ್ದರೆ, ಅದು ಇಲ್ಲಿದೆ ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ಮಾಹಿತಿಯನ್ನು ನೀವು ಪಡೆಯಬಹುದು.

ನಾವು ಗೇಮ್ ಕಂಟ್ರೋಲರ್ ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ನ ರೂಟ್ ಕಂಟ್ರೋಲರ್ ಆಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ. ಗೇಮ್ ಕಂಟ್ರೋಲರ್ ಸಂಗ್ರಹ ವೀಕ್ಷಣೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಅದನ್ನು ನಾವು IBOutlet ಎಂದು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ. ಮತ್ತೊಂದು ಉಲ್ಲೇಖವೆಂದರೆ IBAction onStartGame() ಬಟನ್, ಇದು UIButton ಆಗಿದೆ, ನೀವು ಇದನ್ನು PLAY ಎಂಬ ಸ್ಟೋರಿಬೋರ್ಡ್‌ನಲ್ಲಿ ನೋಡಬಹುದು.

ನಿಯಂತ್ರಕಗಳ ಅನುಷ್ಠಾನದ ಬಗ್ಗೆ ಸ್ವಲ್ಪ:

• ಮೊದಲಿಗೆ, ನಾವು ಎರಡು ಮುಖ್ಯ ವಸ್ತುಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ - ಗ್ರಿಡ್: ಆಟ = MemoryGame(), ಮತ್ತು ಕಾರ್ಡ್‌ಗಳ ಸೆಟ್: ಕಾರ್ಡ್‌ಗಳು = [ಕಾರ್ಡ್]().
• ನಾವು ಆರಂಭಿಕ ಅಸ್ಥಿರಗಳನ್ನು viewDidLoad ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ, ಇದು ಆಟವು ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಕರೆಯಲಾಗುವ ಮೊದಲ ವಿಧಾನವಾಗಿದೆ.
• ಸಂಗ್ರಹ ವೀಕ್ಷಣೆಯನ್ನು ಮರೆಮಾಡಲು ಹೊಂದಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಬಳಕೆದಾರರು ಪ್ಲೇ ಅನ್ನು ಒತ್ತುವವರೆಗೂ ಎಲ್ಲಾ ಕಾರ್ಡ್‌ಗಳನ್ನು ಮರೆಮಾಡಲಾಗಿದೆ.
• ನಾವು PLAY ಅನ್ನು ಒತ್ತಿದ ತಕ್ಷಣ, onStartGame IBAction ವಿಭಾಗವು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಕಾರ್ಡ್‌ಗಳು ಗೋಚರಿಸುವಂತೆ ನಾವು ಸಂಗ್ರಹ ವೀಕ್ಷಣೆ 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
}

ಒಂದು ವರ್ಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಯಮಗಳು ಅಥವಾ ಸೂಚನೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಪ್ರೋಟೋಕಾಲ್ ಅನುಮತಿಸುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ, ಆದ್ದರಿಂದ ಅವುಗಳು ಏನಾಗಿರಬೇಕು ಎಂಬುದರ ಕುರಿತು ಯೋಚಿಸೋಣ. ನಿಮಗೆ ಒಟ್ಟು ನಾಲ್ಕು ಬೇಕು.

• ಆಟದ ಪ್ರಾರಂಭ: ಮೆಮೊರಿ ಆಟಆರಂಭ.
• ನೀವು ಕಾರ್ಡ್ ಮುಖವನ್ನು ಕೆಳಕ್ಕೆ ತಿರುಗಿಸುವ ಅಗತ್ಯವಿದೆ: memoryGameShowCards.
• ನೀವು ಕಾರ್ಡ್ ಮುಖವನ್ನು ಕೆಳಕ್ಕೆ ತಿರುಗಿಸುವ ಅಗತ್ಯವಿದೆ: memoryGameHideCards.
• ಆಟದ ಅಂತ್ಯ: memoryGameDidEnd.

ಎಲ್ಲಾ ನಾಲ್ಕು ವಿಧಾನಗಳನ್ನು ಮುಖ್ಯ ವರ್ಗಕ್ಕೆ ಅಳವಡಿಸಬಹುದಾಗಿದೆ, ಇದು ಗೇಮ್ ಕಂಟ್ರೋಲರ್ ಆಗಿದೆ.

ಮೆಮೊರಿ ಆಟಪ್ರಾರಂಭಿಸಿದೆ

ಈ ವಿಧಾನವನ್ನು ಚಲಾಯಿಸಿದಾಗ, ಆಟವು ಪ್ರಾರಂಭವಾಗಬೇಕು (ಬಳಕೆದಾರರು ಪ್ಲೇ ಅನ್ನು ಒತ್ತುತ್ತಾರೆ). ಇಲ್ಲಿ ನಾವು ಕಾರ್ಡ್‌ಗಳನ್ನು ಷಫಲ್ ಮಾಡುವ collectionView.reloadData() ಗೆ ಕರೆ ಮಾಡುವ ಮೂಲಕ ವಿಷಯವನ್ನು ಮರುಲೋಡ್ ಮಾಡುತ್ತೇವೆ.

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

ಮೆಮೊರಿ ಗೇಮ್ ಶೋ ಕಾರ್ಡ್ಸ್

ಸಂಗ್ರಹಣೆSDViewSelectItemAt ನಿಂದ ನಾವು ಈ ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತೇವೆ. ಮೊದಲು ಅದು ಆಯ್ದ ಕಾರ್ಡ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ. ನಂತರ ಕಾರ್ಡ್‌ಗಳು ತೋರಿಸಿದ ಅರೇಯಲ್ಲಿ ಸಾಟಿಯಿಲ್ಲದ ಕಾರ್ಡ್ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ (ಪ್ರದರ್ಶಿತ ಕಾರ್ಡ್‌ಗಳ ಸಂಖ್ಯೆ ಬೆಸವಾಗಿದ್ದರೆ). ಒಂದು ಇದ್ದರೆ, ಆಯ್ಕೆಮಾಡಿದ ಕಾರ್ಡ್ ಅನ್ನು ಅದರೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಚಿತ್ರಗಳು ಒಂದೇ ಆಗಿದ್ದರೆ, ಎರಡೂ ಕಾರ್ಡ್‌ಗಳನ್ನು ತೋರಿಸಲಾದ ಕಾರ್ಡ್‌ಗಳಿಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮುಖಾಮುಖಿಯಾಗಿ ಉಳಿಯುತ್ತದೆ. ಬೇರೆಯಾದರೆ, ಕಾರ್ಡ್ ಎಲೆಗಳನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎರಡನ್ನೂ ಕೆಳಗೆ ತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಮೆಮೊರಿ ಆಟಹೈಡ್ ಕಾರ್ಡ್ಸ್

ಕಾರ್ಡ್‌ಗಳು ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಈ ವಿಧಾನವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾರ್ಡ್ ಚಿತ್ರಗಳನ್ನು ಮರೆಮಾಡಲಾಗುತ್ತದೆ.

ತೋರಿಸಲಾಗಿದೆ = ತಪ್ಪು.

ಮೆಮೊರಿ ಆಟDidEnd

ಈ ವಿಧಾನವನ್ನು ಕರೆಯುವಾಗ, ಎಲ್ಲಾ ಕಾರ್ಡ್‌ಗಳು ಈಗಾಗಲೇ ಬಹಿರಂಗಗೊಂಡಿವೆ ಮತ್ತು ಕಾರ್ಡ್‌ಗಳು ತೋರಿಸಿದ ಪಟ್ಟಿಯಲ್ಲಿವೆ: cardsShown.count = cards.count, ಆದ್ದರಿಂದ ಆಟವು ಮುಗಿದಿದೆ. 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