Monkey Game Development: Beginner's Guide

5 (1 reviews total)
By Michael Hartlef
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Monkey—Huh?

About this book

Monkey is a programming language and toolset that allows its user to develop modern 2D games easily for mobile and other platforms like iOS, Android, HTML5, FLASH, OSX, Windows and XNA. With Monkey you can create best selling games in a matter of weeks, instead of months.

Monkey Game Development Beginner's Guide provides easy-to-follow step by step instructions on how to create eight different 2D games and how to deploy them to various platforms and markets.

Learning about the structure of Monkey and how everything works together you will quickly create eight classical games and publish them to the modern app markets. Throughout the book you will learn important game development techniques like collision detection, handling player input with mouse, keyboard or touch events and creating challenging computer AI. The author explains how to emit particle effects, play sound and music files, use sprite sheets, load or save high-score tables and handle different device resolutions. Finally you will learn how to monetize your games so you can generate revenue.

Publication date:
April 2012
Publisher
Packt
Pages
402
ISBN
9781849692038

 

Chapter 1. Monkey—Huh?

Monkey is a high-level programming language developed by Mark Sibly, the creator of the very popular Blitz Basic range of programming languages. If you happen to know Blitz Basic, Blitz3D, or BlitzMax, then you know where Monkey is coming from. Its main purpose is to provide you with a helpful tool to create 2D games, but of course, if you are creative, you will be able to create other kinds of apps and programs with it, too. For example, interactive books could a very good playing field for Monkey.

The Monkey programming language is strongly inspired by BASIC and JAVA. BASIC, in particular, is known to be a beginner's programming language. So naturally, Monkey is easy to learn and you can get up and running very fast; just as with most of the BASIC dialects. But it doesn't have to stop there. Monkey is also very extendable through third-party, or your own, Monkey source code and also native code running on each platform.

In this chapter, we will learn what Monkey is in general, how the toolset behind it works, and what kind of general features Monkey provides you with. We won't go into these things in great detail, but just give an overview. We also will have some playtime with games that were created with Monkey. So, if you happen to know all this already, it is safe for you to skip this little chapter and head right on to Chapter 2, Getting to Know Your Monkey—a Trip to the Zoo. If not, then keep on reading and you will learn a little about Monkey's background.

Game development for the rest of us

Since you are reading this book, we can safely assume that you have got the bug that makes a lot of people want to become a great and successful game developer. We have all played these awesome games and read stories about individuals who became wealthy overnight by selling their games on markets such as the Apple AppStore. And you want that too, right? We all do, and there is nothing wrong with that. Go for it! The way to get there was very difficult and long, in the past. For example, not long ago, learning Objective-C and using Xcode was the only way to create a game for the iPhone. Objective-C is not easy to learn if you are a complete beginner when it comes to programming. And a lot of people will tell you to study C and C++ in general before you head into Objective-C. Some people will tell you to study the BASIC language at first. You can imagine that it will take some time to study all this, never mind studying the techniques that are relevant to game development!

Now, with Monkey and various other game creation tools, this process has become much easier and quicker than before. A programming language that is based on a BASIC dialect is easy to learn and the features of Monkey will help you bring your dream of becoming a game developer to life.

 

Game development for the rest of us


Since you are reading this book, we can safely assume that you have got the bug that makes a lot of people want to become a great and successful game developer. We have all played these awesome games and read stories about individuals who became wealthy overnight by selling their games on markets such as the Apple AppStore. And you want that too, right? We all do, and there is nothing wrong with that. Go for it! The way to get there was very difficult and long, in the past. For example, not long ago, learning Objective-C and using Xcode was the only way to create a game for the iPhone. Objective-C is not easy to learn if you are a complete beginner when it comes to programming. And a lot of people will tell you to study C and C++ in general before you head into Objective-C. Some people will tell you to study the BASIC language at first. You can imagine that it will take some time to study all this, never mind studying the techniques that are relevant to game development!

Now, with Monkey and various other game creation tools, this process has become much easier and quicker than before. A programming language that is based on a BASIC dialect is easy to learn and the features of Monkey will help you bring your dream of becoming a game developer to life.

 

Cross-platform development


Ahh, the magic term... cross-platform development! It is the current hype thing. Because before the era of smart phones and tablets, the Windows platform, OSX and Linux were basically the only markets, where an individual game developer could publish games to. Game consoles were accessible only to huge game development companies with a lot of financial background.

