Building Enemy Characters in Games

Building Enemy Characters in Games

Enemy characters are one of the most important parts of game development. Without enemies most games would feel empty and boring. Enemies create challenge excitement danger and action. They force the player to react think dodge attack and survive.

In Flutter web games using Flame Engine enemies can be created in many different ways. Some enemies move continuously. Some stay in one place. Some follow patterns. Others use artificial intelligence systems to react to the player.

Building enemies teaches many important game development skills. You learn movement systems collision detection attack systems timers animations health systems and game logic.

In this chapter you will learn how enemy characters work in different types of games. You will understand moving enemies in traffic games still enemies in endless runners and AI controlled enemies in fighting games.

Understanding Enemy Characters

An enemy is any game object that creates difficulty for the player. Enemies can attack the player block the path chase the player or create obstacles.

Every enemy usually has basic properties such as position speed health damage animation and behavior. Some games use simple enemies while others use advanced AI systems.

In Flame Engine enemies are often built as components. Each enemy updates itself every frame using the update method.

The game loop constantly updates enemy positions animations attacks and logic. This makes enemies feel alive.

Most enemy systems include:

Some enemies are simple. For example an obstacle in a runner game may only move left. Other enemies are complex and can jump attack block or react to the player.

Understanding enemy logic is important because enemies control the difficulty and pacing of the game. 

class Enemy {
  double x = 800
  double y = 300

  double speed = 4

  void update() {
    x -= speed
  }
}

This is a simple enemy example. The enemy continuously moves left every frame.

Even simple enemy systems can create fun gameplay when combined with player movement and collision systems.

Moving Enemies in Traffic Rush Games

Traffic games are one of the best examples for learning moving enemy systems. In games like Traffic Rush or highway racing games enemy vehicles constantly move toward the player.

The player usually controls a car that dodges incoming traffic. The enemy vehicles are the traffic cars. Their job is to block lanes and create danger.

Traffic enemies are normally simple because they move in straight lines. However when many cars appear together gameplay becomes intense and exciting.

In a traffic game enemies are often spawned outside the screen. Then they move downward or toward the player. Once they leave the screen they are removed.

The movement speed can increase over time to make the game harder.

Traffic enemies also teach lane systems. Instead of moving freely cars often stay inside fixed lanes.

For example a game may have three road lanes. Enemy cars randomly appear in one of those lanes. 

class TrafficEnemy {
  double x
  double y = -100

  double speed = 6

  TrafficEnemy(this.x)

  void update() {
    y += speed
  }
}

In this example the enemy car starts above the screen and moves downward.

The game can create multiple enemies using a list. 

List<TrafficEnemy> enemies = []

void spawnEnemy() {
  List<double> lanes = [100, 220, 340]

  double randomLane = lanes.random()

  enemies.add(TrafficEnemy(randomLane))
}

Every frame the game updates all enemy vehicles. 

void updateEnemies() {
  for (var enemy in enemies) {
    enemy.update()
  }
}

Traffic enemy systems become more advanced when adding lane changes acceleration collisions and different vehicle types.

Some traffic enemies may move slowly while trucks move heavily and take more space. Sports cars may move faster.

Enemy variety makes games more interesting because players must react differently to each obstacle.

Traffic enemies also work well for teaching spawn timing. If enemies appear too often the game becomes unfair. If enemies appear too slowly the game becomes boring.

A balanced enemy spawn system is important for creating good gameplay flow.

Traffic games are excellent practice for learning enemy movement because the systems are simple but effective.

Still Obstacles in Traffic Rush

Endless runner games like Traffic Rush often use still obstacles that create movement illusion. In these games obstacles often appear still while the world moves around them.

This creates movement illusion. The player character stays mostly in one place while obstacles move toward the player.

The enemies in Traffic Rush can be parked cars rocks road cones or spikes. These enemies do not need complicated AI systems. Their job is simply to move across the screen and create obstacles.

Since the player is constantly moving forward automatically the enemies only need horizontal or vertical movement depending on the road direction.

The simplicity of this system makes endless runner games fast and smooth for web browsers.

Traffic obstacles are often spawned randomly after a timer delay. This keeps gameplay unpredictable. 

