Introduction

One of key element between a good game and a bad game is its performance. No matter how good your game is, if it performs badly (lagging, not-intuitive) it will be a bad game.

FPS & Frame Skip

A normal mobile game have a 25 FPS (Frame per Second). That means every 1 second, the game updates its condition and refresh screen display 25 times. The higher the FPS, the smoother it will looks like. For example : a video usually have 60FPS. However, in mobile game, 25 FPS is enough to deliver a good gaming experience.

Normally, the game will have 25 Frame per second. However, some time it might have lower FPS due to high process or rendering. When that happen, The Engine will try to have the same update per second, but skip some rendering process. This is because rendering an image requires more time than calculation process. How much frame can be skipped during lagging is defined as FrameSkip.

You can define both FPS and Frameskip when initiating the game in your Launcher. Higher FrameSkip will tolerate more lagging, but might make your screen less smooth.

Performance Statistic

When you develop the game, you will test the game in Emulator because it is simpler. However, emulator might not give the same result as when the game is played on actual device. Some Emulator runs so slow (like Nokia Emulator), others runs so smooth because they use up CPU resources (like Kemulator).

The only way to test whether the game actually performs well is by actually testing it on device. However, unlike Emulator you cannot use console to test the game. Inspedio Engine provide a way to test your game performance on actual device by showing Performance Statistic on device screen.

You can see the statictic on the bottom left of the screen. The statistic is displayed into 4 line :

•  FPS         : This shows how much Update/Render/SkippedFrame on current second.
• Process  : This shows how much time used by Update/Render process.
• Sleep       : This shows how much sleeps time (unused time) on current second.
• Time        : This simply shows how much second has elapsed.

Most time in the game is used for rendering graphics. More assets to render means more time to do the rendering process. When the game process took less time than it provided, the Engine will sleep the process to save battery and stabilize FPS. More sleep time means better performance.

You can disable Performance Statistic by setting InsGlobal.displayFPs to false.

Optimizing Performance

There are 4 usual reason why your game is lagging.

The first one is because you have too much object. More objects equals to more process, especially if you use collision detection on a large set of object. Inspedio Engine collision detection system is good enough for most game where the object count is less than 20. However if your game rely heavily on collision detection with large object (Like Touhou or other Shoot them up game), you should create your own collision detection system.

The second reason is because you use an heavy calculation process on your game. This is mostly done by using a large iteration, loop, or recursive process. For example when you create an AI for chess game, and you use exhaustive search algorithm. There are many ways to optimize this, for example is by storing pre-calculated value, or by using heuristic method.

The third reason for lagging is because you load asset (Image, Sound) during the game. Loading an image/sound will require certain amount of time, depends on how big the asset is. If your state use many assets, you should use Loading Screen during Screen transition, so that player will know that the game is still loading. Some game needs to load an asset during playing, for example an endless runner game with several environment stage. This can be handled by using InsHiddenLoader to load assets, by loading it using different thread (process), so it won’t affect game performance.

The fourth reason for lagging is because you render image outside of screen. Be warned that if you draw an asset outside of screen, it will still drawn, but cannot be seen by user. As a result, you just waste a good amount of processing time by drawing an object which won’t be visible. Inspedio Engine already handle this issue by checking whether the object have visible part on Screen before rendering them. An object is considered visible if any part of it is visible on screen (even only 1 pixel). However, if for some reason you have a very large asset (like World Map), you should split them into several part. Splitting a large asset and draw each pieces of it will prevents some pieces of it to not rendered if they currently are not visible on screen.

Conclusion

Optimizing a game is a tough process, and requires in-depth knowledge of the game mechanic. However you should not worry too much about it as Inspedio Engine already handle most of performance issue for you. As long as you use The engine properly and following tutorial guideline, you should do just fine.

Always remember the golden quote :

Premature optimization is the root of all evil.

Next Step : Optimizing Game Size.

Previous Step : Customize Pause Behavior.

Tutorial Index

Introduction

Pausing a Game is an essential feature for time-sensitive game, like action or real-time simulation. For Mobile game, pausing is even more important, because device event (such as receiving calls, message, or alarm) can interrupt your game. It is very important that you pause the game when it interrupted. Inspedio Engine provide 2 way to implement pause behavior in your game.

