მეხსიერების ბარათების თამაშის დაწერა Swift-ში

ეს სტატია აღწერს მარტივი მეხსიერების სავარჯიშო თამაშის შექმნის პროცესს, რომელიც ძალიან მომწონს. გარდა იმისა, რომ თავისთავად კარგია, თქვენ გაიგებთ ცოტა მეტს Swift-ის კლასებისა და პროტოკოლების შესახებ. მაგრამ სანამ დავიწყებთ, მოდით გავიგოთ თავად თამაში.

შეგახსენებთ: "Habr"-ის ყველა მკითხველისთვის - ფასდაკლება 10 რუბლიდან Skillbox-ის ნებისმიერ კურსზე ჩარიცხვისას "Habr" სარეკლამო კოდის გამოყენებით.

Skillbox გირჩევთ: საგანმანათლებლო ონლაინ კურსი "პროფესია Java Developer".

როგორ ვითამაშოთ მეხსიერების ბარათი

თამაში იწყება ბარათების ნაკრების დემონსტრირებით. ისინი პირქვე წევენ (შესაბამისად, სურათი ქვემოთ). როდესაც რომელიმეზე დააწკაპუნებთ, სურათი იხსნება რამდენიმე წამით.

მოთამაშის ამოცანაა იპოვოთ ყველა ბარათი ერთი და იგივე სურათებით. თუ პირველი კარტის გახსნის შემდეგ მეორეს გადაატრიალებთ და სურათები ემთხვევა, ორივე კარტი ღია რჩება. თუ ისინი არ ემთხვევა, ბარათები კვლავ იხურება. მიზანი ყველაფრის გახსნაა.

პროექტის სტრუქტურა

ამ თამაშის მარტივი ვერსიის შესაქმნელად დაგჭირდებათ შემდეგი კომპონენტები:

• ერთი კონტროლერი: GameController.swift.
• ერთი ხედი: CardCell.swift.
• ორი მოდელი: MemoryGame.swift და Card.swift.
• Main.storyboard კომპონენტების მთელი ნაკრების ხელმისაწვდომობის უზრუნველსაყოფად.

ვიწყებთ თამაშის უმარტივესი კომპონენტით, ბარათებით.

ბარათი.სვიფტი

ბარათის მოდელს ექნება სამი თვისება: id თითოეულის იდენტიფიცირებისთვის, ლოგიკური ცვლადი ნაჩვენები ბარათის სტატუსის დასაზუსტებლად (დამალული ან ღია) და artworkURL ბარათებზე გამოსახულებისთვის.

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

თქვენ ასევე დაგჭირდებათ ეს მეთოდები რუკებთან მომხმარებლის ურთიერთქმედების გასაკონტროლებლად:

ბარათზე გამოსახულების ჩვენების მეთოდი. აქ ჩვენ აღვადგენთ ყველა თვისებას ნაგულისხმევად. id-ისთვის ჩვენ ვქმნით შემთხვევით id-ს 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    
}

და კიდევ ერთი მეთოდია საჭირო ბარათების დასაწყებად ასარევად. ჩვენ გავაკეთებთ მას Array კლასის გაფართოებას.

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 ბადე. მოდელს ექნება ისეთი თვისებები, როგორიცაა ბარათები (ბარათების მასივი ბადეზე), ბარათები ნაჩვენებია მასივი კარტებით უკვე გახსნილი და ლოგიკური ცვლადი არის Playing თამაშის სტატუსის თვალყურის დევნებისთვის.

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 ცვლადს 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 კონტროლერს. GameController-ს ექნება collectionView, რომელსაც ჩვენ მივმართავთ როგორც IBOutlet. კიდევ ერთი მითითება არის IBAction onStartGame() ღილაკი, ეს არის UIButton, შეგიძლიათ იხილოთ სცენარის დაფაზე, სახელად PLAY.

ცოტა რამ კონტროლერების განხორციელების შესახებ:

• პირველ რიგში, ჩვენ ვაკეთებთ ორ ძირითად ობიექტს - ბადეს: game = MemoryGame() და ბარათების ნაკრები: ბარათები = [Card]().
• ჩვენ დავაყენეთ საწყისი ცვლადები, როგორც viewDidLoad, ეს არის პირველი მეთოდი, რომელიც გამოიძახება თამაშის გაშვებისას.
• collectionView დაყენებულია დამალულად, რადგან ყველა ბარათი იმალება მანამ, სანამ მომხმარებელი არ დააჭერს PLAY-ს.
• როგორც კი PLAY-ს დავაჭერთ, იწყება onStartGame IBAction განყოფილება და ჩვენ დავაყენეთ collectView 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)
    }
}

