1. Introduction
2. Our First BlitzMax Program
3. Working With Colors
4. Introduction to Variables
5. Introduction to Loops
6. Moving an object on the Graphic Screen
7. The IF statement
8. Reacting to User Input
9. What we have learnt so far
10. Blitzmax commands we have learnt so far

Introduction

Our First BlitzMax Program

 Now compile and run the program by clicking the "Build and Run" button as you did above. This is what we get:-

Let us try to understand what we have done. We actually have issued 5 instructions to BlitzMax. 

The first instruction,

 tells BlitzMax to create a graphic screen sized at 640 pixels wide and  480 pixels high.

 The second instruction,

 tells BlitzMax to draw at the screen coordinates 50,50 a rectangular box whose sides are 200 pixels wide and 100 pixels high. See diagram below.

 tells BlitzMax to display the hidden screen by flipping it into view.

The fourth instruction,

simply tells BX to wait for us to click the mouse button before moving to the next instruction.

And finally the last instruction simply end the program.

So there we have it our first BlitzMax program. That was not too hard was it?

Working With Colors

In the previous section we drew a WHITE rectangle on to a 640x480 graphic screen. Let us now draw a different color rectangle. This is done via the SetColor instruction. This instruction allows us to select the ink color to draw with. Our new program now looks like this

Notice how the SetColor instruction requires three parameters, the intensity of the red, green and blue colors as numbers between 0 to 255; 255 being the most intense. To obtain a RED color, we issue the instruction SetColor 255,0,0. What we are saying here is that we want maximum intensity RED and zero intensity GREEN and zero intensity BLUE. Note that the intensity for each color can be set from zero to 255 (minimum to maximum intensity).

Let us experiment and see what color we get by combining a maximum intensity RED with a maximum intensity GREEN and zero intensity blue like this:-

Introduction to Variables

Most BlitzMax instructions allow us to vary their behaviours. In the previous tutorial we learnt about the SetColor  instruction. The ink color that it uses to draw the rectangle in our example above was based on the intensities of the defined RGB primary colors.

Instead of issuing the instructions SetColor 255,0,0 we can also issue the instructions like so:-

What are variables? We can think of variables as containers where numbers are stored in. In this example we have placed the numbers 255, zero and zero into the 3 variables R,G and B respectively  So when BlitzMax receives the instruction SetColor R,G,B it first retrieves the number from each variable and then carries out its color mixing.

 Variables which stores numbers are called integer variables. Later we will learn about other different types of containers (or variables) that BlitzMax has.

Lets re-run the program by changing the assignment of the G variable

If we were to run this we also get a yellow rectangle. The reason is when we issue the instruction R = 255, we placed the number 255 into the variable R.

When we issue the instruction G = R, we are telling BlitzMax to pick the number which is stored in the variable R and assign that same number to the variable G.

Lets now have a bit of fun and see what happens when we assign random numbers to the RGB variables.

We’ve introduced two new instructions here, SeedRnd Millisecs() and Rnd(255).

The instruction Rnd(255) simply creates a random number between 0 and 255. This random number is then assigned to each of our RGB variables.

 In order for our Rnd(255) instruction to work properly, we have first to issue the instruction SeedRnd Millisecs(). At this stage let us not worry about why this is the case yet. The important thing to remember is that some instructions depends on other instructions to work properly.

Go on and run this program a few times. Each time we run it we get a different colored rectangle on the graphic screen.

The different colors are caused by different numbers randomly generated by the RND(255) instructions each time we run our program

Let us now familiarize ourselves with another type of BlitzMax variable, the string variable. Earlier we saw that variables which stores numbers are called integer variable. String variables stores text characters (also known as strings) instead of numbers.

To help differentiates between integer variables and string variables, we have to post-fix our variable name by the $ sign.

Let us see an example of this

The instruction a$="Hello World" assigns the phrase “Hello World” to the string variable a$. Strings within BlitzMax must be enclosed within the quote marks.

The next instruction DrawText a$,10,20 writes the text within the string variable a$ to the graphic screen at the screen coordinates 10,20

Now lets do something useful with this new knowledge and modify our random color program like this

The above picture tells us that the combination of the primary colors R,G,B of intensities 93, 86, 119 produces a rectangle with a greyish, purplish color. You will probably get a different color on your screen.

Note that the assignment to the string variable A$ in this example is now more complicated then before. Let us try and dissect the line. 

For example if we have the assignments A$=”MY “ and B$=”CAT”

Then an assignment C$=A$+B$ will result in the string “MY CAT” being stored in the string variable C$.

So what we are doing with this assignment A$ = "RGB COLOR "+R is assembling the string “RGB COLOR “ plus the number stored in the variable R. To make our displayed text to look nicer we also add in the comma before we assemble the next number i.e. A$ = "RGB COLOR "+R+”,”

We then go on and assemble the G and B parts resulting in the final line ;-

Introduction to Loops

Its not that much fun having to run our program each time we want to see a different colored rectangle. Lets see whether BlitzMax can help us out here. In order to do this, we need to be introduced to the concept of loops.