Even these days, it is almost impossible to publish a game for an individual on some platforms. But new markets have arisen and new development tools such as Monkey are available now. Today it is more and more important to target several platforms with your game.

Why miss out on the money that can be made and the extra exposure for your game? There are so many markets to cater to, such as Apple AppStore, Android Market, and others, that it would be silly to throw away the opportunity to publish on them and rake in the extra cash. So, a cross-platform development tool such as Monkey is worth its weight in gold, and you will realize this very soon.

 

Compiler or translator?


Under the hood, Monkey is a translator. That means it will translate your program, which is written in the Monkey programming language, into source code for the supported target languages. And because of this, your program will be able to run on various platforms, such as iOS, Android, XNA, OSX, and Windows.

After Monkey has translated your program into source code for a certain target platform, it will then utilize native tools and SDKs (Software Development Kits) on these platforms to finish the compilation and linking process. For this, you will need to install various tools and SDKs. For example, you need to install Xcode and the iOS SDK to create iPhone apps. Or, to create a Flash app, you need to install the Flex Actionscript compiler.

The following illustration shows the process of creating an application with Monkey:

Don't worry about installing any of these SDKs and other tools for now. We will go through this together. Your default installation of Monkey can always export to HTML5 . To play HTML5 games, the only tool you need to have installed is a current version of an HTML5-compatible browser, such as FireFox, Safari, Chrome, or Internet Explorer.

 

The Monkey toolbox


Every good toolman has a good toolbox. Monkey's toolbox is small but well-equipped. It is basically a combination of two tools and some accessories. The first tool is TRANS, the source code translator. It is responsible for transforming/translating your Monkey source code into code, which can be compiled for each target platform. Basically, you feed it with one programming language and it spills out your code in a different programming language.

The second tool is Monk, the in-built source code editor for Monkey. You can also use other code editors as well, but we will work with Monk in this book, and it wouldn't hurt for you to do the same. A great benefit is that your Monkey installation includes all the source code for the tools, modules, and other stuff. So, if you happen to own a license for BlitzMAX (another programming language) and know what you are doing with it, then you could add features to Monk yourself or change it according to your needs.

The same thing goes for TRANS; you could change it as per your needs. The good thing is that you don't need another programming language. TRANS is self-compiling.

The accessories are Monkey's source code modules. They provide you with all the needed functionality for your games. We will learn more about this module, later on.

 

Time for action — installing Monkey


I guess it is time for the first action. If you haven't already installed Monkey, then you should do so now.

Head over to the Monkey website at http://www.monkeycoder.co.nz and grab your copy of Monkey. This book is based on the full version, so you should get that. Of course, you have to buy it first, but you won't regret this investment. And keep in mind that it is only a one-time investment. Other game creation tools are only available through subscription price models which can become very costly later on. It is not so with Monkey; you buy it once, and then you never have to pay for it again.

Ok, let's go and get it:

  1. 1. Go to http://www.monkeycoder.co.nz.

  2. 2. After you buy Monkey and sign up your user account on the website, download the latest full version from your user account.

  3. 3. Unpack the ZIP file to a location you want to run Monkey from.

    That wasn't much to do, was it? Like everything in Monkey, it is very easy to handle, even the first installation. But oh, we forget something. Something major.

  4. 4. Start Monk, to see the glorious development environment of Monkey.

Please welcome… Monk

Yes, here it is. Monk. Monkey's very own code editor.

This is the place where most of the magic will happen. The magic you will create—your own games. Your own awesome games. You still want to do it, right? Ok, then let's carry on.

When it comes to writing your Monkey code, you won't need anything else. There are other source code editors you could use to code your games with, but this book will utilize Monk for all the coding action.

How Monk works and which tools it provides you with, for your development, will be explained in Chapter 2,Getting to Know your Monkey — a Trip to the Zoo.

MSERVER—Monkey's own web server

Since Version 39, Monkey has been shipped with its own HTML server. This was necessary as certain operations required some security rights for actions such as writing the app state within an HTML app. When MServer starts, you will see a window such as the following:

Later on, when you let an HTML5 game run via Monk, MSERVER will provide you with useful information for certain actions of the game.

What just happened?

Installing Monkey is easy, right? And please note, you can copy the extracted folder to any location you want. The settings file for Monk is called monk.yourComputerName.ini and is located in the root folder of the Monkey installation. If you move the Monkey folder to a new location on your harddrive, you might want to delete it or alter the content in this file depending on the new location of Monkey.

 

Let's have a little playtime


Now that you have this task out of the way, close Monk again. Why? Because we should first see what kinds of games you could create, and then get familiar with Monkey and its feature set.

