ArtsAutosBooksBusinessEducationEntertainmentFamilyFashionFoodGamesGenderHealthHolidaysHomeHubPagesPersonal FinancePetsPoliticsReligionSportsTechnologyTravel

Programming the Basic Game Structure: Flash ActionScript 3

Updated on October 2, 2012

When AI Could Be a Bad Thing

If your flash characters could only talk.
If your flash characters could only talk.

Ahh…yes programming games. It is fun and frustration at the same time. Programming games for beginners could be considered a very daunting task. However, the one thing to keep in mind is there is a structure to the madness of programming games. What I mean is that if you are new to creating games, just remember that if you follow a basic structure, everything should fall into place and you are on the way in creating your own game engine.

I am not talking about the graphics or classes that you need to implement but what your main class is doing. Almost all computer games have a main class that makes calls to other classes to do something in the game. With that said, the main class is the backbone to the game. Sure, the other classes that describe objects are important but they rely on what your main class is doing. So, the following describes the structure you will find in almost any game and all of these can be implemented in your main class of your flash game.

Startup: Step 1.

This maybe a no brainer, but it is the first thing that your main class does. It is the intro that tells the computer that this is what I want initialize prior to doing anything. There are two phases to starting your game: the class variables and the class constructor method.

Your class variables are the variables that you need to do certain tasks within you main class and they are usually placed prior to the constructor. For instance, the following code is an example of how you would do this in ActionScript 3:


import flash.display.MovieClip;

public class Main extends MovieClip {

public var playerName:String;




The variable playerName is an example of defining your initial variables for you main game class.

The second part of startup is you constructor method. The constructor method is where you initialize everything you want to initialize prior to starting the game (for example: your event listeners). Here is an example code of a constructor method:

public function Main() {




In the above code the constructor tells the program to stop frame animation of the stage and then creates a button.

The Game Loop: Step 2.

The second part of the Main Class to consider is the game loop. Games are like creating a movie. It is all based on the amount of frames per second which in turn allows you to make a call to certain methods to see if they are true or false. Without this loop, a game would not be able to update its state in which would not allow you to move or animate objects. In most programming languages like C++ or Java this would consists of a “while type of loop,” that checks a control variable for a true or false (i.e. variable equals a value or if a key is pressed).

There are many methods that could be called in this loop, but in most games there are four main methods that you would implement and they are animation, timing, collision, and movement. Here is a brief explanation of each:

1. Animation: If you have an object that requires animation, this is where the game would call that method.

2. Timing: You would create this method to get the present time from the computer or another source. One of the most usefulness of using a timing function is when you want to create a new game character or event at a certain point in time.

3. Collision: You would create this function to make sure that when two objects collide with each other and action occurs. Like in a space game, when the player collides with an enemy object you may tell the program to run an explosion animation and take one live from that player.

4. Movement: You would usually call this function to move an object on the screen to a specific location. In the case of 2D graphics this would be an X and Y location.

Like stated above, most programming languages uses a while loop to make checks on the above functions, however, flash actionscript 3 has an actual function to do this. Here is the function:

private function onEnterFrame(event:Event):void {

//do checks


checkCollision(player, enemy);




Therefore, if you add the onEnterFrame function in your flash games you have your game loop and this is where you do all of your checks (i.e. collision, timing, etc.) in your game.

Ending the Game:

The last part of a basic game structure is actually ending the game. Remember that the main game loop will run forever. So, you will need something that will stop this loop. This could be a variable or a keystroke. Here is an example of using a variable to end a game within the main game loop in actionscript 3:

private function onEnterFrame(event:Event):void {

//end game

if(endgame == null) {




Basically, the code above checks on every loop to see if the player has ended the game or if the player has lost.


So, the above is what constitutes the basic structure of your main game class. There are other things to consider but just remember that most games (if not all) will always need a starting point, a game loop, and a way to end. Plus, within you main game loop, nine times out of ten you will have to check for timing, collision, movement, and animation. Well... unless your game is a card game ;)

Please put all comments here.

    0 of 8192 characters used
    Post Comment

    No comments yet.

    Click to Rate This Article