In this blog I will not create a “yet another Android game tutorial” as you may find by dozen search on the web.

I will try instead to reassemble the steps it took me to create a complete, playable and distributable Android game, also reporting the results of such process so you may have an idea of what your are going to face, if you wish to prove yourself on creating a new game.

I hope you will enjoy the site and participate with your comments and suggestions, and hopefully someone will find these contents useful.

Happy gaming, happy programming!

The post Creation of an Android game – #1 Introduction appeared first on Nex Game Studios.

So, a brand new JDK 7 , the latest version of Eclipse for Java Developers,  the Android SDK, and all the Eclipse Plugins, to develop for Android 2.1 and above.

The I prepared a new folder ready to contain all the resources:

–          A new eclipse workspace

–          Images, Videos and Sound for the game

–          3^rd party libraries, such as Google Analytics, Flurry, Scoreloop and so

–          Downloads related to the game development

–          Useful samples found on the web

And finally, I created the new Android Project, codename “Andro2012”, as at that time the name was not yet decided.

Ready to start some programming!

#3 Game Activity, Game View, The Main Loop

The post Creation of an Android game – #2 Gathering the tools appeared first on Nex Game Studios.

In the game development, the core is the Game Activity, the view that contains the running game itself. Let’s forget for now the main menu, options views, leaderboards and other tasks.

Basically the Game Activity is just a container for the Game View, a custom control which will contain the graphics of the game.  So the class itself will be empty, while the layout code will be something like:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical">

    <com.nex.andro.game.GameView
      android:id="@+id/gameView"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"/>

</RelativeLayout>

The GameView control will face as the owner of two important objects:

–          The Game Thread, running the main loop, handling the running, stopped and paused states of the game

–          The Game Engine class, an object handling everything that happens during the game

To understand what is the main loop of a game, please follow these links which I found useful:

–          Link 1

–          Link 2

An important thing to keep in mind, while preparing the main loop, is that it is stricly related to the maximum number of loops per second you can achieve. This number depends on many factors, for example the hardware running the game (CPU, Screen resolution, …) and the quantity and quality of the graphics (more and detailed graphics require more time to be drawn).

In my case, I had no heavy graphics so I concentrated on limiting the number of loops, to avoid a game too fast and unusable. There are plenty of solutions around, but in my opinion sometimes the simplest way is the solution.

So let’s say I want a maximum of 15 loops per second, a value that makes the game fast enough for my taste.  First we calculate the minimum time for a single loop:

int minLoopTime = 1000 / limitFps;

This gives me about 66 milliseconds to paint all the graphics.. plenty of time.

Then at the end of each loop, I will measure the time elapsed, and make the thread sleep for the remaining time:

long sleepTime = minLoopTime - (endTime - startTime);

if (sleepTime > 0) {

  Thread.sleep(sleepTime);

}

Simple, right?

And now, the final code of the GameView class (not perfect, but a good starting point)

public class GameView extends SurfaceView implements SurfaceHolder.Callback {

	class GameThread extends Thread {

		private SurfaceHolder mSurfaceHolder;

		private Handler handler;

		private Context context;

		private GameEngine gameEngine;

		private boolean running;

		private boolean paused;

		private int startingLevel;

		public GameThread(SurfaceHolder surfaceHolder, Context context, GameEngine gameEngine, Handler handler) {
			this.mSurfaceHolder = surfaceHolder;
			this.handler = handler;
			this.context = context;
			this.gameEngine = gameEngine;
		}

		public void setStartingLevel(int startingLevel) {
			this.startingLevel = startingLevel;
		}

		public boolean isRunning() {
			return running;
		}

		public void setRunning(boolean running) {
			this.running = running;
		}

		public boolean isPaused() {
			return paused;
		}

		public void setPaused(boolean paused) {
			this.paused = paused;
		}

		@Override
		public void run() {
			try {
				long startTime = 0;
				long endTime = 0;
				int limitFps = AndConsts.LIMIT_FPS;
				int minLoopTime = 1000 / limitFps;

				// Initialise level
				if (startingLevel <= 0) {
					startingLevel = 1;
				}
				gameEngine.initLevel(startingLevel);

				boolean doPause = true;
				boolean doResume = false;

				while (running) {
					startTime = System.currentTimeMillis();

					Canvas c = null;
					try {
						if (!paused) {
							c = mSurfaceHolder.lockCanvas(null);
							synchronized (mSurfaceHolder) {
								if (doResume) {
									doResume = false;
									doPause = true;
									gameEngine.resume();
								}
								// Update Input
								gameEngine.updateInput();
								// Update physics
								gameEngine.updatePlayerPhysics();
								// Update AI
								gameEngine.updateAIPhysics();
								// Update AI
								gameEngine.updatePhysicsChecks();
								// Update game UI
								gameEngine.updateUI(c);
								// Update sounds
								gameEngine.updateSound();
								// Finalize loop
								gameEngine.finalizeLoop();
							}
						} else {
							if (doPause) {
								doResume = true;
								doPause = false;
								gameEngine.pause();
								// Draw an opacity layer to make the user feel the game is paused
								c = mSurfaceHolder.lockCanvas(null);
								synchronized (mSurfaceHolder) {
									Paint p = new Paint();
									p.setStyle(Paint.Style.FILL);
									p.setColor(Color.BLACK);
									p.setAlpha(125);
									c.drawRect(0, 0, ScreenManager.screenWidthPx, ScreenManager.screenHeightPx, p);
									p = null;
								}
							}
						}
					} catch (Exception ex) {
						// TODO Handle errors
						running = false;
					} finally {
						// do this in a finally so that if an exception is thrown
						// during the above, we don't leave the Surface in an
						// inconsistent state
						if (c != null) {
							mSurfaceHolder.unlockCanvasAndPost(c);
						}
					}

					endTime = System.currentTimeMillis();

					try {
						long sleepTime = minLoopTime - (endTime - startTime);
						if (sleepTime > 0) {
							Thread.sleep(sleepTime);
						}
					} catch (InterruptedException e) {
					// TODO Handle errors
					}

				}
			} catch (Exception ex) {
				// TODO Handle errors
			}
		}
	}

