Subversion Repositories AndroidProjects

package com.gebauz.pingK.entities;

import java.util.Vector;

import com.gebauz.pingK.GameMain;

import com.gebauz.pingK.R;

import com.gebauz.pingK.util.Vector2D;

import com.gebauz.pingK.util.MathUtil;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Paint;

public class Ball extends BaseEntity {

        public static final int DIRECTION_RANDOM = 0;

        public static final int DIRECTION_UP = 1;

        public static final int DIRECTION_DOWN = 2;

        public static final float BALL_INITIAL_SPEED = 300.0f;

        public static final float HIT_ZONE_DEVIATION = 0.40f;

        public static final float BALL_STEEPEST_ANGLE_REFLECT_FROM_BOARD = 1.0f;

        public static final float BALL_STEEPEST_ANGLE_HIT_PADDLE = 1.0f;

        public static final float TOP_SPIN_INTENSITY = 0.18f;

        public static final float BALL_MAXIMUM_ANGULAR_SPEED = 500.0f;

        public static final float PLAYFIELD_BORDER = 8.0f;

        public static final float PADDLE_HIT_OFFSET = 0.0f;

        Bitmap mBall;

        Vector2D position = new Vector2D();

        Vector2D lastPosition = new Vector2D();

        int lastPaddleTouched = -1;

        float size;    

        float speed;

        float rotation;

        float angularVelocity;

        public static final int TRAIL_LENGTH = 15;

        Vector<Vector2D> mTrail = new Vector<Vector2D>();

        public Ball(GameMain gameMain) {

                super(gameMain);

        }      

        @Override

        public void init() {

                mBall = BitmapFactory.decodeResource(getResources(), R.drawable.ball);

                size = mBall.getWidth();

                reset(DIRECTION_RANDOM);

        }

        public void reset(int direction) {

                resetTrail();

                position.x = mGameMain.getWidth() / 2.0f;

                position.y = mGameMain.getHeight() / 2.0f;

                speed = BALL_INITIAL_SPEED;

                if (direction == DIRECTION_UP) {

                        rotation = 0.0f;

                } else if (direction == DIRECTION_DOWN) {

                        rotation = 180.0f;

                } else {

                        if (Math.random() > 0.5)

                                rotation = 0.0f;

                        else

                                rotation = 180.0f;

                }

                angularVelocity = 0.0f;

                lastPaddleTouched = -1;

        }

        @Override

        public void destroy() {

        }

        @Override

        public void update(float deltaTime) {

                // move forward, calculating collisions with other entities

                lastPosition.x = position.x;

                lastPosition.y = position.y;

            processAngularVelocity(deltaTime);

            moveForward(deltaTime);

            //collectPowerUps;

            //reflectFromCrystals;

            reflectFromBoard(deltaTime);

            reflectFromEntities(deltaTime);

            //updateBallSparks;

            //updateTrail

            checkPlayerGainsScore();

        }

        public void checkPlayerGainsScore() {

                if (position.y < PLAYFIELD_BORDER) {

                        // reached top -> bottom player scores                  

                        mGameMain.playerGainsScore(Paddle.PADDLE_BOTTOM, lastPaddleTouched);

                        return;

                }

                if (position.y > (mGameMain.getHeight() - PLAYFIELD_BORDER)) {

                        // reached bottom -> top player scores

                        mGameMain.playerGainsScore(Paddle.PADDLE_TOP, lastPaddleTouched);

                        return;

                }                      

        }

        public void processAngularVelocity(float deltaTime) {

                rotation += angularVelocity * deltaTime;

        }

        public void moveForward(float deltaTime) {

                Vector2D move = new Vector2D();

                move.x = (float)Math.sin(Math.toRadians(rotation));

                move.y = (float)Math.cos(Math.toRadians(rotation));

                move.setLength(speed * deltaTime);

                position.addVector(move);

                Vector2D newPos = new Vector2D(position.x, position.y);

                mTrail.add(newPos);

                while (mTrail.size() > TRAIL_LENGTH)

                        mTrail.remove(0);                      

        }

        public void reflectFromBoard(float deltaTime) {

                float impactDirection = -1;

                // left bounce

                if (position.x < PLAYFIELD_BORDER) {

                        reflectAlongNormal(90.0f);

                        impactDirection = 0.0f;

                        clampToAngle(BALL_STEEPEST_ANGLE_REFLECT_FROM_BOARD);   // clamp to steepest angle from board

                        mGameMain.playSound(R.raw.wallimpact);

                        mGameMain.getWallImpactEffect().spawnInstance(PLAYFIELD_BORDER, position.y, 90.0f);

                }

                // right bounce

                if (position.x > (mGameMain.getWidth() - PLAYFIELD_BORDER)) {

                        reflectAlongNormal(270.0f);

                        impactDirection = 180.0f;

                        clampToAngle(BALL_STEEPEST_ANGLE_REFLECT_FROM_BOARD);   // clamp to steepest angle from board

                        mGameMain.playSound(R.raw.wallimpact);

                        mGameMain.getWallImpactEffect().spawnInstance(mGameMain.getWidth() - PLAYFIELD_BORDER, position.y, 270.0f);

                }

                position.x = MathUtil.clampToRange(position.x, 0, mGameMain.getWidth());

                // if (impactdirection >- 1) then generateImpact(settings.pos,impactdirection,SX_EIMPACT_MODE_WALL);

        }

