In over 9 years of web game development I’d never used a third party framework until recently, preferring to code everything up from scratch. Both Flixel and FlashPunk had caught my eye though and for the past year or so I’d been meaning to try one or the other.

Well, a few months ago the opportunity presented itself. Hasbro hired us to develop a multi-world game to promote their new Kre-o range of toys and I decided it was the perfect project to test these frameworks with. Read the rest of this entry »

I had an interesting conversation with one of my pupils over the weekend about whether Flash games development was commercially worth the effort.  His concern was that while he wanted to learn game development for personal reasons, he felt that commercial web design might be a better direction to focus in as it would be easier to get a job, or start a successful business in that field.

My answer was quite simple – there are thousands of very talented web designers out there, and very few good games developers!  Add to that the fact that casual gaming is definitely on the rise, and there are more and more posts on the freelance sites looking for developers every month and it’s clear that this is a growing industry and a better one to be involved in than web design in my opinion.  And I’d like to think that my opinion counts on this matter, since I’ve been a commercial web designer and Flash games developer for the past 8 years!

Anyway, we discussed several different approaches to making an income with Flash game development, many of which my pupil hadn’t considered, so here they are in the hope that more people find inspiration…

6 ways to monetize Flash games development (without getting a job!)

Developing games for clients might be the most obvious way of earning money as a developer, but it’s surprising how few companies offer the service. I’ve been developing games for over 8 years now, and I’m constantly asked to work on new projects. There are lots of companies out there ready and waiting to pay you money to design and develop games for their marketing campaigns.

If you don’t want the obligation and deadlines of working for clients, sponsorship mighht suit you better. This allows you to develop a game at your own pace, and once completed your sponsor pays you to embed their branding and links into the game. The amount you’ll earn will vary, depending on the company which is sponsoring you, and the quality of the game.

Taking it one step further, you can monetise your own games without needing a client or a sponsor. Networks such as Mochiads allow you to embed adverts into your games, and publish your games on their network which gets you both revenue and exposure at the same time.

You can also monetise your games by simply hosting them yourself, and displaying adverts on the same page. Banner adverts, Adsense blocks or affiliate promotions are all viable ways of monetising the traffic that a good Flash game will generate.

A very recent, and rapidly growing technology allows for in game currencies. While this is quite new there are already 2 networks offering the service and I’m sure this will grow tremendously in the coming months and years.

Finally, perhaps the most obvious, and certainly the most glamorous way to capitalize on the success of a good Flash game is to release a commercial version. Whether it’s a downloadable PC game or a port to an entirely new platform, such as the Nintendo DS, the Xbox Live network or the iPhone, a well designed unique game with the right marketing can be a real success, and open the doors into the mainstream gaming industry.

So there you go, six different ways to generate an income from your Flash games development.  In fact, why not start right now.  You could take the Flash Asteroids Tutorial I posted recently, modify that with your own ideas and pop it on your own website with some Adsense ads! Or how about grabbing some Flash Games source code, using some of what you’ve learned here to add new levels, change the graphics and put your own features in and submit them to Mochiads?  The opportunities are all there, you just need to pick an idea and run with it!

I wanted to write a real quick post today about the basic methodology of developing Flash games.  I’ve had a couple of people email me recently after filling in the survey about whether the Flash Games Classroom course will cover subjects like design, planning and asset management and the answer is yes it will!  In this post today though I just want to give a really brief into and explain why just sitting down at Flash and starting to code isn’t a great idea!

A good developer needs to be competent in Flash and Actionscript with solid programming practices, graphical skills, audio skills, a methodical and analytical approach, and the patience of a saint. Here is a guide to how the average developer tackles a games project. Video games are complex beasts. Even a game as simple as Pacman has quite a number of routines, such as controlling the ghosts, taking user input, checking collisions, keeping score, and generating levels, not to mention non-game screens and functions like pre-loaders and splash screens.For this reason, a methodical approach to game development is essential, otherwise the project becomes chaotic, over budget and a nightmare to work on.

The first thing to do is to draw up a solid design, away from Flash, and include complete lists of assets such as graphics and audio. Only then can you begin to develop the game in Flash. The first step once the design is completed it to create a mock-up – an outline demo in Flash using placeholder graphics, which can be used to test and develop the game logic. Once that is nearing completion you can begin to start adding graphical assets and audio. It’s a good idea to leave out all extras at this stage however. Things like splash screens and mid-level animations can slow testing down considerably, so leave them for the beta version.

