Gamasutra: The Art & Business of Making Gamesspacer
View All     RSS
October 22, 2014
arrowPress Releases
October 22, 2014
PR Newswire
View All
View All     Submit Event

If you enjoy reading this site, you might also want to check out these UBM Tech sites:

Build a Bad Guy Workshop - Designing enemies for retro games
by Garret Bright on 04/22/14 03:22:00 pm   Featured Blogs

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.


I recently played through a ton of NES and SNES games and took some notes. As designers, we tend to hear about how a solid level design makes or breaks a game. This is true, but we've also had our share of rough times building levels for our games and no matter what techniques we use, the levels still feel flat and not quite on par with our favorite inspirational levels from other games. The X factor here, I believe, are the Enemies.

I've put together a list of attributes that you can mix and match to create enemies in games. I include examples with each attribute. The examples I use are common and well known, but most great retro classics and neo-retro games have enemies that can serve as great examples. Most well-designed enemies are made up of multiple attributes, and use triggers to switch between conflicting attributes. I'll explain more about tiggers after the list.

You may notice that multiple items on this list could be simplified into more root behavior. Wavers (move like a sign wave) and Floaters (can fly/float/levitate) are essentially the same thing, where the only variable that's different is their Up and Down movement. I chose to build the list this way as an attempt to relate the attributes in a mentally-visual manner. My other objective was to have a list where a designer could effectively choose a few random attributes and see if they can design an enemy out of them. This is meant to be a resource library for enemy behavior.

I also want to mention that I consider projectiles (ranged weapons like bullets and arrows) to be 'enemies' and can be designed as enemies, even though they're not sentient. This is also true for environmental hazards like spikes, swinging blades, and stuff that tries to squish you.

Finally, these attributes were created while playing sidescroller and topdown retro games. Due to the nature of 2D vs 3D game environments and controls, many of these attributes don't translate well to 3D, while others do. Just keep in mind that these were written with 2D action games in mind.

Movement Attributes

Stationary The enemy does not move at all.
Walker The enemy walks or runs along the ground. Example: Super Mario's Goombas
Riser The enemy can increase its height (often, can rise from nothing). Examples: Super Mario's Piranha Plants and Castlevania's Mud Man
Ducker The enemy can reduce its height (including, melting into the floor). Example: Super Mario's Piranha Plants
Faller The enemy falls from the ceiling onto the ground. Usually these enemies are drops of something, like acid. Some games have slimes that do this.
Jumper The enemy can bounce or jump. (some jump forward, some jump straight up and down). Examples: Donkey Kong's Springs, Super Mario 2's Tweeter, Super Mario 2's Ninji
Floater The enemy can float, fly, or levitate. Example: Castlevania's Bats
Sticky The enemy sticks to walls and ceilings. Example: Super Mario 2's Spark
Waver The enemy floats in a sine wave pattern. Example: Castlevania's Medusa Head
Rotator The enemy rotates around a fixed point. Sometimes, the fixed point moves, and can move according to any movement attribute in this list. Also, the rotation direction may change. Example: Super Mario 3's Rotodisc, These jetpack enemeis from Sunsoft's Batman (notice that the point which they rotate around is the player)
Swinger The enemy swings from a fixed point. Example: Castlevania's swinging blades
Pacer The enemy changes direction in response to a trigger (like reaching the edge of a platform). Example: Super Mario's Red Koopas
Follower The enemy follows the player (Often used in top-down games). Example: Zelda 3's Hard Hat Beetles
Roamer The enemy changes direction completely randomly. Example: Legend of Zelda's Octoroks
Liner The enemy moves in a straight line directly to a spot on the screen. Forgot to record the enemies I saw doing this, but usually they move from one spot to another in straight lines, sometimes randomly, other times, trying to 'slice' through the player.
Teleporter The enemy can teleport from one location to another. Example: Zelda's Wizrobes
Dasher The enemy dashes in a direction, faster than its normal movement speed. Example: Zelda's Rope Snakes
Ponger The enemy ignores gravity and physics, and bounces off walls in straight lines. Example: Zelda 2's "Bubbles"
Geobound The enemy is physically stuck to the geometry of the level, sometimes appears as level geometry. Examples: Megaman's Spikes, Super Mario's Piranha Plants, CastleVania's White Dragon
Tethered The enemy is tethered to the level's geometry by a chain or a rope. Example: Super Mario's Chain Chomps
Swooper A floating enemy that swoops down, often returning to its original position, but not always. Example: Castlevania's Bats, Super Mario's Swoopers, Super Mario 3's Angry Sun
Mirror The enemy mirrors the movement patterns of the player. Sometimes, the enemy moves in the opposite direction as the player. Example: Zelda 3's Goriya

