How to add levels 10, 14 cards to the game? - arrays

Question

My game starts with 8 cards or 4 pairs. Where should I insert the function and write it down correctly so that a new game starts if the win and + 2 pairs are added.
import UIKit
class ViewController: UIViewController,UICollectionViewDelegate,UICollectionViewDataSource {
#IBOutlet weak var timeLabel: UILabel!
#IBOutlet weak var collectionView: UICollectionView!
var firstFlippedCardIndex:IndexPath?
var model = CardModel()
var cardArray = [Card]()
var timer : Timer?
var milliseconds: Float = 60 * 1000 // 30 sec
override func viewDidLoad() {
super.viewDidLoad()
cardArray = model.getCard()
collectionView.delegate = self
collectionView.dataSource = self
timer = Timer.scheduledTimer(timeInterval: 0.001, target: self, selector: #selector(timerElapsed), userInfo: nil, repeats: true)
RunLoop.main.add(timer!, forMode: .common)
}
#objc func timerElapsed(){
milliseconds -= 1
//Conver to seconds
let seconds = String(format:"%.2f", milliseconds/1000)
//set Label
timeLabel.text = "time Remaining: \(seconds)"
//When the timer has reached 0 will stop it
if milliseconds <= 0 {
//Stop the timer
timer?.invalidate()
timeLabel.textColor = UIColor.red
//Check if theere are any cards unmatched
ckeckGameEnded()
}
}
func setupNewGame() {
cardArray = model.getCard()
let addCard = Card()
cardArray.append(addCard)
let indexPath = IndexPath(row: cardArray.count - 22, section: 0)
collectionView.insertItems(at: [indexPath])
collectionView.reloadData()
}
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return cardArray.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "cell", for: indexPath) as! CardCollectionViewCell
let card = cardArray[indexPath.row]
// Set that card for the cell
cell.setCard(card)
return cell
}
func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
if milliseconds <= 0 {
return
} // Get the cell that the user selected
let cell = collectionView.cellForItem(at: indexPath) as! CardCollectionViewCell
// Get the card that the user selected
let card = cardArray[indexPath.row]
if card.isFlipped == false && card.isMatched == false {
// Flip the card
cell.flip()
// Set the status of the card
card.isFlipped = true
// Determine if it's the first card or second card that's flipped over
if firstFlippedCardIndex == nil {
// This is the first card being flipped
firstFlippedCardIndex = indexPath
}
else {
// This is the second card being flipped
// Perform the matching logic
checkForMatches(indexPath)
}
}
} // End the didSelectItemAt method
// MARK: - Game Logic Methods
func checkForMatches(_ secondFlippedCardIndex:IndexPath) {
// Get the cells for the two cards that were revealed
let cardOneCell = collectionView.cellForItem(at: firstFlippedCardIndex!) as? CardCollectionViewCell
let cardTwoCell = collectionView.cellForItem(at: secondFlippedCardIndex) as? CardCollectionViewCell
// Get the cards for the two cards that were revealed
let cardOne = cardArray[firstFlippedCardIndex!.row]
let cardTwo = cardArray[secondFlippedCardIndex.row]
// Compare the two cards
if cardOne.imageName == cardTwo.imageName {
// It's a match
// Set the statuses of the cards
cardOne.isMatched = true
cardTwo.isMatched = true
// Remove the cards from the grid
cardOneCell?.remove()
cardTwoCell?.remove()
ckeckGameEnded()
}
else {
// It's not a match
// Set the statuses of the cards
cardOne.isFlipped = false
cardTwo.isFlipped = false
// Flip both cards back
cardOneCell?.flipBack()
cardTwoCell?.flipBack()
}
// Tell the collectionview to reload the cell of the first card if it is nil
if cardOneCell == nil {
collectionView.reloadItems(at: [firstFlippedCardIndex!])
}
// Reset the property that tracks the first card flipped
firstFlippedCardIndex = nil
}
func ckeckGameEnded() {
//Determine if there are any cards unmatched
var isWon = true
for card in cardArray {
if card.isMatched == false {
isWon = false
break
}
}
//Messing variables
var title = ""
var message = ""
//If not, then user has won, stop the timer
if isWon == true {
if milliseconds > 0{
timer?.invalidate()
}
title = "BRAVO !"
message = "You`ve Won"
} else {
//If there are unmatched cards, check if there`s any time left
if milliseconds > 0 {
return
}
title = "Game Over"
message = "You`ve Lost"
}
//Show won/lost messaging
showAlert(title, message)
}
func showAlert(_ title : String, _ message : String){
//Show won/lost messaging
let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
let alertAction = UIAlertAction(title: "Ok", style: .default, handler: nil)
alert.addAction(alertAction)
present(alert, animated: true, completion: nil)
}
} // Endging of veiwController class
Here I am creating 4 pairs for the game and then removing the cards if they match.Tell me how to write down the order correctly, maybe rewrite the code somewhere. And can you show an example?
import Foundation
class CardModel {
func getCard() -> [Card] {
//decare an array to store numbers we`ve already generated
var generatedNumbersArray = [Int]()
//randomly generate pairs of cards
var generatedCardArray = [Card]()
while generatedNumbersArray.count < 4 {
//get a random number
let randomNumber = arc4random_uniform(8) + 1
//Ensure that the random number isn`t one we already have
if generatedNumbersArray.contains(Int(randomNumber)) == false {
//log the number
print(randomNumber)
//Store the number into the generatedCardArray
generatedNumbersArray.append(Int(randomNumber))
//create the first card object
let cardOne = Card()
cardOne.imageName = "card\(randomNumber)"
generatedCardArray.append(cardOne)
//create the second card object
let cardTwo = Card()
cardTwo.imageName = "card\(randomNumber)"
generatedCardArray.append(cardTwo)
// make it so we only have unqiu pairs of cards
} else {
}
}
//Randomize the array
for i in 0...generatedCardArray.count-1{
// find a random index to swap with
let randomNumber = Int (arc4random_uniform(UInt32(generatedCardArray.count)))
// swap the two cards
let temporaryStorage = generatedCardArray[i]
generatedCardArray[i] = generatedCardArray[randomNumber]
generatedCardArray[randomNumber] = temporaryStorage
}
//return
return generatedCardArray
}
}