Chapter 3 Part 1

Front 1

Why is there overlap between animation and AI?

Back 1

Both involve movement

Front 2

What level of our AI model is movement AI?

Back 2

The lowest level

Front 3

What is the basic form of all movement algorithms?

Back 3

Take in geometric data about the world and output a movement based on that data.

Front 4

Does a movement algorithm that requires obstacle avoidance require more or less input?

Back 4

More, because it needs to know the location of objects in the world.

Front 5

Your movement algorithm outputs a direction and vector; this is an example of:

Back 5

Velocity

Front 6

What is kinematic movement?

Back 6

Movement that does not account for acceleration and the current movement of the character.

Front 7

If our movement algorithm simply calculates velocities (direction + speed) at regular intervals, what kind of movement is this?

Back 7

Kinematic; it does not use the current movement or calculate acceleration.

Front 8

What is dynamic movement?

Back 8

Movement which looks at the current motion of the character.

Front 9

What do dynamic movement algorithms output?

Back 9

Forces like acceleration that change a characters velocity.

Front 10

Dynamic movement algorithms are also known as?

Back 10

Steering behavior

Front 11

Movement AI typically considers the character as how many points?

Back 11

A single point

Front 12

What is orientation?

Back 12

The direction a character is facing

Front 13

What does rotation change?

Back 13

Orientation

Front 14

What axis is the plane of the ground in 3d games?

Back 14

X, and Z. Y generally is the direction opposite of gravity.

Front 15

What is a 2.5 game?

Back 15

A game that uses 3d graphics but only allows movement in a 2 dimensional plane.

Front 16

Mortal Combat is an example of a what?

Back 16

2.5 degree game

Front 17

How is orientation represented in a 2.5 degree game?

Back 17

Orientation will only change in a single 2 dimensional plane. (Think where the character looks in Mortal combat)

Front 18

True 3D games differ from 2.5D games how?

Back 18

Neither orientation or movement are restricted to 2 dimensional planes.

Front 19

What is the computational advantage of 2.5D games?

Back 19

Much simpler, more flexible calculations because we don't have to calculate for changes in 3D space.

Front 20

In a 2D/2.5D game, the Z axis typically points where?

Back 20

Straight down

Front 21

In a 2D/2.5D game, initial orientation is set to what?

Back 21

0, along the Z axis.

Front 22

In a 2D/2.5D game, orientation is mathematically represented by what?

Back 22

An angle representing counter clockwise (right hand) distance around the y axis from the z axis.

Front 23

In a 2D game, positions are represented by what?

Back 23

A vector with an x and y number.

Front 24

What coordinate is added to the position vector in a 2.5D/3D game?

Back 24

A y coordinate.

Front 25

What kind of movement/behavior is needed to create realistic movement that works with Newtonian physics?

Back 25

Dynamic movement AKA steering behavior, that keeps track of the characters position/velocity.

Front 26

For movement AI, at minimum characters need what two pieces of information?

Back 26

Position and orientation.

Front 27

What is the kinematic data that characters need for steering behaviors?

Back 27

Position, Velocity, Orientation, Rotation.

Front 28

Write the kinematic struct that holds the information for characters:

Back 28

struct Kinematic:

2Dvector position

float orientation

2Dvector (or 3D vector) velocity

float rotation

Front 29

Write the steering struct:

Back 29

struct Steering:

2Dvector (or 3D vector) linear

float angular

Front 30

Steering behavior requires what kinds of data?

Back 30

A 2D or 3D vector that describes linear acceleration, and/or a floating point that represents angular acceleration.

Front 31

Write simple code for updating the position of a character.

Back 31

xPos += (xVelocity * time)

zPos += (zVelocity * time)

Front 32

Write simple code for updating the orientation (theta) of a character, given a right key press and a angular rotation dtheta. Limit it the turn to -1.0

Back 32

public void gamePressedKey(int keyCode){

....

case: keyEvent.vk_RIGHT

theta -= dtheta

if (theta < -1.0) theta = -1.0;

Front 33

Write pseudocode representation euler-integration updates of position and orientation

Back 33

position += velocity * time;

orientation += rotation * time;

Front 34

Write pseudocode representing euler-integration updates of velocity and rotation

Back 34

velocity += steering.linear * time;

rotation += steering.angular * time;

Front 35

In dynamic movement, before we can calculate the changed position/orientation, we must calculate what first?

Back 35

velocity and rotation

Front 36

How do we get around laggy movement due to variable framerates?

Back 36

By using a time variable multiplied by a velocity at each frame rather than simply a velocity. If we just used a per frame velocity, than whenever framerate slowed, movement would slow too.

Front 37

Write code to change velocity and position by direct control of velocity

Back 37

public void gameKeyPressed(int keyCode) { switch (keyCode) { case KeyEvent.VK_UP: mVZ -= deltaV;

...

} }

...(update)

posX += VX*t;

posZ += VZ*t;

Front 38

Write code to change velocity and position using a steering wheel and forward acceleration

Back 38

case KeyEvent.VK_UP: S += S; break;

case KeyEvent.VK_DOWN: S -= S; break;

case KeyEvent.VK_RIGHT: theta -= dtheta; if (theta < -1.0) theta = -1.0; break;

case KeyEvent.VK_LEFT: theta += dtheta; if (theta > 1.0) theta = 1.0; break; }

...(update)

omega += (S/R)*theta*dt; mVX = S*Math.sin(omega);

VZ = S*Math.cos(omega);

...

posX += (int)(VX*t);

posZ += (int)(VZ*t);

Front 39

What are kinematic movement algorithms?

Back 39

Tried and true processes that take in static data (position, orientation) and return velocities.

Front 40

What is seek behavior?

Back 40

A movement algorithm that returns a velocity that points straight at the target, or another point if we are doing a variant of seek behavior.

Front 41

Write code for a basic seek behavior

Back 41

# Create the structure for output

steering = new KinematicSteeringOutput()

# Get the direction to the target steering.velocity = 16 target.position - character.position

# The velocity is along this direction, at full #speed

steering.velocity.normalize()

steering.velocity *= maxSpeed

# Face in the direction we want to move character.orientation = getNewOrientation(character.orientation,steering.velocity)

# Output the steering

steering.rotation = 0

return steering

Front 42

Write code for the kinematicSteeringOutput struct that our different seek behaviors use

Back 42

struct kinematicSteeringOutput()

velocity

rotation

Front 43

What is flee behavior?

Back 43

A variant of seek behavior where the character moves the opposite direction of the target rather than towards it.

Front 44

Take the relevant line of code in seek behavior and change it to make the character flee

Back 44

# Get the direction away from the target steering.velocity = character.position - target.position

Front 45

What problem does the arrive variant of seek solve?

Back 45

It prevents the characteristic wiggle of seek that results from it approaching too fast and overshooting its target, by slowing the character down as it approaches.

Front 46

Write the arrive variant of seek code

Back 46

SEE BOOK FOR CODE

Front 47

Write the alternate code for the steering seek method

Back 47

SEE BOOK

Front 48

What is clipping?

Back 48

Clipping is setting a max/min value for a certain property. It is uses to set max speeds, level boundaries, etc.

Front 49

Write code to implement border clipping (stop at walls) for the x coordinate

Back 49

if (mX < mRadius) { // if we're at left side

mX = mRadius; }

Front 50

Write code to implement max speed clipping

Back 50

if (mS > maxSpeed) mS = maxSpeed;