Game development involves a wide range of abilities. Mathematics, software programming, graphic design, musical arts, and writing skills. Like a member of a World of Warcraft guild, you need a firm grasp of the tools of your trade before you set out for your quest. Intermediate or advanced Java skills are a must, as is a basic grasp of multimedia design and 3D modeling.

Thanks to 3D engines, however, you do not have to reinvent the mathematical wheel for every 3D game that you write. 3D engines such as jMonkeyEngine handle the following tasks for you:

The sunlit ocean bay in this screenshot is just one of many examples of what can be achieved when a collection of advanced 3D rendering techniques come together:

In addition to transformation, projection, and rendering, there is a lot of internal functionality that is the same in every 3D game. By reusing proven implementations, you spare yourself the need to handcode standard algorithms. jMonkeyEngine includes many features that are otherwise only found in commercial game engines:

jMonkeyEngine gives you a head start, so you have more time for coding the parts that make your game unique.

To set expectations right, jMonkeyEngine is not one of these drag-and-drop tools that mass-produces games with just a few clicks. To create a truly original game, you have to be able to write Java code. Let's have a look at an example:

This screenshot shows a scene from Hostile Sector, a browser-based multiplayer strategy game created with the jMonkeyEngine (http://www.mindemia.com/hostilesector/). In this game, two armed teams fight each other in an abandoned town. To be able to create such a basic game scene, you need to be familiar with the following mathematical concepts:

This book will walk you through these mathematical concepts where necessary, and introduce you to the appropriate built-in methods and classes that get these tasks done.

It is often that successful games such as Minecraft that inspire players to become game developers themselves. An example of a game that was inspired by Minecraft is Mythruna (http://mythruna.com/), an open-world game developed with the jMonkeyEngine.

For its creator, Mythruna was not the first game he ever wrote. Successful developers achieved their level of skill by starting small. Begin your developer career by creating a portfolio of solid mini-games to gain experience. Equipped with this knowledge, you can work your way up to the "MMORPG of your dreams".

The key to success is to stick to one idea and dare to strip off everything unnecessary. Don't aimlessly attempt to top every best-selling game of the last decade in your first release. And don't water down your game by adding tons of distracting effects just because everyone else is doing it.

Everyone else can start a game, but you want to finish it, too. A good feasibility test is to sum up your concept in one line. An example catchline for a Minecraft-like idea could be, "Build by day, survive by night". If you can't convey your idea in one straightforward line, it's too complicated to implement. Start with a clearly cut-out idea, and soon you will have something cool to show.

Do you already have a game idea? Let's have a quick look at the process of breaking down a complex idea into the building blocks of game development.

Let's say you are creating something similar to Hostile Sector, basically an arena with two fighters. One is a player-controlled character, the other a hostile non-player character (NPC).

How does the computer-controlled NPC "see" where the player is? How does the enemy approach the player without stupidly bumping into walls? At first, any game concept may seem like an undertaking of real-life complexity. But when you think about it for a minute, you notice that even a complex game scene is composed of only a handful of basic actions.

Now that you are aware of the basic atoms, a seemingly intricate scene turns into a manageable pattern of smaller pieces. Just like building blocks, you can use these elements in any order or number that fulfills your game's purpose. The only limits are the capabilities of your PC.

Listening to the heartbeat of your game

How do you apply what you just learned in context? Let's look at the overall structure of computer games. Obviously, you will have to write code to initialize the scene, and also to shut down the game cleanly. Between the beginning and the end, every interactive 3D application constantly loops through three stages: listen, update, and render.

• Initialize: The game loads objects and brings them in their starting positions. The loop starts:
  • Listen: The engine detects user input and responds according to your input handlers
  • Update: Your game code polls and updates its state, and acts and reacts according to your game mechanics
  • Render: The engine draws the scene to the screen
• End: The player has won, lost, paused, or quit the game. The loop ends.

In each stage of the game loop, you can make use of all basic elements described here. Let's look at an example of how to put the pieces together.

In the preceding example, you saw how a game scene comes together. As you read on, your understanding of the application structure will improve. The book includes a lot of hands-on sample code and fun challenges, because writing code and trying it out is the best (and most interesting) way to learn.

As additional sources, you should bookmark the following two pages:

In this book, you will find several headings appearing frequently.

To give clear instructions on how to complete a procedure or task, we use:

Instructions often need some extra explanation so that they make sense, so they are followed with:

import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;

SceneGraphVisitorAdapter myEmitterVisitor = 
                         new SceneGraphVisitorAdapter() {
 @Override
  public void visit(Geometry geom) {
    super.visit(geom);
 searchForEmitter(geom); // trigger custom test
  }
 @Override
  public void visit(Node node) {
    super.visit(node);

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or may have disliked. Reader feedback is important for us to develop titles that you really get the most out of.

To send us general feedback, simply send an e-mail to <feedback@packtpub.com>, and mention the book title through the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide on www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

We also provide you a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from http://www.packtpub.com/sites/default/files/downloads/6464OS_ColoredImages.pdf.