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.

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 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.

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.

It’s pretty sad, cause I planned a release on both Google Play and Windows MP on the same day, tomorrow, but I will have to wait one more week.

What I found sadly funny was the reason for the rejection:

“Content that is offensive in any country/region to which your application is targeted is not allowed.”

Ok now look at the picture.. is it so offensive?

The post My App rejected from the Windows Marketplace! appeared first on Nex Game Studios.

The beta will be available for both Android and Windows Phone systems.

New features will include:

–  Online multiplayer

– Deck customisation

– Card balancement improvements

– New achievements instead of the old way to unlock cards

Stay tuned!

The post Register here for Summoner Call Beta Version appeared first on Nex Game Studios.