Game developers should always play other computer games, not only to have fun but also to study them. When you play a game, try to analyze how it could be done; how a certain feature affects gameplay. Or look at the technical aspects of a game, such as what kind of graphic effects a game uses, how the game rewards the player, and so on. You can get so much information out of a game, that it really can help you become a better game developer and designer.

And to get a better picture of Monkey's abilities, you should take the time now to play some games that have already been created with Monkey. As two of Monkey's target platforms are HTML5 and Flash, we can do this inside your browser.

Just make sure you have installed Internet Explorer 9, Firefox 4, Safari, or Google's Chrome browser. Chrome seems to feature the best performance when it comes to HTML5, but it is up to your personal preference.

Ok, head again to Monkey's website, and from there into the apps section. Have a look and play the first game we want to try.

 

Time for action — playing Pirate TriPeaks


Pirate TriPeaks is a solitaire kind of card game. You can find it at http://www.monkeycoder.co.nz/Community/topics.php?forum=1059&app_id=59.

The gameplay is easy, features nice animations of its graphics, and has some good sound effects. You have to click on matching cards to have them removed onto the open stack on the right. Also, you can click on a hidden card on the left stack to have it flip over and be visible on the right stack. The round ends once all cards from the left side are gone or in the event of removing all cards lying out in the open.

Play a few rounds and try to see what kind of gameplay or visual features make Pirate TriPeaks special.

What just happened

Did you notice a few things? For example, the spinning card animation when you click on a card and it flips down onto the stack. Or the coin animation, when you removed one of the three pyramids? Or the sound effects? All these little extras are the eye and ear candy that can separate one game from another. Here is a short list of features:

  • Spinning card animation

  • Flipping card animation

  • Sound effects

  • Coins falling from the top when a pyramid is removed

  • Playable with just the mouse or a finger on a mobile device

As a game developer, and also game designer, you should always play other people's games. Not only to have fun, but also to take inspiration from other games for your own one. Try to analyze them—what they did wrong in your opinion and also what they did great.

 

Time for action — playing Surviball


Next stop, Surviball. You can find this awesome game at http://www.monkeycoder.co.nz/Community/topics.php?forum=1048&app_id=48.

This game kind of looks a bit like the old Marble Madness. Your goal there is to move a marble through a parcour filled with obstacles, ramps, and enemies. In Surviball, you have to direct a marble over a difficult course filled with tiles that give your marble a good speed boost, when sometimes that is not what you need at that very moment.

When you play Surviball, try to pay attention to the controls and the graphical effects.

What just happened?

Ok, what did you notice? Maybe this rotating start effect, which is pretty simple to archive but visually very intense. Or the control scheme. By pressing the cursor keys on your keyboard, the marble speeds up. So you have to take the current speed into account when it comes to directing your marble in the required direction. Another thing is that the play field is assembled by a lot of repeating small tiles, each with a different functionality. Also, there is a timer, which gives the player some pressure to reach the goal in the given time frame.

Again, let's list some of the features of Surviball that we have discovered:

  • Rotation star effect

  • Indirect control scheme of the marble

  • Playfield assembled via small tiles with different functionality

  • Game timer

Playing to have fun, playing to study

Like we have seen already, when you play other developers' games, you should study them. Look at how graphics are used, how the control scheme is set up, and so on. Find out how the player gets rewarded and what makes the player go on and play further.

Of course, have fun with the games, but also analyze them to learn how things could be done. Take inspiration from them and also take the motivation you get from this for your own projects. There is nothing wrong with taking existing ideas and reusing them. Why reinvent the wheel when someone is already driving the car with it! I don't mean shamelessly copy other games, but take a proven concept, enhance it, and put your own stamp on it.

 

So let's go for something big? No!


Ok, so you want to create the next Diablo game, or another Star Craft. Do yourself a favor and take a step back; better, take 10 steps. Each of these games was created by an army of people. We are not talking about five to 10 people. Multiply these figures by 10 or 20 and the result will give you a good estimate of how many people are working on titles like the ones I have mentioned.

The games we have just played were created by individuals. They did the graphics, the sound effects, and the coding, all on their own. So when you start game development, set a small goal. The most important aspect for a game developer is to finish projects. Go for something that you can finish easily and in a short period of time. There are thousands of wannabe game developers out there who have never had something released in their whole career. You will definitely agree that someone who has never finished a game project can't call themselves a game developer.

The alternative

