Subversion Repositories AndroidProjects

package com.gebauz.burutaru.game.entities;

import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.Texture.TextureFilter;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteFrame;
import com.gebauz.bauzoid.graphics.sprite.AtlasSprite;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteInstance;
import com.gebauz.bauzoid.graphics.sprite.Sprite;
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.GameConsts;
import com.gebauz.burutaru.game.GameLogic;

public class Ship extends Entity
{
       
        // Constants========================================================================================

        public static final int SHIP_WIDTH = 64;
        public static final int SHIP_HEIGHT = 64;
       
        // HACK: for powerup pickup
        public static final float SHIP_RADIUS_SQR = SHIP_WIDTH*SHIP_WIDTH * 0.5f;
       
        public static final int NUM_UP_FRAMES = 5;
        public static final int NUM_DOWN_FRAMES = 5;
        public static final int NUM_SHIP_FRAMES = 1 + NUM_UP_FRAMES + NUM_DOWN_FRAMES;
        public static final int SHIP_SPRITE_SIZE = 128;
        public static final int NUM_SHIP_FRAMES_X = 4;
        public static final int NUM_SHIP_FRAMES_Y = 4;
        public static final float UPDOWN_ANIM_SPEED = 4.0f;
        public static final float UPDOWN_THRESHOLD = 20.0f;
       
        public static final float MUZZLEFLASH_DURATION = 0.15f;
        public static final float MUZZLEFLASH_SIZE = 40.0f;
       
        public static final float EXHAUST_WIDTH = 28;
        public static final float EXHAUST_HEIGHT = 16;
       
        public static final float EXHAUST_BOOST_MAX = 0.3f;
        public static final float EXHAUST_BOOST_MIN = -0.1f;
        public static final float EXHAUST_BOOST_FACTOR = 11.0f;
        public static final float EXHAUST_ANIM_SPEED = 4000.0f;
       
       
        public static final float ENGINE_BOOST_DURATION = 0.5f;
       
        public static final float BEAMSHOT_COOLDOWN_TIME = 0.2f;
       
        public static final float DAMAGE_COOLDOWN_TIME = 0.2f;

        // Embedded Types===================================================================================
       
        public enum MoveDirection
        {
                NONE,
                UP,
                DOWN
        }      
       
        // Fields===========================================================================================
       
        private float mPositionX = 100;
        private float mPositionY = 100;
       
        private float mLastMoveX = 0.0f;
        private float mLastMoveY = 0.0f;
       
        private AtlasSprite mShipAtlas = null;
        private AtlasSpriteFrame mShipFrames[] = new AtlasSpriteFrame[NUM_SHIP_FRAMES];
        private AtlasSpriteInstance mSpriteInstance = null;
       
        private Shape mShipShape = null;
       
        private int mCurrentShipFrame = 0;
        private MoveDirection mMoveDirection = MoveDirection.NONE;     
       
        private Sprite mMuzzleFlash = null;
        private float mMuzzleFlashTimer = -1.0f;
       
        private float mBeamShotTimer = 0.0f;
       
        private Sprite mEngineExhaust = null;
        private float mEngineExhaustScale = 1.0f;
        private float mEngineExhaustBoost = 0.0f;
       
        private float mMoveDirectionCoeff = 0.0f;
        private float mMoveDirectionCoeffTarget = 0.0f;
       
        private float mEngineBoostTimer = 0.0f;
       
        private Sound mEngineBoostSfx = null;
       
        private float mDamageCoolDown = 0.0f;

        // Methods==========================================================================================
       
        public Ship(GameLogic gameLogic)
        {
                super(gameLogic);
                mShipAtlas = new AtlasSprite(getGraphics(), "data/textures/shipframes.png", "data/textures/ship.txt");
                mMuzzleFlash = new Sprite(getGraphics(), "data/textures/plasma_muzzleflash.png");
                mEngineExhaust = new Sprite(getGraphics(), "data/textures/engine_exhaust.png");
        }

        @Override
        public void initAsync()
        {
                mShipAtlas.initAsync();
                mMuzzleFlash.initAsync();
                mEngineExhaust.initAsync();
        }
       
