I’m glad to say that my first Android game Grab And Run is now available for free in the android market.

I have implemented everything I wanted for the first release, but there are still a bunch of things I wish to improve in the next versions:

– More levels: even the 10 current levels are quite a challenge, I wish to keep adding new levels on a regular basis

– Different input modes: the physical keyboard support has already been implemented, but I would like to add  accelerometer support as well

– Different character styles: the game already support different style for the player and enemies characters, I will add them as soon as I can prepare the sprites

– Different levels of difficulty: just to make it more fun for skilled players

– Implement scoreloop challenges and leaderboards

Find out more info about the game in the dedicated page !

The post Grab And Run 1.0 Released appeared first on Nex Game Studios.

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.

This is quite interesting, I’ve just released my first Android game to the market, and I’m already planning a porting to Windows Phone 7, am I crazy?

Not that much because, as you will discover in the next days, the porting has revealed to be simpler than I tought!

It’s only the beginning, but I want you to see what I was able to do in just a couple of hours:

Not so bad right? That’s because it is so easy programming on WP7, I hope you will enjoy this serie, I will keep posting my results as well as the making-of of my first Android game!

Stay tuned

The post Porting an Android game to WP7 – #1 Introduction appeared first on Nex Game Studios.

The 1.1 version has already been release in both the Android Market and SlideMe.org.

Let me spend one more word on this bug reporting service (free!) which I found really interesting. It requires just a couple of lines of code, and it’s able to report managed and unhandled exception to the server, with the full stack trace and device information.

Here’s a screenshots:

BugSense report Grab And Run

It also has an e-mail notification service I found really helpful!

I highly recommend this library for your project, it will make your life a lot easier!

The post Grab And Run Update 1.1 Released 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.

A new update of the game Grab And Run has been released to SlideMe.org and the Android Market.

What’s new?

Well, I felt that using only one character was limiting the gameplay possibilities, as the newbie would benefit from a slower, easier to control character, while the expert who want to achieve the highest score would prefer a faster character.

So I’m proud to present your 2 new heroes:

DRAKE

JAY

Among these changes there are now 2 different sets of enemies, and a lot of tweaks, bug fixes and improvements.

Check it out!

The post Grab And Run 1.4 Released appeared first on Nex Game Studios.

It took about 4 days for the certification, and 1 more day to see it published on the market.

I’m just curious now to see how many downloads it will hit.. i’m counting on at least 10 !! XD

Here’s the link to download the App:

Grab And Run on the Windows Marketplace

I’ll try to continue my tutorials as soon as possibile!

The post Grab And Run Released to the Windows Phone Marketplace 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.