So instead of the next AAA title, we will first work together on the small projects. Starting with Chapter 2, Getting to Know your Monkey—a Trip to the Zoo, we will work on projects that you will be able to finish in a short period of time. We will look together at some classic games and will recreate them. Along the way, you will learn your tools and techniques that you'll need when you create games on your own.

The rewards and motivation from finishing a project are immense and will make you want more and more. So let's take some small steps first. Learn how to walk before you learn how to run.

What just happened?

Enough with all this game playing and having fun. Game development is also work. Sometimes it is fun work, but also sometimes dry and tough. But Monkey supports you with a great feature set in its arsenal, and you should now have a little study time in addition to this book. So it's not about what you can do for your Monkey, it's now about what your Monkey can do for you. After all, you shelled out quite a bit of cash and you should get something worthwhile back for it!

 

Time for action — read the manual


There will be a time when you will be participating in some online communities, mostly regarding game development. And of course, you will ask questions. Sometimes they will be good ones, but also sometimes questions about things that you could have figured out on your own. If other people see this, it could happen that you will get told to read the manual/instructions first before asking. Do yourself a huge favor and do just that, as it is rule number one. For every tool you use, read the instructions first. It can be dry and boring sometimes, but don't skip that task. It might come back to you, if you don't. When it comes to Monkey, it ships with a good-sized documentation. Monkey's creator and some helpers took quite some time to create the documentation. You will find information about Monkey's language, the specific modules of Monkey, and also two nice little tutorials to get you started. You will find all this when you open Monk and click on the Docs tab of the coding area.

When you are done with this, come back to this book and we will go over what you have seen. So go... now

What just happened ?

Wow!... the documentation for Monkey is quite a book (when printed)! You can get a lot of information out of it. It describes Monkey's features pretty well. But what are those features?

The Trans tool and the supported target platforms

The Trans tool translates your monkey source code into the native source code for a specific platform. Thanks to Monkey, there are already quite a few platforms you can choose from.

HTML5

Without having installed any platform SDKs and tools, such as Xcode and so on, Monkey can create HTML5 apps right out of the box. If your goal is only to create games for websites, then you won't need anything else besides a HTML5-compatible browser to develop your games. An HTML5 game is always a combination of an HTML file and a Javascript file where your game logic rests. All of your Monkey code is translated to Javascript code. Together with a calling HTML file, you can play this code directly in your browser or put it onto a web server to play it online.

FLASH

To create FLASH games, you need to have another tool installed—FLEX. We will go through this process later on in the book, so don't worry about how to install FLEX. In the process of creating a FLASH game, TRANS translates your Monkey source code into ACTIONSCRIPT code. ACTIONSCRIPT is the programming language behind FLASH apps/games. Then, after TRANS is done, FLEX compiles the created ACTIONSCRIPT code into a FLASH file. The created FLASH file can then be loaded onto a web server and can be played from there. FLASH games created with Monkey tend to perform a little faster than HTML5 apps, but that can change. To play FLASH apps/games, all you need is a browser with a FLASH player plugin installed in it.

iOS

Of course, iOS is supported. iOS is the iPhone/iPod/iPad platform, and for this, you need to have Xcode with the iOS SDK installed. Again, we will install that together later. If you want to create an iOS app, TRANS translates your Monkey code into C++ code. Then Monk will execute XCODE, which will compile your code into an iOS application. The resulting app can then be played inside the Xcode simulator. To test your game on an actual device, you need to sign up for a separate iOS developer account at Apple. There you can create the certificates needed to have an app installed on a device.

Android

The second mobile platform supported is Android. To create Android apps, you need to install the Android SDK, which we will also do together, later on. TRANS will translate your Monkey code into JAVA code. Then, the compiler of the Android SDK will create an application that you can either test on the Android simulator or on an actual device. To test an app on a device, you don't need to sign up for a Google developer account. You need to do this only when you want to sell your game on the Android market.

XNA

Behind XNA are actually three platforms: XNA for Windows desktop, for Mobile Phone 7, and for the XBOX 360. Again, you need to install an SDK for it, the Windows XNA SDK. Monkey's TRANS tool will translate your source code into C#, and then Visual Studio C# will create an application that can run on one of the mentioned XNA platforms.

GLFW

Just like XNA is basically three platforms, GLFW is two platforms. It depends on which development platform you compile your game with, OSX or Windows. For OSX, you need Xcode installed, and for Windows you need Visual Studio C++. So you actually have two platforms for the Windows desktop. Again, TRANS will translate your code into C++ source code, and the platform-corresponding SDK tools will compile that generated C++ code into an executable.