Quality Attributes

These attributes are inherent to the nature of the enemy.

GeoIgnore The enemy ignores the properties of the level's geometry and can pass through solid objects. Examples: Super Mario 3's Rotodisc, many flying enemies will ignore geometry as well.
Shielder Player attacks are nullified when hit from a specific direction or angle, or hit a specific spot on the enemy. Example: Zelda 2's Dark Nuts
Deflector Player's ranged attacks are reflected when the enemy is hit by them.
Secret spot The enemy has a specific spot where damage can only be taken when that spot is hit. The opposite of a Shielder. Many bosses have this attribute.
Invulnerable The enemy cannot be harmed or killed. Examples: Most are geometry based hazzards (spikes, mashing blocks, fire spouts), but also includes enemies like Super Mario 3's Boo Brothers.
Revivor The enemy is revived after dying. Examples: Castlevania's Skeletons, Super Mario's Dry Bones.
Regenerator The enemy's health is regenerated over time.
Secret Weakness The enemy is vulnerable to specific types of attacks (fire, magic, arrows, etc). Example: Zelda's Dodogno (weakness to bombs).
Hard to Hit These enemies are specifically hard to hit with by the player's normal attack ranges. They are aften very fast, or very tiny. Example: Zelda 2's Myu
Segmented These enemies are made up of smaller individual objects or enemies. Each individual segment can often be destroyed independently, and are often in snake-form - but not always. Example: Zelda's
Bumper These enemies act like pinball bumpers, pushing the player (or other objects) away quickly. Example: Zelda 3's Hard Hat Beetles
GeoMimic These enemies have properties of level geometry. Most commonly, the player can stand on them. Examples: Most enemies in Mario 2, Megaman X's Sigma, Castlevania's Catoblepas
Alarm An enemy or object that causes another enemy or object to react. I didn't record any specific examples, unfortunately.


These are abilities that enemies have inherently. They are non-movement related actions that enemies can take.

Grower The enemy can grow in size.
Shrinker The enemy can shrink in size.
Forcer The enemy can apply direct movement force to the player. I don't have any specific examples, but treadmills found in most games apply, as well as enemies who blow air at the player, causing them to move backwards.
Carrier The enemy can carry another enemy, an object, or the player. This one is a bit broad, but includes enemies that pick up the player, that 'eat' the player and spit it out again, or otherwise grab and restrict the movement of the player. Example: Zelda's WallMasters
Thrower The enemy can throw whatever it is holding (an object, the player, or another enemy). This is often combined with Carriers, but not always. Examples: Castlevania's Barrel throwing Skeletons, Super Mario 3's Buster Beetle
Emitter The enemy 'emits' another enemy or projectile. This type is very similar to the Thrower, and the differences are mostly semantic. The main difference being that throwers throw an object they've picked up or spawn with, while Emitters have an infinite supply of the things they can throw out. Examples: Super Mario 3's Bullet Bill Cannons, Super Mario's Lakitus, anything that has a gun, Gauntlet's enemy spawners.
Splitter The enemy can split into multiple other enemies while destroying itself. Examples: Rogue Legacy's Slimes, Legend of Zelda's Vire and Biri.
Cloner The enemy can duplicate itself. Often, the duplicate is an exact clone, but sometimes, the duplicate is very slightly modified (such as having reduced health, or being faster). The enemy that does the cloning is not destroyed. Example: Zelda's Ghini
Morpher The enemy morphs into another enemy type. Sometimes, this is temporary, and sometimes, the enemy will morph into multiple other types of enemies. Unfortunately, I didn't log an example of this.
Sapper The enemy can cause the player's stats to be modified (slower speed, reduced or eliminated jump, inability to attack, etc). These effects can be either permanent or temporary.
Latcher Like a Sapper, the enemy can drain the player's stats and abilities, but does so by latching on to the player. Example: Mario 3's Mini-Goombas, Zelda's Like-Likes.
Hider The enemy can hide from the player. Typically, the enemy is hidden until the player comes within a set distance, or the inverse where the enemy hides once the player comes too close. Example: Mario's Piranha Plants.
Switcher The enemy can toggle between various attributes, such as being stationary and invincible and switching to being a pacer and vulnerable. Example: Mario's Boo Brothers, Zelda's Peahats.
Exploder The enemy can destroy itself and cause splash damage. Example: Proximity Mines found in many games, Mario's Bo-Bombs
Interactor The enemy can interact with scripted objects, such as levers or buttons.
Charger The enemy will pause it's behavior between switching to another behavior Example: Castlevania's Wolves (Who pause a moment and lunge towards the player)


