Warships: Sea on Fire (iPhone version)

Warships: Sea on Fire (iPad version)

Porting to iPad

The greatest challenge in this project was preparation of the iPad version of the game. I only had a couple of days to port it (iPhone version was already completed) and be in time for iPad’s launch. Of course I didn’t have real device, so everything had to be done on emulator. Both iPhone and iPad emulators are very good, but it’s hard to define speed of games on them – especially when they use OpenGL. In addition, emulator not necessarily mirrors the “true” iPad. Static library linking worked fine on emulator, but application wouldn’t run properly on device.

iPad version changes

Eventually we managed to compile it properly and it was accepted by Apple.When you port iPhone game to iPad, it’s very hard to fill that big screen with game content. Of course, you can upscale graphics and leave everything as it is, but we were required to change something in the iPad version. In “Warships”, to utilize that big screen, we made whole playing field visible at once. iPhone version scrolls itself to show each player’s area during consecutive game turns. In addition, there were also some minor UI changes.

Warships: Sea on Fire (iPhone)

Warships: Sea on Fire HD (iPad)

All in all, it was interesting experience to create a game on iPad before it’s launch. Now, when we have the device, development of our next titles will be easier. Some games, especially those with multitouch controls and speed dependant gameplay are nearly impossible to test on emulator.

Architecture is based on three threads: main thread created with every Android application, rendering thread and simulation thread. Simulation should keep watch on timer, update game word, calculate physics, AI, etc. Rendering thread draws a frame as frequent as possible, and it’s independent from simulation. If very long draw call is encountered, the simulation wouldn’t have to wait for it to finish and would continue to update itself, ensuring smoother synchronization with rendering.

Rendering thread must be set up with instance of renderer class implementing IRenderer interface. This way renderers can be easily attached to application. I hope we wouldn’t be forced to use anything beside simple Canvas renderer, although if heavier optimization is required, switching to some fancier renderer which uses OpenGL ES to draw textured squares shouldn’t be a problem.

I have already made some prototypes with flying plane, scrolling background and simple enemies. Game runs fine until garbage collector kicks in, and when it does, everything freezes for about 200-400 miliseconds(!). It happens very often, successfully ruining all gameplay. Of course, that prototype was written very casually, but it appears that almost all memory would have to be allocated before actual gameplay to stop garbage collection during it.

1. Mobile games / Game development

For my point of view (developer and gamer) it is the most interesting part of Android market. I would really wish that more complex games would show up: point and click adventure, RPG or just some shooter with nice controls and graphics. Although I have to admit, many casual games are beautifully polished and they are just pleasure to play (Buka or Jewellust/Devilry Huntress).

I have already spent some time with SDK, and I am aware that writing complex, graphically demanding game is challenging on Android platform. First of all, main there is Java as main programming language. The old programming joke:

“Knock, knock”
“- who’s there?”
…very long pause…
“- Java”

may be funny, but when you write a game on such limited hardware, you suddenly bump into bottlenecks not encountered on other platforms. Excellent talk about Android game development can be found here:
Google I/O 2009 – Writing Real-Time Games for Android. It’s author, Chris Pruett, presents efficent game framework and different rendering methods (Canvas, OpenGL), which I adapted to use with my own project. On the other hand, Mystique is a 3D first person adventure game which overcame platform restrictions. I certainly hope that more games like Mystique would appear on Android market.

2. Malaria Control Mobile

I thought about porting Malaria Control to mobile platforms (IPhone, Android). Unfortunately, current game version have to be modified heavily to run on mobile devices. Changing dialogue layout and setting world map to 2D are easy part, but tower defence gameplay is too big to fit in small display. Another issue is too many educational references that would make a little interest to casual player. I think it could be done, but promoting current, “big” Malaria Control version as application that raises malaria awareness will probably be easier. Nevertheless, I made a dialogue view for Android, which you can check below and compare to PC version:

- Android version (Malaria Control dialogue example)

- PC version (Malaria Control dialogue example)

