Subversion Repositories AndroidProjects

package com.gebauz.burutaru.game.entities;

import java.util.Vector;

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.graphics.sprite.SpriteParameters;

import com.gebauz.bauzoid.math.MathUtil;

import com.gebauz.bauzoid.math.Matrix4;

import com.gebauz.bauzoid.math.Vector2;

import com.gebauz.bauzoid.math.collision.Shape;

import com.gebauz.bauzoid.math.collision.ShapeUtil;

import com.gebauz.burutaru.game.GameLogic;

import com.gebauz.burutaru.game.entities.BlobEnemies.Instance;

import com.gebauz.burutaru.game.entities.PowerUps.Type;

public class CarrotEnemies extends Entity

{

        // Constants========================================================================================

        public static final float SPRITE_WIDTH = 110;

        public static final float SPRITE_HEIGHT = SPRITE_WIDTH/2;

        public static final float ANIM_DURATION = 1.2f;

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

        public class Instance

        {

                public float x = 0;

                public float y = 0;

                public float lifeTime = 0;

                public boolean isAlive = false;

                private SpriteParameters mParams = new SpriteParameters();

                public Instance(float _x, float _y)

                {

                        x = _x; y = _y; isAlive = true;

                        lifeTime = 0.0f;

                }

                public void update(float deltaTime)

                {

                        lifeTime += deltaTime;

                        //x -= deltaTime * 400;

                }

                public void render()

                {

                        float t = (lifeTime % ANIM_DURATION) / ANIM_DURATION;

                        int frame = MathUtil.clamp((int)(t * mCarrotFrames.length), 0, mCarrotFrames.length-1);

                        mParams.x = x;

                        mParams.y = y;

                        mParams.w = SPRITE_WIDTH;

                        mParams.h = SPRITE_HEIGHT;

                        mParams.pivotX = 0;

                        mParams.pivotY = mParams.h/2;

                        mParams.mirrorX = true;

                        //mParams.angle = (lifeTime * 90) % 360;

                        //mParams.angle = 34;

                        //mParams.angle = 90;

                        mCarrotFrames[frame].param.apply(mParams);

                        mCarrotFrames[frame].render();

/*                      float pX = mParams.w/3;

                        float pY = mParams.h/3;

                        Vector2 p = mCarrotFrames[frame].param.transformPoint(pX, pY);

                        mTester.param.x = p.x;

                        mTester.param.y = p.y;

                        mTester.param.w = 4;

                        mTester.param.h = 4;                   

                        mTester.centerPivot();

                        mTester.render();*/

                        /*getGraphics().getBatch().begin();

                        mParams.y += 100.0f;

                        mCarrotFrames[frame].param.apply(mParams);

                        getGraphics().getBatch().drawSprite(mCarrotFrames[frame]);

                        getGraphics().getBatch().end();*/

                }

                public boolean checkForHit(Shape shape, Matrix4 transform)

                {

                        return false;

                }

                public boolean checkForHit(float _x, float _y, float w, float h)

                {

                        return (((_x) > (x - SPRITE_WIDTH/2)) &&

                                        ((_x) < (x + SPRITE_WIDTH/2)) &&

                                        ((_y) > (y - SPRITE_HEIGHT/2)) &&

                                        ((_y) < (y + SPRITE_HEIGHT/2)));

                        /*return (((_x + w/2) > (x - SPRITE_SIZE/2)) &&

                                        ((_x - w/2) < (x + SPRITE_SIZE/2)) &&

                                        ((_y + h/2) > (y - SPRITE_SIZE/2)) &&

                                        ((_y - h/2) < (y + SPRITE_SIZE/2)));*/

                }

        }

        // Fields===========================================================================================

        private Vector<Instance> mEnemies = new Vector<Instance>();

        private Shape mCarrotShape = null;

        private AtlasSprite mCarrotSprite = null;

        private AtlasSpriteInstance mCarrotFrames[] = null;

        private Sprite mTester = null;

        // Methods==========================================================================================

