Subversion Repositories AndroidProjects

package com.gebauz.burutaru.game;

import java.util.Vector;

import com.badlogic.gdx.graphics.Texture.TextureFilter;
import com.gebauz.bauzoid.game.Game;
import com.gebauz.bauzoid.game.GameObject;
import com.gebauz.bauzoid.game.entities.EntityManager;
import com.gebauz.bauzoid.graphics.sprite.Sprite;
import com.gebauz.bauzoid.graphics.sprite.SpriteInstance;
import com.gebauz.bauzoid.graphics.sprite.SpriteParameters;
import com.gebauz.bauzoid.math.Matrix4;
import com.gebauz.bauzoid.math.Vector2;
import com.gebauz.bauzoid.math.collision.AABoundingBox;
import com.gebauz.bauzoid.math.collision.Shape;
import com.gebauz.burutaru.GameConsts;
import com.gebauz.burutaru.game.entities.BeamShots;
import com.gebauz.burutaru.game.entities.BlobEnemies;
import com.gebauz.burutaru.game.entities.CarrotEnemies;
import com.gebauz.burutaru.game.entities.Enemy;
import com.gebauz.burutaru.game.entities.Explosions;
import com.gebauz.burutaru.game.entities.ICollidable;
import com.gebauz.burutaru.game.entities.ImpactExplosions;
import com.gebauz.burutaru.game.entities.PlasmaShots;
import com.gebauz.burutaru.game.entities.PowerUpBomb;
import com.gebauz.burutaru.game.entities.PowerUpMissile;
import com.gebauz.burutaru.game.entities.PowerUps;
import com.gebauz.burutaru.game.entities.Projectile;
import com.gebauz.burutaru.game.entities.Ship;
import com.gebauz.burutaru.game.entities.StarField;
import com.gebauz.burutaru.game.entities.VirtualPad;
import com.gebauz.burutaru.game.level.Level;

public class GameLogic extends GameObject
{


        // Constants========================================================================================
       
       
        public static final float SPAWN_INTERVAL_MIN = 0.2f;
        public static final float SPAWN_INTERVAL_MAX = 1.5f;

        // Embedded Types===================================================================================

        // Fields===========================================================================================
       
        private EntityManager mEntities = new EntityManager();
       
        private Ship mShip = null;
        private ShipController mShipController = null;
        private ShipParameters mShipParameters = null;
       
        private PlasmaShots mPlasmaShots = null;
        private BeamShots mBeamShots = null;
       
        private BlobEnemies mBlobEnemies = null;
        private CarrotEnemies mCarrotEnemies = null;
       
        private Explosions mExplosions = null;
       
        private VirtualPad mVirtualPad = null;
       
        private PowerUps mPowerUps = null;
        private PowerUpMissile mPowerUpMissile = null;
        private PowerUpBomb mPowerUpBomb = null;
        private ImpactExplosions mImpactExplosions = null;
       
        private StarField mStarField = null;
       
        private Level mLevel = null;

        // TEMP:
        private Sprite mBackground = null;
        private float mSpawnTimer = 0.0f;
       
        private float mGlobalScrollX = 0.0f;
        private float mGlobalScrollY = 0.0f;

        // Methods==========================================================================================
       
        public GameLogic(Game game)
        {
                super(game);
               
                // TEMP:
                mBackground = new Sprite(getGraphics(), "data/textures/background.png");
        }
       
        public void createEntities()
        {
                mShip = mEntities.addEntity(new Ship(this));
                mPlasmaShots = mEntities.addEntity(new PlasmaShots(this));
                mBeamShots = mEntities.addEntity(new BeamShots(this));
                mBlobEnemies = mEntities.addEntity(new BlobEnemies(this));
                mCarrotEnemies = mEntities.addEntity(new CarrotEnemies(this));
                mExplosions = mEntities.addEntity(new Explosions(this));
                mVirtualPad = mEntities.addEntity(new VirtualPad(this));
                mPowerUps = mEntities.addEntity(new PowerUps(this));
                mPowerUpMissile = mEntities.addEntity(new PowerUpMissile(this));
                mPowerUpBomb = mEntities.addEntity(new PowerUpBomb(this));
                mImpactExplosions = mEntities.addEntity(new ImpactExplosions(this));
                mStarField = mEntities.addEntity(new StarField(this));
               
                mLevel = mEntities.addEntity(new Level(this));
        }
       