class RoadObstacle {
  double x = 900
  double y = 320

  double speed = 8

  void update() {
    x -= speed
  }
}

Every frame the obstacle moves across the screen.

The player must dodge or change lanes before collision happens.

The enemy itself does not attack or think. The challenge comes from timing and speed.

Traffic Rush style obstacles are powerful examples of simple design. Even basic movement can create addictive gameplay.

Different enemy types can also be added. Some enemies stay on the road while others might move between lanes. 

class MovingObstacle {
  double x = 900
  double y = 220

  double speed = 10

  void update() {
    x -= speed
  }
}

Moving obstacles force the player to react differently. The player may need to time their lane change perfectly.

Traffic style enemy systems are useful for learning:

Many beginners start with endless runner obstacles because they are easier to build than advanced AI enemies.

Even though the enemies are simple they still create excitement because the player must survive continuously.

AI Controlled Enemy in Combat Games

Fighting games use some of the most advanced enemy systems in gaming. In a 2D fighting game the enemy must react intelligently to the player.

This type of system is called artificial intelligence or AI.

AI enemies are different from simple moving enemies because they make decisions. They can walk attack block jump retreat or react depending on player actions.

Fighting game AI usually depends on states. A state controls what the enemy is currently doing.

Common AI states include:

The AI constantly checks player distance and game conditions before choosing an action.

For example if the player is far away the enemy walks forward. If the player is close the enemy attacks. 

class FighterEnemy {
  double x = 500
  double speed = 2

  String state = "idle"

  void update(double playerX) {

    double distance = playerX - x

    if (distance.abs() > 100) {
      state = "walk"

      if (distance > 0) {
        x += speed
      } else {
        x -= speed
      }

    } else {
      state = "attack"
    }
  }
}

In this example the enemy checks the distance between itself and the player.

If the player is far away the enemy walks closer. If the player becomes close enough the enemy attacks.

Fighting game AI becomes more advanced with timers and random decisions.

Without randomness enemies feel robotic and predictable.

Some AI systems randomly choose between punch kick jump or block. 

import 'dart:math'

Random random = Random()

void chooseAttack() {

  int move = random.nextInt(3)

  if (move == 0) {
    print("Punch")
  }

  if (move == 1) {
    print("Kick")
  }

  if (move == 2) {
    print("Jump Attack")
  }
}

AI controlled enemies also use animations. Different animations play depending on the current state.

Walking animations play while moving. Attack animations play during punches or kicks. Damage animations play when hit.

This combination of logic and animation makes the enemy feel intelligent and alive.

Advanced fighting AI systems may even learn player behavior. Some enemies become aggressive if the player blocks too much. Others retreat when health becomes low.

Building AI enemies teaches important programming concepts such as:

Fighting game enemies are difficult to build but extremely rewarding because they create deep gameplay experiences.

AI enemies make games feel dynamic because the enemy reacts differently every match.

Combining Enemy Systems

Most modern games combine multiple enemy systems together. A single game may include moving enemies flying enemies shooting enemies and AI controlled enemies at the same time.

For example a platform game may have:

Each enemy type creates a different challenge for the player.

Building good enemies is not only about coding. It is also about game design. The enemy should match the style and speed of the game.

Fast games need fast enemies. Strategy games need intelligent enemies. Puzzle games may use enemies that move in patterns.

Enemy balance is also important. If enemies are too easy the game becomes boring. If enemies are too difficult players may quit.

Good enemy design slowly increases challenge as the player improves.

Many developers begin with simple enemies and slowly add more features over time.

This approach keeps development easier and helps avoid bugs.

Conclusion

Enemy characters are one of the core parts of game development. They create challenge excitement and gameplay depth.

Traffic games use moving enemy vehicles that block the player path. Endless runner games use simple obstacle enemies that create timing challenges. Fighting games use advanced AI systems that react intelligently to player actions.

By learning enemy systems you also learn movement logic AI behavior collision handling animations timers and combat mechanics.

Simple enemies are often enough to create fun gameplay. As your skills improve you can build smarter and more advanced enemy systems.

In the next chapter you will learn collision detection which allows enemies and players to interact physically inside the game world.

← Previous Chapter Next Chapter 13 →