Subversion Repositories AndroidProjects

package com.gebauz.burutaru.game.entities;

import com.gebauz.bauzoid.graphics.sprite.AtlasSprite;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteFrame;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteInstance;
import com.gebauz.bauzoid.math.MathUtil;
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.game.GameLogic;

public class BeamShots extends Entity
{

        // Constants========================================================================================
       
        public static final int MAX_BEAMSHOTS = 4;
        public static final int BEAMSHOT_DAMAGE = 10;
       
        public static final float BEAMSHOT_WIDTH = 180;
        public static final float BEAMSHOT_HEIGHT = 60;
        public static final float BEAMSHOT_WIDTH_MIN = 30;
        public static final float BEAMSHOT_HEIGHT_MIN = 10;
       
        public static final float BEAMSHOT_SPEED = 1000;
       
        public static final float BEAMSHOT_GROWTH_PERIOD = 0.15f;

        // Embedded Types===================================================================================
       
        public class BeamShotInstance extends Projectile
        {
                public AtlasSpriteInstance spriteInstance = null;
               
                public float lifeTime = 0.0f;

                public BeamShotInstance()
                {
                        super(BEAMSHOT_DAMAGE);
                       
                        spriteInstance = new AtlasSpriteInstance(getGraphics(), mBeamShotSprite, mBeamShotFrames, mBeamShotShape);
                       
                        spriteInstance.param.w = BEAMSHOT_WIDTH;
                        spriteInstance.param.h = BEAMSHOT_HEIGHT;
                        spriteInstance.param.pivotX = BEAMSHOT_WIDTH;
                        spriteInstance.param.pivotY = BEAMSHOT_HEIGHT/2;
                       
                        setAlive(false);
                }
               
                public void spawn(float x, float y)
                {
                        spriteInstance.param.x = x;
                        spriteInstance.param.y = y;
                       
                        lifeTime = 0.0f;
                       
                        setAlive(true);
                }
               
                public void update(float deltaTime)
                {
                        spriteInstance.param.x += deltaTime * BEAMSHOT_SPEED;

                        float w = MathUtil.clamp((lifeTime/BEAMSHOT_GROWTH_PERIOD) * BEAMSHOT_WIDTH, BEAMSHOT_WIDTH_MIN, BEAMSHOT_WIDTH);
                        float h = MathUtil.clamp((lifeTime/BEAMSHOT_GROWTH_PERIOD) * BEAMSHOT_HEIGHT, BEAMSHOT_HEIGHT_MIN, BEAMSHOT_HEIGHT);
                        spriteInstance.param.w = w;
                        spriteInstance.param.h = h;
                        spriteInstance.param.pivotX = w;
                        spriteInstance.param.pivotY = h/2;
                       
                        lifeTime += deltaTime;
                       
                        getGameLogic().checkProjectileHit(this);
                       
                        if (getGameLogic().isOutOfScreen(spriteInstance.param))
                                setAlive(false);
                }
               
                public void render()
                {
                        spriteInstance.renderFrame(0);
                }

                @Override
                public void processHit(Enemy enemy)
                {
                        // beam shots dont get destroyed on impact
                        enemy.hit(getDamage());                
                }

                @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 AtlasSprite mBeamShotSprite = null;
        private AtlasSpriteFrame mBeamShotFrames[] = null;
        private Shape mBeamShotShape = null;
       
        private BeamShotInstance mBeamShots[] = new BeamShotInstance[MAX_BEAMSHOTS];

        // Methods==========================================================================================
       
        public BeamShots(GameLogic gameLogic)
        {
                super(gameLogic);
                mBeamShotSprite = new AtlasSprite(getGraphics(), "data/textures/beamshot.png", "data/textures/beamshot.txt");
        }
       
        @Override
        public void initAsync()
        {
                mBeamShotSprite.initAsync();
        }

        @Override
        public void init()
        {
                mBeamShotSprite.init();
                mBeamShotFrames = mBeamShotSprite.createSpriteInstances();
                mBeamShotShape = ShapeUtil.createShapeFromFile("data/textures/beamshot.shape");
               
                for (int i = 0; i < mBeamShots.length; i++)
                        mBeamShots[i] = new BeamShotInstance();
        }

        @Override
        public void exit()
        {
                mBeamShotShape = null;
                mBeamShotFrames = null;
               
                if (mBeamShotSprite != null)
                {
                        mBeamShotSprite.dispose();
                        mBeamShotSprite = null;
                }
        }

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

        @Override
        public void render()
        {
                for (int i = 0; i < mBeamShots.length; i++)
                {
                        if (mBeamShots[i].isAlive())
                                mBeamShots[i].render();
                }
        }
       
        public void spawnShot(float x, float y)
        {
                for (int i = 0; i < MAX_BEAMSHOTS; i++)
                {
                        if (!mBeamShots[i].isAlive())
                        {
                                mBeamShots[i].spawn(x, y);
                                //mShotSound.play();
                                break;
                        }
                }
        }
       
        // Getters/Setters==================================================================================

}