Global Pause

The first method for implementing pause behavior is by defining Global Pause Object. Global Pause object is a fixed object that doesn’t receive any event. The object can only show Pause notification (The Game is Paused. Touch/press to continue), and automatically resumed upon player input (touch at any position, or any keypad press). You however need to define what to show for each device type (Keypad and Touch). Global Pause object will automatically shown when game is interrupted, regardless of current game state.

You can define your Global Pause Object by extending InsPause class.

public class MyGlobalPause extends InsPause{

 public void showPause(InputType Input) {
  if(Input == InputType.TOUCH){
  // Show Pause notif for Touch Device

  } else if(Input == InputType.KEYPAD){
  // Show Pause notif for Keypad Device
  }
 }
}

Custom Pause

The second method is by using Custom Pause. This is useful if you want to show Pause Popup Menu when game is interrupted, and let user choose their action. For example, you want to show a popup menu which contain Resume, Restart, or Back button upon interruption.

To implement that behavior, you need to disable global pause, and implement your behavior inside pause() method on your state. Note that if you do this, the object on your state will not automatically paused. Which means you have to pause them manually. The better approach is by using a meta-group. Meta-group is a group object which used to contain all object with similar behavior. It works like folder and sub-folder.

The following example can give you a better understanding.

public class MyGameState extends InsState{

 InsGroup meta;

 public void create() {
  // create and add meta group.
  // Any game object to be paused must be added to meta, not state
  meta = new InsGroup();
  this.add(meta);
 }

 public void pause(){
  super.pause();
  // Make all object at meta group inactive (paused)
  meta.active = false;
 }

}

Next Step : Optimizing Game Performance.

Previous Step : Toying With Camera.

Tutorial Index

Introduction

Camera is used in the game when the game environment is larger than the device screen size. Inspedio Engine provide a camera system which helps you explore the game world. It also have built-in autofollow feature, to automatically follow an object movement (usually player’s character).

Boundary

Before using Camera, you must first set the Boundary of Camera. Boundary means the limit of camera movement. For example, you want to limit Camera movement so it will never go out of Game World Area.

Camera is a sub-class of InsBasic, which means you can actually controls it by using action, (MoveTo, MoveBy), or manually setting its position.

Every sprite class have a built-in camera (only sprite, shape and text doesn’t have it). At default, all sprite will use Global Camera Object, which can be accessed at InsGlobal.camera.

AutoFollow

You can set your camera to automatically follow an object movement. The followed object will be put into the center of the screen, unless it goes to camera boundary. You can also place it not exactly on the center (say in the left-center for endless runner game) by setting Offset Value. The Offset will make the Camera place your object in spesific distance from center of the screen.

Usage

You can see an example of Camera Usage in SampleCameraState class.

public void setCamera(){
 // Get Global Camera Object
 InsCamera cam = InsGlobal.camera;

 // Set Camera Boundary
 cam.setBoundary(Left, Right, Top, Bottom);

 // Command Camera to Follow spesific object
 cam.follow(sprite);

}

Next Step : Customize Pause Behavior.

Previous Step : Saving Game Data.

Tutorial Index

Introduction

One of essential aspect of the game is saving game data.  Game Data is the record of player’s progress of the game, for example : how much level he unlocked, his high score, or what equipment he currently owned.

Inspedio Engine provided a way to dynamically save your game data, and load them again when user plays the game next time.

Data Flow

Before explaining how Saving Game Data works, you must first understand the flow of data in the Engine.

There are 3 type of Data you should be aware of.

• Device Data      : This is where the data is stored on actual device. When a data is stored on device, it will stay there as long as user did not uninstall the game.
• Program Data   : Data from your own game. This is what you want to store at device.
• Engine Data     : Intermediary Data from your game to the device. You cannot explicitly use this in your game. This data is used as temporary data when storing data into device, or loading data from device.

The main purpose of Saving Game Data is storing your data from game (program) into user’s device, so you can load it again the next time user plays the game. You can do this by using Engine as your intermediary medium (and also make it easier).

The save/load mechanism works like this :

