This course is for you if you are completely new to programming or the Java language. This course will quickly cover everything you need to know to be building Java games as soon as possible. This course will be equally relevant to you regardless of where you intend to use your Java skills. As we will see there are lots of game related projects to accompany this course and you will be able to choose which ones are relevant to you. We will complete Java desktop games(compatible for Mac, Windows and Linux) as well as Android games in Java too.
[widgets_on_pages id=”udemy_advert_java_1″][widgets_on_pages id=”udemy_code_details”]

This course will assume you know absolutely nothing about Java or any other programming language. It will explain all jargon as we proceed through the course.

At times in the course, we will take an optional break from theory to do an appropriate project. These projects are hands-on real coding and are much more fun than theory. All the projects will be as game related as possible, including some full working games.

When you have read the final level 1 tutorial (Part 10: Interfaces in Java games) you will be qualified to implement all the level 1 game projects for both desktop Java (Windows, Mac, and Linux) or Android’

spaceShip.shoot(alien);

Explaining code through comments

Sometimes I will add extra explanation or clarification within the code itself. To do this I will use Java comments. Whenever you see a line of code with two forward slashes at the start, that line of code doesn’t do anything except make a comment. In our Java programs, we will use comments to remind us of what different blocks or lines of code achieve. Here is what a comment looks like.

// I am just a comment and don't really do anything

spaceShip.shoot(alien);

// The line of code above shoots an alien
// That was a useful comment wasn't it

Enough of all the introductions let’s get on with the tutorials.

The Java game coding tutorials

The tutorials are designed to get you coding games as fast as possible. They are not fully comprehensive and some topics have been trimmed to the maximum. I am sure that the best way of learning to code games; is to code games. So the sooner we can start doing that the better. You will find that all of the practical Java projects on this site come with loads of refresher information and of course lots of useful Java comments using “//”. So don’t feel you need to master a topic before moving on.
We will step by step, walk through the following topics and concepts.

1 – Game Variables in Java

This tutorial serves as an introduction to Java and explains how we keep track of the state of our game when writing in Java. Let’s get started and learn about data and game variables in Java.

2 – Changing Game Variables in Java

This tutorial shows us the mathematical way that we can manipulate our game’s data that is contained within our variables. Changing game variables in Java.

3 – Checking for conditions in our game

Now that we know how to use variables to represent all the important aspects of our gave we will see how we can test for important events called conditions within our game. Find out about Checking for conditions in our game.

4 – Branching our game code

Here we will use everything we learned about conditions and if statements and take it to the next level to finely control the order our code executes within our game . Learn about Branching our game code.

5 – Looping our game code

In game coding, we will regularly want to execute parts of our code multiple times while making subtle or not-so-subtle variations to our code on each pass. This is how: Looping our game code.

6 – Organizing our code with methods

As our game code grows in size and complexity we need smart ways to organize. Organizing our code with methods.

7 – Understanding OOP for coding Java games

Object Oriented Programming (OOP) is a vast topic. It would take multiple complete books to learn it all. However, the complexity and depth of OOP do not have to be a barrier to getting started coding games in Java. This whirlwind tour gives us the absolute basics we need to get started making games. We can then improve our OOP further while making actual games rather than pouring over textbooks. Read the tutorial Understanding OOP for coding Java games.

8 – Handling game data with Java arrays

Here we find out about how to handle multiple game entities using arrays. So we know we can build spaceships, aliens, bombs etc with our new OOP skills but what about if we need hundreds, even thousands of them? Read Handling game data with Java arrays.
[widgets_on_pages id=”udemy_advert_java_3″][widgets_on_pages id=”udemy_code_details”]

9 – Managing simultaneous events with Threads

This is the second to last tutorial before you can make games for real for Android or your desktop OS. Like events that happen to us in life, our games do not run in isolation. They are part of a system. Threads give us the ability handle this apparent complexity with ease. Every game we write will have a thread. Find out about Managing simultaneous events with threads.

10 – Using Java Interfaces

We have made it! The final tutorial before you can take on your first real game project. Learn how to further reuse other people’s hard work with this special type of class. Read about Using Java Interfaces.

All of these things are part of the data of the game. And it is very easy to think of lots more examples of data, a typical game might need. What about the images for the graphics, what if each object has a different image for each of many frames of animation? What about data to describe the game environment, artificial intelligence or the layout of the different levels of a game? All this information, even in a simple retro 2d shooter, for example, will become fairly extensive once the whole game is considered.

Fortunately, the Java programming language solves this problem for us; with variables. Variables enable us to easily store data in a meaningful, accessible and flexible way. Let’s look at some simple examples to start with.

We mentioned a moment ago that we would need to remember the player’s score. To manage this particular piece of data we can create a variable in our code and we can make it meaningful by giving this variable an appropriate name. Let’s call our variable to hold the player’s score 

playerScore

Variable naming conventions

You might have noticed that the name is simply a combination of the two words, with the first letter of the first word in lowercase and the first letter of the second word in upper case. In Java, we can call our variables almost anything we want but by using meaningful names there is never any doubt about what the variable is for. In addition, by using the combination of lower and upper case letters we are adopting a naming convention. By sticking to a naming convention especially when our code eventually becomes more extensive, will make our code more readable and easy to follow.

