SyntaxBomb - Indie Coders

//
//  BonusScene.swift
//  Infection
//
//  Created by Tony Brice on 18/02/2016.
//  Copyright © 2016 Dexterity Design. All rights reserved.
//

// This part will be the bonus game where you can select one of 9 large circles for a
// score boost. A break from the gameplay section while retaining the one tap gameplay idea.

import SpriteKit

class bonusScene: SKScene {
    
    var myGameData:GameData!
    
    var exploding:Bool!
    var sceneExit:Bool!
    var temp:Bool!
    var bonusSelected:Bool!
    
    var score:Int!
    var nodeCounter:Int!
    var XP:Int!
    var YP:Int!
    var bonusNumber:Int!
    var bonusCounter:Int!
    
    var location:CGPoint!
    
    var radius:CGFloat!
    
    var bonus:SKSpriteNode!
    var continueButton:SKSpriteNode!

    var bonusLabel:SKLabelNode!
    var scoreLabel:SKLabelNode!
    
    let bonusScores = [0, 10, 100, 500, 1000, 1500, 2000, 2500, 5000]
    var bonusArray = [0, 10, 100, 500, 1000, 1500, 2000, 2500, 5000]
    
    let nodeX = [300, 500, 700]
    let nodeY = [200, 400, 600]
    
    ///MARK: Move to view.
    override func didMoveToView(view: SKView) {
        backgroundColor = SKColor.blackColor()
        #if DEBUG
            print ("Bonus scene is active.")
        #endif
        let screenSize = self.frame
        
        myGameData = GameData()
        score = Variables.score
        sceneExit = false       // Flag so that only one bonus node can be chosen.
        
        #if os(iOS)
            continueButton = SKSpriteNode(imageNamed: "IOS_Continue")
        #endif
        
        #if os(OSX)
            continueButton = SKSpriteNode(imageNamed: "OSX_Continue")
        #endif
        continueButton.position = CGPoint(x: screenSize.width * 0.50, y: screenSize.height * 0.10)
        continueButton.zPosition = 3
        self.addChild(continueButton)
        continueButton.hidden = true
        
        bonusLabel = SKLabelNode(fontNamed: "Chewy")
        bonusLabel.fontSize = 25
        bonusLabel.zPosition = 3
        bonusLabel.position = CGPoint(x: screenSize.width * 0.5, y: screenSize.height * 0.95)
        bonusLabel.fontColor = SKColor.greenColor()
        bonusLabel.text = ("*** Select a bonus score token ***")
        self.addChild(bonusLabel)

        scoreLabel = SKLabelNode(fontNamed: "Chewy")
        scoreLabel.fontSize = 25
        scoreLabel.zPosition = 4
        scoreLabel.fontColor = SKColor.yellowColor()
        scoreLabel.text = ("")
        scoreLabel.position = CGPoint(x: screenSize.width * 0.5, y: screenSize.height * 0.95)
        self.addChild(scoreLabel)
        scoreLabel.hidden = true
        
        nodeCounter = -1
        for YP in 0..<3 {
            for XP in 0..<3 {
                nodeCounter = nodeCounter+1
                location = CGPoint(x: nodeX[XP], y: nodeY[YP])
                drawBonusCircle(location , node: nodeCounter)
            }
        }
        random()
        #if DEBUG
            // seeing this sequence means you can work out which bonus scores the most.
            print("Number sequence \(bonusArray)")
        #endif
    }
    