1. When you want to save the game, you have to assign data from your game into the engine.
2. And then you call save method. The engine will store your assigned data into device.
3. When you want to load the data from device, you first call load method. The engine will load data from device.
4. Then you retrieve the data from engine into your game.

Assign & Retrieve

Save and Load process are already handled by Engine. However, Assign & retrieve process must be defined for each game, because each game have different data to save. You can define this by creating your own Save class.

Create a class that extends InsSave, declare a constructor with your Game Name. Make Sure you use consistent name, as his name will be used to load your game back. If you update the game, do not change the Name, so it can load previous data.

Assigning data is simply adding new SaveDataObject by declaring its name and its value. The value can be everything from Integer, String, Boolean, Byte, and even Array.

Retrieving Data is checking whether data exist, and then assigning it to variable in your game. When retrieving data, you have to define its type. The type must match your variable type.

public class MyOwnSaveLoad extends InsSave{

 public static int _SCORE;

 public MyOwnSaveLoad() {
  super("MyGame");
 }

 public void assignData() {
  this.addData(new SaveDataObject("Score", _SCORE));
 }

 public void retrieveData() {
  if(isDataExist("Score")){_SCORE = this.getData("Score").GetDataInt();}
 }

}

Set As Default Save Class

Finally, you need to set your own save class as default SaveLoad. This can be done by using your own Save Class as default value during launcher init() method.

public class MyLauncher extends InsMain{

 protected void init() {
  this.init(new MyInitialState(), new MyOwnSaveLoad(), ScreenOrientation.PORTRAIT);
 }

}

Save & Load

After set up your own Custom Save Class, you can save the game whenever you want by calling save() method. You can also call load() method to load the game, but it is actually unneeded. The game automatically load saved data during initiating. And The Engine will automatically retrieve it for you.

You can then use the retrieved data (in previous sample, the program data is _SCORE).

InsGlobal.save.save();

Next Step : Toying with Camera.

Previous Step : Enhancing Game Loader.

Tutorial Index

Introduction

If you have played many games, you will be familiar with Loading Screen. But do you know what it actually does? Loading Screen is an intermediate screen, which displayed when next screen is not ready yet.

Some Game Screen requires some time to constructed, for example if that screen use a large image, or need to somehow generate large data (like randomized dungeon generator).

Load Progress

Inspedio Engine provide a way to manage your loading screen, and shows loading progress to user. You can use this by defining loading progress during state creation. This can be done by setting InsGlobal.loadProgress value progressively after each process in your state creation.

package game.state;

import com.inspedio.entity.InsState;
import com.inspedio.system.core.InsGlobal;

public class LoadState extends InsState{

 public void create() {
   // Do process 1 here
   InsGlobal.loadProgress = 25;

   // Do process 2 here
   InsGlobal.loadProgress = 50;

   // Do process 3 here
   InsGlobal.loadProgress = 75;

   // Do process 4 here
   InsGlobal.loadProgress = 100;
  }
}

Please note that Load progress must have value between 0-100.

Customize Loading Screen

You can customize Loading Screen by defining your own Loader State. This can be done by creating  a class which extends InsLoader. InsLoader is similar to InsState (because it is subclass of InsState). The difference is that you have to define state behavior when Loading progress changed.

A simple approach is by using InsProgressSprite (a sprite which can be drawn progressively) to represents current loading progress.

public class MyOwnLoader extends InsLoader{

 public void create() {
 // set up your loader visual here

 }

 public void progressChanged(int CurrentProgress) {
 // Define screen behavior when progress value changed

 } 

}

Set Default Loader

Finally, you need to set your own loader as default Loader. This can be done by using your own Loader State as default value during launcher init() method.

public class MyLauncher extends InsMain{

 protected void init() {
  this.init(new MyInitialState(), new MyOwnLoader(), ScreenOrientation.PORTRAIT);
 }

}

Next Step : Saving Game Data.

Previous Step : Playing Sound & Music

Tutorial Index

Introduction

Music & Sound is important for game. It can enhance game experience, and makes it more fun. Inspedio Engine provide a way to manage your audio files.

Audio Format

