সুইফটে একটি মেমরি কার্ড গেম লেখা

এই নিবন্ধটি একটি সাধারণ মেমরি প্রশিক্ষণ গেম তৈরি করার প্রক্রিয়া বর্ণনা করে যা আমি সত্যিই পছন্দ করি। নিজে ভালো হওয়ার পাশাপাশি, আপনি যেতে যেতে সুইফট ক্লাস এবং প্রোটোকল সম্পর্কে আরও কিছু শিখবেন। তবে আমরা শুরু করার আগে, আসুন খেলাটি নিজেই বুঝতে পারি।

আমরা মনে করিয়ে দিচ্ছি: "Habr"-এর সকল পাঠকদের জন্য - "Habr" প্রচারমূলক কোড ব্যবহার করে যেকোনো Skillbox কোর্সে নথিভুক্ত করার সময় 10 রুবেল ছাড়।

Skillbox সুপারিশ করে: শিক্ষাগত অনলাইন কোর্স "পেশা জাভা বিকাশকারী".

কিভাবে মেমরি কার্ড খেলতে হয়

গেমটি কার্ডের একটি সেট প্রদর্শনের মাধ্যমে শুরু হয়। তারা মুখ করে শুয়ে থাকে (যথাক্রমে, চিত্র নিচে)। আপনি যেকোনো একটিতে ক্লিক করলে, ছবিটি কয়েক সেকেন্ডের জন্য খোলে।

প্লেয়ারের কাজ হল একই ছবি সহ সমস্ত কার্ড খুঁজে বের করা। যদি, প্রথম কার্ড খোলার পরে, আপনি দ্বিতীয়টি উল্টে দেন এবং ছবিগুলি মিলে যায়, উভয় কার্ডই খোলা থাকে। সেগুলো না মিললে কার্ডগুলো আবার বন্ধ হয়ে যায়। লক্ষ্য হল সবকিছু খোলা।

প্রকল্প কাঠামো

এই গেমটির একটি সহজ সংস্করণ তৈরি করতে আপনার নিম্নলিখিত উপাদানগুলির প্রয়োজন:

• এক কন্ট্রোলার: GameController.swift।
• ওয়ান ভিউ: CardCell.swift।
• দুটি মডেল: MemoryGame.swift এবং Card.swift।
• উপাদানগুলির সম্পূর্ণ সেট উপলব্ধ রয়েছে তা নিশ্চিত করতে Main.storyboard।

আমরা গেমের সহজতম উপাদান, কার্ড দিয়ে শুরু করি।

Card.swift

কার্ডের মডেলের তিনটি বৈশিষ্ট্য থাকবে: প্রতিটিকে শনাক্ত করার জন্য আইডি, কার্ডের স্থিতি (লুকানো বা খোলা) নির্দিষ্ট করার জন্য একটি বুলিয়ান ভেরিয়েবল এবং কার্ডের চিত্রগুলির জন্য আর্টওয়ার্ক ইউআরএল।

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 এরকম কিছু দেখায়:

প্রাথমিকভাবে, আপনাকে নতুন গেমটিকে কন্ট্রোলারে ভিউডিডলোড হিসাবে সেট করতে হবে, গ্রিডের জন্য চিত্রগুলি সহ। গেমটিতে, এই সমস্তগুলি একটি 4*4 সংগ্রহ ভিউ দ্বারা প্রতিনিধিত্ব করা হবে। আপনি যদি এখনও collectionView এর সাথে পরিচিত না হন তবে এটি এখানে আপনি আপনার প্রয়োজনীয় তথ্য পেতে পারেন.

আমরা গেম কন্ট্রোলারকে অ্যাপ্লিকেশনটির রুট কন্ট্রোলার হিসাবে কনফিগার করব। গেম কন্ট্রোলারের একটি কালেকশন ভিউ থাকবে যা আমরা একটি IBOutlet হিসাবে উল্লেখ করব। আরেকটি রেফারেন্স হল IBAction onStartGame() বোতাম, এটি একটি UIButton, আপনি এটি PLAY নামক স্টোরিবোর্ডে দেখতে পারেন।

কন্ট্রোলার বাস্তবায়ন সম্পর্কে একটু:

• প্রথমে, আমরা দুটি প্রধান অবজেক্ট শুরু করি - গ্রিড: গেম = মেমরিগেম(), এবং তাসের একটি সেট: কার্ড = [কার্ড]()।
• আমরা ভিউডিডলোড হিসাবে প্রাথমিক ভেরিয়েবল সেট করি, গেমটি চলাকালীন এটিই প্রথম পদ্ধতি যা বলা হয়।
• CollectionView লুকানো অবস্থায় সেট করা হয়েছে কারণ ব্যবহারকারী প্লে প্রেস না করা পর্যন্ত সমস্ত কার্ড লুকানো থাকে।
• যত তাড়াতাড়ি আমরা 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)
    }
}

