Level Design Workflow

My idea was to create a side scrolling shooter involving planes. The planes fly through a city

and have an air battle.

I wanted to have the game take place at night time in the city. So I made 1 background

which consisted of buildings and the sky and I made a second background with a different

depth so that it was in front of the previous background.

My character Is a fighter jet plane, I used an image for help to get the shape and colour

correct.

My inspiration for this game came from playing games like battlefield and call of duty.

I began designing my game by first creating a player sprite which is shown above, then I

created a player object and then I created a room for which I would use to create my level. I

had to make the background a scrolling background. After creating a background for my

game I would continue on to create my player object.

Objects in the game use sprites and can be coded using different events. In my player object

I selected sprites and added events so that I could move, shoot and be destroyed. I also

added an event so that when my character spawns he has a jet flame on the back.

After this I created a system object and a jetpack object, which would allow enemy’s to

spawn and for me to respawn when I died, I would then go on to create my first enemy. I

created a sprite for my first enemy. Then I created the enemy object using this sprite. I

added codes so that the enemy will shoot if my character is on screen and so that when

they leave the room border they are destroyed. I also added some sounds for the enemy

shooting.

I also created “player_lazer” sprites which my player would shoot, as you can see from the

image I added a collision event so that when my player missiles hit my enemy he will be

destroyed. I also added sounds so that when the player_lazer and enemy_lazer are shot

they make a noise.

Next I added a sprite for when my enemy is destroyed, for this I made a set of sprites to

create an animation for my enemys death, I also made one for my player. I also created a

bar at the top left of the screen and added and event so that when the bar reaches 0 my

player would die. This would act as my player health bar.

I also added an event in the system so that when my player object is hit by an enemy missile

the health bar decreases. I went into my enemy_lazer object and added a collision event

and some coding to make the health bar decrease. The code for this was;

///hit

Global.shield -= 25;

Which meant it was now possible for my player to die in game. The code I used was put into

the system create event and was name shield. The code was as follows;

///shield

Global.var shield;

Shield = 100

I also had to add a draw event to actually draw the health bar in game. This draw event was

also added to the system object. The code used was;

///draw shield

Draw_rectangle_colour(32, 32, 32+global.shield, 40, c_green, c_green, c_green,

c_green, false);

At first the health bar would go negative (below zero health) and would continue to

increase in size backwards off the screen. This was easily sorted out by creating a player

destroyed sprite and creating an object for this sprie, in the sprite object I added the code;

///explosion particle system

Explosion_2 = part_system_create();

Part3 = part_type_create();

Part_type_sprite(part3, playerdestroyed_sprite, true, true, true);

Part_type_size(part3, 0.5, 2, -0.3, 0);

Part_type_life(part3, 30, 60)

Part_type_gravity(part3, random_range(2,7), random(360));

Part_type_alpha(part3, random_range(0.1, 0.75));

Part_particles_create(explosion_2, x, y, part3, 10);

Next I added an alarm event into my player_destroyed object, this would allow my player to

explode for a set number of frames then restart the game. The code which I used to do this

was;

Instance_destoy()

Room_restart()

I also needed to create a create event in the player_destroyed object to initialize the alarm.

For this I coded;

Alarm[0] = 60

Audio_play_sound(playerdestroyedsound, 1, false);

Finally I had to add a step event into my player_1 object so that it would be destroyed, the

code was;

///destroyed

If global.shield <=0

{

Instance_change(player_destroyed, true)

With(jetpack)

{

Instance_destroy()

}

}

Now when my player object is hit it should be destroyed, show the explosion sprite and also

reset the game to the start.

As you can see the health bar in the top left is down to zero and my player has been killed so

the explosion takes place and the game restarts. After this my next task was to create a

score system which would count the amount of points a player gets in the game before they

die and it is reset. For this I went into the system object and created a score variable in the

create event. The code I put into this was;

///score variable

Global.var points;

Points = 0

Then in the draw event of the system object I added some code so that the points system is

draw on screen below the health bar. First I created a font using the create font tool which I

then named font1. Then I began coding my score variable. For this I entered the code;

///draw score

Draw_set_font(font1);

Draw_set_colour(c_white);

Draw_set_halign(fa_center);

Draw_text(36,40,global.points);

I had to add the amount of score I get when an enemy is destroyed. I added a cod to the