        public void initAsync()
        {
                createEntities();
               
                mEntities.initAsync();
               
                // TEMP:
                mBackground.initAsync();
        }
       
        public void init()
        {
                mEntities.init();
               
                // TEMP:
                mBackground.init();
                mBackground.getTexture().setFilter(TextureFilter.Linear, TextureFilter.Linear);
               
                mShipController = new ShipController(this);
                mShipParameters = new ShipParameters(this);
               
                //mCarrotEnemies.spawn(300.0f, 200.0f);
        }
       
        public void exit()
        {
                mShipController = null;
                mShipParameters = null;
               
                mEntities.exit();
        }
       
        public void update(float deltaTime)
        {
                mGlobalScrollX = -75.0f;
                //mGlobalScrollY = -15.0f;
               
                mShipController.handleInput(deltaTime);
               
                mShip.update(deltaTime);
                mPlasmaShots.update(deltaTime);
                mBeamShots.update(deltaTime);
                mBlobEnemies.update(deltaTime);
                mCarrotEnemies.update(deltaTime);
                mExplosions.update(deltaTime);
                mPowerUps.update(deltaTime);
                mPowerUpMissile.update(deltaTime);
                mPowerUpBomb.update(deltaTime);
                mImpactExplosions.update(deltaTime);
               
                mStarField.update(deltaTime);
               
                mLevel.update(deltaTime);
               
                checkShipHit();
               
                // TEMP:
                mSpawnTimer -= deltaTime;
                if (mSpawnTimer < 0.0f)
                {
                        int which = getGame().getRandomInt(0, 1);
                        if (which == 0)
                                mBlobEnemies.spawn(GameConsts.VIRTUAL_SCREEN_WIDTH + 100.0f, getGame().getRandomFloat(100.0f, GameConsts.VIRTUAL_SCREEN_HEIGHT - 100.0f));
                        else if (which == 1)
                                mCarrotEnemies.spawn(GameConsts.VIRTUAL_SCREEN_WIDTH + 100.0f, getGame().getRandomFloat(100.0f, GameConsts.VIRTUAL_SCREEN_HEIGHT - 100.0f));
                       
                        //mCarrotEnemies.spawn(GameConsts.VIRTUAL_SCREEN_WIDTH + 100.0f, 200);
                               
                        mSpawnTimer = getGame().getRandomFloat(SPAWN_INTERVAL_MIN, SPAWN_INTERVAL_MAX);
                }
        }
       
        public void render()
        {      
                // TEMP:
                mBackground.param.x = 0;
                mBackground.param.y = 0;
                mBackground.param.w = GameConsts.VIRTUAL_SCREEN_WIDTH;
                mBackground.param.h = GameConsts.VIRTUAL_SCREEN_HEIGHT;
                mBackground.param.pivotX = 0;
                mBackground.param.pivotY = 0;
                mBackground.render();
               
               
                // render level
                // TODO: might be required to render it in separated passes (foreground/background)
                mLevel.renderBackground();
               
                // render background
                mStarField.render();
               
                // render powerups
                mPowerUps.render();
               
                // render weapons
                mPlasmaShots.render();
                mBeamShots.render();
                mPowerUpMissile.render();
                mPowerUpBomb.render();
               
                // render enemies
                mBlobEnemies.render();
                mCarrotEnemies.render();

                // render ships
                mShip.render();
               
                // render effects
                mExplosions.render();
               
                mImpactExplosions.render();
               
                mLevel.renderForeground();
               
                // render UI
                mVirtualPad.render();
        }
       
        public boolean checkShipHit()
        {
                // TODO: maybe use more allocation-efficient data structures
                Vector<ICollidable> collidables = getCollidableList();
               
                AABoundingBox b = mShip.getBounds();
               
                boolean found = false;
                for (int i = 0; i < collidables.size(); i++)
                {
                        ICollidable collidableObject = collidables.get(i);
                       
                        // check if the two things are in closer proximity
                        AABoundingBox a = collidableObject.getBounds();
                       
                        if (a == null)
                                continue;
                       
                        if (!a.intersetcs(b))
                        {
                                // even bounding boxes do not intersect, so no need to test further
                                continue;
                        }
                       
                        // detail check
                        if (collidableObject.checkShipHit(mShip))
                        {
                                mShip.processHit(collidableObject);
                                found = true;
                        }
                }
               
                // check static level element collisions
                // get level's ICollidables
                // hmm..
               
                // check static level element collisions
                /*if (mLevel.checkShipHit())
                        found = true;*/
               
                return found;
        }
       