        public CarrotEnemies(GameLogic gameLogic)

        {

                super(gameLogic);

                mCarrotSprite = new AtlasSprite(getGraphics(), "data/textures/carrot.png", "data/textures/carrot.txt");

                mTester = new Sprite(getGraphics(), "data/textures/tester.png");

        }

        @Override

        public void initAsync()

        {

                mCarrotSprite.initAsync();

                mTester.initAsync();

        }

        @Override

        public void init()

        {

                mCarrotSprite.init();

                mCarrotFrames = mCarrotSprite.createSpriteInstances();

                mTester.init();

                mCarrotShape = ShapeUtil.createShapeFromFile("data/textures/carrot.shape");

        }

        @Override

        public void exit()

        {

                mCarrotShape = null;

                mCarrotFrames = null;

                if (mTester != null)

                {

                        mTester.dispose();

                        mTester = null;

                }

                if (mCarrotSprite != null)

                {

                        mCarrotSprite.dispose();

                        mCarrotSprite = null;

                }

        }

        @Override

        public void update(float deltaTime)

        {

                int i = 0;

                while (i < mEnemies.size())

                {

                        Instance enemy = mEnemies.get(i);

                        enemy.update(deltaTime);

                        if (!enemy.isAlive)

                        {

                                mEnemies.remove(i);

                                continue;

                        }

                        ++i;

                }

        }

        @Override

        public void render()

        {

                int i = 0;

                while (i < mEnemies.size())

                {

                        Instance enemy = mEnemies.get(i);

                        if (enemy.isAlive)

                        {

                                enemy.render();

                        }

                        ++i;

                }

        }

        public void spawn(float x, float y)

        {

                mEnemies.add(new Instance(x, y));

        }

        public boolean checkForHit(Shape shape, Matrix4 transform)

        {

                boolean hitFound = false;

                int i = 0;

                while (i < mEnemies.size())

                {

                        Instance enemy = mEnemies.get(i);

                        if (enemy.checkForHit(shape, transform))

                        {

                                getGameLogic().getExplosions().spawn(enemy.x, enemy.y);

                        }

                        ++i;

                }

                return hitFound;

        }

        // TODO: unify

        public boolean checkForHit(float x, float y, float w, float h)

        {

                boolean hitFound = false;

                int i = 0;

                while (i < mEnemies.size())

                {

                        Instance enemy = mEnemies.get(i);

                        if (enemy.checkForHit(x, y, w, h))

                        {

                                getGameLogic().getExplosions().spawn(enemy.x, enemy.y);

                                // spawn powerup

                                // TEMP:

                                /*int n = getGame().getRandomInt(1, 10);

                                if (n == 5)

                                {

                                        int rand = getGame().getRandomInt(PowerUps.Type.SPEED_UP.ordinal(), PowerUps.Type.MISSILE.ordinal());

                                        getGameLogic().getPowerUps().spawn(enemy.x, enemy.y, Type.values()[rand]);

                                }*/

                                //mEnemies.remove(i);

                                //hitFound = true;

                                //continue;                             

                        }

                        ++i;

                }

                return hitFound;

        }

        // TODO: unify

        public boolean getNearestEnemy(float x, float y, Vector2 result, float previousDistanceSqr)

        {

                boolean found = false;

                float distanceSqr = previousDistanceSqr;

                for (int i = 0; i < mEnemies.size(); i++)

                {

                        Instance enemy = mEnemies.get(i);

                        if (enemy.isAlive)

                        {

                                float diffX = enemy.x - x;

                                float diffY = enemy.y - y;

                                float currentDistanceSqr = diffX*diffX + diffY*diffY;

                                if ((distanceSqr < 0) || (currentDistanceSqr < distanceSqr))

                                {

                                        found = true;

                                        distanceSqr = currentDistanceSqr;

                                        result.x = enemy.x;

                                        result.y = enemy.y;

                                }

                        }

                }

                return found;

        }

        // Getters/Setters==================================================================================

}