As you can see, it is not possible to keep space for two characters and dialogue text in mobile version (resolution and device screen are too small). Instead, text would have to float left or right, depending on which character are talking. Of course, it is one of the possible solutions of this problem and it’s not necessary the best way. Those difficulties and nuances are nice to solve, and if final effect is plausible, you can be proud of yourself. Of course best way to check usability is to observe someone playing your game or using your application.

Python was my language of choice to write some simple code that sorts words in order of their occurrence. That task is easy, sure, but you have to get full lyrics first, preferably stored in one place(i.e. file). I haven’t even bothered to look after something like that on the Net. Instead, I used Beautiful Soup to parse artist’s web pages, download lyrics and write them to file. Beautiful Soup is fast and simple Python parser, excellent tool for this kind of job. http://www.bobdylan.com/ and http://www.brucespringsteen.net/ contains new and error-free songs lyrics (from 2009 albums) – you can’t say that about lyrics found on various strange fan-made pages in the internet.

Although I specified some popular prepositions, postpositions, pronouns etc. to be omitted, running my “lyrics processor” for the first time gave a poor results – recurring words were “it’s”, “have”, “where”, “their”, “don’t”, “from” and so on. I added some more common/unattractive words to omitted list, and got nicer results in graph format:

Those are definitely more interesting. Dylan likes to ask questions (but not necessarily answer them), so “know” is not a suprise. Both artist use “baby”, “love” or “girl”, words common in love-oriented songs (”It’s all over now, baby blue”, “Tunnel of Love”). “Night” and “tonight” are frequently used by Springsteen, night time is often used/anticipated in his songs (”Born to run”, “Thunder road”, “Because The Night”).

This simple analysis isn’t 100% accurate, but shows some frequent words used by Dylan and Springsteen. In future, I may compare more artists and introduce some other comparison method than simple word frequency. I used Python 3000 to do this task – it is more consistent, new dictionary views make it harder to do some bad mistakes. Unfortunately, there are incompability problems with Beautiful Soup and graph plotting libraries (and many other), they have yet to be ported to 3000.

Below you can find .rar with Python 3000 code I used to calculate frequency and sanity input. You can use WordAnalizer class to calculate common words in any text file, and both lyric files are also there. I didn’t include plot and parsing code, because they are written in Python 2.6 and including 3000 and 2.6 files in one package could be misleading.

WordAnalizer.rar

The whole process – setting everything up, going through hello world and adding controls to simple OpenGL ES demo took me around an hour. It is indeed very easy to start developing on Android. I would like to create something more sophisticated now – maybe a game with touch interface. Android store is not overwhelmed by games like Apple store, creating even simple, free game could be nice thing for community.

Result may be not very impressive , but anyway – here’s the screenshot:

If you would like to read more, a nice artice which compares Android and IPhone development can be found here:

Android vs IPhone Development: a comparison

PS. Android also has ASE – Android scripting enviroment that allows you to write simple Python or Lua scripts directly on your phone (preferably by using attached keyboard). Scripts can be used to make phone calls, send messages, poll location from GPS, use text-to-speech module and many more. There is even a guy who wrote automatic garage door opener using ASE – you can read about it on his blog: brad’s life .

Graphics need polishing and vehicle model is temporary. Notice that size of rendered model and size of Visual Debugger vehicle shape don’t match (in reference to terrain). This is the first issue I have to fix. I plan to add some rigid body objects to scene, crashing into them should be fun. Terrain should be flattened a little (…or maybe vehicle replaced with an-off road car?). I’d like to publish some source code here, although some improvements and refactoring have to be done – it works, but it’s not very pretty.

It could be hard for one to instantly “jump in” and create a simulation using Havok. Provided documentation is excellent and there are Havok software engineers on Intel Software Network to help and answer questions, but the SDK and it’s range of features are huge. Therefore I would like to write some tutorials or helpers about starting with Havok Physics 6.5.0. I believe that beside official support, it’s hard to find such information elsewhere, so hopefully it will help someone (or not, anyway – I’m going to write something).

Tutorial is intended for C++ developers, not artits or modellers (you can also use Havok in 3D modelling applications, like 3ds max), so you should have basic C++ skills and Microsoft Visual C++ IDE. I will present how to setup and link libraries, initialize Havok, create a flat surface and preview it in Visual Debugger. Of course all of it can be found in documentation and demos added to SDK, but I’ll try to compact everything here. Continue to tutorial with following link:

1. Getting started with Visual Debugger

After unpacking SKD, check folder structure. /Docs contains quickstart and user guides, which you should get familliar with and refer to when something written here is incomplete, doesn’t work for you or you have a feeling that i’m just wrong.

Check the /Demo and /Tools folders. /Tools contains Visual Debugger – a very useful application which we will be using extensively from now to preview results of our progress. Powerful feature of Visual Debugger is ability to remotely connect to machine which runs the simulation. In Network bookmark in Visual Debugger options you can set IP address and socket used to communicate over network. If you use the same machine to run simulation and Visual Debugger, set ip address to localhost or 127.0.0.1

All right, Visual Debugger presents empty scene and says [Connecting...] on title bar. We have to feed simulation data to it. Go to /Demo folder to find executable demo example in /StandAloneDemos. Run ConsoleExample… executable and check Visual Debugger. You should see ball breaking through set of walls. Steer camera to preview entire scene (check View->Camera->Fly mode).

SimpleMultithreadedConsoleMain.cpp contains whole source code of this demo. It is excellent starting point to learn. If you feel adventurous, open provided VC++ solution (.vcproj), look at, modify the code and build it yourself. Proivided project is already set up, so it should build without a problem. In the next section we will see how to link newly created project and initialize Havok from scratch.

2. Linking with Havok

Run Visual C++ and create new windows console empty project. I use VC++ 2008 Express, if you have another version, there will probably be minor interface differences from provided screenshots. In project properites window select Linker->General->Additional Library Directiories. Add a library path hk650r1\Lib\win32_net_9-0\debug_multithreaded_dll using file dialog.

Add common and physics libraries in Linker->Input->Additional Dependencies.

common libraries (hk prefix):

• hkBase.lib (provides functionality common to all Havok libraries)
• hkCompat.lib (version compatibility library)
• hkGeometryUtilities.lib (geometry operations)
• hkInternal (A public interface to Havok’s internal classes and data structures)
• hkSceneData.lib (data descriptions that are extracted from the animation toolchain)
• hkSerialize.lib (import/export library – havok data serialization)
• hkVisualize.lib (Visual Debugger definition)

physics libraries (hkp prefix):

• hkpConstraintSolver.lib (constraint solver)
• hkpCollide.lib (collision detection functionality)
• hkpDynamics.lib (core dynamics library)
• hkpInternal.lib (a public interface to Havok’s internal classes and data structures)
• hkpUtilities.lib (contains a number of handy utilities, including example actions and the Visual Debugger)
• hkpVehicle.lib (abstraction layer and default vehicle implementations for the Havok Vehicle Kit)

Thats all we need for now. Library detail and dependencies can be also be found in Quickstart Guide. If you check properties of stand-alone demo mentioned earlier, you will see those libraries linked there. You can copy entire list to your project.

3. Coding – Havok utility class

Some coding at last! If you look on that stand alone demo we launched at at the beginning, you will see that it is written procedurally for simplification. Drawback of that solution is much code in one place (although comments written by demo makers are very good and they help to orientate). I deciced to take adventage of more OO approach. Take a look at declaration of a class which encapsulate Havok data and allow to step the simulation forward.

class HavokUtilities
{
public:
 HavokUtilities(void);
 virtual ~HavokUtilities(void);

 void registerVisualDebugger();

 void stepSimulation(float dt);
 void stepVisualDebugger(float dt);

 hkpWorld* getWorld();
 hkVisualDebugger* getVisualDebugger();
 float getTimestep();

private:
 void initHavok();
 void deinitHavok();

 bool m_visualDebuggerActive;

 hkpWorld* m_world;
 hkVisualDebugger* m_vdb;
 hkpPhysicsContext* m_context;

 hkJobThreadPool* m_threadPool;
 hkThreadMemory* m_threadMemory;
 hkJobQueue* m_jobQueue;
 char* m_stackBuffer;
};