        public void reflectFromEntities(float deltaTime) {

                // entities in this case are the paddles

                Paddle[] paddles = mGameMain.getPaddles();

                reflectFromPaddle(paddles[Paddle.PADDLE_TOP]);

                reflectFromPaddle(paddles[Paddle.PADDLE_BOTTOM]);

        }

        public void reflectFromPaddle(Paddle paddle) {

                // if hit

                if (Math.abs(position.x - paddle.position.x) < (paddle.getWidth()/2.0f)) {

                        float paddleY = paddle.position.y;

                        if (paddleY < (mGameMain.getHeight() / 2.0f)) {

                                paddleY -= PADDLE_HIT_OFFSET;

                                if ((position.y <= paddleY) && (lastPosition.y > paddleY)) {

                                        ballHitsPaddle(paddle);

                                        lastPaddleTouched = paddle.getMode();

                                        mGameMain.playSound(R.raw.paddleimpact);

                                }

                        } else {

                                paddleY += PADDLE_HIT_OFFSET;

                                if ((position.y >= paddleY) && (lastPosition.y < paddleY)) {

                                        ballHitsPaddle(paddle);

                                        lastPaddleTouched = paddle.getMode();

                                        mGameMain.playSound(R.raw.paddleimpact);

                                }

                        }

                }

        }

        public void ballHitsPaddle(Paddle paddle) {

                paddle.startImpactEffect();

                float newY = position.y;

                float xDifference = (position.x - paddle.position.x) * HIT_ZONE_DEVIATION;

                // TODO: concave handling

                float direction = 0.0f;

                float paddleDirection = 0.0f;

                int invertPlayer2Paddle = 0;

                if (paddle.getMode() == Paddle.PADDLE_TOP) {

                        paddleDirection = 0.0f;

                        //direction = 90.0f - xDifference;

                        direction = xDifference;

                        newY += 6;

                        invertPlayer2Paddle = 1;

                } else {

                        paddleDirection = 180.0f;

                        //direction = 270.0f + xDifference;

                        direction = 180.0f + xDifference;

                        newY -= 6;

                        invertPlayer2Paddle = -1;

                }

                // todo: belong to player

                position.y = newY;

                reflectAlongNormal(direction);

                // todo: generate impact                

                // generateImpact(paddle.settings.pos,paddledirection, SX_EIMPACT_MODE_PADDLE);

                float angularSpeed = paddle.getMovementSpeed() * TOP_SPIN_INTENSITY * invertPlayer2Paddle;

                setAngularVelocity(angularVelocity + angularSpeed);

                clampToAngle(BALL_STEEPEST_ANGLE_HIT_PADDLE);

        }

        public void reflectAlongNormal(float rot) {

                rotation += 180.0f;

                rotation = MathUtil.stayInDegrees0to360(rotation);

                float difference = rot - rotation;

                rotation = rot + difference;

                rotation = MathUtil.stayInDegrees0to360(rotation);

                if (MathUtil.turnDegrees(rotation, rot) >= 90.0f) {

                        rotation = (float)(2*Math.PI) - rotation;

                        rotation = MathUtil.stayInDegrees0to360(rotation);

                }              

        }

        public void clampToAngle(float steepestAngle) {

                rotation = MathUtil.stayInDegrees0to360(rotation);

                if (steepestAngle <= 0)

                        return;

                if (rotation < steepestAngle)

                        rotation = steepestAngle;

                if (rotation > (360.0f - steepestAngle))

                        rotation = 360.0f - steepestAngle;

                if ((rotation > (180.0f - steepestAngle)) && (rotation <= 180.0f))

                        rotation = 180.0f - steepestAngle;

                if ((rotation < 180.0f + steepestAngle) && (rotation >= 180.0f))

                        rotation = 180.0f + steepestAngle;

        }

        @Override

        public void render(Canvas canvas) {

                Paint paint = new Paint();

                Matrix matrix = new Matrix();

                matrix.setTranslate(position.x - mBall.getWidth()/2, position.y - mBall.getHeight()/2);

                canvas.drawBitmap(mBall, matrix, paint);

                renderTrail(canvas);

        }

        public void renderTrail(Canvas canvas) {

                Paint paint = new Paint();

                paint.setStrokeWidth(10.0f);

                for (int i = 0; i < mTrail.size()-1; i++) {

                        int alpha = (int)(((float)i / (float)mTrail.size()) * 128.0f);

                        paint.setColor(Color.argb(alpha, 255, 0, 153));

                        Vector2D pt1 = mTrail.get(i);

                        Vector2D pt2 = mTrail.get(i+1);

                        canvas.drawLine(pt1.x, pt1.y, pt2.x, pt2.y, paint);

                }

        }

        public void setAngularVelocity(float angularSpeed) {

                angularVelocity = MathUtil.clampToRange(angularSpeed, -BALL_MAXIMUM_ANGULAR_SPEED, BALL_MAXIMUM_ANGULAR_SPEED);        

        }

        public void resetTrail() {

                mTrail.removeAllElements();

        }

        public Vector2D getPosition() {

                return position;

        }

}