So far what we have done was to issue instructions to BlitzMax in a linear fashion. BlitzMax executes each instruction one line at a time until it reaches the END instruction upon which BlitzMax then stops. This is also known as a linear Program Flow.

Lets see how a loop will work in BlitzMax

What we now see when we run the above program is a flashing rectangle. This is because the loop is going through too fast. We will fix this later.

We now have 2 new instructions to look at, Repeat and Until MouseHit(1) 

When BlitzMax encounters the Repeat instruction, it knows that it is now entering the start of a loop. BlitzMax will then executes the other instructions line by line as before.

When BX gets to the Until MouseHit(1)  instruction, it will check to see whether we have click the left mouse button. If we have not, it will then loop back to the line which contains the Repeat  instruction and continues to perform the instructions in the subsequent lines below it.

This LOOP will repeat infinitely until we click the mouse button upon which it will exit the loop and then continues on to the next line which in our particular example happens to be the instruction to End the program

Now lets do something about that flashing rectangle by introducing another instruction called Delay

The Delay (500) instruction tells BlitzMax to pause our program for 500 milliseconds (which is half a second) before going to the next line

Moving an object on the Graphic Screen

In games, we normally see all sorts of objects whizzing around the screen. Lets now make a start to move our rectangle around the graphic screen.

Lets go back to our simple white rectangle but lets introduce two new integer variables X and Y

We can see that the values of the integer variables X and Y is now displayed on the screen with our familiar white 200x100 rectangle.

We are now going to introduce another concept, the concept of incrementing our variables. Let us add one new instruction to the previous program

Building and running the above program yields an ever growing white rectangle.

The reason this is the case is because the number stored in the variable X is increasing by 1 each time we go through the loop. This behavior is achieved by the instruction

The start of our rectangle is then moved one pixel to the right as well. As we move around the loop, the rectangles get drawn on top of each other, thus the rectangle appears to grow longer rather than moving.

Now lets make a small modification to our program by adding the CLS (Clearscreen) instruction and then see what happens.

Notice that instead of growing bigger, the rectangle is now actually moving to the right. We can also see the Rectangle Coordinates incrementing as per our DrawText instruction.

Remember in the beginning of this tutorial we came across this curious fact that the DrawRect instructions draws to a hidden area and we had to Flip in order to see the rectangle?

When we issue the Cls instruction, the hidden area (also known as the BACKBUFFER) is first cleared of all previous drawings thus allowing us to clearly see the rectangle moving instead of being drawn over the previous drawings (albeit moving slightly to the right each time)

So there we have it, a moving object on our graphic screen. These set of instructions (Repeat Until  Loop, Cls, Drawing and Flip) forms the basis of most game programs

In later tutorials we will learn about two other elements, USER INPUT to control PLAYER Movement and ARTIFICIAL INTELLIGENCE to control ENEMY Movement

But first, we need to be introduced to the conditional IF statement

The IF statement

The IF statement is a class of programming concept called conditionals.  Let us see how to use this in practice.

Lets us insert an IF statement into our program and also make our rectangle move faster by incrementing with a bigger number

We now see our rectangle moving much faster on the screen as well as moving back to the left side once it reaches the far right of the screen.

This re-start back to the left side is achieved by our new instruction IF X>400 THEN X=0

The IF instruction works by evaluating the logic of X>400 (read as X greater than 400). The expression X>400 is a true statement when the number contained in the X variable is bigger than 400. If this statement is true, the instruction after THEN is then carried out i.e the value zero is stored into the integer variable X.

If this statement is false, then the instruction X=0 is not carried out and the variable X gets to retain whatever value it held before.

In later tutorials we will be introduced to more complicated forms of the IF statement. The IF statement (or more accurately conditionals) is the cornerstone of programming logic.

Reacting to User Input

In the previous section, we learnt how to move a rectangular object on the screen own its own accord. We simply issue the right set of instructions (programming logic) to move the object to the far right and back again.

Let us now see how we can control the movement of the object using our mouse. We will now replace two lines from the above program with two new functions, the MouseX() and MouseY() functions. 

Now build and run the above program. You should now be able to move the rectangle by moving the mouse around the screen..

This behaviour is achieved by the introduction of two new instructions MOUSEX() and MOUSEY().

What MouseX() does is it returns the X coordinate of the mouse and the X=MousxeX() instruction then assigns this returned coordinate to the X integer variable.  Similarly for the MouseY() instruction.

What we have learnt so far

We have learnt some fairly fundamental stuff about programming today

• We learnt how to compile a BlitzMax program and to execute it. With BlitzMax this is done easily by clicking the "Build and Run" button..
• We've learnt about how the instructions in programs are executed sequentially unless told otherwise
• We've learnt about variables; storage areas to store numbers and text
• We've learnt about loops, where series of the same instructions gets repeated
• We've learnt about conditionals, using the IF statement to only execute an instruction when the conditions are right
• We've learnt how to display graphic objects onto a graphic screen
• We've learnt how users can interact with our program using the mouse
• We've learnt how to make our graphic object moves on the graphic screen
• We've learnt how to use the help file
  

Blitzmax commands introduced so far