    ///MARK: IOS input
    #if os(iOS)
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
    // Called when a touch begins
    let touchLocation = touches.first?.locationInNode(self)
    buttonHandler(touchLocation!)
    }
    #endif
    
    // MARK: OSX Mouse Inputs.
    #if os(OSX)
    override func mouseDown(theEvent: NSEvent) {
        // Called when a mouse click begins
        let clickLocation = theEvent.locationInNode(self)
        buttonHandler(clickLocation)
    }
    #endif
    
    func buttonHandler(location:CGPoint) {
        let touchedNode = self.nodeAtPoint(location)
        if sceneExit == true {
            let myScene = gameScene(size: self.size)
            let transition = SKTransition.doorsCloseVerticalWithDuration(0.7)
            myScene.scaleMode = SKSceneScaleMode.AspectFill
            self.scene!.view?.presentScene(myScene, transition: transition)
        }
        
//        #if DEBUG
//            print ("Object: \(touchedNode.name) touched.")
//        #endif
//        if (touchedNode.name == "Exit") {
//            let myScene = gameScene(size: self.size)
//            let transition = SKTransition.doorsCloseVerticalWithDuration(0.7)
//            myScene.scaleMode = SKSceneScaleMode.AspectFill
//            self.scene!.view?.presentScene(myScene, transition: transition)
//        }
        
        if sceneExit == false {
            if let name = touchedNode.name {
                // Convert the touched node (named 0 to 8) into an integer so we can work out its score figure.
                sceneExit = true    // Ensure we can't select more than one bonus and that exit selected can't crash the game.
                continueButton.hidden = false
                bonusNumber = Int(name)
                Variables.score = Variables.score + bonusArray[bonusNumber]
                
                //let nodeX = [300, 500, 700]
                //let nodeY = [200, 400, 600]
                
                // Work out Y position of selected node.
                YP = 2
                if bonusNumber < 6 {
                    YP = 1
                }
                if bonusNumber < 3 {
                    YP = 0
                }
                
                // Work out X position of selected node. Temp code just to get working. 
                // but the or operator || wont work with an Int. There must be a neater way to do this.
                XP = 0
                if bonusNumber == 1 {
                    XP = 1
                }
                if bonusNumber == 2 {
                    XP = 2
                }
                if bonusNumber == 3 {
                    XP = 0
                }
                if bonusNumber == 4 {
                    XP = 1
                }
                if bonusNumber == 5 {
                    XP = 2
                }
                if bonusNumber == 6 {
                    XP = 0
                }
                if bonusNumber == 7 {
                    XP = 1
                }
                if bonusNumber == 8 {
                    XP = 2
                }
                let location = CGPoint(x: nodeX[XP], y: nodeY[YP])
                drawColourCircle(location , node: bonusNumber)
                scoreLabel.hidden = false
                scoreLabel.position = CGPoint(x: nodeX[XP], y: nodeY[YP])
                scoreLabel.text = ("\(bonusArray[bonusNumber])")
                #if DEBUG
                    print("Number:\(bonusNumber) & your score increased by:\(bonusArray[bonusNumber]) to \(Variables.score)")
                #endif
            }
        }
    }
    
    func random() {
        // This function will set up the bonus array with a score for each token.
        // How it works is a random number is chosen from 0 to 8 and then the counter starts from there loading the
        // bonusArray array with what's in the bonusScores array at that location. If it goes beyond 8 then it resets to location
        // 0 and carries on loading the array from there. Hence the scores will always be in order but, without knowing what the
        // starting counter was, player won't know this or be able to work it out as they can only select one bonus and the
        // locations for the scores changes each time.
        
        bonusCounter = Int(arc4random_uniform(9)) // random number 0 - 8. This is the node that is going to start with 0 bonus score.
        for temp in 0..<9 {
            bonusArray [temp] = bonusScores[bonusCounter]
            bonusCounter = bonusCounter + 1
            if bonusCounter > 8 {
                bonusCounter = 0
            }
        }
    }
    
    func drawBonusCircle(location:CGPoint, node:Int) {
        // Here we draw our 9 selectable nodes for the bonus score selector.
        let myBonusCircle:BonusCircle = BonusCircle(Radius: 10, Position: location, Exploding: true, ID: node)
        self.addChild(myBonusCircle)
        
    }
    
    func drawColourCircle(location:CGPoint, node:Int) {
        // Here we draw our selected bonus circle a different colour. We set exploding flag to false so the entity class knows.
        let myColourCircle:BonusCircle = BonusCircle(Radius: 10, Position: location, Exploding: false, ID: node)
        self.addChild(myColourCircle)
    }
    
    override func update(currentTime: CFTimeInterval) {
        /* Called before each frame is rendered */
        // Change colour or something here on the selectable tokens.
        self.enumerateChildNodesWithName("*") { // Checks everything so may need edit.
            node, stop in
            if let currentBonusCircle = node as? BonusCircle {
                currentBonusCircle.update()
            }
        }
    }
}

self.scene!.view?.presentScene(myScene, transition: transition)