Most quality enemies are actually a combination of multiple attributes.

Here are some examples:

  • Zelda 2's Myus are a combination of: Hard to Hit + Bouncer + Roamer.
  • Castlevania's Medusa Heads: Waver + GeoIgnore.
  • Mario 2's Tweeters: Bouncer + GeoMimic
  • Zelda 1's Wizrobes: Liner + Teleporter + Emitter.
  • Zelda 1's Patra: Segmented + Roamer + Hard to Hit
  • Mario 3's Sledge Bros.: Roamer + Jumper + Sapper (Player's ability to act)

Trigger Attributes

Triggers are events and game states that occur that can change an enemy's behavior and attributes on the fly. For example, most enemies with the Swooper movement don't perform this movement until they are close to the player. Another example, Mario's Boo Brothers Follower movement behavior is triggers when the player looks away from it, and the stationary movement behavior is triggered when the player looks towards it.

I didn't start taking notes on triggers until most of the way through my game-a-thon, but here's what I did take notes of. Anything you can contribute to this would be helpful.

  • Is hit by player
  • Hits player
  • Timer (After X seconds, change behavior - this is most typical of bosses)
  • Follows another action it previously performed (Example: After the enemy attacks, it dashes backwards)
  • Proximity to the player or an object
  • Random (Enemies randomly choose their next behavior or set of attributes in their AI)
  • The player has direct line of sight to the enemy
  • The player does not have direct line of sight to the enemy.


  • Super Mario's Piranha Plants are a combination of: Hider + Riser + Ducker + Emitter(for the ones that shoot fireballs) + [Trigger - Player Proximity : Hider].
  • Castlevania IV's Golem Boss: Emitter/Thrower + Walker + Jumper + [Trigger - Hit by player : Shrinker]
  • Zelda 3's Buzz Blob: Roamer + [Trigger - Random : Invincible + [Trigger - Hit By Player : Sapper]]


Finally, here's a list of variables that can be used to throw some variation in your enemies. You may have two enemies that fit the exact same attributes, but perform differently - here are some ideas on how to do that. This isn't a complete list, but made to get some juices flowing.

  • Movement Speed - any movement attribute can be modified to alter the enemy's difficulty or interest by changing the speed which they move. Consider the slow moving Boo Brothers and how different the players interaction with them would be if they moved three times as fast.
  • Jump Height
  • Dash Length - does the enemy dash in short bursts, or all the way across the screen?
  • Attack Range
  • Splash damage radius
  • Enemy Size


Just for fun, I made a few enemy ideas using random attributes from these lists. Here are a few I came up with:

Trigger - Player Proximity : Dasher. Enemy behavior: The enemy dashes away from the player whenever it gets close, forcing the player to push it up against a wall or use ranged weapons. (This is the behavior of some Skeleton Enemies in Link to the Past).

Waver + Pacer + Shielder. Enemy behavior: The enemy travels across the screen in a sign wave, but can only be hit from behind. At the edge of the screen, the enemy turns around.

Faller + Exploder. Enemy behavior: Falls from the ceiling, and explodes when it hits the ground.

Carrier + Exploder + [Trigger - Player does not have direct line of sight : Dasher]. Enemy behavior: Dashes towards the player whenever its back is turned, grabs the player and explodes while holding it.