The Monkey standard modules

Modules are a huge part of the concept of Monkey. Besides the general language features, other commands are added to Monkey, via modules. They are written in Monkey code and maybe native code (C++, JavaScript, and so on). These modules either provide new commands and/or interface with commands from external native code, so you can use them in your game. In the following text, we will see what they are good for. It won't be a detailed explanation of how they work; only what you can do with them.

For more information on modules, please look into the Monkey documentation within the Module Reference section.

Lang

The lang module adds basic features to Monkey, such as Print, different data type-related handling functions, and one of the most important features, objects—the base for Monkey's class implementation. Here is a short code example:

Function Main()
Print ("Hello World")
End

Lists

If you know the concept of linked lists, this module provides something that will be familiar to you. If not, Wikipedia has a good explanation at http://en.wikipedia.org/wiki/Linked_list.

A list is a data container that lets you store something, from the same type of object as a node, inside memory. The list supports easy addition and removing from objects. You can iterate through the list of nodes in each direction. Another nice feature of a list is that you can convert it to an array of strings. To find a specific node inside the list, you need to iterate through the list, node-by-node, till you find the one you need.

Here is a small code example for a list in Monkey, without further explanation:

Function Main()
'create a new list
Local myList:=New StringList
'add some data
myList.AddLast "first entry"
myList.AddLast "second entry"
myList.AddLast "third entry"
'iterate through a list with an EachIn loop
For Local item:=Eachin myList
Print item
Next
End

Map

A map data container is similar to a list, as it is built from nodes too, and you can iterate through them. And node of a map is a pair of a value object and a key object. This key can only exist once. With it, you can retrieve the corresponding value very fast. If you need to find elements of a data container very fast, choose a map over a list.

The following image shows how map nodes have a relationship with each other. In a list, there is always a pre and post node from a current one. In a map, nodes have a loose relationship with each other. That means that you CAN iterate through a map, like you can with a list, but the real strength comes from searching nodes with the corresponding keys. So when you add a node to a map, this node will be placed inside a pool of nodes.

That is shown in the following screenshot with with Node 6. Knowing their keys, you can retrieve the corresponding data very very fast.

Here is a small code example with no further explanation:

Function Main()
'Define a string map with a string key
Local myMap:= New StringMap<String>
'insert entries
myMap.Insert("First","First entry")
myMap.Insert("Second","Second entry")
myMap.Insert("Third","Third entry")
'Print all entries
Print (myMap.Get("Third"))
Print (myMap.Get("First"))
Print (myMap.Get("Second"))
End

Math

Almost each game needs something to be calculated. The Math module provides a good set of mathematical functions for your game developing needs. Here is a nice example where the Sin function is used:

Function Main()
Local pi:Float
pi = 3.14159265
Print (Sin(pi))
End

Random

Since our game should not always run in the same way as the last time we played it, we need some randomness in it. The random module provides functions just for that—to retrieve random numbers. The following code is a little example of how to retrieve a random number:

Function Main()
'Retrieve a random number and print it inside the console
Local r:Float = Rnd(10,100)
Print (r)
End

Set

A set stores objects. It is like a shoebox that you can store your toy cars in. Like lists and maps, you can iterate through them. The difference from a list is that the objects in a set can only exist once in it. No matter how many times you add an object to it, the set will contain it only once. So it is good to keep track of a number of objects.

In the next example, you will see that the same entries won't be stored inside the set:

Function Main()
'create a new set
Local mySet:=New StringSet
'Add entries
mySet.Insert("First")
mySet.Insert("Second")
mySet.Insert("Second")
mySet.Insert("Second")
mySet.Insert("Third")
'Print all entries in the set
For Local s:= Eachin mySet
Print (s)
Next
End

Stack

Monkey provides a few ways to store data. The last module in this category is Stack. Imagine a stack of books. Basically, you can store them by placing one book on top of another (Push). If you want to take away one, you take it back from the top (Pop). Of course, you can squish a book in between the stack (Insert) or remove one from in between (Remove). And like all data storing features, you can iterate through a Stack in all directions.

Here is a small example for the usage of Stacks:

Function Main()
'create a new stack
Local myStack:=New Stack<String>
'Add entries
myStack.Push("First")
myStack.Push("Second")
myStack.Push("Third")
'Print all entries in the set
For Local s:= Eachin myStack
Print (s)
Next
End

Mojo — The 2D framework/modules