That seems complicated, and it may break “The Single responsibility principle” but at least everything is contained in single class for your convenience. Let’s start with interface:

• HavokUtilities() sets default timestep and calls private initHavok() method (data initialization).
• ~HavokUtilities() calls deinitHavok(). This way, if HavokUtilities object is destroyed, all resources assigned by it will be freed.
• registerVisualDebugger() sets up Visual Debugger. If you want to use VD, you have to call this after creating HavokUtilities object
• stepSimulation(float dt) and stepVisualDebugger(float dt) methods have to be called inside some loop. They tell the simulation and VD to step forward by delta time dt.
• getWorld() returns pointer to hkpWorld (Havok world instance)
• getVisualDebugger() returns pointer to hkVisualDebugger (VD instance)

In the interface section you can see declaration of physics world, Visual Debugger and context(which processes information from referenced world and presents them to debugger). World is container for simulated objects. We can add simulation elements to it, and during simulation stepping physical interactions of those objects will be resolved.

Havok memory, thread pool and job queue are declared below. Thread pool and job queue are used in multithread world stepping. If you would like to read more about how multithreading is implemented in Havok, refer to “Multithreading” chapter in User Manual. At the moment keep in mind that after registering physics world with job queue (initHavok() function):

m_world->registerWithJobQueue(m_jobQueue);

we can step the world using current and all the threads in the thread pool (stepSimulation() function):

m_world->stepMultithreaded(m_jobQueue, m_threadPool, dt);

There is no point in pasting whole source file here, just download header and implementation and add them to your project. Header has also pretty number of necessary includes not listed in class declaration previously. Both have extensive comments so take a look at them and try to figure how everything works. You should have HavokUtilities.hpp, HavokUtilities.cpp and main.cpp with empty main() function in your project.

HavokUtilities.hpp

HavokUtilities.cpp

4. Coding – application loop

Now we have to esablish some kind of game loop in main(). We will duplicate this loop from stand alone Havok demo, but before that we have to create our HavokUtilities object, register VDB:

int main(int argc, const char** argv)
{
    HavokUtilities* havokUtilities = new HavokUtilities();
    havokUtilities->registerVisualDebugger();

and create application loop:

   //create watch object - we will simulate for 30 seconds of real time
   hkStopwatch stopWatch;
   stopWatch.start();
   hkReal lastTime = stopWatch.getElapsedSeconds();

   //initialize fixed time step - one step every 1/60 of a second
   hkReal timestep = 1.f / 60.f;
   //calculate number of steps for entire loop
   //(30 seconds divided by single time step)
   int numSteps = int(30.f / timestep);

   //application loop, breaks after 15 real time seconds
   for ( int i = 0; i < numSteps; ++i )
   {
       //step the simulation and VDB
       havokUtilities->stepSimulation(timestep);
       havokUtilities->stepVisualDebugger(timestep);

       //pause until the actual time has passed
       while (stopWatch.getElapsedSeconds() < lastTime + timestep);
       {
            lastTime += timestep;
       }
   }

We set a watch to simulate 30 seconds of real time - that's our simulation duration. 1/60 time step means that simulation should be stepped 60 times during one second of real time. Time stepping if complicated concept, especially with varying framerate (i.e. in real applications with graphics). For our console demo this fixed step should work well.

After setting time step, we calculate number of steps needed for entire simulation and run a loop, where simulation and VDB are stepped forward by that fixed time step. To simulate real time pass, we hold loop execution after stepping until the actual time has passed. Don't forget to delete HavokUtilities object after loop, so it can call deinitHavok() and free aquired resources.

Our demo should confirm connection to Visual Debugger by writing to the console, although scene in VBD will be still empty - we haven't added any objects to the simulation.

5. Coding - creating fixed surface

Last thing I promised at the beginning of this tutorial - we will create a flat, fixed(static game scene element) surface to preview in VDB. It's not much, but it shows the basics of Havok shapes creation. Write function definition in main.cpp, before main() function:

void addFixedSurface(hkpWorld* world, const hkVector4& position,
                             const hkVector4& dimensions)

Function takes a pointer to physics world, shape position, size and width. Fixed figure with specified dimensions will be added to simulation. Let's see the implementation:

void addFixedSurface(hkpWorld* world, const hkVector4& position,
                             const hkVector4& dimensions)
{
  	//addFixedSurface function
  	//creates fixed surface with specified position and dimensions

  	//create box shape using given dimensions
  	hkpConvexShape* shape = new hkpBoxShape(dimensions,0);

  	//create rigid body information structure
  	hkpRigidBodyCinfo rigidBodyInfo;

  	//MOTION_FIXED means static element in game scene
  	rigidBodyInfo.m_motionType = hkpMotion::MOTION_FIXED;
  	rigidBodyInfo.m_shape = shape;
  	rigidBodyInfo.m_position = position;

  	//create new rigid body with supplied info
  	hkpRigidBody* rigidBody = new hkpRigidBody(rigidBodyInfo);

  	//add rigid body to physics world
  	world->lock();
  	world->addEntity(rigidBody);

  	//decerase reference counter for rigid body and shape
  	rigidBody->removeReference();
  	shape->removeReference();

  	world->unlock();
}

Funtion first creates a hkBoxShape, which defines the object's shape and size for collision detection purposes. hkBoxShape constructor takes half extents as a parameter - X by Y by Z box has a X/2 by Y/2 by Z/2 half extents. This shape, among with position and motion type is used to fill rigid body info structure. Any scene object that doesn't change it's size could be rigid body - boxes, surfaces, car chassis etc. MOTION_FIXED motion type means that object will be static in our physics world. It is necessary - fixed motion type will cause it to fall, according to gravitation set during initialization.

The function has one more thing to do: create a rigid body with rigidBodyInfo passed as a parameter and add it to physics world. Notice the removeReference() calls on rigidBody and shape objects. Havok manages those objects by using a reference system. Therefore physics world (hkpWorld) will keep reference to rigid body once added. If we don't need it anymore here, we could decerase reference counter, giving hkpWorld object full ownership over the object.

We have to call addFixedSurface() in our main() function, after we create HavokUtilities object:

 HavokUtilities* havokUtilities = new HavokUtilities();
 havokUtilities->registerVisualDebugger();
 addFixedSurface(havokUtilities->getWorld(), hkVector4(0,0,0),
                 hkVector4(50.0f,1.0f,50.0f));

This code will create a 100 by 100 surface, with 2 units height, positioned in world origin. Run console application and connect Visual Debugger, you should see something similar to this:

Full main.cpp source can be found here:

main.cpp

6. Summary

This demo covers basic knowledge about Havok Physics. Change something in our application, i.e. change created surface or rigid body motion to MOTION_DYNAMIC, and see the results. The User Guide is very well written and it's your main source of knowledge about Havok, so take a look inside if you haven't already. I plan another part of this tutorial, with dynamic bodies and real physics simulation. If you don't want to wait - see that multithreaded standalone demo supplied with Havok (you should now understand most of the source) - in the next tutorial we create something similar. You can check other demos too, but they have to be build first. Quickstart Guide contains information how to do it.

Archive with full source code and VC++ 2008 solution for this tutorial can be obtained using following link (don't forget to change paths for included directories):

HavokTutorial1.rar

I had done some research before and it appears that both of them are fantastic books about game development. Third edition of Game Coding Complete was released recently, in March 2009. In principle, if a book has more than one edition, there are chances for that book to be good. I’m also waiting for third edition of best programming book I have ever read – Code Complete by Steve McConnell. Programming Game AI by Example should give me some prospect on AI programming. I have only used simple state machines to manage world entities behavior in my projects .

I can’t wait until my shipment arrives (It will take around 3 weeks, I have selected standard delivery terms). Until then I’m going back to reading Real-Time Rendering.

I am interested in web development (my M.A. thesis was titled “The accessability and usability in methodology of creating Web services for disabled people”) and game development (recently I was programming “Imagine Cup” competition entry game, titled Malaria Control). You can find my portfolio and works on this page, just follow the links in right panel.

This is my first attempt in blog field, so I will appreciate all feedback. I use Wordpress, because it is a reliable, popular platform and I can customize it to match my own needs.