Naming conventions vary from language to language, company to company and different preferences for particular conventions abound. In Java, you can choose your convention of choice -unless you’re being paid to follow a specific convention. Here we are using the simple lower case word followed by upper case word because it makes the second word clear and when we introduce more types of Java code later in the course it will make our variables stand out from other types of code.

Java variable types

The next thing we need to do, before we can begin to write code for our variables, Java forces us to decide what type of variable it will be. Types are simple to understand. It is just a case of thinking about what information (what type) any particular variable will be used to store. In the case of our

playerScore

What about the name of the player, perhaps we could use a variable called

playerName

To avoid any ambiguity about what type a variable is, Java makes us declare a type before we can use a variable. This makes it plain what that variable will be used to store. Java then knows how much space is required but also, because it can help us enforce rules about the correct usage of different types. As we progress with this Java course and complete our first projects we will see this is a very useful feature.

Let’s have a look at some common types in Java. The list below is a mere fraction of the full range of available types; all the variable types should appear fairly straight forward with the exception of one really powerful variable type, known simply as an object or class, which will be covered in the tutorial Understanding OOP for coding Java games. We can write almost any game with just these seven types.

int

String

float

long

boolean

[]

The table shows the seven key variable types that will allow us to make almost any game. The last one, Object, is the most powerful of all and will be covered at level 2.
[widgets_on_pages id=”udemy_advert_java_3″][widgets_on_pages id=”udemy_code_details”]

How variables work

We can think of a variable as a kind of storage space. And when we declare a variable along with its type Java not only reserves a space in memory, appropriate for that type but also links the name we give it to that space. So whenever we refer to

playerScore

This happens in two steps; declaration followed by initialization. We have already mentioned we must declare our variables so let’s have a look at what that code might look like then we will look at the second step, initialization.

Declaring a variable

We can declare a variable in Java like this:

int playerScore;
String playerName;
float valuePi;
long millisecondsSince1970;
boolean isAlive;

Above we simply state the type followed by the variable name and end the line with a semicolon. We add the semicolon to the end of the line to tell the Java compiler that it is the end of the line.

On line 1 of our code we have a

int

playerScore

String

playerName

float

valuePi

long

Notice in the examples above and the examples that follow we have left out further discussion of arrays and objects for a later time.

Initializing a variable

Now we have declared the variables with meaningful names we can initialize those same variables with appropriate values, like this:

playerScore = 0;
playerName = "Alan Turing";
valuePi = 3.141f;
millisecondsSince1970 = 1415187526;
//the above is true this 5th November morning in 2014
isAlive = true;

Notice on the end of the

float

f

Declaring and initializing in one step

int playerScore = 0;
String playerName = "Alan Turing";
float valuePi = 3.141f;
long millisecondsSince1970 = 1415187526;
boolean isAlive = true;

Remember that Java helps us enforce the rules about a variable’s type. So we couldn’t do this:

Types matter and cannot be used with the wrong type of data.

playerScore = "Alan Turing";
//error Strings are not the same as int
isAlive = 10;
//boolean can either be true or false

What next?

Of course, to make our variables any use at all we need to be able to read them and manipulate them. So let’s learn about changing the value of game variables with expressions. Or, if you haven’t already, you might like to consider setting up an Android development environment ready to do some projects.

Java operators