Monkey ships with a 2D framework module called Mojo. It provides all the meat (functionality) for each supported target platform. From handling graphics, to sound over input and device events, Mojo provides everything a good 2D game needs.

App

The app module provides some basic functions to load strings from the device and store/retrieve an application's state. Also, you can control the update rate for your render process with it and make it react to certain events, such as onResume, onSuspend, and others.

Audio

Ding dong!... Bang!...Wooosh! Almost all games have some kind of sound effect, and the audio module is Mojo's one-stop-shop for that. Load and play sound effects or total music for your background.

Graphics

Ladies and gents...please have a look at...the engine! The graphics module is responsible for loading and rendering images, drawing all kinds of graphical shapes, such as lines, rectangles, and circles, and also text. How else could you tell the player what to do next? Without this module, there is no output in Monkey. So this is a very important part of Monkey.

Input

When it comes to mouse input, violently hitting the keyboard, touching softly the screen of your mobile device, or tilting it wildly in every possible direction, the Input module is the way to go to retrieve information about how the user interacts with a game and its controls.

Monkey is extendable

One of Monkey's greatest features is that you can easily extend it. And the good thing is that you don't have to wait till Blitz Research does that for you. You are not bound to what the creator of Monkey will implement.

Your own modules

If you have Monkey code that you will use all the time and in every project you work on, then it is time for a module. Study how the native modules of Monkey implement new commands and functionalities.

Native source code

Another great thing is that you can add and link to external native code, import that code, and make some external declarations. It is very easy to do.

Third-party modules

Slowly, there are more and more third-party modules being developed for Monkey. Just to name a few, the following modules add some pretty interesting and valuable features:

  • fling—A physaxe 2D implementation that will add nice physics to your games

  • diddy—A great library of mixed functions

  • mnet—A network module to add access to server-based network connections

Note

These modules can be found at the following websites:

fling: http://code.google.com/p/fling/

diddy: http://code.google.com/p/diddy/

mnet: http://code.google.com/p/mnet/

You will find links to these modules and other modules inside the module registry section of Monkey's website. You can find this section at http://www.monkeycoder.co.nz/Community/modules.php.

Your own targets

The final feature you have with Monkey is that you can add your own target platforms, but, for this, you would need good knowledge of Monkey's internal structure and extensive knowledge to code for this platform. We definitely won't cover this topic further in this book. Say someone is working on a target for the Nintendo DS; you can find more about this at:

http://www.monkeycoder.co.nz/Community/posts.php?topic=652#5053.

Your game is easily portable

The last feature, which you're going to love, is that you don't have to code differently when it comes to making your game run on different platforms. Your Monkey code stays the same; the difference lies inside the created source code on each platform.

 

Summary


Wow! A lot to read and not much to do. Ok, you got some playtime here but also some good information. Let us revise what we have learned so far and looked at in this chapter:

  • We learned where Monkey comes from

  • We found out that Monkey translates your code into the native language of each platform

  • To find out what kind of games Monkey can create, we played a few

  • We studied the key features of the games we played

  • Of course, we installed Monkey on our computer

  • And, most importantly we learned about Monkey's feature set in general

So what's next? Do you agree that we can now dive into the inner caves of Monkey, bring out some fine functionality, and create your first game? Yes? You should answer more loudly! YES! Ok, so let's get rolling with the next chapter!

About the Author

  • Michael Hartlef

    Being into game development for a long long time, Michael Hartlef started in 1984 at the early age of 18 with this great hobby called developing computer games on the Commodore C64. Following this machine, he worked on most well know computers like the Amiga 1000 and 500, the Atari 1024 STFm and of course various PC's. These days it is mostly his IMac that he uses. Over the years, he developed a great knowledge about general and specific concepts for developing games and worked with a various range of game development tools/programming languages like thinBasic, Delphi, 3D GameStudio, Blitz3D, BlitzMax, DarkBasic Pro, App Game Kit (AGK), Corona ® SDK and of course Monkey! Besides working on games, Michael has developed various add ons for these tools like command library extensions and programming editors. At day Michael works for an utility company where he maintains the billing system (SAP IS-U). Michael is also the founder of an independent game developer startup called Whitesky Games (http://www.whiteskygames.com). There he spends a lot of his spare time working on game development tools (IndeED), addons and games for friends, clients and his own projects.

    Browse publications by this author

Latest Reviews

(1 reviews total)
It a great boom at it is easy to understand while tackling quality game projects.
Book Title
Access this book, plus 7,500 other titles for FREE
Access now