Question

I’ve been following a tutorial over the web but it somehow did not show something about creating a game over function. I am new to the Starling framework and Actionscript so I’m kind of still trying to find a way to make it work. Here’s the complete snippet of the code.

package screens

{


import flash.geom.Rectangle;
import flash.utils.getTimer;
import events.NavigationEvent;

import objects.GameBackground;
import objects.Hero;
import objects.Item;
import objects.Obstacle;

import starling.display.Button;
import starling.display.Image;
import starling.display.Sprite;
import starling.events.Event;
import starling.events.Touch;
import starling.events.TouchEvent;
import starling.text.TextField;
import starling.utils.deg2rad;

public class InGame extends Sprite
{
    private var screenInGame:InGame;
    private var screenWelcome:Welcome;
    private var startButton:Button;
    private var playAgain:Button;
    private var bg:GameBackground;
    private var hero:Hero;

    private var timePrevious:Number;
    private var timeCurrent:Number;
    private var elapsed:Number;

    private var gameState:String;

    private var playerSpeed:Number = 0;
    private var hitObstacle:Number = 0;
    private const MIN_SPEED:Number = 650;

    private var scoreDistance:int;
    private var obstacleGapCount:int;

    private var gameArea:Rectangle;

    private var touch:Touch;
    private var touchX:Number;
    private var touchY:Number;

    private var obstaclesToAnimate:Vector.<Obstacle>;
    private var itemsToAnimate:Vector.<Item>;

    private var scoreText:TextField;
    private var remainingLives:TextField;
    private var gameOverText:TextField;
    private var iconSmall:Image;

    static private var lives:Number = 2;

    public function InGame()
    {
        super();
        this.addEventListener(starling.events.Event.ADDED_TO_STAGE, onAddedToStage);
    }

    private function onAddedToStage(event:Event):void {
        this.removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage); 
        drawGame();

        scoreText = new TextField(300, 100, "Score: 0", "MyFontName", 35, 0xD9D919, true);
        remainingLives = new TextField(600, 100, "Lives: " + lives +" X ", "MyFontName", 35, 0xD9D919, true);
        iconSmall = new Image(Assets.getAtlas().getTexture("darnahead1"));
        iconSmall.x = 360;
        iconSmall.y = 40;
        this.addChild(iconSmall);

        this.addChild(scoreText);
        this.addChild(remainingLives);


    }

    private function drawGame():void {
        bg = new GameBackground();

        this.addChild(bg);
        hero = new Hero();
        hero.x = stage.stageHeight / 2;
        hero.y = stage.stageWidth / 2;
        this.addChild(hero);

        startButton = new Button(Assets.getAtlas().getTexture("startButton"));
        startButton.x = stage.stageWidth * 0.5 - startButton.width * 0.5;
        startButton.y = stage.stageHeight * 0.5 - startButton.height * 0.5; 

        this.addChild(startButton);

        gameArea = new Rectangle(0, 100, stage.stageWidth, stage.stageHeight - 250);        
    }

    public function disposeTemporarily():void {
        this.visible = false;
    }

    public function initialize():void {
        this.visible = true;

        this.addEventListener(Event.ENTER_FRAME, checkElapsed);

        hero.x = -stage.stageWidth;
        hero.y = stage.stageHeight * 0.5;

        gameState ="idle";

        playerSpeed = 0;
        hitObstacle = 0;
        bg.speed = 0;
        scoreDistance = 0;
        obstacleGapCount = 0;

        obstaclesToAnimate = new Vector.<Obstacle>();
        itemsToAnimate = new Vector.<Item>();

        startButton.addEventListener(Event.TRIGGERED, onStartButtonClick);
        //var mainStage:InGame =InGame.current.nativeStage;
        //mainStage.dispatchEvent(new Event(Event.COMPLETE));
        //playAgain.addEventListener(Event.TRIGGERED, onRetry);
    }

    private function onStartButtonClick(event:Event):void {
        startButton.visible = false;

        startButton.removeEventListener(Event.TRIGGERED, onStartButtonClick);
        launchHero();
    }

    private function launchHero():void {
        this.addEventListener(TouchEvent.TOUCH, onTouch);
        this.addEventListener(Event.ENTER_FRAME, onGameTick);
    }

    private function onTouch(event:TouchEvent):void {
        touch = event.getTouch(stage);

        touchX = touch.globalX;
        touchY = touch.globalY;
    }

    private function onGameTick(event:Event):void {
        switch(gameState) {
            case "idle":
                if(hero.x < stage.stageWidth * 0.5 * 0.5) {
                    hero.x += ((stage.stageWidth * 0.5 * 0.5 + 10) - hero.x) * 0.05;
                    hero.y = stage.stageHeight * 0.5;

                    playerSpeed += (MIN_SPEED - playerSpeed) * 0.05;
                    bg.speed = playerSpeed * elapsed;
                } else {
                    gameState = "flying";

                }
                break;
            case "flying":
                if(hitObstacle <= 0) {
                    hero.y -= (hero.y - touchY) * 0.1;

                    if(-(hero.y - touchY) < 150 && -(hero.y - touchY) > -150) {
                        hero.rotation = deg2rad(-(hero.y - touchY) * 0.2);
                    }

                    if(hero.y > gameArea.bottom - hero.height * 0.5) {
                        hero.y = gameArea.bottom - hero.height * 0.5;
                        hero.rotation = deg2rad(0);
                    }

                    if(hero.y < gameArea.top + hero.height * 0.5) {
                        hero.y = gameArea.top + hero.height * 0.5;
                        hero.rotation = deg2rad(0);
                    }
                } else {    
                    hitObstacle--
                        cameraShake();
                }

                playerSpeed -= (playerSpeed - MIN_SPEED) * 0.01;
                bg.speed = playerSpeed * elapsed;

                scoreDistance += (playerSpeed * elapsed) * 0.1;
                scoreText.text = "Score: " + scoreDistance;

                initObstacle();
                animateObstacles();

                createEggItems();
                animateItems();

                remainingLives.text = "Lives: "+lives + " X ";

                if(lives == 0) {
                    gameState = "over";
                }

                break;
            case "over":
                gameOver();
                break;

        }
    }

    private function gameOver():void {

        gameOverText = new TextField(800, 400, "Hero WAS KILLED!!!", "MyFontName", 50, 0xD9D919, true);
        scoreText = new TextField(800, 600, "Score: "+scoreDistance, "MyFontName", 30, 0xFFFFFF, true);
        this.addChild(scoreText);

        this.addChild(gameOverText);

        playAgain = new Button(Assets.getAtlas().getTexture("button_tryAgain"));
        playAgain.x = stage.stageWidth * 0.5 - startButton.width * 0.5;
        playAgain.y = stage.stageHeight * 0.75 - startButton.height * 0.75; 

        this.addChild(playAgain);
        playAgain.addEventListener(Event.TRIGGERED, onRetry);

    }

    private function onRetry(event:Event):void {

        playAgain.visible = false;
        gameOverText.visible = false;
        scoreText.visible = false;

        var btnClicked:Button = event.target as Button;

        if((btnClicked as Button) == playAgain) {

            this.dispatchEvent(new NavigationEvent(NavigationEvent.CHANGE_SCREEN, {id: "playnow"}, true));
        } 

        disposeTemporarily();
    }

    private function animateItems():void {
        var itemToTrack:Item;

        for(var i:uint = 0; i < itemsToAnimate.length; i++) {
            itemToTrack = itemsToAnimate[i];

            itemToTrack.x -= playerSpeed * elapsed;

            if(itemToTrack.bounds.intersects(hero.bounds)) {
                itemsToAnimate.splice(i, 1);
                this.removeChild(itemToTrack);
            }

            if(itemToTrack.x < -50) {
                itemsToAnimate.splice(i, 1);
                this.removeChild(itemToTrack);
            }
        }
    }

    private function createEggItems():void {
        if(Math.random() > 0.95){
            var itemToTrack:Item = new Item(Math.ceil(Math.random() * 10));
            itemToTrack.x = stage.stageWidth + 50;
            itemToTrack.y = int(Math.random() * (gameArea.bottom - gameArea.top)) + gameArea.top;
            this.addChild(itemToTrack);

            itemsToAnimate.push(itemToTrack);
        }
    }

    private function cameraShake():void {

        if(hitObstacle > 0) {
            this.x = Math.random() * hitObstacle;
            this.y = Math.random() * hitObstacle;
        } else if(x != 0) {
            this.x = 0;
            this.y = 0;
            lives--;
        }
    }

    private function initObstacle():void {
        if(obstacleGapCount < 1200) {
            obstacleGapCount += playerSpeed * elapsed;
        } else if(obstacleGapCount !=0) {
            obstacleGapCount = 0;
            createObstacle(Math.ceil(Math.random() * 5), Math.random() * 1000 + 1000);
        }
    }

    private function animateObstacles():void {
        var obstacleToTrack:Obstacle;

        for(var i:uint = 0; i<obstaclesToAnimate.length; i++) {
            obstacleToTrack = obstaclesToAnimate[i];

            if(obstacleToTrack.alreadyHit == false && obstacleToTrack.bounds.intersects(hero.bounds)) {
                obstacleToTrack.alreadyHit = true;
                obstacleToTrack.rotation = deg2rad(70);

                hitObstacle = 30;
                playerSpeed *= 0.5;
            }

            if(obstacleToTrack.distance > 0) {
                obstacleToTrack.distance -= playerSpeed * elapsed;
            } else {
                if(obstacleToTrack.watchOut) {
                    obstacleToTrack.watchOut = false;
                } 

                obstacleToTrack.x -= (playerSpeed + obstacleToTrack.speed) * elapsed;
            }

            if(obstacleToTrack.x < -obstacleToTrack.width || gameState == "over") {
                obstaclesToAnimate.splice(i, 1);
                this.removeChild(obstacleToTrack);
            }
        }
    }

    private function checkElapsed(event:Event):void {
        timePrevious = timeCurrent;
        timeCurrent = getTimer();

        elapsed = (timeCurrent - timePrevious) * 0.001;
    }

    private function createObstacle(type:Number, distance:Number):void{
        var obstacle:Obstacle = new Obstacle(type, distance, true, 300);
        obstacle.x = stage.stageWidth;

        this.addChild(obstacle);

        if(type >= 4) {
            if(Math.random() > 0.5) {
                obstacle.y = gameArea.top;
                obstacle.position = "top"
            } else {
                obstacle.y = gameArea.bottom - obstacle.height;
                obstacle.position = "bottom";
            }
        } else {
            obstacle.y = int(Math.random() * (gameArea.bottom - obstacle.height - gameArea.top)) + gameArea.top;
            obstacle.position = "middle";
        }

        obstaclesToAnimate.push(obstacle);
    }

}

}

Answer 1

You’re not calling initialize() anywhere, which is where the gameState is initially set to “idle” it seems… what does this code do currently when you run it?

The goal here is to get the onGameTick(event) function running every frame, which is going to switch between idle/flying/over game states.