Once the game reaches the later stages of development, when the game engine is mostly complete and tested, the final touches can be added. Introductions, help screens, preloaders and game over screens should all be added at this point. Leaving these until now means that testing is quicker, with less clicks, keypresses or waiting is required to restart levels or replay the game.

Then finally you’ll have a completed game, ready for final beta testing. Even though we started with a complex project, by breaking the design and development process down into bite sized chunks it became manageable. If you’re thinking of getting started in Flash game development then it’s a really good idea to edit an existing game or two first. Making changes to an existing game, such as adding new levels or power-ups, can be a far less daunting task than building a whole game from scratch. You can even take the source code for an existing game and turn it into a new game entirely. Then once you’ve gained more experience you’ll be in a better position to start building your own games from scratch.

This is a follow-up to the main tutorial from last week, How to write the arcade classic Asteroids in Flash, which originally appeared in the January edition of Flash and Flex Developer’s Magazine which can be found at FFDmag.com

In the tutorial we built a fully working, but rather basic version of Asteroids and today we’re going to add a couple of improvements.  I’ll leave features like power-ups and shields for a future post, but there is one gameplay tweak which is quit important.  In our original game we had no maximum speed on our spaceship, which meant that if the player held the thrust (UP) key down the ship would continue to accelerate ad infinitum.

That’s all well and good, but apart from looking glitchy one the ship starts travelling too far on screen each frame, if the ship is allowed to accelerate too much it could interfere with the collision detection, as it would effectively “jump” over an asteroid.  So today we’re going to fix that, and also add some simple audio so that it starts to feel like a real game.  Here’s an example of the updated game in action…

Setting a maximum speed

Our ship’s velocity is a vector, meaning it has both magnitude and direction.  That means we can’t simply check the current speed against a maximum speed and prevent further thrusting if it’s too high – that would prevent the player from turning, and thrusting away in a different direction.

There are several solutions to this, but since it’s such a simple game and we’re not interested in real-world simulations we’ll go with a nice simple one.  Effectively we’ll check both the X and Y velocity of the ship after the thrust key is hit, if the extra thrust would push either the X or Y velocity over the limit we won’t apply it!

This means our ship will have a higher maximum velocity if travelling diagonally on the screen than if it’s going straight up/down or left/right, but for our purposes that’s not much of an issue.

Coding the change

We’ll need one new class variable:

Then we need to make a change to the moveSpaceship() method.  Replace these lines:

1
2
3
4
5
if(thrust) {
shipDX += Math.sin(Math.PI*spaceship.rotation/180)*thrustAmt;
shipDY -= Math.cos(Math.PI*spaceship.rotation/180)*thrustAmt;
spaceship.gotoAndStop("thrust");
}

with this…

1
2
3
4
5
6
7
8
9
10
11
12
if(thrust) {
// Check if adding thrusting would exceed max speed, if not then thrust...
var tempDX:Number;
var tempDY:Number;
tempDX = shipDX;
tempDY = shipDY;
tempDX += Math.sin(Math.PI*spaceship.rotation/180)*thrustAmt;
tempDY -= Math.cos(Math.PI*spaceship.rotation/180)*thrustAmt;
if(tempDX < shipMaxSpeed) {
shipDX = tempDX;
}
if(tempDY < shipMaxSpeed) {      shipDY = tempDY;    }   spaceship.gotoAndStop("thrust"); }

As you can see, we’ve calculated the new thrust values for a pair of temporary variables, then we compare the new velocities based on these values, and only if they are below the maximums do we apply them to the actual ship velocities shipDX and shipDY.

Adding audio

No game is complete without sound effects, so take a look at a couple of ways of adding them to a game. I won’t go into detail here about using sound channels and transforms to allow for mute controls etc, that can be another post another time, for now let’s just get some simple sound effects into the game. First we’ll need some sounds. Flash will support Wav or MP3 format audio and there are loads of sites online where you can download free (or cheap) sound effects in those formats. If necessary you can trim or edit them using something like Audacity and then you want to import them into our FLA file. Go File > Import to Library and select all of the sounds you want to import. I’ve imported 4, one for the ship exploding, one for the ship firing, one for hitting an asteroid, and one for end of level/game.

