Click here to find out all the themes.

Requirements

We’ll need the following components for a small indie MMO:
1. Dedicated server
2. Socket server and Client API
3. Game client

1. Dedicated server

We need a dedicated server so that we can host our socket server program and get a static domain name or IP that our game clients can connect through the Internet. With the popularity of cloud-computing over the years, the price of running such a server has dropped to even around 30USD per month for a typical virtual Linux server running on Amazon EC2 services. More pricing on Amazon EC2 can be found here.
Cloud computing and hosting has a number of advantages over the traditional server hosting. One of the main advantages is the scalability which is very important for a MMO project. Joyent, RackSpace and Amazon are the popular cloud hosting providers among others. I’ll take Amazon EC2 as an example for I’ve some experience with it. They are running a large computing infrastructure behind. And when you sign up, you’ll be presented with a web based control panel. You can start building your own server from there by choosing the backend OS and the hosting plan. Once you’ve configured and launch that server, they’ll build a virtual server with your configuration in the backend. And in a minute or two, you’ll have your own virtual private server with a static IP (they called it elastic static IP) which you can access from Internet. You can run another instance in this way, balancing load between them, or build a higher performance instance.

Another advantage is cost-effectiveness. We don’t need to pay for the extra traffic if we don’t use. It also makes a bit difficult to project costs as it’ll charge us based on our usage. When we reach a massive concurrent user base we’re going to cost a lot.

2. Socket server and Client API

Socket servers are those running on our dedicated server and accept and broadcast messages between multiple clients. If they are intelligent enough, they can reduce network traffic by sending messages to only those who need to receive. They usually come with client API libraries for various platforms, for e.g., C#, Objective-C, Java, ActionScript, etc. Most of these socket-servers started out as multiplayer network engines for Flash games, initially supporting client API only for Flash. Smartfox, ElectroServer and Photon are some popular socket servers available on market. Now, they also provide client libraries for Unity engine as well. Smartfox and Electro servers can be also run on Linux systems.

Running either a Smartfox or Electro server on a Linux instance hosted on cloud would be cool choice for our small MMO.

3. Game Client

We’ll need a game client to render our virtual world like Bluemars is using Crytek as. With the availability of client API, web player, cross-platform deployments (PC, Mac, iOS, Android, Xbox, PS3), easy to use and not too expensive criteria, we would choose Unity for our own MMO project. Paradise Paintball on Facebook (used Photon as backend socket server) and Fusion Fall from Cartoon Network are the MMOs currently using Unity as the game client.

Development

The very first phase of an indie MMO project would include the following essential features:

1. Player registration and log in mechanism
2. One of our scenes from Payback movie (Wasteland may be) as a virtual world
3. Public chat with chat bubbles

One way to balance load for an MMO server is to set up different worlds, zones, rooms. So that the players will not be crowded in only one place and over load the server. Once the player registered, they will be able to log in to our server and they will choose a zone to enter. And they will be able to start chatting with others in public.

In the next phase, we can have a little ecosystem happening there as well. For e.g., every newcomer can choose a side, like either Zombie or Human. From there we can have different races on each side. For zombies instance, according to The Zombie Hunters, there can be six classes: BASILISK, BERSERKER, CRAWLER, HOWLER, HUNTER, MERCY and SPITTER. And different appearance and ability for each class. Same for the human, they will be able to choose a class like SOLDIER, MEDIC, ENGINEER, etc.

Revenue

Our revenue will be mainly from micro-transactions of selling virtual items. For instance, if it is a horror survival game, zombies might want to buy an Instant Flesh Pack if they can’t find the victims and are starving to dead. Same for the human, they can buy weapons and armours to protect them from zombies. Or if it’s an social hangout to the zombie world, we can sell special outfits to the players. According to this source, virtual items has become a billion dollar industry nowadays with 1.02 Billion USD even only in European Market.

Conclusion

You don’t need such a hosting on cloud yet until you launch to public. You can set up a socket server in your own LAN or even on a single development PC and start developing using the Unity. Only when you launch to public you might need a more experienced server engineer to manage the deployment servers with many concurrent users. You can start developing with not much initial investment and but the ongoing maintenance would be quite costly.

Here are new screen shots of this new version.

[Show as slideshow]

You can read this article here:

Game Engines and Frameworks for Small and Independent Studios

Cheers!

I prototyped different game play mechanics. And keep repeating start from scratch, implement another kind of mechanic. And hdd crash and data lost in between. As a result I didn’t get any far with the project. So finally I decided to do clone of a simple time management game like Diner Dash, Cake Mania, etc. The player would be selling guitars in the game. I started the project properly. Created a svn host on Assembla (until they removed the free hosting plan). And use AnkhSVN with Visual Studio to do proper back up and source control.

Here are some screenshots of the current state of the game.

[Show as slideshow]

