Character Movement Help

/**
 *   PokéNation, a free to play online Pokémon Game
 *   Copyright (C) 2011-2012 Keywork Studios
 *
 *   This program is free software: you can redistribute it and / or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (At your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see (link removed).
 *   
 *  Any media presented to you by this game (such as graphics, sounds or GUI)
 *  was created by and is the property of Nintendo. The only thing Nintendo
 *  did not create was the source code, which belongs to Keywork Studios.
 *  
 */

package org.keyworkstudios.pokenation.screens;

import org.keyworkstudios.pokenation.framework.Screen;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Animation;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.g2d.tiled.TiledLayer;
import com.badlogic.gdx.graphics.g2d.tiled.TiledLoader;
import com.badlogic.gdx.graphics.g2d.tiled.TiledMap;
import com.badlogic.gdx.math.Vector2;

public class SplashScreen extends Screen {
	
	TiledMap mapData;
	TiledLayer map;
	
	Texture tileTexture;
	TextureRegion[] tileGraphics;
	
	Texture charactersTexture;
	TextureRegion[] cSprites;
	
	Sprite character;
	
	@Override
	public void create() {
		mapData = TiledLoader.createMap(Gdx.files.internal("map.tmx"));
		map = mapData.layers.get(0);
		
		tileTexture = new Texture("tiles.png");
		tileGraphics = new TextureRegion[(tileTexture.getWidth() / 16) * (tileTexture.getHeight() / 16)];
		
		int i = 0;
		for (int y = 0; y <= (tileTexture.getHeight() / 16) - 1; y++) {
			for (int x = 0; x <= (tileTexture.getWidth() / 16) - 1; x++) {
				tileGraphics[i] = new TextureRegion(tileTexture, x * 16, y * 16, 16, 16);
				tileGraphics[i].flip(false, true);
				i++;
			}
		}
		
		charactersTexture = new Texture("characters.png");
		
		cSprites = new TextureRegion[(charactersTexture.getWidth() / 20) * (charactersTexture.getHeight() / 25)];
		i = 0;
		for (int y = 0; y <= (charactersTexture.getHeight() / 25) - 1; y++) {
			for (int x = 0; x <= (charactersTexture.getWidth() / 20) - 1; x++) {
				cSprites[i] = new TextureRegion(charactersTexture, x * 20, y * 25, 20, 25);
				cSprites[i].flip(false, true);
				i++;
			}
		}
		
		character = new Sprite(cSprites[0]);
		
		sCharDownWalk = new int[] {1, 2};
		sCharUpWalk = new int[] {4, 5};
		sCharRightWalk = new int[] {7, 8};
		sCharLeftWalk = new int[] {10, 11};
	}
	
	Vector2 charPos = new Vector2(24, 33);
	
	int[] sCharDownWalk;
	int [] sCharUpWalk;
	int[] sCharRightWalk;
	int[] sCharLeftWalk;
	
	int sCharDown = 0;
	int sCharUp = 3;
	int sCharRight = 6;
	int sCharLeft = 9;
	
	boolean step = false;
	int cStep = 0;
	
	boolean moving = false;

	final int direction_up = 0;
	final int direction_left = 1;
	final int direction_down = 2;
	final int direction_right = 3;
	
	int direction = direction_down;
	
	int spriteIndex = 0;
	
	@Override
	public void update(float deltaTime) {
		if (currentTime == 0) currentTime = System.currentTimeMillis();
	}
	
	long currentTime = 0;
	
	public boolean hasPassed(int ms) {
		if (System.currentTimeMillis() >= currentTime + ms) {
			currentTime = 0;
			return true;
		} else {
			return false;
		}
	}
	
	boolean moveKeyPressed = false;
	int moveStage = 0;
	
	@Override
	public void renderDesktop(float deltaTime) {
		for (int x = 0; x <= map.getWidth() - 1; x++) {
			for (int y = 0; y <= map.getWidth() - 1; y++) {
				if (map.tiles[x][y] - 1 == -1) {
				} else {
					game().batch().draw(tileGraphics[map.tiles[x][y] - 1], y * 16, x * 16);
				}
			}
		}
		
//		character.draw(game().batch());
//		character.setPosition((charPos.x * 16), (charPos.y * 16) - 8);
		
		moveKeyPressed = Gdx.input.isKeyPressed(Input.Keys.UP) || Gdx.input.isKeyPressed(Input.Keys.LEFT) ||
							Gdx.input.isKeyPressed(Input.Keys.DOWN) || Gdx.input.isKeyPressed(Input.Keys.RIGHT);
		
		if (!moving && moveKeyPressed && hasPassed(50)) {
			if (Gdx.input.isKeyPressed(Input.Keys.UP)) {
				if (direction != direction_up) {
					direction = direction_up;
				} else {
					moving = true;
				}
			}
			
			if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) {
				if (direction != direction_left) {
					direction = direction_left;
				} else {
					moving = true;
				}
			}
			
			if (Gdx.input.isKeyPressed(Input.Keys.DOWN)) {
				if (direction != direction_down) {
					direction = direction_down;
				} else {
					moving = true;
				}
			}
			
			if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) {
				if (direction != direction_right) {
					direction = direction_right;
				} else {
					moving = true;
				}
			}
		}
		
		
		if (!moving) {
			switch (direction) {
			case direction_up:
				spriteIndex = sCharUp;
				break;
				
			case direction_left:
				spriteIndex = sCharLeft;
				break;
				
			case direction_down:
				spriteIndex = sCharDown;
				break;
				
			case direction_right:
				spriteIndex = sCharRight;
				break;
			}
		} else {
			if (moveStage == 0) {
				step = !step;
				if (step) 	cStep = 0;
				else		cStep = 1;
				
				if (direction == direction_up) {
					spriteIndex = sCharUpWalk[cStep];
				}
				
				if (direction == direction_left) {
					spriteIndex = sCharLeftWalk[cStep];
				}
				
				if (direction == direction_down) {
					spriteIndex = sCharDownWalk[cStep];
				}
				
				if (direction == direction_right) {
					spriteIndex = sCharRightWalk[cStep];
				}
				
				moveStage++;
			} else if (moveStage <= 11) {
				if (direction == direction_up) 		charPos.y -= 0.1f;
				if (direction == direction_left)	charPos.x -= 0.1f;
				if (direction == direction_down)	charPos.y += 0.1f;
				if (direction == direction_right)	charPos.x += 0.1f;
				
				moveStage++;
			} else if (moveStage == 12) {
				moving = false;
				moveStage = 0;
				
//				switch (direction) {
//				case direction_up:
//					spriteIndex = sCharUp;
//					break;
//					
//				case direction_left:
//					spriteIndex = sCharLeft;
//					break;
//					
//				case direction_down:
//					spriteIndex = sCharDown;
//					break;
//					
//				case direction_right:
//					spriteIndex = sCharRight;
//					break;
//				}
			}
		}
		
		game().camera().position.set(charPos.x * 16, (charPos.y * 16) - 8, 0);
		game().batch().draw(cSprites[spriteIndex], (charPos.x * 16), (charPos.y * 16) - 8);
	}

	@Override
	public void renderAndroid(float deltaTime) {
	}

	@Override
	public void pause() {
	}

	@Override
	public void resume() {
	}

	@Override
	public void onBackKey() {
		Gdx.app.exit();
		System.exit(0);
	}

	@Override
	public void dispose() {
	}
}