Here is a list of the most useful Java operators that allow us to do things with our game’s variables. One of which we already know about.
The assignment operator which we have already seen (

=

hiScore = score;

or

score = 100;

The addition operator

+

score = aliensShot + wavesCleared;

or

score = score + 100;

Notice that it is perfectly acceptable to use the same variable on both sides of an operator.
The subtraction operator

-

lives = lives - 1;

or

aliensRemaining = aliensRemaining - numberAliensDestroyed;

The division operator

/

hitPoints = hitPoints / swordLevel;

or

recycledValueOfBlock = originalValue / .9;

Obviously, in the previous example, the variable

recycledValueOfBlock

float

*

answer = 10 * 10;

or

biggerAnswer = 10 * 10 * 10;

The increment operator

++

This:

myVariable = myVariable + 1;

is the same as this:

myVariable ++;

The decrement operator

--

playerHealth = playerHealth -1;

is the same as:

playerHealth --;

We want to be able to do things like this:

if the player has no lives left end the game.

	Go back to the main menu screen

if the last alien has been destroyed 

	start the next level.

Note that the above is pseudo code to demonstrate how if works. It is not real Java. We will see real Java code using the

if

Java has the

if

if(some condition is true) {

	// do whatever

}

The

if

()

{}

// do whatever

if

Comparison operators

We can already add (

+

-

*

/

=

++

==

--

There, we will put some comparison operators to use and they will become much clearer as we see a few examples of what they allow us to do. They are presented here in a list just to make the variety and scope of operators apparent from the start.

==

if(10 == 9){

	// is obviously false 10 is not equal to 9.

}

!

if(!(10 == 9)){

	// This is true because 10 is NOT 9.
	// This may seem convoluted but we will see
	// this type of comparison can be useful.

}

!=

if(10 != 9){

	// is true because 10 is not equal to 9.

}

>

if(10 > 9){

	// is, of course, true.

}

>=

if(10 >= 9){

	// is true.

}

Also look at this for further clarification.

if(10 >= 10){ 

	// is also true because 10 equals 10
	// even though 10 is not greater than 10

<=

if(10 <= 9){ 

	// is false.

}

However, both of these conditions are true.

if (10 <= 10){

	// is true because 10 equals 10

}

if (9 <= 10){

	// is true because 9 less than 10

}

&&

if((10 > 9) && (10 < 11)){

	// is true because both parts are true.

}

However, this turns out false:

if((10 > 9) && (10 < 9)){

	// is false because only one part of the expression
	// is true (10 > 9) and the other is false (10 < 9).

}

||

||

if((10 > 9) || (10 < 9)){

	// is now true because...
	// one part of the expression is true (10 > 9)

}

And as you might expect, we can use our game’s variables in if statements as well. Here are a few examples. You don’t need to fully understand how the code in the next few samples works just take a look at it and think about how we are controlling our game code with the if statements and their conditions. This is real code from a game.

boolean hitDetected = false;

// Some code that detects
// if the player ship was hit goes here

if(hitDetected) {

	playSound(explosion);
	playerLives --;

}

Now, look at how we might check to see if the player had got a new fastest time at the end of a racing game. The variables would have been declared and initialized previously.

//check for new fastest time

if(timeTaken < fastestTime) {

	// the player took less time than the fastest time!!
	// So a new fastest time has been set

	// Now change the the fastest time variable
	// to the new fastest time (timeTaken)
	fastestTime = timeTaken;

}

[widgets_on_pages id=”udemy_advert_java_3″][widgets_on_pages id=”udemy_code_details”]
The

if

{}

if

if

We will explore two key ideas conditional branching which is really just a closer look at

if

Conditional branching

As with many topics in Java, you could write a whole book on structuring code. What we will do is cover just enough so we can start to make games. Here are the vital ways we can conditionally branch our code. Let’s have some fun with branching.

If they come over the bridge shoot them

The captain is dying and, knowing that his remaining subordinates are not very experienced, he decides to write a Java program to convey his last orders after he has died. The troops must hold one side of a bridge while awaiting reinforcements. The first command the captain wants to make sure his troops understand is this:

If they come over the bridge, shoot them.

So how do we simulate this situation in Java? We need a

boolean

isComingOverBridge

isComingOverBridge

if

if(isComingOverBridge){

	// Shoot them

}

If the

boolean isComingOverBridge

if

Else do this instead

The captain also wants to tell his troops what to do (stay put) if the enemy is not coming over the bridge. Now we introduce another Java keyword 

else

if

else

if(isComingOverBridge){

	//Shoot them

}else{

	//Hold position

}

The captain then realized that the problem wasn’t as simple as he first thought. What if the enemy comes come over the bridge, but has more troops? His squad would be overrun. So, he came up with this code (we’ll show some variables as well this time.):

boolean isComingOverTheBridge;
int enemyTroops;
int friendlyTroops;
// Code that initializes the above variables one way or another

//Now the if
if(isComingOverTheBridge && friendlyTroops > enemyTroops){

	//shoot them

}else if(isComingOverTheBridge && friendlyTroops < enemyTroops) {

	//blow the bridge

}else{

	//Hold position

}

And finally, the captain’s last concern was that if the enemy came over the bridge waving the white flag of surrender and were promptly slaughtered, then his men would end up as war criminals. The Java code needed being obvious. Using the

wavingWhiteFlag

if (wavingWhiteFlag){

	//Take prisoners

}

But where to put this code was less clear. In the end, the captain opted for the following nested solution and changing the test for

wavingWhiteFlag

if (!wavingWhiteFlag){ // not surrendering so check everything else

	if(isComingOverTheBridge && friendlyTroops > enemyTroops){

		// shoot them

	}else if(isComingOverTheBridge && friendlyTroops < enemyTroops) {

		// blow the bridge

	}

}else{ // this is the else for our first if

	// Take prisoners

{

// Holding position

This demonstrates that we can nest

if

else

Switching to make decisions

Sometimes a decision in Java can be better made in other ways. When we have to make a decision based on a clear list of possibilities that doesn’t involve complex combinations wide ranges of values, then

switch

switch

switch(argument){

}

In the previous example,

argument

case

break

case x:
	//code to for x
	break;

case y:
	//code for y
	break;

You can see in the previous example each

case

break

case

switch

default

case

default: // Look no value
	// Do something here if no other case statements are true
	break;

Supposing we are writing an old-fashioned text adventure game, the kind of game where the player types command like “Go East”, “Go West”, “Take Sword” etc. In this case,

switch

default

// get input from user in a String variable called command
switch(command){

	case "Go East":
		// code to go east
		break;

	case "Go West":
		// code to go west
		break;

	case "Take sword":
		// code to take the sword
		break;

	//more possible cases

	default:
		// Sorry I don't understand your command
		break;

}

Now we will look at looping our game code.