I was still working on it until January this year. But there was a mobile game development project to do for school. I decided to do an iPhone game and found DragonFire SDK to implement the project. And after the school project, I’ve already written a small framework in DragonFire, so I decided to use it and made 2 other simple games which are on App Store now.

It got shelf since then. It was my first game that has made that far also. Actually it’s almost finish and I learnt a lot from this project. First, 2D casual games are not that easy to make for an indie trying to make a debut. Especially for today market when there are so many other games with high quality and production value. Another thing I learnt is engines and frameworks are not everything. They just render graphics, play sounds, etc. You still need a lot to implement your game logic.

Cheers!

Setting up the development environment – Option 1 (The hard way)

Here’s the hard way of doing the setup.
Launch Visual C++ or Visual Studio.
Language Visual C++->Win32->Win32 Project
Give it a name and choose the location.

Click OK.
Click Next in Welcome dialog.
Choose Windows application, check Empty project.
Click Finish.
Copy DragonFireSDK.h and DragonFireSDK.lib from your downloaded DragonFireSDK folder to the project folder.
In Solution Explorer of your project, right click on Header Files and choose Add->Existing Item.
Choose DragonFireSDK.h file and click Add.
Right click on Source files and choose Add->New item.
Choose C++ file, give it a name and click Add.

Choose Project->Properties.
And set the following properties:
Configuration Properties
General->Character Set->Use Multi-Byte Character Set
C/C++->Code Generation->Runtime Library->Multi-threaded Debug (/MTd)
C/C++->Output Files->ASM List Location->.\Debug/
C/C++->Output Files->Object File Name->.\Debug/
C/C++->Output Files->Program Database File Name->.\Debug/
Linker->General->Output File->.\Debug/MyGame.exe
Linker->Input->Ignore Specific Library->libcmt.lib
Linker->Debugging->Generate Program Database File->.\Debug/MyGame.pdb

Create a folder under your project folder and name it as Debug.

Setting up the development environment – Option 2 (The easy way)

Go to C:\DragonFireSDK.
Copy MyFirstApp folder and paste at a place you want.
Rename App.cpp to Main.cpp.
Open the MyFirstApp.dsw, .sln or .vcproj with your selected version of Visual Studio.
Choose Yes to convert all to your version of Visual Studio solution format if you were asked.
Remove App.cpp from the solution and Add Main.cpp.
Open it and delete all the code.

Creating the first DF SDK app

Create a new folder under Debug (which is under your project folder) and name it as Images.
I used http://getpaint.net and create a new image with 320×480 size.
Use gradient tool and text tool to create a background image something like this. (or just copy this image.)

Save it under the newly created Images folder.
Now in Visual Studio open up your Main.cpp source file and enter the following code.

#include "DragonFireSDK.h"

int imgBg;

//===============================================
void AppMain()
{
	imgBg = ViewAdd("Images/Background.png",0,0);
}

//===============================================
void OnTimer()
{

}

void AppExit()
{

}

Press F5 and debug run the code.

You should see something like this.

That’s it! That’s your DragonFire Hello World.
We’ll explore more in our next tutorials.

Enjoy coding!

Then just wrap your code with sourcecode tag. Samples, complete list of language supported and other parameters can be found here: http://en.support.wordpress.com/code/posting-source-code/

Anyway, these are just the steps I took. There can be many other ways of achieving this.

Enjoy blogging!

iPhone game dev with GameMonkey script and DragonFire SDK

In this post, I’ll share my experiment embedding a scripting language called GameMonkey to our DragonFire SDK game. Even though this post uses DragonFire SDK game as a host project, the idea behind this can be applied to any other project using GameMonkey as a scripting language.

Why GameMonkey?

When it comes to game-play scripting, Lua is also a popular choice. In fact, GameMonkey itself inherits the design concepts of Lua.
The reason I chose GM is because of it’s C like syntax, ease of use and even smaller size. And it was implemented with game developments in mind as well (you see, there’s Game in its name). I like the name as well.
By all means, you can choose Lua and can achieve the same results as well. Its just my personal choice.

Anyway, here it goes:

- GameMonkey Home: http://www.somedude.net/gamemonkey/
- Download: http://www.somedude.net/gamemonkey/downloads/
- Direct Download Link: http://www.somedude.net/gamemonkey/downloads/gmsrc_1_27_2.zip
- Extract the zip file to let’s say C:\ drive.

- Copy the MyFirstApp project from DF SDK to start working on scripting.
- Create a folder called “Scripts” in this solution folder. This is where we are going to put the gm scripts for our project.
- Open the VS solution file. Right click on “Header Files” in solution explorer and choose Add->New Filter. Name it as “gm”.
- Right click on gm and choose “Add->Existing Item…”. Go to C:\gmsrc\src\gm and select all the .h and .cpp files except gmDebugger.h and gmDebugger.cpp.
- Repeat the above process again to add the gmCall.h and gmCall.cpp files which are under gmsrc\src\binds.