এখন গুরুত্বপূর্ণ প্রোটোকল সম্পর্কে একটু কথা বলা যাক।

প্রোটোকল

প্রোটোকলের সাথে কাজ করা সুইফট প্রোগ্রামিং এর মূল। প্রোটোকল একটি শ্রেণী, কাঠামো, বা গণনার জন্য নিয়ম সংজ্ঞায়িত করার ক্ষমতা প্রদান করে। এই নীতিটি আপনাকে মডুলার এবং এক্সটেনসিবল কোড লিখতে দেয়। প্রকৃতপক্ষে, এটি একটি প্যাটার্ন যা আমরা ইতিমধ্যেই GameController-এ collectionView এর জন্য প্রয়োগ করছি। এখন আমাদের নিজস্ব সংস্করণ তৈরি করা যাক. সিনট্যাক্স এই মত দেখাবে:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

আমরা জানি যে একটি প্রোটোকল আমাদের একটি ক্লাস বাস্তবায়নের জন্য নিয়ম বা নির্দেশাবলী সংজ্ঞায়িত করতে দেয়, তাই আসুন সেগুলি কী হওয়া উচিত তা নিয়ে ভাবি। আপনার মোট চারটি প্রয়োজন।

• খেলা শুরু: memoryGameDidStart.
• আপনাকে কার্ডের মুখ নিচে নামাতে হবে: memoryGameShowCards।
• আপনাকে কার্ডের মুখ নিচে নামাতে হবে: memoryGameHideCards।
• খেলা শেষ: memoryGameDidEnd.

সমস্ত চারটি পদ্ধতিই মূল শ্রেণীর জন্য প্রয়োগ করা যেতে পারে, যা গেম কন্ট্রোলার।

মেমরি গেমডিডস্টার্ট

এই পদ্ধতিটি চালানো হলে, গেমটি শুরু হওয়া উচিত (ব্যবহারকারী প্লে টিপে)। এখানে আমরা শুধুমাত্র collectionView.reloadData() কল করে বিষয়বস্তু পুনরায় লোড করব, যা কার্ডগুলিকে এলোমেলো করবে।

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

মেমরি গেমশোকার্ড

আমরা সংগ্রহ এসডিভিউ সিলেক্ট আইটেমআট থেকে এই পদ্ধতিটিকে কল করি। প্রথমে এটি নির্বাচিত কার্ড দেখায়। তারপরে কার্ড দেখানো অ্যারেতে একটি অমিল কার্ড আছে কিনা তা পরীক্ষা করে দেখুন (যদি দেখানো কার্ডের সংখ্যা বিজোড় হয়)। যদি একটি থাকে তবে নির্বাচিত কার্ডটি এর সাথে তুলনা করা হয়। ছবি একই হলে, উভয় কার্ডই কার্ডে যোগ করা হয় দেখানো হয় এবং মুখোমুখি থাকে। ভিন্ন হলে, কার্ড ছেড়ে কার্ড দেখানো হয় এবং উভয়ই মুখ থুবড়ে পড়ে।

মেমরি গেমহাইডকার্ড

যদি কার্ডগুলি মেলে না, এই পদ্ধতিটি বলা হয় এবং কার্ডের ছবিগুলি লুকানো হয়।

দেখানো = মিথ্যা।

মেমরি গেমডিডএন্ড

যখন এই পদ্ধতিটি বলা হয়, এর মানে হল যে সমস্ত কার্ড ইতিমধ্যেই প্রকাশ করা হয়েছে এবং কার্ড দেখানো তালিকায় রয়েছে: cardsShown.count = cards.count, তাই গেমটি শেষ। পদ্ধতিটিকে বিশেষভাবে বলা হয় যখন আমরা endGame() কে কল করে isPlaying var-কে মিথ্যা সেট করার জন্য, তারপরে গেমের শেষ বার্তাটি দেখানো হয়। এছাড়াও 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()
    }
}

আসলে, যে সব. আপনি গেমটির নিজস্ব সংস্করণ তৈরি করতে এই প্রকল্পটি ব্যবহার করতে পারেন।

শুভ কোডিং!

Skillbox সুপারিশ করে:

• ব্যবহারিক কোর্স "মোবাইল ডেভেলপার প্রো".
• অনলাইন কোর্সের আবেদন করা হয়েছে "পাইথন ডেটা বিশ্লেষক".
• দুই বছরের ব্যবহারিক কোর্স "আমি একজন প্রো ওয়েব ডেভেলপার".

উত্স: www.habr.com