સ્વિફ્ટમાં મેમરી કાર્ડ્સ ગેમ લખવી

આ લેખ એક સરળ મેમરી તાલીમ ગેમ બનાવવાની પ્રક્રિયાનું વર્ણન કરે છે જેનો મને ખરેખર આનંદ છે. પોતે સારા હોવા ઉપરાંત, તમે જાઓ ત્યારે તમે સ્વિફ્ટ ક્લાસ અને પ્રોટોકોલ્સ વિશે થોડું વધુ શીખી શકશો. પરંતુ આપણે શરૂ કરીએ તે પહેલાં, ચાલો રમતને જ સમજીએ.

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

સ્કિલબોક્સ ભલામણ કરે છે: શૈક્ષણિક ઓનલાઈન કોર્સ "પ્રોફેશન જાવા ડેવલપર".

મેમરી કાર્ડ કેવી રીતે રમવું

રમત કાર્ડ્સના સમૂહના પ્રદર્શન સાથે શરૂ થાય છે. તેઓ મોઢા નીચે સૂઈ જાય છે (અનુક્રમે, છબી નીચે). જ્યારે તમે કોઈપણ એક પર ક્લિક કરો છો, ત્યારે છબી થોડી સેકંડ માટે ખુલે છે.

ખેલાડીનું કાર્ય એ જ ચિત્રોવાળા બધા કાર્ડ્સ શોધવાનું છે. જો, પ્રથમ કાર્ડ ખોલ્યા પછી, તમે બીજાને ફેરવો અને ચિત્રો મેળ ખાય, તો બંને કાર્ડ ખુલ્લા રહે છે. જો તેઓ મેળ ખાતા નથી, તો કાર્ડ ફરીથી બંધ કરવામાં આવે છે. ધ્યેય બધું ખોલવાનું છે.

પ્રોજેક્ટ માળખું

આ રમતનું સરળ સંસ્કરણ બનાવવા માટે તમારે નીચેના ઘટકોની જરૂર પડશે:

• એક નિયંત્રક: GameController.swift.
• એક દૃશ્ય: CardCell.swift.
• બે મોડલ: MemoryGame.swift અને Card.swift.
• ઘટકોનો સંપૂર્ણ સેટ ઉપલબ્ધ છે તેની ખાતરી કરવા માટે Main.storyboard.

અમે રમતના સૌથી સરળ ઘટક, કાર્ડ્સથી પ્રારંભ કરીએ છીએ.

કાર્ડ.સ્વિફ્ટ

કાર્ડ મોડેલમાં ત્રણ ગુણધર્મો હશે: દરેકને ઓળખવા માટે id, કાર્ડની સ્થિતિ (છુપાયેલ અથવા ખુલ્લી) સ્પષ્ટ કરવા માટે બતાવવામાં આવેલ બુલિયન ચલ અને કાર્ડ પરની છબીઓ માટે આર્ટવર્ક 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    
}

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    
}

અને શરૂઆતમાં કાર્ડ્સને શફલ કરવા માટે એક વધુ પદ્ધતિની જરૂર છે. અમે તેને એરે ક્લાસનું એક્સ્ટેંશન બનાવીશું.

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 ગ્રીડ સેટ કરીએ છીએ. મોડેલમાં કાર્ડ્સ (ગ્રીડ પર કાર્ડ્સની એરે), કાર્ડ્સ પહેલાથી જ ખુલેલા કાર્ડ્સ સાથે બતાવેલ એરે અને રમતની સ્થિતિને ટ્રૅક કરવા માટે બુલિયન વેરીએબલ ઇઝ પ્લેઇંગ જેવી પ્રોપર્ટીઝ હશે.

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 વેરીએબલને true માં શરૂ કરવા માટેની પ્રથમ પદ્ધતિ કહીએ છીએ.

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 કંઈક આના જેવું દેખાય છે:

શરૂઆતમાં, તમારે ગ્રીડ માટેની છબીઓ સહિત કંટ્રોલરમાં વ્યુડિડલોડ તરીકે નવી ગેમ સેટ કરવાની જરૂર છે. રમતમાં, આ બધું 4*4 કલેક્શન વ્યૂ દ્વારા રજૂ કરવામાં આવશે. જો તમે હજી સુધી કલેક્શન વ્યૂથી પરિચિત નથી, તો તે અહીં છે તમે તમને જોઈતી માહિતી મેળવી શકો છો.

અમે ગેમ કંટ્રોલરને એપ્લિકેશનના રૂટ કંટ્રોલર તરીકે ગોઠવીશું. ગેમ કંટ્રોલર પાસે કલેક્શન વ્યૂ હશે જેનો અમે IBOutlet તરીકે સંદર્ભ આપીશું. બીજો સંદર્ભ IBAction onStartGame() બટનનો છે, આ એક UIButton છે, તમે તેને PLAY નામના સ્ટોરીબોર્ડમાં જોઈ શકો છો.