So this is my Build a Bad Guy Workshop. I didn't mention the Megaman games in the examples often. While Nintendo has made some fantastic platformers (and now after reading this list, you can see why they're so fantastic - they pioneered enemy behavior), the Megaman games really excel at using creative enemies. For fun, play through any of the levels of any of the Megaman games (or just watch a Let's Play) and see if you can rebuild the enemies using the attributes on this list.

Related Jobs

DeNA Studios Canada
DeNA Studios Canada — Vancouver, British Columbia, Canada

Analytical Game Designer
University of Texas at Dallas
University of Texas at Dallas — Richardson, Texas, United States

Assistant/Associate Prof of Game Studies
Avalanche Studios
Avalanche Studios — New York, New York, United States

UI Artist/Designer
Bohemia Interactive Simulations
Bohemia Interactive Simulations — ORLANDO, Florida, United States

Game Designer


Michele Pirovano
profile image
Hello Garret, thank you for the article, it was an interesting read! I too have been thinking about identifying and organizing enemy patterns in 2D action games, especially for games similiar to The Legend of Zelda and Castlevania, where each enemy requires a specific tactic, but I've never written down my ideas.

I've been thinking about it as I wanted to try using evolutionary algorithms to generate enemies, so I need to identify their 'building blocks'. I think your tables are a good start and lists a large amount of the enemies, even if a bit rough, as I think some of them are just instances of the same 'enemy trait' (example: rising and ducking may just be special cases of linear movement). Some of your traits are also just extremes of variables (such as the 'hard to it' quality), which could be better explained as emergent consequences, as they would not need a specific implementation (to make an enemy hard to it, you would just raise its speed).

If I were you, I'd try to get to the bare bones and I'd do so by considering the possible implementation of those behaviours, I think the relationships will be clearer then (I know it may not be your intention, but I guess it could be a likely evolution).

I'll add some more meat to the fire, and I'd advise you to play another more recent game of the genre: The Binding of Isaac.
- I'd add 'charging' as an ability, to account for all the enemies that charge an ability before triggering it (such as jumping wolves in Castlevania)
- 'Mirror', will mirror the movement of the player (found in Zelda and Isaac)

I'll keep thinking about this... in the meanwhile, good job!

Garret Bright
profile image
At one point, I did boil the list down into more root based building blocks, but I found that most of the traits could be boiled toooooo far. For example, consider:

Mover - The enemy translates on the X and Y axis, often at different speeds on each axis.

This attribute is the root of all movement attributes, where all movement patterns are just the speed and direction being changed over time.

I decided not to boil down too far because I wanted a higher-level concept that designers could relate to. A Waver is the same as a Liner + Pacer (moves horizontally from one point to another at a constant speed, and paces vertically), but all three of these individual concepts invoke specific mental pictures.

I think that if I were to write some algorithm for use in a game engine that allows the designer to build an enemy with a set of flags, I would definitely try to boil everything down into a hierarchy of some sort in the code. I'm no where near advanced enough of a programmer to figure this out tho.

Your two additions are great, and I'll add them. Note that the wolf behavior is:
Pacer + [Trigger : Player Proximity : become Stationary] + [Trigger : Follow Stationary Action : Bouncer]. I'd definitely want to add Charger though the attribute list separately even though that behavior can already be made up by the smaller blocks.

Matthew Dorry
profile image
To touch upon the 'x-' and 'y-axis' issue further, in accordance with what you said, speaking in those terms would actually fail to communicate anything of meaning or conceptual significance. It would be like explaining what a rose is by only talking about what happens on an atomic level. It might be a fundamental, structural part of reality, but it isn't the reality itself.

I do have to scratch one little itsy-bitsy terminological itch, though: I'm not a big fan of the word 'retro,' and it's my great hope that we all stop using the word for games from the 80s and 90s. They are old-school, yes, but 'retro' would better describe a game made today along the same aesthetic values as old-school games. It would be 'retro' in the sense that it would be "looking back" (hence, the use of 'retro') upon the old-school in a nostalgic sense.

As another example, we've seen the recent resurgence of the hi-top fade hairstyles. This resurgence can be called retro as an attribute of a person in the present calling upon styles of the past, but Will Smith and Jazzy Jeff weren't retro in their time. At the time of "Fresh Prince," they were current.

Welp, I dealt with my OCD for the day. Enjoy yours! The article is otherwise a great one with a lot of practical use. It's going near the top of my favorites list for game design.

Stephen Horn
profile image
This is a really cool list, thanks for putting it together!

Resident Evil 4 has many examples of enemies that are "morphers", triggered on being hit in particular areas.

Megaman X also has several interesting interesting enemies which may or may not be of the morpher variety. I'm specifically thinking of areas where you can get into one of the larger walker bots. If you skip the walker, enemies later on that would have been walkers instead spawn as an entity outside of their walker, which will trigger on player proximity to try and enter their walker. They can be killed before that, though, at which point you can steal their walker. A great little detail.

Metal Gear Solid has cameras which act to alarm NPCs, and of course the NPCs alarm each other. In the more traditional platformer sense, Megaman X7 used the idea of security cameras in one particular level that, if memory serves, was a disabled power plant.

One of Storm Eagle's abilities from Megaman X1 seems like "liner" behavior, when he enters the attack pattern of flying off screen and then diving in diagonal lines from the top of the screen. If that seems too "swooper", an even better example is Rangda Bangda, the face boss from Sigma's lair, stage 2, in the same game. When Rangda Bangda's eyes turn blue or red, they use classic Liner behavior as they move in a straight line towards the player (red are specifically Liner + Emitter, blue are just Liners).

Edit: Hopping outside of platformers again, Chrono Trigger used several places where an enemy that would trigger on proximity to the player would run over and alarm another enemy, triggering patrol behaviors and/or changes to the enemy's parameters. Specifically, in the Denadoro Mountains, Bellbirds would wake up Goblins, turning them into Ogans (though Lucca's fire abilities could burn the hammers and change them back into much-weaker Goblins).