- Go to Project->Properties and under C/C++->General->Additional Include Directories, add these two folders so that the compiler can find the files:
C:\gmsrc\src\binds;C:\gmsrc\src\gm;C:\gmsrc\src\platform\win32msvc
The last folder depends on the compiler environment you are using. GM comes with 3 ready made config headers for Win32 VC, Win32 GCC and PS2 CW.
We’ll choose win32msvc folder as we are using MS Visual Studio for our project.

Now copy the following code and replace with all the code from App.cpp.

//====================================================
// App.cpp
//====================================================

#include
#include

#include "DragonFireSDK.h"
#include "gmThread.h"
#include "gmCall.h"

//Load the script file and execute
int gmLoadAndExecuteScript( gmMachine &a_machine, const char *a_filename )
{
   std::ifstream file(a_filename);
   if (!file)
      return GM_EXCEPTION;

   std::string fileString = std::string(std::istreambuf_iterator(file),
   std::istreambuf_iterator());
   file.close();
   return a_machine.ExecuteString(fileString.c_str());
}

//add an image from gm, param is path to image
int GM_CDECL gm_addImage(gmThread* a_thread)
{
   // Check the number of parameters passed is correct
   GM_CHECK_NUM_PARAMS(1);		// This func needs 1 param
   GM_CHECK_STRING_PARAM( a_image, 0 );	// of string type

   int retImg = ImageAdd((char*)a_image);	// Call DragonFire func to actually add the image.

   a_thread->PushInt(retImg);			// Return the added image ID to script

   return GM_OK;
}

//add a view from gm, params are image hnd, x, y
int GM_CDECL gm_addView(gmThread* a_thread)
{
   // Check the number of parameters passed is correct
   GM_CHECK_NUM_PARAMS(3); // This func needs 3 params
   // All must be int
   GM_CHECK_INT_PARAM( a_image, 0 );
   GM_CHECK_INT_PARAM( a_x, 1 );
   GM_CHECK_INT_PARAM( a_y, 2 );

   int retView = ViewAdd(a_image, a_x, a_y);	// Call DragonFire func to actually add the View.

   a_thread->PushInt(retView);			// Return the added image ID to script

   return GM_OK;
}

void AppMain()
{
   // Create the GM Machine object on the stack
   gmMachine gm;

   // Register our C functions with GM
   gm.RegisterLibraryFunction("gm_addImage",gm_addImage);
   gm.RegisterLibraryFunction("gm_addView",gm_addView);

   // Execute a simple script file
   gmLoadAndExecuteScript ( gm, "Scripts/init.gm" );

   // Create gmCall to call scripted function
   gmCall call;
   if ( call.BeginGlobalFunction( &gm, "initGame" ) ) //search our function
   {
      /*
      We can add param to our scripted function here if we need.
      But in our case our scripted function initGame doesn't require any param.
      */

      // Execute the call
      call.End();
   }
   else
   {
      printf("Error calling 'initGame'\n");
   }
}

void AppExit()
{

}

void OnTimer()
{

}

The code is quite self explanatory. Basically we create 2 functions to expose to GM using gm.RegisterLibraryFunction. The idea is to add images and views from GM script.
Then we load a script file called init.gm from our Scripts directory and execute the function initGame.

So, let’s create a GM script for our DF game.
Go to your Scripts folder and create a new file called “init.gm”.
Add the following GM script to init.gm and save it.

//create a function called initGame
global initGame = function()
{
   img = gm_addImage("Images/Logo.png"); //call the gm_addImage function exposed from our project and get the return image id
   gm_addView(img, 10, 100); //use the image id and call gm_addView function from our engine to add view
   gm_addView(img, 150, 100);
   gm_addView(img, 10, 200);
   gm_addView(img, 150, 200);
};

- In the Visual Studio solution explorer, right click on MyFirstApp project and Add->New Filter. Name it Scripts. Right click on it and choose Add->Existing Item… and add the init.gm you just created.

- Build->Build Solution (F7) to test build the solution. You should be fine as long as there are no errors and will have to ignore warnings (or you can investigate how to fix all the warning if you want, don’t forget to share me back.).
- Press F5 to start debugging.

- You should see four DF logos added.

Now, this will only work on Windows obviously. If we want to get it work on our iPhone build, we must somehow include all the GameMonkey src when sending our project to DF build server.
There’ll be some works to get this system working on iPhone as we can never know what will happen on real device.
I have only exposed two main functions from DF SDK in this tutorial. Apparently, if I exposed everything from DF SDK to GameMonkey and set up an engine that will call appropriate functions for AppMain, AppExit and OnTimer, I should be able to create iPhone games with GM script without needing to tweak, compile, run, repeat procedure.

Share your ideas here in DF forum or leave comment if you have any question, suggestions or feedbacks.

Cheers!

[Ref1]
[Ref2]