        @Override
        public void init()
        {
                mEngineBoostSfx = getAudio().newManagedSound("data/sounds/speedup.wav");
               
                mShipAtlas.init();
                mShipAtlas.getTexture().setFilter(TextureFilter.Linear, TextureFilter.Linear);
                mShipAtlas.createSpriteInstances(mShipFrames);
                mMuzzleFlash.init();
                mMuzzleFlash.getTexture().setFilter(TextureFilter.Linear, TextureFilter.Linear);
                mEngineExhaust.init();
                mEngineExhaust.getTexture().setFilter(TextureFilter.Linear, TextureFilter.Linear);
               
                mShipShape = ShapeUtil.createShapeFromFile("data/textures/ship.shape");
               
                mSpriteInstance = new AtlasSpriteInstance(getGraphics(), mShipAtlas, mShipFrames, mShipShape);
        }
       
        @Override
        public void exit()
        {
                mShipShape = null;
                mSpriteInstance = null;
               
                for (int i = 0; i < NUM_SHIP_FRAMES; i++)
                {
                        mShipFrames[i] = null;
                }
               
                if (mShipAtlas != null)
                {
                        mShipAtlas.dispose();
                        mShipAtlas = null;
                }
               
                if (mMuzzleFlash != null)
                {
                        mMuzzleFlash.dispose();
                        mMuzzleFlash = null;
                }
               
                if (mEngineExhaust != null)
                {
                        mEngineExhaust.dispose();
                        mEngineExhaust = null;
                }
               
                if (mEngineBoostSfx != null)
                {
                        getAudio().removeManagedSound(mEngineBoostSfx);
                        mEngineBoostSfx = null;
                }
        }
       
        @Override
        public void update(float deltaTime)
        {
                if (mMoveDirection == MoveDirection.UP)
                {
                        // move towards -1
                        mMoveDirectionCoeff -= deltaTime * UPDOWN_ANIM_SPEED;
                        if (mMoveDirectionCoeff < mMoveDirectionCoeffTarget)
                                mMoveDirectionCoeff = mMoveDirectionCoeffTarget;
                }
                else if (mMoveDirection == MoveDirection.DOWN)
                {
                        // move towards +1
                        mMoveDirectionCoeff += deltaTime * UPDOWN_ANIM_SPEED;
                        if (mMoveDirectionCoeff > mMoveDirectionCoeffTarget)
                                mMoveDirectionCoeff = mMoveDirectionCoeffTarget;
                }
                else if (mMoveDirection == MoveDirection.NONE)
                {
                        // move towards 0
                        if (mMoveDirectionCoeff > 0)
                                mMoveDirectionCoeff = MathUtil.clamp(mMoveDirectionCoeff - deltaTime * UPDOWN_ANIM_SPEED, 0, 1);                               
                        else if (mMoveDirectionCoeff < 0)
                                mMoveDirectionCoeff = MathUtil.clamp(mMoveDirectionCoeff + deltaTime * UPDOWN_ANIM_SPEED, -1, 0);
                }
               
                mMoveDirectionCoeff = MathUtil.clamp(mMoveDirectionCoeff, -1, 1);
               
                if (mMoveDirectionCoeff > 0)
                {
                        mCurrentShipFrame = (int)(1 + (NUM_DOWN_FRAMES-1) * (mMoveDirectionCoeff));
                }
                else if (mMoveDirectionCoeff < 0)
                {
                        mCurrentShipFrame = (int)(1 + NUM_DOWN_FRAMES  + (NUM_UP_FRAMES-1) * (-mMoveDirectionCoeff));                  
                }
                else
                {
                        mCurrentShipFrame = 0;
                }
               
                //Gdx.app.log(GameConsts.LOG_TAG, "coeff = " + mMoveDirectionCoeff + ", frame = " + mCurrentShipFrame + ", dir = " + mMoveDirection);
               
                mCurrentShipFrame = MathUtil.clamp(mCurrentShipFrame, 0, NUM_SHIP_FRAMES-1);
               
                if (mLastMoveX > 0.0f)
                {
                        // grow
                        float diff = EXHAUST_BOOST_MAX - mEngineExhaustBoost;
                        mEngineExhaustBoost += diff * deltaTime * EXHAUST_BOOST_FACTOR;
                }
                else if (mLastMoveX < 0.0f)
                {
                        float diff = EXHAUST_BOOST_MIN - mEngineExhaustBoost;
                        mEngineExhaustBoost += diff * deltaTime * EXHAUST_BOOST_FACTOR;
                }
                else
                {
                        float diff = 0.0f - mEngineExhaustBoost;
                        mEngineExhaustBoost += diff * deltaTime * EXHAUST_BOOST_FACTOR;
                }
                mEngineExhaustScale = 0.9f + MathUtil.sin(getGame().getTime() * EXHAUST_ANIM_SPEED) * 0.05f + mEngineExhaustBoost;
               
                if (mEngineBoostTimer > 0.0f)
                {
                        mEngineBoostTimer -= deltaTime;
                        if (mEngineBoostTimer < 0.0f)
                                mEngineBoostTimer = 0.0f;
                }
               
                mEngineExhaustScale += ((mEngineBoostTimer / ENGINE_BOOST_DURATION) * 1.8f);
               

                if (mMuzzleFlashTimer > 0.0f)
                        mMuzzleFlashTimer -= deltaTime;
               
                if (mBeamShotTimer > 0.0f)
                        mBeamShotTimer -= deltaTime;
               
                if (mDamageCoolDown > 0.0f)
                        mDamageCoolDown -= deltaTime;
        }
       