Garret Bright
profile image
These are some excellent examples! The Megaman series doesn't get enough love when it comes to how well done the enemies are, so I especially like that you grabbed examples from those games.

Chrono Trigger is another game where I don't hear much about enemy and boss design, but they really are great enemies, especially for a jRPG. Almost every enemy has some special gimmick to it.

Maybe my next project will be a "Turn Based Combat Workshop."

Nathan Tompkins
profile image
Cool idea! I want to add to this handy and timeless list a different list I have dwelt on for some time, also inspired by Megaman, as well as Mike Tyson's Punch Out (and more recently, Demon's Souls, Ninja Gaiden, No More Heroes, etc).
The is a list of boss difficulty scalar attributes, and the theory is that all fun "retro" bosses have a few abstract attributes that can be tweaked pretty easily to adjust the difficulty of whatever boss design you have.

- Number of different attack moves/patterns (with each different move possibility, they become exponentially more difficult)
- Amount of time you have between a "tell" and the move. (For example a boss that raises his eyebrows before a devastating dashing strike.)
- How much damage you take for getting hit (or, how many chances you have to fail to react to a tell)
- How much life the boss has (or, how many repetitions of an attack pattern you must withstand to win)

This is a little more abstract than the tools you've listed out, but I believe these principles are good to keep in mind when designing rewarding retro boss battles.

Garret Bright
profile image
This has given me an idea... Abilities themselves would have attributes.

From your post, I'll start a list here:

- Telegraphed (The enemy telegraphs this ability before using it)
- Telegraph Time (The amount of time the telegraph is visible)
- Charged (would replace Charger as an ability, and become an attribute of an ability)
- Ability Speed (How fast the ability is performed once the action starts)
- Ability Strength (How much damage is dealt, how many clones are made, etc)
- Cost (How much Energy/MP/HP/Stamina the ability uses)
- Range (How far in distance the ability extends)

Thinking about it, there's not much of a difference between 'telegraphing' and 'charging' an ability. Perhaps, abilities scale in strength depending on how long the charge was.

I'll let my brain rattle around a bit to see if i can think of more. I'm welcome to hear any additions or thoughts on this.

Nathan Tompkins
profile image
Sounds like a separate article! I think both viewpoints are useful, because listing out the different abilities gives you a nice toolkit to design interesting and varied enemy behavior, while applying attributes to each ability (for example, duration), is a handy way to tweak difficulty once you've decided how your enemies will behave.