The simplest way to add a sound is on the timeline.  Open up the ship movieclip and add a new level called audio.  Add a new keyframe (F6) on frame 3 (the same frame that the explosion animation starts) and on the properties panel, click on the Sound dropdown and select the sound you want to play when the ship explodes.  You’ll notice a waveform for the sound shown on the timeline, as shown below.

Adding sound to the timeline

Adding sound to the timeline

You can do the same thing in the messages movieclip to add the end of level, and end of game audio.

Now the asteroid getting hit, and the ship firing can’t be done in this way since they don’t have animations, but that’s good because it gives us a good reason for using Actionscript to play the audio.  Controlling sound with Actionscript is much more powerful than using the timeline as it gives loads of extra control, and allows us to do things dynamically (it’s also how we would add a mute or volume control to the game!)

First of all we need to right-click on each of the audio assets we intend to control in the library, check the “Export for Actionscript” setting and give them an appropriate class name:

Check Export for Actionscript and give it a class name

Check "Export for Actionscript" and give it a class name

To use simple sound we need to add one new import to our AS file:

1
import flash.media.Sound;

Then we need to declare a class variable for each sound we want to use:

1
2
private var thisExplode:Explode = new Explode();
private var thisShot:Shot = new Shot();

The type is whatever class name we gave that sound when we set the linkage (and is case sensitive!)

Then we simply use Sound.play() to play those sounds at the correct moment. So add this line to the fireBullet() method right after adding the bullet to the bullets array:

1
thisShot.play();

And add this line to the removeAsteroids() method, right after splicing the asteroids array:

1
thisExplode.play();

That’s all there is to it.  We now have basic, but fully working audio in our game!

As usual, comments or questions are very welcome.  I’ll come back to this again in a week or so and we’ll add some other gameplay features such as powerups!

(If you want to see the original Asteroids tutorial, and download the source files click here)

Those of you who read Flash and Flex Developer’s Magazine might have already read my Asteroids tutorial in the January edition.  If not, you can grab yourself a copy over at FFDmag.com

The tutorial shows you how to create a simple arcade game from scratch, based on the classic arcade hit Asteroids.  Rather than completely rehash the entire article here, what I wanted to do was back the article up with a little more info, show some of the setup in a more visual manner (with a short video) and then show how the game in the tutorial could be extended with extra features like audio, powerups and other game extensions.

In today’s post I’ll show you how to set up the Flash file, and go over how I designed and built the basic game.  Then I’ll follow up in a few days with a second post showing how to add extra functionality to the game, and get it to a level where it could be published online.  First of all, let’s take a look at the game… (note this is scaled down from full size of 800×600 px)

I’ve named it “Space Debris” but essentially it’s the same gameplay as the old Atari classic.  You move a small spaceship around the screen by rotating (cursors LEFT/RIGHT) thrusting (cursor UP) and firing bullets (X) in an attempt to destroy the asteroids.  Shoot a large asteroid and it becomes 2 smaller asteroids, they in turn become 2 yet smaller asteroids, and finally the smallest ones are removed when hit.  Clear the screen and you’ll have to face a larger, harder wave.

The player begins with 3 lives, they lose one if they crash into an asteroid, and the game is over when all lives are lost.  Pretty basic stuff right?

OK so the game will be written in a single class named Asteroids.as and we’ll also use a Flash file which will handle the intro/outro screens and hold our graphical assets etc.  In this video I’ll quickly show you how to set it up and then I’ll move on to actually coding the game, or simply click here to download all the source files.

Setting up the Asteroids game file

Writing the Asteroids game class

The following is taken from my article in Flash and Flex Developer’s Magazine January 2010 edition, reformatted slight for this blog but it is LONG!  I would highly recommend grabbing the FFDMag January edition and reading from that instead, which also includes full setup details for the Flash file!  Then just skip to the end of this post to grab the FLA and AS3 source files…

First create a new actionscript file and save it as Asteroids.as

Listing 1 (please download the AS files at the bottom of this page) shows the Asteroids class which extends MovieClip. It uses 4 imports, and has quite a number of class variables. Most of these are self explanatory such as lives or score. Some however need a little explanation.

We use 2 eponymous arrays to keep track of all the asteroids and bullets currently on screen, and we use a movieclip called gameField which will contain all the game objects (spaceship, asteroids, bullets).

The variable oldTime is used with our timer to calculate the new positions of each object on every frame, depending on their current speed and how long since the last frame.