	private GameEngine gameEngine;
	private GameThread thread;

	public GameView(Context context, AttributeSet attrs) {
		super(context, attrs);
		gameEngine = new GameEngine((Activity) context);
		try {
			// Load game
			gameEngine.initGame(this);
			// Register our interest in hearing about changes to our surface
			SurfaceHolder holder = getHolder();
			holder.addCallback(this);
			thread = new GameThread(holder, context, gameEngine, new Handler() {
				@Override
				public void handleMessage(Message m) {
					//Do nothing for now
				}
			});

			setFocusable(true); // Make sure we get key events
			setFocusableInTouchMode(true);// Make sure we get key events

		} catch (AbnormalException e) {
			//TODO Handle errors
		}
	}

	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
	}

	@Override
	public void surfaceCreated(SurfaceHolder holder) {
		start();
	}

	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
		stop();
	}

	public void stop() {
		// Stop the gaming thread
		thread.setRunning(false);
		try {
			thread.join(500);
		} catch (InterruptedException e) {
		}
	}

	public void pause() {
		thread.setPaused(true);
	}

	public void resume() {
		thread.setPaused(false);
	}

	public void start() {
		thread.setRunning(true);
		thread.start();
	}

	public void restartLevel() {
		gameEngine.restartLevel();
	}
}

The post Creation of an Android game – #3 Game Activity, Game View, The Main Loop appeared first on Nex Game Studios.

Usually I would not put any logic in such entities, using an external class to handle it, but in this case I wanna try a different approach, inserting the logic of each entity inside the class it self.

I said usually I would not do it, because in my experience an entity always need its context to perform even the most basic operation, but in this game it has revelead a good approach.

The Level class

This class will store the data regarding the current level of the game, such as the tile map.

The initialisation will load the tilemap and the bitmaps needed to draw the level backround:

–          The tilemap is a 18×34 matrix of integer, each cell referring to a particular tile type, and it’s loaded from a properties file stored in the assets folder

–          There are around 20 different tiles, this class will store each bitmap in an array

–          Additional bitmaps are the prize disappearing animation and the “hole in the ground”animation

The drawing method will render the current level, based on the current camera position.

The GameCharacter class

This class keeps each chracter information, such as position, status and style.

The initialisation method will load the character animations set (i.e. stop, running, climbing and so on), and cache the bitmaps.

The drawing method will render the player on the screen at its current position. For enemies outside the screen, an arrow will be rendered to inform the user about the enemy position.

The Player  and Enemy classes

This classes simply extend the Game Character class, without any logic or information except for indicating the character as a player (overriding the method isPlayer())

The Score class

This class stores the current game score and lives count, and also calculate when the player gains a life at certain level caps.

The initialisation loads and keeps in memory the Bitmap used to draw the score.

The drawing method renders the score on the game Canvas, at the bottom of the screen.

—

Now I’m ready to fill up these entities and draw something on the screen, in next posts I will post portion of the source code for each of these classes.

The post Creation of an Android game – #4 Domain Entities appeared first on Nex Game Studios.

It’s been a while since my last post, but here are the news! A new game has been released on the Android market and soon in the Windows Marketplace!

Check out the dedicated page here!

The post Tap That Building Released! appeared first on Nex Game Studios.

The first one is called Summoner Call and should be available in a couple of weeks on Android and Windows markets.

It’s basically a Card Game with a simplified and quicker gameplay, here’s a screenshot:

The second one has no name yet, and its development is in a really early stage. It’s actually an experiment that I wish to transform to a real game.

It’s a classic Action RPG, and will be available only on Windows Phone, where this genre is not yet overloaded with games:

Please feel free to comment and share your opinion!

The post Update – Currently Work in Progress appeared first on Nex Game Studios.

The update will include 2 major new features:

1. Automatic cards updates:

With this feature, I will be able to add or update the cards without releasing a new version of the game. This means I’ll be able to skip the long certification process required for a full update, as well as fixing card values on the fly.

It’s a really important feature that will help to increase the number of cards and keep the game balanced.

2. Games notifications:

I have noticed that lots of times players cannot find a game just for a matter of few minutes. A player joins, he leaves, than another one joins a minute later.

With this new feature, you will be able to ask the game to find a match for you. Once activated, you can leave the game and do anything you want; once a game slot opens, you will get a system notification so you can access the multiplayer page and join the game.

The notifications are not invasive: they last just about 1 hour and are automatically stopped if you access the multiplayer page again.

With version 2.0 there will be a major deck rebalance, following the suggestions of some of the  users.

So.. stay tuned!

Update:

The version 1.9 is out on Android and within one week on Windows Phone!

The post Summoner Call – Status of update 1.9 – Released! appeared first on Nex Game Studios.

It’s an action/rpg turn based board game, like the ones really popular in the 90’s, for example Hero Quest, Space Crusade, Space Hulk and so on.

A beta will be available soon for Android and then for Windows Phone 7 and 8.

If you wish to receive the beta and try it out, please drop a comment or send a mail to thenex@nexgamestudios.com !

The post Arcane Quest BETA Available soon appeared first on Nex Game Studios.

Find more information in the dedicated page here!

The post Arcane Quest Released! appeared first on Nex Game Studios.

Nex Game Studios Forums

The post New forums are available appeared first on Nex Game Studios.