Plan your behavior

So I have introduced how to plan out simple AI behavior from my previous post – Cheating AI from Hardcourt – Plan it out – if you haven’t, read that one first before this.

Our next step would be writing the data charts into codes. It might look quite easy when you see the simple flow charts but remember that the AI must process this through out the game with a character’s lifespan.

What I’m about to share is simply a psuedo codish (partly actionscript syntax) of the AI’s logic. Eventually you can port it into which ever approach you are comfortable with, like OOP or the old school timeline.

Remember that this is my first published game where as I still used AS2 using prototypes and functions but I’ll discuss this in a little of close objective approach. First of we prepare a few world declarations & preparation in a quick manner.

Prepare the world

In the game world object or whichever the game’s entities reside, we’ll be having a calculateDistance method that pre-calculates distances of each of the characters then stores each of their enemies distance on an enemyDist container object.

// from the game world
 // called within the main loop
function calculateDistances() {
  // pre-calculate distances of:
  //   ball to char - store distance to the character's ballDist variable
  //   char to char - store all other character's (enemy's) distance to character's enemyDist container variable
}

The code below acts as base methods for all characters. This is primarily an advantage from inheritance whereas properties and methods of the base class is inherited by the class that extends it. Basically all the characters will be capable of methods such as moving (moveChar), getting the ball (getBall), shooting it (shoot) and punching their enemies (punch).

  // used to store the ball object also do determine if the we have the ball; set to null if we not
var myBall:Ball;
  // the distance of the ball from character in Vector2D (x, y)
var ballDist:Vector2D;
  // contains enemies distances
var enemyDist:Object;
  // assuming that 25 is the range where the character can punch it's enemies
var punchRange:Number = 25;
 
 // moves the character
function moveChar( xdir, ydir ) {
  //  xdir - move left (-1) or right (1)
  //  ydir - move up (-1) or down (1)
}
 
 // determines if we have the ball else if the ball is close & not owned (by enemy) then get it
function getBall():Object {
  //  use ballDist for the calculated distance;
  //  returns: ball object - if our char already has it
  // 	      null - if the ball is nowhere near
}
 
 // shoots the ball
function shoot() {
  // release the ball towards the ring
  // set myBall to null
}
 
 // attacks the enemy
 //  params: enemy:Object - the enemy instance to punch
function punch( enemy:BaseChar ):Boolean {
  //  returns: true - if successful hit
  //           false - else not
}

Note: for the Vector2D, some might be wondering what it is, well it is a class whose purpose is to calculate Vector operations in two dimensions.

Now we have prepared the initial methods, let’s go with the proposed coding of the flow charts.

Basic Behaviors

The AI controlled character behavior:

  // runs with the main loop for each AI character
function thinkAI(){
  var xdir = 0;
  var ydir = 0;
 
    // if we have the ball
  if ( getBall() ) {
      // then shoot it!!
    shoot();
    // if not
  }else {
      // get the direction of the ball
    xdir = ballDist.x ? ballDist.x / Math.abs( ballDist.x ) : 0;
    ydir = ballDist.y ? ballDist.y / Math.abs( ballDist.y ) : 0;
      // and move towards it
    moveChar( xdir, ydir );
  }
}

Basic Chart - Get & shoot

We used the method getBall() to determine if we have the ball or not, if so shoot it. Else, we get the distance from ballDist (which contains the distance in x & y values), have it’s polarity from it’s the absolute value and move towards it.

This is only the first chart (Basic Chart), our AI only considers that in the game world there is only the character himself and the ball, so whenever he gets the ball he shoots it immediately and repeats the process.

Expanding for more Interactions

What we do next is implement the second chart (Interactive Chart) and consider situations with the enemy and interact with it.

So improving the thinkAI() method:

function thinkAI() {
  var xdir = 0;
  var ydir = 0;
 
    // if we have the ball
  if ( getBall() ) {
      // then shoot it!!
    shoot();
    // if not,
  }else {
    var ball = GameWorld.ball;
    var dist:Vector2D;
      // check if another char has the ball, since definitely it isn't this char
    if ( ball.owner ) {
        // store the enemy who has the ball in a local var
      var targetEnemy = enemyDist[ ball.owner.id ];
        // this is the distance of the enemy char with respect to this char
      dist = targetEnemy.dist;
        // if this enemy is within punching range
      if ( dist.len < punchRange ) {
        punch( ball.owner );
          // no need to do the processes below...
        return;
      }
    } else {
      dist = ballDist;
    }
      // get the direction
    xdir = dist.x ? dist.x / Math.abs( dist.x ) : 0;
    ydir = dist.y ? dist.y / Math.abs( dist.y ) : 0;
      // and move towards it
    moveChar( xdir, ydir );
  }
}

Interactive Chart - Steal the ball

After determining that the ball is not in our character’s possession, we check if the ball is owned by another character. As it is owned, it certainly is not our character who has it as we already tested. So from the enemyDist container object (this has the pre-calculated distances of the character’s enemies) we get the enemies distance. See if the enemy is within stealing (ok, punching) range and punch if so, else move towards the enemy.

Now we have considered enemies too, if they have possession of the ball, our AI char simply goes after him and if he is within range we steal/punch.

Take note that when a character is punched he losses the ball so I also call punching stealing the ball.

Then we take this into the 2nd chart.

function thinkAI() {
  var xdir = 0;
  var ydir = 0;
 
    // if we have the ball
  if ( getBall() ) {
      // then shoot it!!
    shoot();
      // if not,
  } else {
    var ball = GameWorld.ball;
    var dist:Vector2D;
      // check if another char has the ball, since definitely it isn't this char
    if ( ball.owner ) {
        // store the enemy who has the ball in a local var
      var targetEnemy = enemyDist[ ball.owner.id ];
        // targetEnemy.dist is the distance of the enemy char with respect to this char
      dist = targetEnemy.dist;
        // if this enemy is within punching range
      if ( dist.len < punchRange ) {
        punch( ball.owner );
          // no need to do the processes below...
        return;
      }
    } else {
        // default the distance from the ball
      var dist = ballDist;
      var ds;
        // loop through enemies
      for ( c in enemyDist ) {
        ds = enemyDist[ c ].dist;
          // see if they are closer
        if ( ds.len < dist.len )
          dist = ds;
          // it seems that this enemy is already in range, no need to check the others
        if ( ds.len < punchRange )
          break;
      }
        // if this is not the ball distance then it could only be the enemy
      if ( dist != ballDist ) {
          // if this enemy is within punching range
        if ( dist.len < punchRange ) {
            // attack!!
          punch( ball.owner );
            // no need to do the processes below...
          return;
        }
      }
    }
      // get the direction
    xdir = dist.x ? dist.x / Math.abs( dist.x ) : 0;
    ydir = dist.y ? dist.y / Math.abs( dist.y ) : 0;
      // and move towards it
    moveChar( xdir, ydir );
  }
}

Interactive Chart 2 - Go offensive, attack!

What I added here is for our AI character to consider not only the ball itself and it’s possible owner, but also nearby enemies. Checking through all enemies and determining if they are close enough or within range, therefore stopping them with a punch.

You can also see clearly the advantage of pre-calculating the distances, as I used the enemy and ball distances enough to avoid recalculating them again and again when needed.

Now we have our competitive AI ready! Or not. Feeling like something is missing? Yes, its “difficulty!” Basically as you might have suspected that this AI behavior has the perfect reflex (well not so perfect really). It does what it has to depending on exact situations at the exact time on the next loop.

Example this:

Just at the same moment you grab the ball the enemy would instantly steal the ball or, simply saying, you can’t even run away, your character’s very change in position and angle is updated and read by the AI at the same time or yet exactly at the next frame therefore it knows where exactly you are same way the moment you move anywhere.

And another problem with the perfect reflex is same way we planned it, the moment the AI character grabs the ball he just shoots it at once.

For this problem, a good fix I did was based around with numbers. Yes, “numbers” will help with everything, you can imagine setting a level of intelligence for the AI and how much well it executes it’s task depends on the numbers assigned. But I’ll leave that to another post to discuss about it more…

What do you think? Play hardcourt now! to experience the AI in action.

Hardcourt