        @Override
        public void render()
        {
               
                if (mEngineBoostTimer > 0.0f)
                {
                        mMuzzleFlash.param.x = mPositionX;
                        mMuzzleFlash.param.y = mPositionY - 1;
                        mMuzzleFlash.param.w = MUZZLEFLASH_SIZE * (1 + mEngineBoostTimer / ENGINE_BOOST_DURATION);
                        mMuzzleFlash.param.h = MUZZLEFLASH_SIZE * (1 + 0.5f*mEngineBoostTimer / ENGINE_BOOST_DURATION);
                        mMuzzleFlash.param.pivotX = mMuzzleFlash.param.w;
                        mMuzzleFlash.param.pivotY = mMuzzleFlash.param.h/2;
                        mMuzzleFlash.param.mirrorX = true;
                        mMuzzleFlash.param.alpha = (mEngineBoostTimer / ENGINE_BOOST_DURATION);
                        mMuzzleFlash.render();
                }
               
                mEngineExhaust.param.x = mPositionX - EXHAUST_WIDTH/2;
                mEngineExhaust.param.y = mPositionY - 1;
                mEngineExhaust.param.w = EXHAUST_WIDTH * mEngineExhaustScale;
                mEngineExhaust.param.h = EXHAUST_HEIGHT;
                mEngineExhaust.param.pivotX = mEngineExhaust.param.w;
                mEngineExhaust.param.pivotY = mEngineExhaust.param.h/2;
                mEngineExhaust.render();

               
                mSpriteInstance.param.x = mPositionX;
                mSpriteInstance.param.y = mPositionY;
                mSpriteInstance.param.w = SHIP_WIDTH;
                mSpriteInstance.param.h = SHIP_HEIGHT;
                mSpriteInstance.param.centerPivot();
                mSpriteInstance.renderFrame(mCurrentShipFrame);
               
                /*mShipFrames[mCurrentShipFrame].param.x = mPositionX;
                mShipFrames[mCurrentShipFrame].param.y = mPositionY;
                mShipFrames[mCurrentShipFrame].param.w = SHIP_WIDTH;
                mShipFrames[mCurrentShipFrame].param.h = SHIP_HEIGHT;
                mShipFrames[mCurrentShipFrame].centerPivot();
                mShipFrames[mCurrentShipFrame].render();*/
               
                if (mMuzzleFlashTimer > 0.0f)
                {
                        mMuzzleFlash.param.x = mPositionX + SHIP_WIDTH/2;
                        mMuzzleFlash.param.y = mPositionY;
                        mMuzzleFlash.param.w = MUZZLEFLASH_SIZE;
                        mMuzzleFlash.param.h = MUZZLEFLASH_SIZE;
                        mMuzzleFlash.param.pivotX = mMuzzleFlash.param.w/3 + 1.0f;
                        mMuzzleFlash.param.pivotY = mMuzzleFlash.param.h/2;
                        mMuzzleFlash.param.mirrorX = false;
                        mMuzzleFlash.param.alpha = mMuzzleFlashTimer/MUZZLEFLASH_DURATION;
                        mMuzzleFlash.render();
                }
        }
       