ახლა მოდით ვისაუბროთ ცოტა მნიშვნელოვან პროტოკოლებზე.

ოქმები

პროტოკოლებთან მუშაობა არის Swift-ის პროგრამირების საფუძველი. პროტოკოლები იძლევა კლასის, სტრუქტურის ან ჩამოთვლის წესების განსაზღვრის შესაძლებლობას. ეს პრინციპი საშუალებას გაძლევთ დაწეროთ მოდულური და გაფართოებადი კოდი. სინამდვილეში, ეს არის ნიმუში, რომელსაც ჩვენ უკვე ვახორციელებთ collectionView-ისთვის GameController-ში. ახლა მოდით გავაკეთოთ ჩვენი საკუთარი ვერსია. სინტაქსი ასე გამოიყურება:

protocol MemoryGameProtocol {
    //protocol definition goes here
}

ჩვენ ვიცით, რომ პროტოკოლი საშუალებას გვაძლევს განვსაზღვროთ წესები ან ინსტრუქციები კლასის განხორციელებისთვის, ასე რომ, მოდით ვიფიქროთ იმაზე, თუ როგორი უნდა იყოს ისინი. სულ ოთხი გჭირდებათ.

• თამაშის დაწყება: memoryGameDidStart.
• თქვენ უნდა მოაბრუნოთ ბარათი სახეზე ქვემოთ: memoryGameShowCards.
• თქვენ უნდა მოაბრუნოთ ბარათი სახეზე ქვემოთ: memoryGameHideCards.
• თამაშის დასასრული: memoryGameDidEnd.

ოთხივე მეთოდის დანერგვა შესაძლებელია ძირითადი კლასისთვის, რომელიც არის GameController.

memoryGameDidStart

ამ მეთოდის გაშვებისას თამაში უნდა დაიწყოს (მომხმარებელი დააჭერს PLAY-ს). აქ ჩვენ უბრალოდ გადავიტვირთავთ შიგთავსს collectView.reloadData()-ის გამოძახებით, რაც ბარათებს აერიებს.

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

memoryGameShowCards

ჩვენ ვუწოდებთ ამ მეთოდს collectionSDViewSelectItemAt-დან. ჯერ აჩვენებს არჩეულ ბარათს. შემდეგ ამოწმებს, არის თუ არა შეუსაბამო ბარათი cardsShown მასივში (თუ კენტია ნაჩვენები ბარათების რაოდენობა). თუ არის ერთი, შერჩეული ბარათი შედარებულია მასთან. თუ სურათები ერთნაირია, ორივე კარტი ემატება კარტებს, რომლებიც ნაჩვენებია და რჩება პირისპირ. თუ განსხვავებულია, ბარათი ტოვებს კარტებს, რომლებიც ნაჩვენებია და ორივე შებრუნებულია პირისპირ.

memoryGameHideCards

თუ ბარათები არ ემთხვევა, ეს მეთოდი გამოიძახება და ბარათის სურათები დამალულია.

ნაჩვენები = ყალბი.

memoryGameDidEnd

ამ მეთოდის გამოძახებისას, ეს ნიშნავს, რომ ყველა კარტი უკვე გამოვლენილია და არის cardsShown სიაში: cardsShown.count = cards.count, ასე რომ თამაში დასრულდა. მეთოდს გამოიძახებენ კონკრეტულად მას შემდეგ, რაც ჩვენ მოვუწოდებთ endGame() isPlaying var-ის დასაყენებლად false-ზე, რის შემდეგაც გამოჩნდება თამაშის დასრულების შეტყობინება. ასევე alertController გამოიყენება როგორც ინდიკატორი კონტროლერისთვის. გამოიძახება 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 გირჩევთ:

• პრაქტიკული კურსი "Mobile Developer PRO".
• მიმართა ონლაინ კურსს "პითონის მონაცემთა ანალიტიკოსი".
• ორწლიანი პრაქტიკული კურსი "მე ვარ PRO ვებ დეველოპერი".

წყარო: www.habr.com