The three booleans simply keep track of whether the ship is currently turning or thrusting, and then we have variables for all of the ship parameters, from how fast it rotates, to the maximum number of bullets it can fire.

Finally we declare 4 points, and another boolean. The points are the co-ordinates of the outer extremities of our ship and will be used when we write our collision detection function to see if the ship has crashed. The boolean simply tracks whether the game is currently playing (and the ship hasn’t already crashed!)

Beginning our game

You’ll notice that there is no constructor method. That is because we don’t want the game to start automatically, so instead we write a method called startGame() which we call frame 2 of our FLA file.

The startGame() method sets up our game by resetting variables such as level and score, creating new arrays to keep track of the asteroids and bullets, and creating our gameField movieclip which we move behind our control panel with the addChildIndex method.

We add 3 event listeners – one for ENTER_FRAME, which is our main game loop, and 2 for user input (KEY_DOWN and KEY_UP). We also call a method called addShip() which, as the name suggests, creates our ship object. We could also call nextLevel() from here to generate the first asteroid field, but instead we play the message movie clip, and add a listener which will call messageHandler() on each frame. The messageHandler() method in turn will call nextLevel() once the message “Get Ready…” has been shown on screen.

Main game loop

Asteroids in an action based game. Unlike a puzzle game or turn based game like Tic Tac Toe, or Sudoku, an action game has things happening all the time, on every frame, whether there is input from the user or not. To handle this we create a method called gameLoop() which is called every frame from the listener we declared above.

This gameLoop() method calculates the position of every object on screen, based on its velocity, and the time passed since the previous frame (see Time based animation post for more details). It does this by first getting the time in milliseconds since the game started and subtracting from that the time of the previous frame. This gives us the exact number of milliseconds since the last time the screen updated which is then passed to a number of methods to calculate the new positions of the ship, bullets and asteroids.

We also check for collisions (to see if an asteroid has been shot, or has crashed into the ship) and finally we update the text field for the score.

Game objects

We have 3 different types of game objects – our spaceship, the bullets it fires, and the asteroids. Each type of object has a method to create it, a method to move it (i.e. update its position on screen) and a method to remove it. Let’s look at each object type in turn.

Spaceship

Firstly the spaceship. This is what the user controls via keyboard inputs. It starts in the middle of the screen and there it remains until we give it some input. The addShip() method is very simple – it creates a new SpaceShip object, sets its position to the center of the screen, adds it as a child of the gameField object and sets the inGame variable to true.

The moveSpaceship() method is quite simple too, but involves just a little maths First it deals with the user input. If turnLeft or turnRight are true (set when the left/right cursor keys are pressed) then the rotation of the ship is either increased or decreased by the rotation speed.

If the thrust variable is set however there is a little more going on. We need to convert the thrust force into cartesian values for x and y. This is done with basic trigonometry If you think back to your trigonometry lessons from school you’ll remember that the x or y value can be found by using sine or cosine of the angle (rotation of the ship) multiplied by the hypotenuse (thrustAmt). We’re working in radians (rather than degrees) so we find the increase or decrease in x and y velocities like this:

1
2
shipDX += Math.sin(Math.PI*spaceship.rotation/180)*thrustAmt;
shipDY -= Math.cos(Math.PI*spaceship.rotation/180)*thrustAmt

Now that we know the velocities we can update the position of the ship by simply adding the new velocity values to the x and y co-ordinates of the ship. We also show frame 2 (the thrust frame) of the ship movie clip if thrusting, or frame 1 if not.

The last part of the moveSpaceship() method handles the edge of the screen. In Asteroids, the spaceship and asteroids “wrap” from one side of the screen to the other, and from top to bottom. To handle this we simply check to see if the ship’s position is outside of those boundaries, and if it is we wrap it to the opposite edge (with a little overlap of 20 pixels, roughly the width of the ship, which makes the transition look smooth!)

Removing the spaceship is actually handled by 2 methods – firstly we call explodeSpaceship() which sets inGame to false, moves the spaceship to the top of the gameField display list (to make sure it’s in front of the other graphics), and then plays the explode animation. We also take a life off at this point and update the lives field on the control panel.

An event listener is added which calls removeSpaceship() once the explode animation is completed. This removes the spaceship movie clip, then either calls addShip(), or if there are no lives remaining ends the game by playing the gameover frame in the messages clip.

Asteroids

