Subversion Repositories AndroidProjects

package com.gebauz.burutaru.game.entities;

import com.gebauz.bauzoid.graphics.sprite.Sprite;
import com.gebauz.bauzoid.graphics.sprite.SpriteInstance;
import com.gebauz.bauzoid.math.Matrix4;
import com.gebauz.bauzoid.math.collision.AABoundingBox;
import com.gebauz.bauzoid.math.collision.Shape;
import com.gebauz.bauzoid.math.collision.ShapeUtil;
import com.gebauz.burutaru.GameConsts;
import com.gebauz.burutaru.game.GameLogic;

public class PowerUpBomb extends Entity
{

        // Constants========================================================================================
       
        public static final int MAX_BOMBS = 1;
       
        public static final int BOMB_DAMAGE = 5;
       
        public static final float BOMB_WIDTH = 35;
        public static final float BOMB_HEIGHT = BOMB_WIDTH/2;
       
        public static final float FALL_ACCELERATION = 550;
        public static final float INITIAL_FALL_SPEED = 20;
        public static final float FORWARD_SPEED = 100;
       
        public static final float EXPLOSION_TIME = 0.2f;
        public static final int NUM_EXPLOSIONS = 5;
        public static final float MIN_EXPLO_SIZE = 55;
        public static final float MAX_EXPLO_SIZE = 80;
        public static final float EXPLO_DISPLACE_X = 48;
        public static final float EXPLO_DISPLACE_Y = 25;

        // Embedded Types===================================================================================
       
        public enum BombPhase
        {
                FALLING,
                EXPLODING              
        }
       
        public class Bomb extends Projectile
        {
                public SpriteInstance spriteInstance = null;
               
                private float mFallSpeed = INITIAL_FALL_SPEED;
                private BombPhase mPhase = BombPhase.FALLING;
                private float mExplosionTimer = 0.0f;

                public Bomb()
                {
                        super(BOMB_DAMAGE);
                       
                        spriteInstance = new SpriteInstance(getGraphics(), mBombSprite, mBombShape);
                       
                        spriteInstance.param.w = BOMB_WIDTH;
                        spriteInstance.param.h = BOMB_HEIGHT;
                        spriteInstance.param.pivotX = BOMB_WIDTH;
                        spriteInstance.param.pivotY = BOMB_HEIGHT/2;
                       
                        setAlive(false);
                }
               
                public void launch(float x, float y)
                {
                        spriteInstance.param.x = x;
                        spriteInstance.param.y = y;
                       
                        mFallSpeed = INITIAL_FALL_SPEED;
                       
                        mPhase = BombPhase.FALLING;
                       
                        setAlive(true);
                }
               
                public void update(float deltaTime)
                {
                        if (mPhase == BombPhase.FALLING)
                        {
                                mFallSpeed += FALL_ACCELERATION * deltaTime;
                                spriteInstance.param.x += mFallSpeed * deltaTime * 0.5f;
                                spriteInstance.param.y += mFallSpeed * deltaTime;
                               
                                getGameLogic().checkProjectileHit(this);
                               
                                if (getGameLogic().isOutOfScreen(spriteInstance.param))
                                {
                                        // out of screen -> make un alive
                                        setAlive(false);
                                }
                        }
                        else if (mPhase == BombPhase.EXPLODING)
                        {
                                // spawn series of enemy-damaging explosions
                               
                                float t1 = (mExplosionTimer % (EXPLOSION_TIME / NUM_EXPLOSIONS));
                                float t2 = ((mExplosionTimer - deltaTime) % (EXPLOSION_TIME / NUM_EXPLOSIONS));
                               
                                mExplosionTimer -= deltaTime;
                               
                                // flipped over -> spawn
                                if (t2 > t1)           
                                        spawnExplosion();
                               
                                if (mExplosionTimer <= 0)
                                {
                                        setAlive(false);                                       
                                }
                        }
                }
               
                public void render()
                {
                        if (mPhase == BombPhase.FALLING)
                                spriteInstance.render();
                }

                @Override
                public void processHit(ICollidable hitObject)
                {
                        // spawn impact effect
                        hitObject.hit(getDamage());
                        //setAlive(false);
                       
                        mPhase = BombPhase.EXPLODING;
                        mExplosionTimer = EXPLOSION_TIME;
                       
                        spawnExplosion(spriteInstance.param.x, spriteInstance.param.y);
                }
               
                public void spawnExplosion()
                {
                        float exploX = spriteInstance.param.x + getGame().getRandomFloat(-EXPLO_DISPLACE_X, +EXPLO_DISPLACE_X);
                        float exploY = spriteInstance.param.y + getGame().getRandomFloat(-EXPLO_DISPLACE_Y, +EXPLO_DISPLACE_Y);
                        spawnExplosion(exploX, exploY);
                }
               
                public void spawnExplosion(float x, float y)
                {
                        float exploSize = getGame().getRandomFloat(MIN_EXPLO_SIZE, MAX_EXPLO_SIZE);
                        getGameLogic().getImpactExplosions().spawn(x, y, exploSize);
                }

                @Override
                public AABoundingBox getBounds()
                {
                        return spriteInstance.param.getBoundingBox();
                }

                @Override
                public Shape getShape()
                {
                        return spriteInstance.getShape();
                }

                @Override
                public Matrix4 getShapeTransform()
                {
                        return spriteInstance.param.getTransform();
                }
               
        }

        // Fields===========================================================================================
       
        private Sprite mBombSprite = null;
        private Shape mBombShape = null;
       
        private Bomb mBombs[] = new Bomb[MAX_BOMBS];

        // Methods==========================================================================================
       
        public PowerUpBomb(GameLogic gameLogic)
        {
                super(gameLogic);
               
                mBombSprite = new Sprite(getGraphics(), "data/textures/bomb.png");
        }
       
        @Override
        public void initAsync()
        {
                mBombSprite.initAsync();
        }

        @Override
        public void init()
        {
                mBombSprite.init();
               
                mBombShape = ShapeUtil.createShapeFromFile("data/textures/bomb.shape");
               
                for (int i = 0; i < MAX_BOMBS; i++)
                {
                        mBombs[i] = new Bomb();
                }
        }

        @Override
        public void exit()
        {
                mBombShape = null;
               
                if (mBombSprite != null)
                {
                        mBombSprite.dispose();
                        mBombSprite = null;
                }
        }

        @Override
        public void update(float deltaTime)
        {
                for (int i = 0; i < mBombs.length; i++)
                {
                        if (mBombs[i].isAlive())
                                mBombs[i].update(deltaTime);
                }
        }

        @Override
        public void render()
        {
                for (int i = 0; i < mBombs.length; i++)
                {
                        if (mBombs[i].isAlive())
                                mBombs[i].render();
                }
        }
       
        public void launch(float x, float y)
        {
                for (int i = 0; i < MAX_BOMBS; i++)
                {
                        if (!mBombs[i].isAlive())
                        {
                                mBombs[i].launch(x, y);
                        }
                }
        }
       
        // Getters/Setters==================================================================================

}