J2ME platform supports 3 audio format : MIDI, AVI, and MP3. All of them can be used, but we strongly encourage you to only use MIDI format. The most crucial reason is filesize, as both MP3 and AVI file usually have large size.

A good J2ME game have less than 1 megabyte size, which already includes the whole program, image asset, audio asset, text (for level design or dialog). Some older device cannot even download file higher than 1 megabyte.

BGM & SFX

An audio file can be categorized into one of 2 type : BGM or SFX. A BGM or Background Music is a infinitely repeated music that played as background audio, usually last for 30-90 second. A SFX or Sound Effect is a one-time play audio effect, usually have very short duration, used to give special audio effect such as explosion, collision, etc.

You have to declare an audio file as BGM or SFX before playing them. Important note though : J2ME device only have 1 audio channel, which means you cannot play multiple audio at the same time. Only one of them can be played. So you have to choose between BGM or SFX in your game. You can work around this by using BGM in menu screen and then use SFX in play screen.

Usage

To play an audio, you have to load it first, and then play or stop it whenever you want. Remember that only one audio can be loaded at the time. You can play audio with following code :

public static void playBGM(){
// Load BGM files
InsGlobal.setAudio("/bgm.mid", AudioEncode.MIDI, AudioType.BGM);
 // Play Audio, or resume paused Audio
 InsGlobal.startAudio();
}

public static void playSFX(){
 // Load SFX files
 InsGlobal.setAudio("/sfx.mid", AudioEncode.MIDI, AudioType.SFX);
 // Play Audio, or resume paused Audio
 InsGlobal.startAudio();
}

public static void stopAudio(){
 // Pause or Stop Audio
 InsGlobal.stopAudio();
}

public static void resetAudio(){
 // Reset currently played audio
 InsGlobal.resetAudio();
}

Next Step : Enhancing Game Loader.

Previous Step : Detecting Collision.

Tutorial Index

Introduction

Collision detection is a method to detect whether two object collided. Most games relies heavily on this as their core gameplay. Inspedio engine also provide a way to detect collision heavily. Collision detection in Inspedio Engine use the simplest implementation, which is by using Collision Box or Collision Sphere.

Collision Box Vs Sphere

There are many type of collision detection, but the simplest method are by using collision area (and also what we use in The Engine). Collision Area are geometrical shape that represent area of collision. An example of Collision Area is shown below :

The object on the left use Collision Box while the other use Collision Sphere. Notice that when using collision box, the collision area is larger than actual shape of sprite. On the other hand, using collision sphere, some part of sprite is not covered by collision area. Which type is better to use depends on the object itself.

Tolerance Value

The size of Collision Box and Collision Sphere are calculated from Sprite size. However, for some games, you might need to increase or decrease its size. You can easily do that by setting tolerance value.

The above image shows how tolerance value affects Collision Area. The higher tolerance, the smaller collision area, thus requiring object to be more closer toward each other in order to collide. Tolerance can also used to enlarge collision area by setting its value to negative.

• Blue Area     : Normal Collision Area
• Green Area  : Collision Area with Tolerance Value = 10
• Red Area      : Collision Area with Tolerance Value = -10

Collision Callback

To handle collision, you need a callback which will be executed when the collision happen. For example, if you have a bullet and a player object. When they collided, the player will lost some energy and the bullet destroyed. Please remember to destroy unused game object, to prevent memory leak and prevent game from lagging.

Usage

To handle collision, you need to create 2 group. The group contains a list of object that might collide with each other. You can create an object and add it into group during the game. For example : in shooting game a bullet hot by player can only collide with enemy object, but cannot collide with its own bullet. Then you register object group and collision callback into state.

You can add multiple collision event into state. However, keep in mind that too many object will make the game laggy, so make sure you clear/destroy unused game object (after collided or out of screen).

The sample code can be found at SampleCollisionState class.

 public void setCollision(){
 // Register Collision Event into State.
  this.addCollisionEvent("<NAME>", group1, group2, tolerance,
  CollisionType.SPHERE, new InsCollisionCallback() {
   public void call(InsBasic obj1, InsBasic obj2) {
   // Put Collision handler here
   }
  });
 }

Next Step : Playing Sound & Music

Previous Step : Handling User Input

Tutorial Index