At this point we have a spaceship flying around the screen, but that’s not much of a game on its own so lets add some asteroids! Again, we have methods to add, move, and remove, but we also have a method called nextLevel() which generates the entire asteroid field for the level.

Let’s begin with the addAsteroid() method. It accepts 3 parameters – asteroidType which is a string (big, medium or small) along with x and y co-ordinates. We declare a new MovieClip variable called newAsteroid, and depending on the asteroidType parameter we create a new big, medium or small asteroid object. We also give the new asteroid a random vertical and horizontal speed within certain limits (the smaller asteroids can move faster than the big ones!)

We then position the asteroid according to the x and y parameters, rotate it to a random angle and finally add it to both the asteroids array and the gameField movie clip.

Responsible for generating the asteroid field, and passing the parameters to addAsteroid is the nextLevel() method. It begins by incrementing the level variable (which we initially set to 0 in the startGame() method. We generate a number of asteroids, equal to the level number plus one so we open a for loop, and then create asteroids in random positions on the screen.

We don’t want asteroids to appear in the center (that’s where our ship is) or too close to the edges (otherwise they may instantly wrap which will cause a flicker) so we split the game field up into 4 quadrants. We randomly choose a quadrant, and then randomly generate a position within that quadrant to place the asteroid. That position, along with the size is passed to the addAsteroid() method to generate the asteroid field for the level.

Moving the asteroids is simpler than the ship since there is no user input to worry about, except that this time we loop through each asteroid in the asteroids array one by one. We again use the timeFrame parameter generated in gameLoop() but this time we simply move the asteroid based on its horizontal and vertical speed. We rotate it based on the difference between those 2 speeds (saves having to generate another random number, but keeps them all rotating differently) and we wrap at the edges just as we did with the spaceship.

While moving the asteroids is simpler than the spaceship, removing them is very slightly more complex. If it’s a small asteroid we can simply remove it, and increase the score. If it’s medium or large however we need to split it into 2 smaller asteroids. We do that by first checking the the type, and then calling addAsteroid() twice for the next size down. We also increase the score here, based on the size of asteroid hit, and finally we remove the asteroid both from the array and the game field.

At this point we also check the asteroids array to see if there are any remaining asteroids. If there are none then the level is over, and we play the messages clip from the “next level” frame, and add a listener which calls messageHandler() (and in turn the nextLevel() method) when the message finishes.

Bullets

Bullets are actually very simple since they don’t rotate, and they don’t wrap (we’ll remove them when they reach the edge of the screen). First we create a new bullet with the fireBullet() method which takes no parameters. It is called when the player hits the X key to shoot, and creates a new Bullet object. We calculate the new bullet’s velocity based on the current rotation of the ship in the same way we calculate the ship’s velocity. We then position the bullet just in front of the ship, add it to the gameField and the bullets array.

Moving the bullets is just like moving the asteroids in that we loop through the bullets array one by one. For each bullet we move it based on its velocity (multiplied by bulletSpeed) and we then check it against the edges of the gameField. Once the bullet goes beyond the edge of the screen we call removeBullet.

removeBullet() method accepts a single parameter, which is the index of the bullet in the bullets array. This method simply removes the bullet from the game field, and from the array.

Pulling it all together

OK so we now have a spaceship flying around the screen under the player’s control, we have asteroids floating through space, and we are able to shoot but there is one big element yet to code – the collision detection!

At the moment our spaceship is invincible, and our bullets pass right through the asteroids without making a dent. What we need is a final method added to our game loop which checks for collisions between the asteroids, and our ship and bullets.

So the checkColisions() method actually handles 2 different types of collision – asteroid/ship and asteroid/bullet. Let’s take a look at the ship collisions first.

First we check the inGame variable to ensure that the ship is still in play. If it is then we loop through the asteroids array and check each asteroid’s hit clip against each of the collision points on the ship using hitTestPoint with the shapeFlag parameter set to true (see collision detection box). The localToGlobal method is used to convert the collision points (which are relative to the ship) to global co-ordinates. If there is a match (i.e. if one of the collision points is within the boundary of an asteroid’s hit clip then there has been a crash and explodeSpaceship() is called.

For the bullet collisions we loop through the asteroids array, and for each asteroid we loop through the bullets array. Using hitTestPoint again, this time we simply check the bullet’s x and y co-ordinates against the asteroid’s hit clip. If there is a collision we call both removeAsteroid() and removeBullet(). We then break out of the inner for loop, using continue loopAsteroids; to prevent checking another bullet against the asteroid which has just been removed.

Finishing and running the game

The final methods, showScores(), restartGame(), keyIsDown() and keyIsUp() are self explanatory, and if you’ve followed the tutorial this far you should now have a simple but working game.

While this works as a great example for learning some of the fundamental principles of game development, and a few years ago it probably would have been enough to compete with many other Flash games on the web, these days players want something a little more refined.

{ End of magazine tutorial… }

Whew – I told you that was long!  OK, so rather than list all the actionscript here too I’ve put all the source files together in a zip which you can download here.

I really hope you enjoy tinkering with the game, and you learn a ton from it.  Please do give me some feedback, just leave a comment with any questions or suggestions and I will read them and resond.  Next week I’ll post a follow-up article which will extend the game, and audio and some other functionality, and basically turn it into a usable web game, so if you want to see specific features added do let me know!

In the meantime, have fun playing with it ;)

Download Flash Social Media Buttons
Download the Flash social media buttons components

One of the first things to understand when you’re looking to develop browser games is what game genres lend themselves favourably to the medium. Truth be told, these days Flash games can be made in just about any genre, but understanding the limitations of Flash allows us to see which genres are best suited to browser games.

Flash is slow. There, I said it. While the Flash engine has come on leaps and bounds in recent years, and Actionscript 3.0 can be written quite efficiently there is no getting away from the fact that Flash games are significantly restricted compared to games developed with other technologies, such as Java. Now of course there are many other advantages to Flash, so I’m not suggesting you should ditch Actionscript and start learning Java, but if you’re creating Flash games you need to be aware of exactly what you can and can’t accomplish!

Along with the lack of performance, the other big issue is 3D. While there are now real solutions to developing 3D content in Flash (technologies such as PaperVision – which I’ll cover in another post!) Flash is still essentially a 2 dimensional technology, so you’re not going to be creating the next GTA or Gran Turismo in Flash.

So if we don’t have speed, and we don’t really have 3D, what CAN we do in Flash? Well actually quite a lot, and so let’s look at some of the game genres where Flash really excels.

Puzzle Games

In 2007 Tetris was voted as the second best video game of all time in IGN, and has sold 70 million copies worldwide. I mention this because Tetris is a great example of the type of game Flash is superb at. In fact, there have been many ports of the game to Flash, and many derivative works already.

Puzzle games or “Brain games” using Nintendo’s parlance tend to be logic based, and can be extremely addictive and lots of fun, but they are also ideally suited to being written in Actionscript. They tend to have fairly simple 2D graphics without too many moving objects on screen at once. The gameplay is often “turn based” and unlike action games a momentary slowdown will usually go un-noticed by the player.

Word Games

Word games can usually be considered a sub-set of puzzle games, but I include them for a simple reason – they are hugely popular! In fact, word games such as scrabble, word searches, crosswords and countless other variations are among the most played games online. If you want your game to be played by millions, you could do a lot worse than choosing to create a word game!

Card/Casino Games

Another massively popular genre, card and casino games are again ideally suited to Flash. When coupled with a socket server, Flash is very capable of handling multiplayer games like Texas Hold’em poker with ease. Doubt the popularity of card and casino Flash games? The top poker game on Facebook, Zynga Texas Hold’em attracts 44 million players monthly!

2D and Retro Arcade Games

Here’s a genre after my own heart, and Flash is perfect for remakes of classic 80’s arcade games, platformers and shoot-em-ups, top-down racing games, shooting games, simple adventure games… in fact any style of 2D sprite based games that you would have found in the arcades in the 1980s and early 1990s can be created in Flash.

Looking for niche genres?

Of course there are loads of “hidden” gems, as the number of genres suitable for Flash games is seemingly never ending. Dress-up games and cooking games are popular with young girls, programming games like Light-Bot are popular with techies, Mah-jongg and Go games are hugely popular in Asia, and rhythm games are popular with just about anyone who’ll have a go!

As you can see there are no shortage of genres, and choosing what style of games to develop will depend on your reasons for creating games. If you’re developing commercially then your clients will usually have the final say on the styles of games you create, but if you’re developing for sponsorship deals, to distribute your games via networks such as Mochimedia, or for your own personal entertainment then use your imagination, who knows you might come up with a new genre of your own!

Just keep the limitations of the medium in mind, and learn to work within the constraints imposed by Flash rather than trying to fight them!