Java4K - Minimum Games, Maximum Fun!

View Game: Runner4K

Runner4K
By enaiel, submitted on Dec 29, 2012
Min JRE version: 1.6
1587 downloads.
This game was submitted in the Java4K 2013 Competition.
Source code available! Show source code
(Click on game for focus)

You need Java installed to play this game.
You may use the button below to get it.
Description

Get ready to run!

Presenting my very first ever Java4K submission. Jump over chasms while running at break neck speeds. Collect carrots for points (yes, those orange and green triangles are supposed to be carrots!). Collect speed boost orbs for bonus points and to go at even more uncontrollable speeds. Do you think you can avoid splatting into the canyon walls?
Instructions

W to jump up
SPACE to start game

Tip: Look before you leap! Jump early when getting onto a lower ledge. Jump late to get onto a higher ledge.
User Comments

Total 8 comments:
#1	By sixtyten	Dec 29, 2012 at 18:06:42
You die if you touch the top of the screen?
#2	By enaiel	Dec 29, 2012 at 20:17:40
Lol! Not supposed to. Fixing it.
#3	By enaiel	Dec 29, 2012 at 21:42:58
Fixed the bug. Please try again.
#4	By enaiel	Jan 4, 2013 at 03:33:01
Fixed the bug that caused the game to lag as the level proceeds and added 2 more levels.
#5	By Sri Harsha Chilakapati	Jan 8, 2013 at 11:53:50
Wow! It's addicting... Played it for 3 hrs before commenting. Will you release source code? I was eager to look at it!
#6	By enaiel	Jan 10, 2013 at 01:19:53
Added Speed Boost powerup. And posted the scource code. Game is now functionally complete. May just try to add some sound effects.
#7	By Sri Harsha Chilakapati	Jan 17, 2013 at 02:06:43
Noticed a small bug. The text `Level:01` appears as `Level:)1`. : and 0 are drawn at same position
#8	By enaiel	Jan 18, 2013 at 01:43:46
That bug does not show up in Linux. I added more spacing so hopefully it's now fixed.
You need be logged in to write comments. If you need to register click here.
Source code

Note: We recommend you copy+paste this to a better editor. Some special character encoding may have been lost.
/*******************************************************************************
 * Copyright (c) 2012-2013.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

import java.applet.Applet;
import java.awt.Color;
import java.awt.Event;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Polygon;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.text.DecimalFormat;

import javax.xml.bind.DatatypeConverter;

/**
 * Runner4K
 * 
 * @author enaiel
 * @version 0.7.1
 * @start_date 11/14/2012
 * @end_date 01/17/2013
 */
public class G extends Applet implements Runnable
{
	final static int WIDTH = 640;
	final static int HEIGHT = 480;
	final static int WORLD_WIDTH = 128 * 64;
	final static int WORLD_HEIGHT = 1024;
	Thread thread;

	// Key codes
	int keyStates;

	@Override
	public void start()
	{
		if (thread == null)
		{
			thread = new Thread(this);
			thread.start();
		}
	}

	@Override
	public void run()
	{
		// SECTION: Initialize
		setSize(WIDTH, HEIGHT); // For AppletViewer, remove later.

		// Set up the graphics stuff, double-buffering.
		BufferedImage screen = new BufferedImage(800, 600,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D g = (Graphics2D) screen.getGraphics();
		g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);
		Graphics appletGraphics = getGraphics();
		Font smallFont = Font.decode(Font.DIALOG + "-BOLD-16");

		Font largeFont = Font.decode(Font.DIALOG + "-BOLD-72");

		// Setup image tiles
		BufferedImage[] cloudTiles = new BufferedImage[4];
		Color c1 = Color.WHITE;
		Color c2 = Color.DARK_GRAY;
		GradientPaint gradient = new GradientPaint(0, 0, c1, 16, 16, c2);
		for (int i = 0; i < 4; i++)
		{
			cloudTiles[i] = new BufferedImage(16, 16,
					BufferedImage.TYPE_INT_RGB);
			Graphics2D cg = (Graphics2D) cloudTiles[i].getGraphics();
			int transX = 0, transY = 0;
			switch (i)
			{
			case 1:
				transX = 16;
				break;
			case 2:
				transX = 16;
				transY = 16;
				break;
			case 3:
				transY = 16;
				break;
			}
			cg.translate(transX, transY);
			cg.rotate(Math.toRadians(90 * i));
			cg.setPaint(gradient);
			cg.fillRect(0, 0, 16, 16);
			cloudTiles[i].flush();
		}
		int cloudX, cloudY;

		BufferedImage[] sunTiles = new BufferedImage[4];
		c1 = Color.YELLOW;
		c2 = Color.RED;

		gradient = new GradientPaint(0, 0, c1, 16, 16, c2);
		for (int i = 0; i < 4; i++)
		{
			sunTiles[i] = new BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB);
			Graphics2D cg = (Graphics2D) sunTiles[i].getGraphics();
			int transX = 0, transY = 0;
			switch (i)
			{
			case 1:
				transX = 16;
				break;
			case 2:
				transX = 16;
				transY = 16;
				break;
			case 3:
				transY = 16;
				break;
			}
			cg.translate(transX, transY);
			cg.rotate(Math.toRadians(90 * i));
			cg.setPaint(gradient);
			cg.fillRect(0, 0, 16, 16);
			sunTiles[i].flush();
		}
		int sunX, sunY;