        public void moveBy(float x, float y, float deltaTime)
        {
                mPositionX += x*deltaTime;
                mPositionY += y*deltaTime;
               
                // TODO: scale with amount of y
                if (y < -UPDOWN_THRESHOLD)
                {
                        mMoveDirection = MoveDirection.UP;
                        //mMoveDirectionCoeffTarget = -1.0f;
                        mMoveDirectionCoeffTarget = (y + UPDOWN_THRESHOLD) * 0.01f;
                }
                else if (y > UPDOWN_THRESHOLD)
                {
                        mMoveDirection = MoveDirection.DOWN;
                        mMoveDirectionCoeffTarget = (y - UPDOWN_THRESHOLD) * 0.01f;
                }
                else
                {
                        mMoveDirection = MoveDirection.NONE;
                        mMoveDirectionCoeffTarget = 0.0f;
                }
               
                mPositionX = MathUtil.clamp(mPositionX, 0.0f, GameConsts.VIRTUAL_SCREEN_WIDTH);
                mPositionY = MathUtil.clamp(mPositionY, 0.0f, GameConsts.VIRTUAL_SCREEN_HEIGHT);
               
                mLastMoveX = x * deltaTime;
                mLastMoveY = y * deltaTime;
        }
       
        public void resetNoUpDownMovement()
        {
                mMoveDirection = MoveDirection.NONE;
                mMoveDirectionCoeffTarget = 0.0f;
        }
       
        public void shoot()
        {
                switch (getGameLogic().getShipParameters().getWeaponType())
                {
                case PLASMA_SHOT:
                        shootPlasma();
                        break;
                case BEAM_SHOT:
                        shootBeamShot();
                        break;
                case SPREAD_SHOT:
                        break;
                case NAPALM_SHOT:
                        break;
                }
               
                shootMissile();
                shootBomb();           
        }
       
        public void shootPlasma()
        {
                getGameLogic().getPlasmaShots().spawnShot(mPositionX + SHIP_WIDTH/2, mPositionY);
                mMuzzleFlashTimer = MUZZLEFLASH_DURATION;
        }
       
        public void shootMissile()
        {
                if (getGameLogic().getShipParameters().areMissilesEnabled())
                        getGameLogic().getPowerUpMissile().launch(mPositionX + SHIP_WIDTH/3, mPositionY);
        }
       
        public void shootBomb()
        {
                if (getGameLogic().getShipParameters().areBombsEnabled())
                        getGameLogic().getPowerUpBomb().launch(mPositionX + SHIP_WIDTH/3, mPositionY);
        }
       
        public void shootBeamShot()
        {
                if (mBeamShotTimer <= 0.0f)
                {
                        getGameLogic().getBeamShots().spawnShot(mPositionX + SHIP_WIDTH/2, mPositionY);
                        mBeamShotTimer = BEAMSHOT_COOLDOWN_TIME;
                }
        }
       
        public void boostEngine()
        {
                // boost for speed up powerup
                mEngineBoostTimer = ENGINE_BOOST_DURATION;
                mEngineBoostSfx.play();
        }
       
        public void processHit(ICollidable collidable)
        {
                if (mDamageCoolDown <= 0.0f)
                {
                        getGameLogic().getExplosions().spawn(mPositionX, mPositionY, 100);
                        mDamageCoolDown = DAMAGE_COOLDOWN_TIME;
                }
        }

        // Getters/Setters==================================================================================
        public float getPositionX() { return mPositionX; }
        public float getPositionY() { return mPositionY; }
       
        public AABoundingBox getBounds() { return mSpriteInstance.param.getBoundingBox(); }
       
        /** Get the shape of the projectile for testing. */
        public Shape getShape() { return mShipShape; }
       
        /** Get the transformation of the shape for testing. */
        public Matrix4 getShapeTransform() { return mSpriteInstance.param.getTransform(); }
       
}