Working with AI is a real pain, but I say, it most likely depends on what your game needs, what you want it to do. Most developers who are new would quickly ask the magical word “how?” or “how to start?”. If you haven’t had experience or good experience with AI patterns and behaviors, hear me out on how I did it with this game.

With my first game, Hardcourt, it was also my first time to encounter programming (or should I say cheating) artificial intelligence (AI). I myself didn’t have proper educational background with AI patterns and behaviors else haven’t even read anything about it when I made that game (I still had dial-up before, so no online tutorials too). With the first build of Hardcourt there were no AI so no playing with CPU, it was just a 2 player on a single PC game. After some time I decided to make it into a much complete game and had been finalized as it is now. I’ve had received good reviews with how the AI performs. It can totally beat the players up (esp with quick play, hard mode).

AI was the most troubling part as I thought; I didn’t even have an idea where to begin with. Now let me share a little knowledge on how I have dealt with this so called “artificial intelligence” and cheated my way through it. This shall be some multi-part discussion on the step by step methods when I dealt with them.

Note: Starting here, we reference the character AI (which is the CPU controlled enemies) as our player or the primary character; hence the human player will be referenced as the enemy. So don’t confuse yourselves.

Charts:

Flow charts were the first logical programming I had; it can clearly display your problem’s logic through proper data flow. So basically, what I wanted was the AI to do all the same things that a human can and would do (just the common and usual behaviors):

1. go after the ball
2. shoot
3. steal the ball
4. go offensive (attack)

… it does look simple, but where do we start?

Basic Behaviors

First thing to do is look for actions which least require external forces/object interaction but executes the aim of the game.

These steps are primarily available for those “race to finish” games where the primary aim is achieved without requiring going after opponents. This would be good for certain sports games, racing, who-is-faster, etc games. For hardcourt, since the game is basketball, the primary aim is to shoot into the hoops. So that would include going after the ball and shooting the ball.

Basic Chart - Get, move shoot

To explain the chart through words:

1. See if our character has the ball or not,
2. if not, get the ball and check again if the ball was acquired (»1)
3. else if yes, shoot the ball,
4. then check if the ball was acquired again (»1)

It’s actually a very simple loop but provides the main action required to fulfill the game’s primary purpose. Upon testing this basic behavior, the character shall go after & get the ball, shoot, do get the ball again and repeat the process.

Expanding for more Interactions

The next step is to consider the external factors. This is where the character considers the status or actions of another character. It can either be to support allies or to go after enemies depending of certain conditions.

Case: What if the enemy has possession of the ball? – Then steal the ball.

Interactive Chart - Steal the ball

From this case after knowing that the ball is not in the character’s possession we have to determine where the ball specifically is.

1. So the enemy has the ball:
2. if so, we have to steal it
3. else if not, we just go after and get the ball.
4. Either way we loop again with checking if we have the ball’s possession.

So basically we determine the ball’s condition, our character doesn’t just chase it, and he has to steal it if it’s in the enemy’s possession. In case you’re wondering why we did not consider getting the ball directly after stealing the ball is because there will chances that stealing the ball would simply fail and the enemy still has its possession.

Case: The enemy doesn’t have the ball and we don’t want the enemy to get a hold of it. – go offensive, attack!

On this next expansion, we decide to make our character more aggressive and attempt to stop the enemy to from gaining the ball.

Interactive Chart 2 - Go offensive, attack!

Now we made it clearer that for stealing the ball we attack the enemy. For this, before going after the ball, we determine if the enemy is closer than the ball is.

1. Check if enemy is closer than the ball,
2. if so, attack him
3. else if not, we go after ball first.
4. Either way we loop again with checking if we have the ball’s possession.

With this chart expansion, our AI now considers the enemy position compared to the ball’s position and determines which action to do. It might not be the wisest decision making but it would comprehend that fact that the enemy is offensive in a way.

Now our AI behavior chart is complete enough to be competitive… or at the least it does what it has to. We can even add some more like evading the enemy when taking a shot, even simply evading enemy attacks or other more complex actions/reactions from various events and circumstances. But with hardcourt, this is all that I would have needed. Although if you’ll consider more decision making for your AI with more specific situations, you’ll be making a better AI and might even be more intelligent than the human.

You want to see these behaviors in action? – analyze and see for yourself: play hardcourt now!