		BufferedImage[] rockTiles = new BufferedImage[4];
		c1 = new Color(160, 82, 45);
		c2 = Color.BLACK;

		gradient = new GradientPaint(0, 0, c1, 16, 16, c2);
		for (int i = 0; i < 4; i++)
		{
			rockTiles[i] = new BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB);
			Graphics2D cg = (Graphics2D) rockTiles[i].getGraphics();
			int transX = 0, transY = 0;
			switch (i)
			{
			case 1:
				transX = 16;
				break;
			case 2:
				transX = 16;
				transY = 16;
				break;
			case 3:
				transY = 16;
				break;
			}
			cg.translate(transX, transY);
			cg.rotate(Math.toRadians(90 * i));
			cg.setPaint(gradient);
			cg.fillRect(0, 0, 16, 16);
			rockTiles[i].flush();
		}

		BufferedImage[] playerTiles = new BufferedImage[2];
		playerTiles[0] = new BufferedImage(16, 32, BufferedImage.TYPE_INT_ARGB);
		Graphics2D cg = (Graphics2D) playerTiles[0].getGraphics();
		cg.setColor(Color.PINK);
		cg.fillOval(4, 0, 10, 10);
		cg.fillRoundRect(5, 12, 8, 8, 2, 2);
		cg.fillRoundRect(6, 22, 2, 4, 2, 2);
		cg.fillRoundRect(0, 26, 6, 2, 2, 2);
		cg.fillRoundRect(10, 22, 2, 10, 2, 2);
		cg.setColor(Color.RED);
		cg.drawOval(4, 0, 10, 10);
		cg.drawRoundRect(5, 12, 8, 8, 2, 2);
		cg.drawRoundRect(6, 22, 2, 4, 2, 2);
		cg.drawRoundRect(0, 26, 6, 2, 2, 2);
		cg.drawRoundRect(10, 22, 2, 10, 2, 2);
		playerTiles[0].flush();
		playerTiles[1] = new BufferedImage(16, 32, BufferedImage.TYPE_INT_ARGB);
		cg = (Graphics2D) playerTiles[1].getGraphics();
		cg.setColor(Color.PINK);
		cg.fillOval(4, 0, 10, 10);
		cg.fillRoundRect(5, 12, 8, 8, 2, 2);
		cg.fillRoundRect(6, 22, 2, 10, 2, 2);
		cg.fillRoundRect(10, 22, 2, 4, 2, 2);
		cg.fillRoundRect(4, 26, 6, 2, 2, 2);
		cg.setColor(Color.RED);
		cg.drawOval(4, 0, 10, 10);
		cg.drawRoundRect(5, 12, 8, 8, 2, 2);
		cg.drawRoundRect(6, 22, 2, 10, 2, 2);
		cg.drawRoundRect(10, 22, 2, 4, 2, 2);
		cg.drawRoundRect(4, 26, 6, 2, 2, 2);
		playerTiles[1].flush();

		int horizonX, horizonY = 0;

		int[] colorMap = new int[364];
		int red = 100;
		int green = 225;
		int blue = 255;
		for (int i = 100; i > 0; i--)
		{
			colorMap[i * 3] = red;
			colorMap[(i * 3) + 1] = green;
			colorMap[(i * 3) + 2] = blue;
			blue = (blue > 3) ? blue - 3 : 0;
			green = (green > 3) ? green - 3 : 0;
			red = (red > 3) ? red - 3 : 0;
		}

		// Setup Carrot Tile
		BufferedImage carrotTile = new BufferedImage(16, 16,
				BufferedImage.TYPE_INT_ARGB);
		cg = (Graphics2D) carrotTile.getGraphics();
		Polygon poly = new Polygon();
		poly.addPoint(0, 0);
		poly.addPoint(16, 0);
		poly.addPoint(8, 4);
		cg.setColor(Color.GREEN);
		cg.fill(poly);
		cg.setColor(Color.BLUE);
		cg.draw(poly);
		poly.reset();
		poly.addPoint(0, 4);
		poly.addPoint(16, 4);
		poly.addPoint(8, 16);
		cg.setColor(Color.ORANGE);
		cg.fill(poly);
		cg.setColor(Color.RED);
		cg.draw(poly);
		carrotTile.flush();

		// Setup Powerup Tile
		BufferedImage powerupTile = new BufferedImage(16, 16,
				BufferedImage.TYPE_INT_ARGB);
		cg = (Graphics2D) powerupTile.getGraphics();
		cg.setColor(new Color(255, 0, 0, 155));
		cg.fillOval(0, 0, 16, 16);
		cg.setColor(Color.BLACK);
		cg.drawOval(0, 0, 16, 16);
		powerupTile.flush();

		// Level Data
		final short NO_TERRAIN = 1;
		final short TERRAIN = 2;
		final short TERRAIN_UP = 4;
		final short TERRAIN_DOWN = 8;
		final short CARROT_DOWN = 16;
		final short CARROT_UP = 32;
		final short TERRAIN_SKY = 64;
		final short TERRAIN_DOWN_2 = 128;
		final short TERRAIN_DOWN_3 = 256;
		final short POWERUP_DOWN = 512;
		final short POWERUP_UP = 1024;

		final byte CARROT_TAKEN = 1;
		final byte POWERUP_TAKEN = 2;

		final String[] levelDataStr = new String[] {
				"AAIAAgACAAIAAgACAAIAEgACAAIAAgACAAIAAgABAAEAAgACABIAAgACAAEAAQACAAIAEgACAAIAAgACAAEAAQACABIAAgACAAIAAgACAAEAAQACABIAAgACAAIAAQABAAIAIgACAAIAAgACAAIAAgACAAIAAQABAAICAgACAAIAAgACAAIAAQABAAIAEgACAAIAAgABAAEAAgACAAIAAgAiAAIAAgABAAEAAgACAAIAEgACAAIAAgABAAEAEgACAAIAAgACAAEAAQASAAIAAgABAAEAAgASAAIAAgACAAIAAQABAAIAAgACAAEAAQACAAIAAgACAAIAAgACAAIAAgAC",
				"AAIAAgACAAIAAgACAAIAEgACAAIAAgACAAIAAgABAAEACAAIABgACAAIAAEAAQCAAIAAkACAAIAAgACAAAEAAQAIABgACAAIAAgACAAIAAEAAQCAAoAAgACAAIAAAQABAQABIAEAAQABAAEAAQABAAEAAQAAAQABAIAAkACAAIAAgACAAIAAAQABAAgAGAAIAAgACAABAAEAAgACABIAAgACAAIAAgABAAEACAAIAAgAEgACAAIAAgABAAEAFAAEAAQABAAEAAEAAQASAAIAAgACAAIAAgAEAAQABAAEAAEAAQAEABQABAAEAAEAAQAEAAQABAAEAAQABAAEAAQABAAE",
				"AAIAAgACAAIAAgACAAIAEgACAAIAAgACAAIAAgABAAEACAAIABgACAAIAAEAAQCAAIAAkADAAMAAgACAAAEAAQAIABgASABIAEgACAAIAAEAAQCAAJAAgACAAIAAAQABBQABAAEAAQABAAEAAUABQAFAAQAAAQABAIAAkACAAMAAwACAAIAAAQABAAgAGAAIAAgACAABAAEAAgACABIAQgBCAAIAAgABAAEACAAIAAgAAgASAAIAAgABAAEAFAAEAEQARAAEAAEAAQACAAIAAgACAAIAAgAUAAQABAAEAAEAAQAEAAQAJAAEAAEAAQAEAAQABAAEAAQABAAEAAQABAAE",
				"AAIAAgACAAIAAgACAAIAIgACAAIAAgACAAIAAgABAAEAGAAIAAgAAQABAAIAEgACAAIAAQABAAQABAAEAAEAAQACABIAQgBCAEIAAgACAAEAAQIIAAgACAABAAEAgACAAIAAAQABAAgACAAIAAEAAQACACIAAgABAAEAGAAIAEgASAAIAAgAAQABAAIAEgACAAIAAgABAAEABAAEABQARABEAAQABAABAAEAAgACAAIAAQABABQABAAEAAQAAQABABIAAgACAAEAAQAIAAgACAABAAEAAgASAEIAQgACAAEAAQAEAAQAJAAEAAEAAQACAAIAAgACAAIAAgACAAIAAgAC",
				"AAIAAgACAAIAAgACAAIAIgACAAIAAgACAAIAAgABAAECBABEAEQABAAEAAEAAQACAAIAEgBCAEAAQgACAAEAAQAIABgACABIAEgACAAIAAEAAQCAAJAAgACAAIAAgACAAQABAAFAAUABQAEAAQABAAEgAQAAAQABAIAAkACAAMAAwACAAIAAAQABAAgAGAAIAAgACAABAAEAAgACABIAQgBCAAIAAgABAAEACAAIAAgACAACABIAAgACAAIABAAEABQABAAEAAEAAQACAAIAAgACAAIAAgAUAAQABAAEAAEAAQAEAAQAJAAEAAEAAQAEAAQABAAEAAQABAAEAAQABAAE" };

		byte[] itemData = new byte[128 * 64];
		short[] levelData = null;

		int tick = 0;
		// int fps = 0, acc = 0;
		long lastTime = System.nanoTime();
		long delta, now, totalTime = 0;
		long timeSinceLast = 0;

		final int LEVEL_COMPLETION_BONUS = 4000;
		final int CARROT_SCORE = 100;
		final int POWERUP_SCORE = 1000;
		int level = 1;
		long score = 0;
		int carrots = 0;
		int totalCarrots = 0;
		int powerups = 0;
		int tries = 1;
		String carrotsStr = "X 00/00";
		String triesLabel = "TRY: ";
		int[] triesP = { 160, 16 };
		int[] carrotsP = { WIDTH / 2, 16 };
		String levelLabel = "LEVEL: ";
		int[] levelP = { 8, 16 };
		String scoreLabel = "SCORE: ";
		int[] scoreP = { WIDTH - 144, 16 };
		// int[] fpsP = { 32, 32 };
		String levelStr = "";
		String triesStr = "";
		String scoreStr = "";
		// String fpsStr = "";
		DecimalFormat twoFormat = new DecimalFormat("00");
		DecimalFormat sixFormat = new DecimalFormat("000000");
		levelStr = twoFormat.format(level);
		triesStr = twoFormat.format(tries);
		// fpsStr = twoFormat.format(fps);
		scoreStr = sixFormat.format(score);
		int viewX = 0;
		int viewY = (WORLD_HEIGHT - HEIGHT) / 2;

		boolean stateChanged = true;
		String message = null;
		final int LEVEL_INIT = 1;
		final int GAME_RUNNING = 2;
		final int LEVEL_COMPLETE = 4;
		final int LIFE_LOST = 16;
		final int GAME_OVER = 32;
		int gameState = LEVEL_INIT;

		float pixelsToMove = 0f;
		float dist = 0f;
		float MAX_SPEED = 0.00035f;
		float MIN_SPEED = 0.000271f;
		float pixelsPerMs = MIN_SPEED;

		int cloudDist = 0;
		float cloudPixelsPerMs = 0.000003f;

		int[] playerP = new int[] { WIDTH / 4, 0 };
		int playerWidth = 16;
		int playerHeight = 32;
		final int STANDING = 1;
		final int RUNNING = 2;
		final int JUMPING = 4;
		final int FALLING = 16;
		final int DYING = 32;
		int playerFloor = 0;
		int playerCeiling = 0;
		int playerState = 0;
		float fallingPixelsPerMs = 0.000025f;
		float gravityPixelsPerMs = 0.000010f;
		float jumpingPixelsPerMs = -0.0004f;
		final float MAX_UP = -0.0000025f;
		float speedY = 0;
		boolean justJumped = false;
		boolean firstRun = true;
		final Color messageColor = new Color(255, 255, 255, 125);
		final Color pinkColor = new Color(255, 175, 175, 125);

		int fluff = 0;

		// Game loop.
		while (isActive())
		{
			// SECTION: Render
			g.setColor(Color.GRAY);
			g.fillRect(0, 0, WIDTH, HEIGHT);

			if (gameState != LEVEL_INIT)
			{
				// Draw Sky
				int scale = 4;
				int a = 8 * scale;
				int b = 16 * scale;
				int c = 18 * scale;
				Color tmpColor;

				int offset = 99; // between 0-99
				for (int y = (HEIGHT / a) + 1; --y >= 0;)
				{
					red = colorMap[((offset) * 3)];
					green = colorMap[((offset) * 3) + 1];
					blue = colorMap[((offset) * 3) + 2];
					tmpColor = new Color(red, green, blue);
					g.setColor(tmpColor);
					g.fillRect(0, (y * a), WIDTH, b);
					g.drawLine(0, (y * a) + c, WIDTH, (y * a) + c);
					offset -= 4;
					if (offset < 0)
						offset = 0;
				}

				// Draw Sun
				sunX = 516;
				sunY = 56;
				int posX = sunX;
				int posY = sunY;
				int index = 0;

				for (int i = 0; i < 4; i++)
				{
					index = i % 4;
					g.drawImage(sunTiles[index], posX, posY, null);
					if (i > 0 && i < 4 - 1)
					{
						g.drawImage(sunTiles[index > 0 ? index - 1 : 3], posX,
								posY + 16, null);
						g.drawImage(sunTiles[index], posX, posY, null);
						g.drawImage(sunTiles[index < 3 ? index + 1 : 0], posX,
								posY - 16, null);
					}
					posX += 16;
				}

				// Draw Clouds
				cloudDist = (int) Math.ceil(totalTime * (cloudPixelsPerMs)
						% WIDTH);
				for (int j = 0; j < (WIDTH * HEIGHT); j += 1024 * 33)
				{
					cloudX = j % WIDTH;
					cloudY = j % HEIGHT + 32;
					posX = (cloudX - cloudDist > 0) ? (cloudX - cloudDist)
							: WIDTH + (cloudX - cloudDist);
					posY = cloudY;
					index = 0;
					int cloudSize = 8;

					for (int i = 0; i < cloudSize; i++)
					{
						index = i % 4;
						g.drawImage(cloudTiles[index], posX, posY, null);
						if (i > 0 && i < cloudSize - 1)
						{
							g.drawImage(cloudTiles[index > 0 ? index - 1 : 3],
									posX, posY + 16, null);
							g.drawImage(cloudTiles[index], posX, posY, null);
							g.drawImage(cloudTiles[index < 3 ? index + 1 : 0],
									posX, posY - 16, null);
						}
						posX = (posX < WIDTH - 16) ? posX + 16 : posX - WIDTH;
					}
				}

				// Draw Rocks
				horizonX = 0;
				int horizon = WORLD_HEIGHT / 2;
				horizonY = horizon;
				posX = horizonX;
				posY = horizonY;
				index = 0;

				for (int i = viewX / 64, fluffX = viewX % 64; i <= Math
						.ceil((viewX + WIDTH)) / 64; i++)
				{
					if ((levelData[i] & NO_TERRAIN) != 0)
					{
						posX += 64;
					}
					else
					{
						if ((levelData[i] & TERRAIN) != 0)
						{
							horizonY = horizon;
						}
						else if ((levelData[i] & TERRAIN_UP) != 0)
						{
							horizonY = horizon - 64;
						}
						else if ((levelData[i] & TERRAIN_DOWN) != 0)
						{
							horizonY = horizon + 64;
						}
						else if ((levelData[i] & TERRAIN_DOWN_2) != 0)
						{
							horizonY = horizon + 64 * 2;
						}
						else if ((levelData[i] & TERRAIN_DOWN_3) != 0)
						{
							horizonY = horizon + 64 * 3;
						}
						posY = horizonY;
						for (index = 0; index < 4; index++)
						{
							for (int j = 0; j < Math.ceil(HEIGHT
									- (horizonY - viewY) / 16); j++)
							{
								g.drawImage(rockTiles[index], posX + index * 16
										- fluffX, posY - viewY, null);
								posY += 16;
							}
							posY = horizonY;
						}
						if ((levelData[i] & TERRAIN_SKY) != 0)
						{
							for (index = 0; index < 4; index++)
							{
								for (int j = 0; j < Math
										.ceil((horizonY - viewY) / 16); j++)
								{
									// index = index < 1 ? index + 1 : 0;
									g.drawImage(rockTiles[index], posX + index
											* 16 - fluffX, posY - viewY - 48,
											null);
									posY -= 16;
								}
								posY = horizonY;
							}
						}

						posX += 64;
					}

					// Draw Carrot
					if (((levelData[i] & CARROT_DOWN) != 0 || (levelData[i] & CARROT_UP) != 0)
							&& (itemData[i] & CARROT_TAKEN) == 0)
					{
						int carrotX = posX - fluffX;
						int carrotY = posY - viewY - 16;
						carrotY = ((levelData[i] & CARROT_UP) != 0) ? carrotY - 48
								: carrotY;
						carrotY -= fluff;
						g.drawImage(carrotTile, carrotX, carrotY, null);
						if ((playerP[0] <= carrotX + 16)
								&& (playerP[0] + 16 >= carrotX)
								&& (playerP[1] <= carrotY + 16)
								&& (playerP[1] + playerHeight >= carrotY))
						{
							carrots++;
							carrotsStr = "X " + twoFormat.format(carrots) + "/"
									+ twoFormat.format(totalCarrots);
							itemData[i] |= CARROT_TAKEN;
						}

					}

					// Draw Powerup
					if (((levelData[i] & POWERUP_DOWN) != 0 || (levelData[i] & POWERUP_UP) != 0)
							&& (itemData[i] & POWERUP_TAKEN) == 0)
					{
						int powerupX = posX - fluffX;
						int powerupY = posY - viewY - 16;
						powerupY = ((levelData[i] & POWERUP_UP) != 0) ? powerupY - 48
								: powerupY;
						powerupY -= fluff;
						g.drawImage(powerupTile, powerupX, powerupY, null);
						if ((playerP[0] <= powerupX + 16)
								&& (playerP[0] + 16 >= powerupX)
								&& (playerP[1] <= powerupY + 16)
								&& (playerP[1] + playerHeight >= powerupY))
						{
							itemData[i] |= POWERUP_TAKEN;
							pixelsPerMs = MAX_SPEED;
							powerups++;
						}

					}

					// Check Collisions
					if (playerP[0] < (i * 64) - viewX
							&& (playerP[0] + playerWidth > (i * 64) - viewX))
					{
						playerFloor = ((levelData[i] & NO_TERRAIN) != 0) ? HEIGHT
								: horizonY - viewY;
						playerCeiling = ((levelData[i] & TERRAIN_SKY) != 0) ? horizonY
								- viewY - 48
								: -999;
						if ((levelData[i] & TERRAIN) != 0)
						{
							if (playerState == STANDING)
								playerP[1] = playerFloor - playerHeight;
						}
						if (playerP[1] > playerFloor - playerHeight
								|| playerP[1] < playerCeiling)
						{
							if (playerState != DYING)
							{
								if (playerP[0] + playerWidth >= (i * 64)
										- viewX
										&& (playerP[0] + playerWidth <= (i * 64)
												- viewX + 64))
								{
									playerP[0] = (i * 64) - viewX - playerWidth;
									playerState = DYING;
								}
							}
						}

					}

				}
			}

			// Draw Player
			g.drawImage(playerTiles[fluff % 2], playerP[0], playerP[1], null);

			// Draw Trail
			if (powerups > 0)
				for (int i = 0; i < 3; i++)
				{
					g.setColor(pinkColor);
					g.fillOval(playerP[0] - 8 - i * 8 - fluff % (i + 2),
							playerP[1] + fluff % (i + 2), 8, 8);
				}

			// Draw Message
			if (message != null)
			{
				g.setColor(messageColor);
				g.setFont(largeFont);
				g.drawString(message,
						(WIDTH - g.getFontMetrics().stringWidth(message)) / 2,
						(HEIGHT + g.getFontMetrics().getHeight()) / 2);
				g.setFont(smallFont);
				g.drawString(
						"Press SPACE To Start",
						(WIDTH - g.getFontMetrics().stringWidth(
								"Press SPACE To Start")) / 2, (HEIGHT + g
								.getFontMetrics().getHeight()) / 4 * 3 - 16);
				g.drawString("Press W To Jump", (WIDTH - g.getFontMetrics()
						.stringWidth("Press W To Jump")) / 2, (HEIGHT + g
						.getFontMetrics().getHeight()) / 4 * 3 + 16);
				g.drawString(
						"Collect       For Points",
						(WIDTH - g.getFontMetrics().stringWidth(
								"Collect       For Points")) / 2, (HEIGHT + g
								.getFontMetrics().getHeight()) / 4 * 3 + 48);
				g.drawImage(carrotTile, 295, (HEIGHT + g.getFontMetrics()
						.getHeight()) / 4 * 3 + 48 - 16, null);

				g.drawString(
						"Collect       For Speed Boost And Bonus Points",
						(WIDTH - g
								.getFontMetrics()
								.stringWidth(
										"Collect       For Speed Boost And Bonus Points")) / 2,
						(HEIGHT + g.getFontMetrics().getHeight()) / 4 * 3 + 72);
				g.drawImage(powerupTile, 200, (HEIGHT + g.getFontMetrics()
						.getHeight()) / 4 * 3 + 72 - 16, null);
			}
			// Draw HUD
			g.setColor(Color.WHITE);
			g.setFont(smallFont);
			g.drawString(levelLabel, levelP[0], levelP[1]);
			g.drawString(levelStr, levelP[0] + 64, levelP[1]);
			g.drawString(triesLabel, triesP[0], triesP[1]);
			g.drawString(triesStr, triesP[0] + 45, triesP[1]);
			g.drawString(scoreLabel, scoreP[0], scoreP[1]);
			g.drawString(scoreStr, scoreP[0] + 64, scoreP[1]);
			g.drawImage(carrotTile, carrotsP[0], carrotsP[1] - 16, null);
			g.drawString(carrotsStr, carrotsP[0] + 32, carrotsP[1]);
			// g.drawString(fpsStr, fpsP[0], fpsP[1]);

			// Draw the entire results on the screen.
			appletGraphics.drawImage(screen, 0, 0, null);

			// SECTION: Update
			now = System.nanoTime();
			timeSinceLast = (now - lastTime) / 1000;
			// acc += now - lastTime;
			totalTime += timeSinceLast;

			tick++;
			// if (acc >= 1000000000L)
			// {
			// acc -= 1000000000L;
			// fps = tick;
			// tick = 0;
			// fpsStr = twoFormat.format(fps);
			// }

			// Do something
			switch (gameState)
			{
			case LEVEL_INIT:
				// Generate level Data
				levelData = toShortArray(levelDataStr[level - 1]);
				viewX = 0;
				pixelsPerMs = MIN_SPEED;
				gameState = GAME_RUNNING;
				message = (firstRun) ? "Runner4K" : "Level " + levelStr;
				stateChanged = true;
				playerFloor = HEIGHT / 2;
				playerP[0] = WIDTH / 4;
				playerP[1] = playerFloor - playerHeight;
				playerState = STANDING;
				carrots = 0;
				totalCarrots = 0;
				powerups = 0;
				for (int i = 0; i < levelData.length; i++)
				{
					itemData[i] = 0;
					if ((levelData[i] & CARROT_DOWN) != 0
							|| (levelData[i] & CARROT_UP) != 0)
						totalCarrots++;
				}
				carrotsStr = "X " + twoFormat.format(carrots) + "/"
						+ totalCarrots;

				break;
			case GAME_RUNNING:
				if (stateChanged)
				{
					// Press Fire To Start
					if (((keyStates & (1 << ' ')) != 0))
					{
						if (!firstRun)
						{
							message = null;
							stateChanged = false;
							playerState = RUNNING;
						}
						else
						{
							firstRun = false;
							message = "Level " + levelStr;
						}
						keyStates = 0;
					}
				}
				else
				{
					if (playerState == DYING)
						break;

					pixelsToMove = 250;
					dist = 0;

					dist = dist + (pixelsPerMs * timeSinceLast);

					float dx = dist;
					float dy = 0f;

					if (dx != 0 || dy != 0)
					{
						if (dx > 0)
						{
							if (viewX + dx > WORLD_WIDTH - WIDTH)
								viewX = WORLD_WIDTH - WIDTH;
							else
								viewX = (int) (viewX + dx);
						}
						if (dx < 0)
						{
							if (viewX + dx < 0)
								viewX = 0;
							else
								viewX = (int) (viewX + dx);
						}

						if (dy > 0)
						{
							if (viewY + dy > WORLD_HEIGHT - HEIGHT)
								viewY = WORLD_HEIGHT - HEIGHT;
							else
								viewY = (int) (viewY + dy);
						}
						if (dy < 0)
						{
							if (viewY + dy < 0)
								viewY = 0;
							else
								viewY = (int) (viewY + dy);
						}
						pixelsToMove = pixelsToMove
								- (Math.abs(dx) + Math.abs(dy));
						dist = 0;
					}
					if (viewX == WORLD_WIDTH - WIDTH
							&& gameState != LEVEL_COMPLETE)
					{
						gameState = LEVEL_COMPLETE;
						message = "Level Complete!";
						stateChanged = true;
						score += LEVEL_COMPLETION_BONUS;
						score += carrots * CARROT_SCORE;
						score += powerups * POWERUP_SCORE;
						scoreStr = sixFormat.format(score);

					}

				}
				break;
			case LEVEL_COMPLETE:
				if (stateChanged)
				{
					// Press Fire To Start
					if (((keyStates & (1 << ' ')) != 0))
					{
						message = null;
						stateChanged = false;
						keyStates = 0;
					}
				}
				else
				{
					level++;
					if (level > levelDataStr.length)
					{
						level--;
						gameState = GAME_OVER;
						message = "Game Over!";

					}
					else
					{
						levelStr = twoFormat.format(level);
						gameState = LEVEL_INIT;
						tries = 1;
						triesStr = twoFormat.format(tries);
					}
					stateChanged = true;
				}
				break;
			case LIFE_LOST:
				// Press Fire To Start
				if (((keyStates & (1 << ' ')) != 0))
				{
					message = null;
					gameState = LEVEL_INIT;
					playerState = STANDING;
					keyStates = 0;
					tries++;
					triesStr = twoFormat.format(tries);
				}
				break;
			case GAME_OVER:
				if (stateChanged)
				{
					// Press Fire To Start
					if (((keyStates & (1 << ' ')) != 0))
					{
						message = null;
						stateChanged = false;
						keyStates = 0;
					}
				}
				else
				{
					level = 1;
					levelStr = twoFormat.format(level);
					score = 0;
					scoreStr = sixFormat.format(score);
					tries = 1;
					triesStr = twoFormat.format(tries);
					gameState = LEVEL_INIT;
					stateChanged = true;
					firstRun = true;
				}
				break;
			}

			// Update Player
			switch (playerState)
			{
			case STANDING:
				speedY = 0;
				break;
			case RUNNING:
				speedY = 0;
				if (playerP[1] < playerFloor - playerHeight)
					playerState = FALLING;
				else if (((keyStates & (1 << 'W')) != 0))
				{
					playerState = JUMPING;
					justJumped = true;
				}
				break;
			case FALLING:
				speedY += fallingPixelsPerMs;
				playerP[1] += speedY * timeSinceLast;
				if (playerP[1] >= playerFloor - playerHeight)
				{
					playerP[1] = playerFloor - playerHeight;
					playerState = RUNNING;
				}
				if (playerP[1] + playerHeight > HEIGHT)
				{
					playerState = DYING;
				}
				break;
			case JUMPING:
				if (justJumped)
				{
					speedY += jumpingPixelsPerMs;
					justJumped = false;
				}
				speedY += gravityPixelsPerMs;
				if (speedY < MAX_UP)
				{
					playerP[1] += MAX_UP * timeSinceLast;
				}
				else
				{
					playerP[1] += speedY * timeSinceLast;
				}
				if (speedY > 0)
					playerState = FALLING;
			case DYING:
				speedY += fallingPixelsPerMs;
				playerP[1] += speedY * timeSinceLast;
				if (playerP[1] >= HEIGHT)
				{
					gameState = LIFE_LOST;
					message = "Aaaaaaaaargh!";
				}
				break;
			}

			fluff = (int) Math.ceil(totalTime * cloudPixelsPerMs) % 8;

			lastTime = now;

			// Lock the frame rate
			delta = System.nanoTime() - lastTime;
			if (delta < 20000000L)
			{
				try
				{
					Thread.sleep((20000000L - delta) / 1000000L);
				}
				catch (Exception e)
				{
					// It's an interrupted exception, and nobody cares
				}
			}
		}
		thread = null;
	}

	private short[] toShortArray(String levelDataStr)
	{
		byte[] bytes = DatatypeConverter.parseBase64Binary(levelDataStr);
		short[] shorts = new short[bytes.length / 2];
		for (int i = 0; i < shorts.length; i++)
		{
			shorts[i] = (short) ((bytes[i * 2] & 0xff) << 8 | bytes[i * 2 + 1] & 0xff);
		}
		return shorts;
	}

	@Override
	public boolean handleEvent(Event e)
	{
		switch (e.id)
		{
		case Event.KEY_PRESS:
			// key pressed
			keyStates |= 1 << e.key;
			break;
		case Event.KEY_RELEASE:
			// key released
			keyStates &= ~(1 << e.key);
			break;
		}
		return false;
	}
}
Java4K.com

View Game: Runner4K

Description

Instructions

User Comments

Source code
