Pong in Java; using LibGDX

package com.humborstad.GDXTest;

import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.graphics.FPSLogger;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.Texture.TextureFilter;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.math.Rectangle;

public class GDXTest implements ApplicationListener {
    private OrthographicCamera camera;
    private SpriteBatch batch;
    private Texture ballTexture;
    private Sprite ballSprite;
    private Texture paddleTexture;
    private Sprite[] paddleSprite = new Sprite[2];

    private Rectangle ballRectangle;
    private Rectangle[] paddleRectangle = new Rectangle[2];

    //We're twoplayers
    private int[] player = new int[2];

    private float ballXMoveSpeed = 300;
    private float ballYMoveSpeed = 300;

    private float w;
    private float h;

    private FPSLogger log = new FPSLogger();

    @Override
    public void create() {
        w = Gdx.graphics.getWidth();
        h = Gdx.graphics.getHeight();

        camera = new OrthographicCamera();
        camera.setToOrtho(false, w, h);

        batch = new SpriteBatch();

        ballTexture = new Texture(Gdx.files.internal("img/ball.png"));
        ballTexture.setFilter(TextureFilter.Linear, TextureFilter.Linear);

        paddleTexture = new Texture(Gdx.files.internal("img/paddle.png"));
        paddleTexture.setFilter(TextureFilter.Linear, TextureFilter.Linear);

        TextureRegion ballRegion = new TextureRegion(ballTexture, 0, 0, 16, 16);
        TextureRegion paddleRegion = new TextureRegion(paddleTexture, 0, 0, 16, 64);

        ballSprite = new Sprite(ballRegion);
        //ballSprite.setSize(0.9f, 0.9f * ballSprite.getHeight() / ballSprite.getWidth());

        // create a Rectangle to logically represent the bucket
        ballRectangle = new Rectangle();
        ballRectangle.x =  w/2; // center the bucket horizontally
        ballRectangle.y = h/2; // bottom left corner of the bucket is 20 pixels above the bottom screen edge
        ballRectangle.width = 16;
        ballRectangle.height = 16;

        ballSprite.setOrigin(ballSprite.getWidth()/2, ballSprite.getHeight()/2);
        ballSprite.setPosition(ballRectangle.x, ballRectangle.y);

        paddleSprite[0] = new Sprite(paddleRegion);
        paddleSprite[1] = new Sprite(paddleRegion);
        //ballSprite.setSize(0.9f, 0.9f * ballSprite.getHeight() / ballSprite.getWidth());

        // create a Rectangle to logically represent the bucket
        paddleRectangle[0] = new Rectangle();
        paddleRectangle[0].width = 16;
        paddleRectangle[0].height = 64;
        paddleRectangle[0].x = 30; // center the bucket horizontally
        paddleRectangle[0].y = h/2; // bottom left corner of the bucket is 20 pixels above the bottom screen edge

        paddleRectangle[1] = new Rectangle();
        paddleRectangle[1].width = 16;
        paddleRectangle[1].height = 64;
        paddleRectangle[1].x = w - 30 - paddleRectangle[1].width; // center the bucket horizontally
        paddleRectangle[1].y = h/2; // bottom left corner of the bucket is 20 pixels above the bottom screen edge

        paddleSprite[0].setOrigin(paddleSprite[0].getWidth()/2, paddleSprite[0].getHeight()/2);
        paddleSprite[0].setPosition(paddleRectangle[0].x, paddleRectangle[0].y);

        for(int i = 0; i < player.length; i++){
            player[i] = 0;
        }
    }

    @Override
    public void dispose() {
        batch.dispose();
        ballTexture.dispose();
        paddleTexture.dispose();
    }

    @Override
    public void render() {
        // clear the screen with a dark blue color. The
        // arguments to glClearColor are the red, green
        // blue and alpha component in the range [0,1]
        // of the color to be used to clear the screen.
        Gdx.gl.glClearColor(0, 0, 0.2f, 1);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

        // tell the camera to update its matrices.
        camera.update();
        // tell the SpriteBatch to render in the
        // coordinate system specified by the camera.
        batch.setProjectionMatrix(camera.combined);

        if(Gdx.input.isKeyPressed(Keys.S)) paddleRectangle[0].y -= 400 * Gdx.graphics.getDeltaTime();
        if(Gdx.input.isKeyPressed(Keys.W)) paddleRectangle[0].y += 400 * Gdx.graphics.getDeltaTime();
        if(Gdx.input.isKeyPressed(Keys.DOWN)) paddleRectangle[1].y -= 400 * Gdx.graphics.getDeltaTime();
        if(Gdx.input.isKeyPressed(Keys.UP)) paddleRectangle[1].y += 400 * Gdx.graphics.getDeltaTime();

        //Uh, yay for readability.
        for(Rectangle i : paddleRectangle){
            if(i.y < 0) i.y = 0;
            if(i.y > h - i.height) i.y = h - i.height;
        }

        if(ballRectangle.x + ballRectangle.width < 0 ){
            player[1]++;
            ballRectangle.x = w - w/4;
            //ballXMoveSpeed =- ballXMoveSpeed;
        } else if(ballRectangle.x + ballRectangle.width > w){
            player[0]++;
            ballRectangle.x = w/4;
            //ballXMoveSpeed =- ballXMoveSpeed;
        } else if (ballRectangle.y < 0 || ballRectangle.y + ballRectangle.height > h){
            ballYMoveSpeed =- ballYMoveSpeed;
        }

        for(Rectangle i : paddleRectangle){
            if(ballRectangle.overlaps(i)){
                ballXMoveSpeed =- ballXMoveSpeed;
            }
        }

        batch.setProjectionMatrix(camera.combined);
        batch.begin();
            ballSprite.setPosition(ballRectangle.x, ballRectangle.y);
            ballSprite.draw(batch);
            //This is a bit sketchy. We don't certainly know if paddleSprite.length == paddleRectangle.length
            for(int i = 0; i < paddleSprite.length; i ++){
                BitmapFont font = new BitmapFont();
                font.draw(batch, String.valueOf(player[1]), w - 50, h - 50);
                font.draw(batch, String.valueOf(player[0]), 50, h - 50);
                paddleSprite[i].setPosition(paddleRectangle[i].x, paddleRectangle[i].y);
                paddleSprite[i].draw(batch);
            }
            log.log();
        batch.end();

        ballRectangle.x += ballXMoveSpeed * Gdx.graphics.getDeltaTime();
        ballRectangle.y += ballYMoveSpeed * Gdx.graphics.getDeltaTime();
    }

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }
}