        public boolean checkProjectileHit(Projectile projectile)
        {
                // TODO: maybe use more allocation-efficient data structures
                Vector<ICollidable> collidables = getCollidableList();

                AABoundingBox b = projectile.getBounds();
               
                boolean found = false;
                for (int i = 0; i < collidables.size(); i++)
                {
                        ICollidable collidableObject = collidables.get(i);
                       
                        // check if the two things are in closer proximity
                        AABoundingBox a = collidableObject.getBounds();
                       
                        if (a == null)
                                continue;
                       
                        if (!a.intersetcs(b))
                        {
                                // even bounding boxes do not intersect, so no need to test further
                                continue;
                        }
                       
                        // detail check
                        if (collidableObject.checkHit(projectile.getShape(), projectile.getShapeTransform()))
                        {
                                projectile.processHit(collidableObject);
                                found = true;
                        }
                }
               
                // check static level element collisions
                /*if (mLevel.checkProjectileHit(projectile))
                        found = true;*/
               
                return found;
        }

        public boolean getNearestEnemyPosition(float x, float y, Vector2 result)
        {
                ICollidable nearestEnemy = getNearestEnemy(x, y);
               
                if (nearestEnemy == null)
                        return false;
               
                result.x = nearestEnemy.getX();
                result.y = nearestEnemy.getY();
               
                return true;
        }
       
        public Enemy getNearestEnemy(float x, float y)
        {
                Enemy foundEnemy = null;
               
                float distanceSqr = Float.MAX_VALUE;
               
                Vector<Enemy> enemies = getEnemyList();        
                for (int i = 0; i < enemies.size(); i++)
                {
                        Enemy enemy = enemies.get(i);
                        if (enemy.isAlive())
                        {
                                float diffX = enemy.getX() - x;
                                float diffY = enemy.getX() - y;
                               
                                float currentDistanceSqr = diffX*diffX + diffY*diffY;
                                if (currentDistanceSqr < distanceSqr)
                                {
                                        foundEnemy = enemy;
                                        distanceSqr = currentDistanceSqr;
                                }
                        }
                }
               
                return foundEnemy;
        }
       
        public Vector<ICollidable> getCollidableList()
        {
                Vector<ICollidable> collidables = new Vector<ICollidable>();
                mCarrotEnemies.fillCollidableList(collidables);
                mBlobEnemies.fillCollidableList(collidables);
                mLevel.fillCollidableList(collidables);
                return collidables;
        }
       
        public Vector<Enemy> getEnemyList()
        {
                Vector<Enemy> enemies = new Vector<Enemy>();
                mCarrotEnemies.fillEnemyList(enemies);
                mBlobEnemies.fillEnemyList(enemies);
                return enemies;
        }
       
        public boolean isOutOfScreen(SpriteParameters param)
        {
                return ((param.x > (GameConsts.VIRTUAL_SCREEN_WIDTH + param.w)) ||
                                (param.x < (-param.w)) ||
                                (param.y > (GameConsts.VIRTUAL_SCREEN_HEIGHT + param.h)) ||
                                (param.y < (-param.h)));                       
        }
       
        // Getters/Setters==================================================================================

        public final Ship getShip() { return mShip; }
        public final PlasmaShots getPlasmaShots() { return mPlasmaShots; }
        public final BeamShots getBeamShots() { return mBeamShots; }
        public final Explosions getExplosions() { return mExplosions; }
        public final VirtualPad getVirtualPad() { return mVirtualPad; }
        public final PowerUps getPowerUps() { return mPowerUps; }
        public final PowerUpMissile getPowerUpMissile() { return mPowerUpMissile; }
        public final PowerUpBomb getPowerUpBomb() { return mPowerUpBomb; }
        public final ImpactExplosions getImpactExplosions() { return mImpactExplosions; }
        public final ShipParameters getShipParameters() { return mShipParameters; }
       
        public final float getGlobalScrollX() { return mGlobalScrollX; }
        public final float getGlobalScrollY() { return mGlobalScrollY; }
       
}