Physics

1
Physics

• CIS 488/588
• Bruce R. Maxim
• UM-Dearborn

2
Newtonian Physics

• Successful prediction of movement requires the
  level understanding used by physics engines
• All entities have certain physical properties
  (velocity, acceleration, center of mass)
• Velocity is derivative of the position
• v dx/dt
• Acceleration is derivative of velocity
• A dv/dt

3
Numeric Integration

• One big problem in physics implementations is
  keeping track of position changes over time
• Position can be defined as the integral (or
  accumulation) of the velocity
• Numeric integrators are algorithms that compute
  values that change over time
• Integrators for position and velocity as time
  functions might be denoted as x(t) and v(t)

4
Euler Integration

• Takes approach of estimating next values for v(t)
  and x(t) based on the derivative and the current
  value
• v(t ?t) v(t) a(t) ?t
• x(t ?t) x(t) v(t) ?t
• Computationally this becomes for clock ticks
• x_velocity x_velocity x_acceleration
• y_velocity y_velocity y_acceleration
• player_x player_x x_velocity
• player_y player_y y_velocity

5
Problems with Euler Integration

• Acceleration often changes between time steps ?t
• Collisions need to be dealt with during time
  steps ?t
• More sophisticated approaches can help the
  physics model, but are not usually needed from a
  AI perspective

6
Perfect Intersection - 1

• It is possible to use physics to predict the
  collision of two moving points
• In 3D space position and velocity are
• p px, py , pz and v vx, vy , vz
• The position of a player at time t will be
• p(t) p vt
• If s is the speed of the projectile fired from
  the origin (0,0,0) then position will be
• p(t) s2t2

7
Perfect Intersection - 2

• Computationally our aiming point becomes
• p vt s2t2
• (px vx)2 (py vy)2 (pz vz)2 s2t2
• With an appropriate variable substitution we get
• at2 bt c 0
• We can use the quadratic equation to get
• t -b sqrt(b2 4ac) / 2a

8
Perfect Intersection - 3

• The coefficient values are (0 lt i lt 2)
• a -s2 ? vi2
• b 2 ? vipi2
• c ? pi2
• Note the result is defined as long as the radical
  expression is positive (meaning the projectile is
  moving fast enough to hit target)
• The positive quadratic root predicts negative
  values of t and really just predicts the past

9
Predictor 1

• Predict function implements the math model
• Checks for visible players first
• If nearby enemy is found, its position and
  velocity are monitored
• The position and velocity values are plugged into
  the equation

10
Predictor 2

• Predict function implements the math model
• Checks for visible players first
• If nearby enemy is found, its position and
  velocity are monitored
• The position and velocity values are plugged into
  the equation

11
Mathematical Model

• const Vec3f e_pos enemy.position - position
• float a -k_ProjectileSpeed
  k_ProjectileSpeed,
• b 0.0f, c 0.0f
• for (int i0 ilt3 i)
• a enemy.velocityi enemy.velocityi
• b e_posi enemy.velocityi
• c e_posi e_posi
• b 2.0f
• // use constants to determine time of
  intersection
• const float t (-b - sqrtf(bb - 4ac)) /
  (2a)
• // direction of travel is based on velocity
• return enemy.position enemy.velocity t

12
Predicting Behavior 1

• When predicting movement of living things, it
  does not matter how well the equations and
  integrator performs
• Real world creature behavior is not governed by
  rules
• There is lots of uncertainty in forces creatures
  can apply and their acceleration can vary

13
Predicting Behavior 2

• Neither AI or human players have any knowledge of
  internal object states
• Object movement is observed and velocity is
  estimated by 3 observations at different times
• Noting initial position
• Understand velocity by processing position change
• Extract acceleration by noting velocity changes
• Estimating velocity and acceleration based on
  stopped/running basis is better than lag caused
  by trying to average observations

14
Simulation Algorithm

• Simulation can be used to predict target
  collisions as opposed to creating a perfect
  physics equations
• The simulation algorithm can use successive
  iterations to find an acceptable estimate for the
  point in time for the intersection of the paths
  of the projectile and its target

15
(No Transcript)
16
Finding Collision PointUsing Forward Integration

• repeat
• // update enemy position during time step
• enemy.position enemy.position delta
• // increment time step
• time delta
• // compute projectile flight time to enemy
• flight_time length(enemy.position origin) /
• projectile.speed
• // compute distance between enemy and projectile
• difference abs(time flight_time)
• until((difference lt threshold) or (time gt
  max_time))

17
Evaluation

• Linear search for collision point is OK, as long
  as it can be found after a small number of
  iterations
• If we used a much larger time step the point of
  collision could be found in O(log(n)) time
• If the simulation goes to far, we need to back
  and redo the last step with a smaller delta

18
Code Needed to Adjust Delta

• // if sign changes simulation has gone too far
• if sign XOR time lt flight_time then
• // reverse direction and decrease delta
• delta - delta / 2.0
• // remember when enemy is farther than projectile
• sign time lt flight_time

19
Evaluation

• There are few cases where the updated version of
  the algorithm is preferred
• The author claims that in practice this approach
  often takes longer to compute the same result as
  the first algorithm
• A purely mathematical algorithm might be better
  if greater precision is needed
• In the first algorithm it is easier for AI to
  anticipate changes in enemy velocity

20
Colin

• Anticipates enemy position based on what it can
  see
• Checks to see is enemy path is blocked by a wall
• If wall can be side-stepped enemy velocity can be
  adjusted by guessing
• If wall is major blockage simulation is halted
  and that point is used as a target

21
Experimentation - 1

• To emphasize benefits of prediction the animats
  use a blaster that fire slow projectiles
• Fight finish, but last long enough to evaluate
  animat abilities
• Forcing animats to shoot from great distance also
  showcases their prediction ability (in fact these
  animats will not attack close enemies)
• Simple movement code can be used to test
  prediction (e.g. Pinbot)

22
Experimentation - 2

• Animats need to be modified to look in direction
  or enemy during combat rather than in the
  direction of travel
• To allow movement without seeing the obstacles,
  requires the animats to use physical sensors to
  bounce off walls
• Steering behaviors are acceptable using this
  strategy since humans often cannot look backward
  while firing weapons

23
Evaluation 1

• In many cases shooting without prediction can be
  acceptable (e.g. enemy close by or running in
  line of fire)
• At distance, predictions skills are surprisingly
  good for Colin (esp. in large areas with few
  turns required for movement)
• Moving average gives good performance, but needs
  to be biased toward recently observed velocity
  (e.g. 80/20)

24
Evaluation 2

• With two animats movement prediction is
  essentially one dimensional
• When animats are on different levels requires a
  2D prediction strategy
• The mathematical model will be fooled by a animat
  running up a stairway
• Colin will be fooled by enemies running into
  walls and will not shoot at them
• Bots using dodging tactics will also fool Colin
  into firing where the bot was last