For my next Flash game, I plan on making a vertical shooter/shoot em up game. My idea for the game is pretty simple, with an interesting art style, but pretty typical in game play and features. However, one thing I have always wondered about, is how exactly do space shooters handle the enemy waves? Each unit generally has its own statistics that are static and generally attack in the same way, but the individual movement patterns and timing changes from level to level.

I was wondering, from peoples experience/thoughts how do games handle the waves of enemies exactly? Something like a "timeline" for each level, that places enemy emitters at certain locations at certain times (or events) with given parameters to adjust the movement of the emitted enemies? Because thats the best that I can come up with, unless someone has a better idea!

Thanks

I'm working on something similar at the moment, so I'll give you an overview of what I'm doing so far. Hopefully it will help or give you some ideas. My level files are Lua scripts that get loaded and run by the game. The level script looks something like this:


function run()
setup()
wave1()
boss()
wait("all_enemies_dead")
local script2 = script("script2")
wait("script_finished", script2)
end

local function setup()
-- do some level specific setup stuff
background{ type="scrolling", image="background0" }
end

local wave1()
for i=1,10 do
spawn{
type="Enemy0",
path="path0",
... -- other args
}
wait("milli", 400)
end
end

local boss()
spawn { "boss0", x = 0, y = 0 }
end




When the wait() function is called, the script will halt until the condition specified is met. The script is entered by calling the run() function. Wave 1 will spawn 10 Enemy0 instances and wait 400 milliseconds between them. I've noticed you might want wait conditions other than time too. It might be useful to wait until all enemies have been killed (either by the player or from going off screen). That can be useful for boss fights, which typically last until either the player or boss is dead.

As you mentioned, each unit has its own behaviour and some properties that can be configured by the arguments passed to it when it's spawned (such as setting the path for it to follow).

In shmups, you'd often see the same enemy patterns come at you multiple times, so I have a way to start sub scripts (script2 above). This allows me to define waves that I can reuse multiple times. Sub scripts are the same thing as the main level script, and run in parallel with all other scripts (note: not actually concurrently, it's all single threaded. I loop over each active script and run it until it halts by issuing a wait command, The game will then only resume a script when its wait condition has been met).

You don't have to be using a scripting language either, the same concepts obviously apply if you load the data from XML or whatever you'd like to use.