enemy movement and shoot event in the create event. I added;

///increase score

Global.points +=1;

Next I went into my collision with the player missile in the enemy destroyed object and

edited the code. I added;

Global.points +=1;

Now when my missile hits the enemy the enemy is destroyed and also I get points added to

my score. My next task was to add a second enemy. I did this by creating a new sprite, a

new enemy destroyed sprite and a new enemy_lazer2 sprite. Also I added a new sound for

when my enemy 2 shoots. I went about creating the second enemy by first creating a new

alarm in the system object called alarm 1. This contained the spawn enemy 2 code which

was as follows;

///spawn enemy 2

Randomize()

Var y_spawn;

Y_spawn = random_range(32, 448)

Instance_create(1104, y_spawn+0, enemy_2)

///reset alarm

Alarm[1] = random_range(20, 80);

I also added an enemy 2 spawn alarm code into my create event in the system object to

initiate the alarm 1 which spawns the enemy. This code was;

///enemy 2 spawn alarm

Alarm[1] = 60

This means my second enemy will spawn 30 frames after the second enemy appears so 1

second after as my game runs at 30fps. Next I created the enemy 2 object which would be

the actual enemy we see in game. I added the enemy 2 sprite, a create event for the

movement and shooting of my enemy 2, an alarm 0 and alarm 1 event, a step event and 2

collision events, one for each of my players weapons. In the create event I added the code;

///movement and shoot alarm

Hspeed =-8

///shoot alarm

Alarm [0] = 20;

///move alarm

Alarm [1] = 20;

In my alarm 1 I added the code;

///movement

Randomize()

Vspeed = choose(0, -5, +5)

Alarm[1] = random_range(30,60)

The vspeed function means that the enemy can either mover up or down at a speed of 5 so

they will move around the screen. In the step event I added two pieces of code. One being

the leave screen code and the other being the limits code. The leave screen code was;

///leave screen

If x<=0

{

Instance_destroy

}

This means that when the enemy leaves the left side of the screen it will be automatically

destroyed. In the limits the code was;

///limits

If y<=32

{

Y=32;

If y>=544

{

Y=544;

}

This means that the enemy will not be able to go off of the top or the bottom of the screen.

Finally in the collision event with the player missile I added the code;

///shot by player

Instance_change(explosion1, true)

///increase score

Global.points +=5;

This means that when the enemy 2 is destroyed then it will change to the explosion and will

disappear off screen, also global.points +=5; means that when you destroy this enemy you

get an additional 5 points added to your total score. Next I created the enemy_lazer2 object

which I added a create event, a step event and a collision event with my player. In the

create event I added the code;

If instance_exists(player_1)

{

Hspeed = 20

}

Audio_play_sound(pew_sound, 1, false);

This means that the enemy_lazer2 moves towards my player at a speed of 20 and also when

shot the enemy_lazer2 makes a sound. In my step event I added the code;

If x>=room_width

{

Instance_destroy()

}

This means that if the enemy_lazer2 object leaves the room then it will be destroyed. Next I

added a code to the collision event which was;

Instance_destroy()

Which means that if the enemy_lazer2 collides with the player then the lazer is destroyed.

To make this work with our damage system we had to create a collision with the

enemy_lazer2 in our player_1 object. In the collsion I added the code;

///hit

Global.shield -=25

This means that when my player object is hit by the enemy_lazer2 it loses 25 health.

Player

score and

health

Enemy 2 Group of 3

enemy1s

After doing this I had basically finished my game however I went back to it and added a title

screen for my game. I did this by creating a second room. My title screen would link to the

actual game room and that is how the game would start.

The only thing left for me to do was to do final testing to make sure everything worked well

and that I was happy with the final product. After playing my game for a while I decide I

wanted to make it harder by mking my enemy 2 spawn quicker but also by making my

enemy 1 and 2 shoot and move faster. This mad my game a lot more challenging and a lot

more fun.

After playing my game for a while decided that my second missile the rocket was too

powerful and made my game too easy. I want to put a timer on it so it could only be used

once every 5 seconds however I never got to doing it and it may be something I add in the

future if I ever come back to this game. I am happy with the way my game turned out as this

is the way I pictured it in my planning, I made my sprites 128x128 and 64x64 so I could add

more detail and make my sprites a lot more detailed.