નિયંત્રકોના અમલીકરણ વિશે થોડું:

• પ્રથમ, અમે બે મુખ્ય ઑબ્જેક્ટ શરૂ કરીએ છીએ - ગ્રીડ: ગેમ = મેમરીગેમ(), અને કાર્ડ્સનો સમૂહ: કાર્ડ્સ = [કાર્ડ]().
• અમે પ્રારંભિક ચલોને viewDidLoad તરીકે સેટ કરીએ છીએ, આ પહેલી પદ્ધતિ છે જેને રમત ચાલી રહી હોય ત્યારે કહેવામાં આવે છે.
• કલેક્શન વ્યૂ છુપાયેલ પર સેટ છે કારણ કે જ્યાં સુધી વપરાશકર્તા PLAY દબાવશે નહીં ત્યાં સુધી તમામ કાર્ડ છુપાયેલા છે.
• જેમ જેમ આપણે 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)
    }
}

હવે મહત્વના પ્રોટોકોલ્સ વિશે થોડી વાત કરીએ.

પ્રોટોકોલ્સ

પ્રોટોકોલ સાથે કામ કરવું એ સ્વિફ્ટ પ્રોગ્રામિંગનો મુખ્ય ભાગ છે. પ્રોટોકોલ્સ વર્ગ, માળખું અથવા ગણતરી માટે નિયમો વ્યાખ્યાયિત કરવાની ક્ષમતા પ્રદાન કરે છે. આ સિદ્ધાંત તમને મોડ્યુલર અને એક્સ્ટેન્સિબલ કોડ લખવાની મંજૂરી આપે છે. વાસ્તવમાં, આ એક પેટર્ન છે જે અમે પહેલાથી જ GameController માં કલેક્શન વ્યૂ માટે લાગુ કરી રહ્યા છીએ. હવે આપણું પોતાનું વર્ઝન બનાવીએ. સિન્ટેક્સ આના જેવો દેખાશે:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

અમે જાણીએ છીએ કે પ્રોટોકોલ અમને વર્ગના અમલીકરણ માટે નિયમો અથવા સૂચનાઓને વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે, તેથી ચાલો તે શું હોવું જોઈએ તે વિશે વિચારીએ. તમારે કુલ ચારની જરૂર છે.

• રમતની શરૂઆત: મેમરીગેમડીડસ્ટાર્ટ.
• તમારે કાર્ડનો ચહેરો નીચે કરવાની જરૂર છે: memoryGameShowCards.
• તમારે કાર્ડનો ચહેરો નીચે કરવાની જરૂર છે: memoryGameHideCards.
• રમતનો અંત: memoryGameDidEnd.

તમામ ચાર પદ્ધતિઓ મુખ્ય વર્ગ માટે લાગુ કરી શકાય છે, જે ગેમ કંટ્રોલર છે.

મેમરીગેમડીડસ્ટાર્ટ

જ્યારે આ પદ્ધતિ ચલાવવામાં આવે છે, ત્યારે રમત શરૂ થવી જોઈએ (વપરાશકર્તા PLAY દબાવશે). અહીં અમે collectionView.reloadData() પર કૉલ કરીને સામગ્રીને ફરીથી લોડ કરીશું, જે કાર્ડ્સને શફલ કરશે.

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

મેમરીગેમશોકાર્ડ્સ

અમે આ પદ્ધતિને સંગ્રહ SDViewSelectItemAt માંથી કૉલ કરીએ છીએ. પ્રથમ તે પસંદ કરેલ કાર્ડ બતાવે છે. પછી કાર્ડ્સ બતાવેલ એરેમાં એક મેળ ન ખાતું કાર્ડ છે કે કેમ તે જોવા માટે તપાસો (જો બતાવેલ કાર્ડ્સની સંખ્યા વિચિત્ર છે). જો ત્યાં એક હોય, તો પસંદ કરેલ કાર્ડ તેની સાથે સરખાવવામાં આવે છે. જો ચિત્રો સરખા હોય, તો બંને કાર્ડ બતાવવામાં આવેલા કાર્ડ્સમાં ઉમેરવામાં આવે છે અને સામસામે રહે છે. જો અલગ-અલગ હોય, તો કાર્ડ છોડે છે કાર્ડ્સ બતાવવામાં આવે છે અને બંને મોઢા નીચે કરવામાં આવે છે.

મેમરીગેમહાઇડકાર્ડ્સ

જો કાર્ડ મેળ ખાતા નથી, તો આ પદ્ધતિ કહેવામાં આવે છે અને કાર્ડની છબીઓ છુપાવવામાં આવે છે.

બતાવેલ = ખોટું.

મેમરીGameDidEnd

જ્યારે આ પદ્ધતિને બોલાવવામાં આવે છે, ત્યારે તેનો અર્થ એ છે કે બધા કાર્ડ્સ પહેલેથી જ જાહેર થઈ ગયા છે અને કાર્ડ્સ બતાવવામાં આવેલી સૂચિમાં છે: 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