Game Development Final Exam

Newton's Laws of Motion

1. bodies move steadily unless a force is applied 2. bodies accelerate in the direction of a force applied, at a rate proportional to it 3. to every action there is an equal and opposite reaction

desirable properties of interpolation techniques

1. interpolation should be along the shortest path ("least torque", least twisting) - exponential map interpolation doesn't achieve this 2. interpolation should proceed at constant speed - nlerp doesn't achieve this 3. order of blending three rotations should not matter - slerp doesn't achieve this no technique could ever achieve all three; nlerp is simplest so it is preferred

2.5D

3 interpretations: 1. stereoscopic vision in depth perception 2. 2D gameplay set in a 3D-modeled scene 3. using projections or a series of images to simulate 3D appearance

audio

Doppler effect, attenuation, each, stereo/surround sound

issues to avoid in physics simulation

Game crash - can be caused by numerical integration over discrete time steps with bizarre results - infinite forces, objects squashed into negative volume, ... unrealistic collision behavior -energy and direction of object movements after collision should be believable inaccurate friction behavior - friction should not cause objects to start moving in reverse framerate drop - physics simulation time step can be independent of graphics rendering time step unrealistic oscillations - dropped objects should not lie forever chattering on the floor

desirable features of game AI

NPC behavior should appear intelligent while being deliberately flawed NPCs should not generally appear dumb AI should run fast enough to keep within the 20% limit AI should be tunable - developers able to tweak for playability, sometimes player-customizable AI should not crash the game, should not endanger success of game, should be testable

path finding (navigation)

NPCs usually move, either wandering or aiming for a target space through which they move must be represented - grids, waypoint graphs, navigation meshes, etc. routes through this space must be found - boss characters: nearly optimal search - lower-skilled NPCs: random trace or breadth-first

non-player characters (NPC)

NPCs with some AI are useful for - challenging opponents, helpful allies, timid victims, etc. - unseen controllers of opposing armies, etc. should be believable, appearing goal-driven, maybe adaptive should appear to perceive and react to player actions go through a sense-think-act cycle (possible learn-adapt as well) AI component of a game should be safe - never jeopardize the delivery of the game AI component seldom allowed even 20% of computation time - simple & reliable techniques are used

multi-phase collision detection

O(N^2) complexity of sprite/sprite comparisons; very costly reduce complexity of individual sprite/sprite comparison - broad phase: quickly eliminate pairs that cannot possibly be in collision - narrow phase follows: determine pairs that are actually in collision - middle phase is also possible: determine pairs that must be in collision

sprite

a 2-dimensional image or animation, generally with transparent parts overlaid onto other screen info, floating above it without altering it (though the term may also be applied to a background) originally in hardware, like fixed-image screen cursors: limited number and variety now, with 3D graphics, applies to flat images superimposed on 3D screens transparency may involve special color codes, or additional bit masks takes some time: double buffering often necessary to avoid flicker and tear

non-convex polygon

a general polygon with concavities, made by joining several complex polygons - polygons with concavities must have more than three vertices: there is always more than one way to carve up a many-sided polygon into smaller parts - intersection of general polygons can be handled by breaking them into convex polygons, then determining intersections of these smaller parts for collision detection, it may be necessary to distinguish between internal & external edges

finite state machine

a machine that consists of a fixed set of possible states with a set of allowable inputs that change the state and a set of possible outcomes actions may be performed on transitions (Mealy machine) or when in a state (Moore machine) or both FSMs can be coded in mainstream programming languages or in bespoke language created specially for a game project

finite state machines: elaborations

agent may have multiple FSMs concurrently executing - a "brain" FSM dealing with decisions - a "movement" FSM dealing with issues like obstacle avoidance may be arranged in hierarchies, simplifying FSMs for high-level behaviors - subsumption architecture is another way of hierarchically arranging multiple FSMs that run concurrently: lower levels continuously running, doing rudimentary things; higher levels are more like conscious decision-making history of FSM states may usefully be maintained, allowing an agent to resume a behavior that was interrupted

behavior tree

allows the complex behavior of a NPC to be expressed as a combination of simpler behaviors which are arranged in a tree structure; on every tick the BT determines what the NPC does simpler behaviors can be thought of as modular components (routines, FSMs, other BTs) that can be shared in various mixtures between different NPCs leaf nodes are concerned with actual NPC behaviors - may succeed or fail, throw an error, and/or still be running from a previous tick interior nodes are concerned with organizing behavior subtrees; two most important: - selector: proceed left-to-right until some subtree succeeds (OR) - sequencer: proceed left-to-right until some subtree fails (AND) both have random-order variants less important: - parallel: perform all subtrees simultaneously - decorators: dominating only one subtree; filters, control modifiers

kinetics

analytical dynamics - object masses, forces on objects, resultant acceleration - conservation of momentum - Newton's Laws of Motion - may be computational overkill, giving more realism but perhaps less fun

exponential map

another way to represent rotations in 3D; the space defined is non-Euclidean - a rotation is represented with 3 numbers, representing x, y, and z components - the ratio of x : y : z specifies a vector in 3D - its magnitude specifies, in radians, the clockwise rotation around that axis - a zero magnitude vector must be treated as describing no rotation at all

influence mapping

applicable most when both the player and the AI control a host of characters (war games, some strategy board games) place grid over game world, count player-controlled vs AI-controlled characters influence decay with distance linearly, exponentially, or blocked used to identify safe refuges or pathways near-zero values may indicate areas of no interest

terrain analysis

apply image-processing techniques to terrain maps (passable-terrain grids) to identify, for example, choke points that impede movements Perkins' 8-step algorithm: 1. recognize obstacle polygons: identify polygons consisting entirely of impassable pixels, simplify by eliminating tiny obstacles & insides of sufficiently-small concave boundaries 2. compute Voronoi diagram: Delaunay triangulation of a set of points = triangulation with no point inside circumcircle of any triangle; connect the centers of the triangles' circles to form the Voronoi diagram 3. prune Voronoi diagram: eliminate a leaf node if its circumcircle is smaller than its neighbor's circumcircle; iterate while possible & eliminate nodes whose circumcircle is smaller than some threshold 4. identify region nodes: pick out nodes with other than two neighbors or nodes with two neighbors whose neighbors' circumcircles are smaller 5. identify choke point nodes: the node(s) along any path with smallest circumcircle are identified as choke points 6. merge adjacent regions based on thresholds: where the choke point has a circle nearly as large as that of a connected region, eliminate the choke point and merge the connected regions 7. wall off choke points: identify lines passing through a choke point and its adjacent obstacle promontories 8. recognize region polygons: use these walls together with the obstacles to partition the map into regions

skinning

association of mesh vertices with (generally) multiple bones - bones define an envelope of surrounding parts of mesh

bounding circles

can be easily checked for potential overlap of sprites within - test whether distance between circle centers is less than the sum of circle radii - more cheaply, saving sqrts

character attachments

characters may have other objects attached and moving with them - weapon may be treated as a wholly separate object, or could be treated as part of the character when toted (then character has two possible meshes - with & without weapon) character may be an attachment to another object - eg. helicopter - position of character's root bone must be determined from the point of attachment

Bayesian networks

collection of tables used for probability estimation ex. when rolling two dice, how often does a particular number win, draw, or lose? observation of experience leads to estimate of probabilities

geometry, physics, and animation

combining rotations, avoiding self-intersections, expensive "special effects"

separating axis theorem

convex polygons do not overlap if any separating axis can be found, ie. if there is some vector onto which the projections of the polygons do not overlap AABBs are a very simple example of convex polygons not all the infinitely-many possible axes need be tested, just the normals suffice - if any separating axis is found, immediately stop, knowing polygons do not overlap - if no separating axis is found, polygons do overlap

multiple constraints

dealing with one constraint violation may introduce another deal with this iteratively with a good chance of success but no guarantee - collect set of constraint violations and the few objects they involve - calculate a minimal compensating movement for each one in turn - repeat until all violations fixed, iteration limit reached, or configuration is stable

computational tradeoff: list management vs object comparisons

deep tree: objects typically in many lists, each such list quite small shallow tree: objects typically in one or a few lists, but each list may be large

collision points

detecting player collision using six points in a hexagonal configuration

cross product

determine if two 3D vectors are parallel determine if a complex polygon has a non-coplanar point to its "front" or "rear" determine if a convex polygon contains a coplanar point

handling bounce (without real physics simulation: with kinematics)

determine instant and velocity (speed & direction) of impact between meshes - repeated subdivision of interval between frames gives approximate instant Gilbert-Johnson-Keerthi algorithm (GJK) (for convex objects) - determine fact of, then depth of, objects' interpenetration in next frame - move objects apart by that depth - adjust velocities and recalculate next-frame positions

multibone inverse kinematics by cyclic coordinate descent

determine which joints in tree (from root bone to end effector) are allowed to move for each joint, find the rotation that minimizes angle between end effector's position and its desired position iterate until - reach limit on iterations - end effector's position is within acceptable tolerance cyclic coordinate descent has problem with 2-bone case when bones are nearly straight

voxels

divide 3D space into uniform cubes, like pixels divide 2D into squares drawbacks: - voxels will be very numerous especially for game levels set outdoors; - need inside/outside distinction, containing object information - for exterior voxels, colour and/or texture info needed for rendering; - a lot of data shuffling will occur when objects move; - granular for both motion purposes and for visuals (cf. anti-aliasing in 2D)

portals

doors, windows, turns along an outdoor pathway, level advancement - 3D world is divided into "rooms" with portals connecting adjacent rooms - a camera in a room sees inside that room; into adjacent ones through its portals - portals (e.g. doors) may be open or shut - see through open ones only - portal itself occupies both rooms - further portals may be seen through, and still further ones through them - much of what is in an adjacent room may be culled, not painted at all

faults of spherical interpolation (slerp)

ex. "Mercator's Projection" used in flat maps - exaggerates the sizes of areas near the poles, best paths follow a "great circle"

looping animations

first and last poses, bone velocities must be identical; bone accelerations probably need not be identical

z-buffering method

for each pixel on screen, trace a line into the simulated world - when a poly is found, compare its distance with the closest known (initially ∞) - if closer, update closest distance and paint that pixel (possibly overpainting) - again does not help with collision detection, that must be separately done

perfect & imperfect AI

game's AI not required to be perfect - player should be entertained - imperfect heuristics can be faster than perfect algorithms should not exploit access to perfect information - robotics-style perception and motion control should be avoided - players should not feel like the AI is cheating - human-like limitations placed on AI

Euler angles

give rotations about 3 axes, extrinsic (x y z) or intrinsic (pitch, roll, yaw) - order is important; different toolsets may assume different orders - spatially close angles may not be numerically close; difficulty for interpolation - Gimbal Lock problem arises; some orientations have multiple representations, also very fast changes of one angle may be needed near poles

grid representations of space for navigation

if using a 2D grid, regularly spaced cells are marked passable or not NPC may occupy one or more cells one bit per grid cell: little memory needed easy to map a world location to a grid cell

properties of BSP Trees

in order to speed up search for collisions, trees should not necessarily be balanced - it is more desirable to have trees where there are large regions with few polygons, and small regions with many polygons - this allows the commonest case (no-collision) to be detected more quickly, there is a greater probability that some object is in the larger region than in the smaller one trees carve up 3D space into progressively smaller regions - multi-resolution spatial reasoning (and rendering) is possible - with well-chosen pivot planes (such as those on objects' convex hulls) good approximations to their overall shape can be obtained by limiting the depth of tree that is considered

motion extraction

interplay of graphical animation and game logic can bring problems of several kinds animations should not affect object locations/orientations, but it may be required that an object's game movement is coordinated somehow with its animation then it is necessary to use motion extraction: - create poses which move the object's root bone - modify them so that the root bone is (mostly) fixed - give the game logic access to the deltas to be applied to the poses

collision detection

intersections of polygons, collisions of polyhedra, spheres, polygon meshes

forward kinematics

involves applying a rotation to a bone, and cascading that rotation to all bones that are daughters in tree of bones

inverse kinematics

involves figuring out how bones need to be positioned to get an "end effector" (a robotics heritage term) into a particular position may run into problems - may be no solution (object out of reach) - solution usually has to be found iteratively rather than analytically (cyclic coordinate descent) - two bones problem when nearly straight (eg. knees must not bend backwards) - loop of bones may exist

composite motion extraction

involves: - extracting the motion and orientation of root bone between each successive pose, rather than only the start and end as in LME - encoding movement as relative to current orientation, rather than as absolute

machine learning: N-gram statistical prediction

keep records of n-grams (bigrams, trigrams, etc.) of observations (eg. behaviors) when trying to predict what might happen next, look for most commonly seen followup to previous sequence alternatively, use data to estimate probabilities of predictions use fading memory

collision response

kinematics and kinetics approaches in 3 dimensions

octrees

like quadtrees, each node either is a leaf or has eight daughters - coordinate ranges should ideally be power of two in all 3 directions - empty regions may be represented by vastly fewer nodes than voxels - (parts of) objects listed as occupying octree node must have color/texture

potentially visible sets

like with portals, space is divided into rooms (or "nodes") each room holds a list of others that might be seen from any point within it - conceptually simple - for rendering, offers rapid elimination of many polygons that cannot be seen

rag-doll physics

make body object out of bones (links) and joints (as "particles") - forces on one part of the body are propagated to other objects through joints - "penalty spring" forces can be brought to bear if constraints violated - "zero tolerance" involves calculating the moment at which a constraint is about to be violated, processing it to prevent it from happening (gets expensive) - "relaxation" involves changing the state so violation is reduced or zeroed (a kinematics approach rather than kinetics)

player modelling

make observations of the player's behavior, and use these observations to tailor AI's behavior - exploit the player's weaknesses, making the game more challenging - avoid the player's weaknesses, making the game more fun

sequencing of collision tests

may need to reconsider an outcome for collisions: - one collision may result in another - one collision may avert another

axis-aligned bounding box (AABB)

minimum bounding box subject to the constraint that the edges of the box are parallel to the (Cartesian) coordinate axes used to an approximate location of an object in question and as a very simple descriptor of its shape can be easily checked for potential overlap of sprites based on collision detection constraints

reputation system

model the communication that might take place among NPCs: the beliefs that NPC might come to have about player, the ways that they might react to the player if a player is seen to shoot townsfolk indiscriminately, survivors will talk, player might find life gets harder: gives player a motivation to play nice, or to make sure there are no witnesses

filter randomness

monitor randomly generated sequences to maintain player belief in randomness simplest case often used: if choosing between several behaviors, don't make the same choice twice in a row more complex case: model what results user will strongly suspect are not random, override the random choice if it will appear nonrandom

collision response

mostly 2D effects a game object suffers during or after a collision

axonometric projection

non-use of perspective; foreshortening of 3 axes - isometric: all 3 the same (engineering drawings) - dimetric: 2 of the 3 the same, lessens anit-aliasing problems (2:1 pixel ratio) - trimetric: no 2 the same

machine learning

numerous techniques available: - decision trees - Bayesian networks - Genetic algorithms - Genetic programming (could be good for behavior trees) - Neural networks (connectionist networks, multi-layer perceptions)

motion constraints

objects should not intersect obstacles in the environment, nor each other or themselves (usually) - if they do, interesting things should happen so it is highly likely that graphical representations of the objects will change animations may involve coordinated and constrained movements of multiple objects: - link constraints (pairwise, commonly in animations; eg. distance/length) - angle constrains (three-way; eg. angle)

animated sprites

often looping (while pixel art is okay for one-off, it is very expensive for animation purpose) obtainable in several ways: - filmed performance - "rotoscoping": animation by artist of filmed performance by actors - "claymation": where live actors cannot be useful (eg. Wallace & Gromit) - pre-rendered Computer-Generated Imagery (CGI) where a dynamic (maybe 3D) scene can be generated, but not generated fast enough for use in game - ripping from other sources (movies, games, image databases, etc.)

sense-think-act: act

only through NPC's behavior that the player is made to believe that any sensing and thinking has taken place choice of action should appear to be rational given some reasonable goal that can be attributed to it action repertoire may involve thousands of animations: data-driven design allows removing animation choice from code, promoting scalability NPC's thinking may indicate there's no suitable action saving it from doom - be entertaining or resign (strategy games)

painter's algorithm

paint furthest polygons first, overpaint with progressively nearer ones does not help with collision detection, that must be separately done partially transparent polygons can alter the color of what is seen behind them

breadth first algorithm

path finding algorithm: - maintain a queue of partial paths - grow the path at head of queue in all possible non-looping ways - put the resulting new paths at queue end - stop when finding any path that ends at the goal - won't get stuck: it will find a path if there is one - the path it finds has fewest links, not necessarily lowest cost

A* search algorithm

path finding algorithm: better because more efficient if an admissable heuristic is used - keep sequence of partial paths, sorted by sum of cost incurred so far & heuristic lower-bound estimate of cost remaining - grow cheapest-by-sum so far in all non-looping ways and insert into sequence - can prune search if heuristic's consistency is assured or if recording costs of cheapest paths yet to intermediates

best first algorithm

path finding algorithm: keep sequence of partial paths, sorted by cost incurred so far - grow cheapest path so far in all possible non-looping ways - insert the new paths into the sorted sequence - stop when about to grow a path that has already reached the goal - guarantees to find a path if there is one - finds path with lowest cost provided all links have non-negative cost - can prune search: abandoning new paths to an intermediate is costlier than another reaching that intermediate

obstacle avoidance

path-finding algorithm may give similar routes for many allied NPCs, and may easily get in each other's way, especially at choke points (narrow bridge/streets) concerned mainly with moving obstacles combining separation rule with path prediction for allies allows smoother flow

random trace algorithm

path-finding algorithm: head directly for target if possible, otherwise randomly pick left or right - can easily get stuck - makes no real attempt to find a good path

waypoint representations

paths that can be safely traversed have their endpoints marked as nodes - 3D can be handled just as easily as 2D - paths may have diameter associated with them - paths may have associated traversal cost - trickier to map world position to waypoint graph - memory hungry: a node stores paths to neighbors - neighbor, diameter, cost

3D planar intersection

plane-plane intersection - infinite plans are defined by: - a normal (perpendicular) vector - preferably but not necessarily a unit vector - a distance between the plane and the coordinate system origin - parallel planes => cross product of normal vectors = 0 - two infinite parallel planes intersect iff distances using unit normal vectors between plane and coordinate system origin are the same (if normal vectors have same direction) or opposite (if normal vectors have opposite directions) - two infinite non-parallel planes always intersect

object modelling

polygon mesh approximations, multiple coordinate systems (world, intrinsic)

two-bone inverse kinematics

problem addressed cheaply by using a geometric technique consider case of hip-knee-ankle: - hip's position is known, and fixed - ankle's desired position is known - plane of knee joint is known - lengths of hip-to-knee and knee-to-ankle bones define spheres - equations will generally yield two possible solutions (or none) - if two, only one solution will respect the knee-forward constraint

dot product

projection of a point P onto a vector, or onto a finite line A---B determine if the two 3D vectors are perpendicular

3 stages of collision handling

prologue stage: - callback function determines if motion-alteration response is needed - prologue may also trigger eg sound effects, by notifying colliding (sw) objects Collision stage (only needed if prologue has determined a response is needed) - place objects at point of impact - assign new velocities (with physics or otherwise) epilogue stage - handle post-collision effects, eg sound effects, destruction, fragmentation - again by notifying affected (sw) objects it is somewhat arbitrary what effects are caused by prologue or by epilogue, it is no accident that 'sound effects' is given as an example in both cases.

quadtrees

provide a way of partitioning 2D space; each node represents a rectangle and may have four child nodes, dividing its area into four quarters tree structure may repeat as many or as few depths as is required - if tree is deep, each node covers a small area and usually contains few objects (probably contains only parts of those objects) - if tree is shallow, large area with many objects; objects may still be spread out - tree depth does not in principle have to be uniform each leaf node has a list of relevant objects which occupy some of its space

disadvantages of physics simulation

real-time solution can be very expensive computationally - memory may be short (especially for console games) duration of simulation step may be unpredictable/variable integration errors may cause unrealistic behaviors - collisions, oscillations, frictional overcompensation

advantages of physics simulation

reduces artist workload - artwork can be very costly (time and money) physics can react dynamically to player's choices of actions and create appropriate images as needed makes possible the rendering of emergent behavior, where multiple objects interact in practically unforeseeable ways

kinematics

regarding the properties of motion without regard to its causes - how acceleration affects velocity, how velocity affects position - direct manipulation (in code) of object position and/or velocity

normalized quaternions

represent a rotation as a 4-tuple <x, y, z, w> - x, y, and z can be interpreted as a 3D vector, giving the axis of rotation - the length of that vector gives sin(θ/2) where θ is the angle of rotation (radians) - w gives cos(θ/2) - since sin^2(x)+cos^2(x) = 1, making x^2+y^2+z^2+w^2=1 is normalization of quaternion we can interpolate these using: lerp, nlerp, slerp, log-quaternion lerp, etc.

polygon meshes

represent the surface of a 3D shape using many plane polygons; can be created using tools such as Blender, 3Ds, etc. - polys are usually convex, triangles particularly popular, quads less so - represent only the surface: not explicitly the interior of a solid object - collision detection might not spot one object existing or moving inside another

sense-think-act: sense

sensing (without cheating) - seeing, hearing, being told - visibility can involve computationally expensive tests - hearing; ie. loud noises, soft sounds - each sound occurs in an area, travels a distance; avoid expensive audio simulations, notify NPC agents within sound's travel distance - communication between NPCs (by speech, gesture, writing) reaction times are never instantaneous, sense modality matters here

flocking

separation - steer oneself to avoid collision with other alignment - steer in the average direction of others close to self cohesion - steer toward the average position of others close to self (contradictory influences result in realistic behavior of a flock)

level-of-detail optimization

similar in spirit to the graphics optimization, where polygons too small to be noticed are not drawn individually for AI, behavior of characters that won't be observable in detail can be replaced with grossly simplified behavior; examples: - base update frequency on proximity to player character - use straight-line approximations for faraway NPCs movement - use deliberately poor but cheap pathfinding for faraway NPCs

manager task assignment

sometimes a host of disparate NPCs must collectively perform many tasks allowing each NPC's AI to pick the task it is best at has problems - too many NPCs may perform the same task - important tasks may not be chosen at all manager task assignment instead picks for each task the NPC best suited to it (given priorities) - ensures the most important tasks get done with the best possible NPC resources - duplication of effort can be avoided

sprite-based "exact" collision detection

sprites have transparent pixels, visible pixels; sprites overlap if after scaling, translation, rotation, they share visible pixels gives precise detection of collisions, but - it is an expensive operation to perform (especially if scaled and/or rotated) - collisions are in practice relatively rare and that expense may get wasted - precision may not even be what is wanted, especially if collision response changes sprite (it may cause new sprite to have no collision, change back to old, ..., and loop)

GJK support function

takes a direction and shape, returns extreme point of shape iteratively finds "simplexes" progressively more likely to encompass origin converges on direction, and hence depth, of maximum penetration (may be useful in deciding on direction & magnitude of (kinematics) displacement to achieve separation (kinetics) direction and strength of correctional "penalty force")

smart terrain

technique of putting "intelligence" into inanimate objects "affordance theory" - the design of an object suggests the ways it can be used - door without handle can be pushed but not pulled - microwave oven can cook things - food items can satisfy hunger player can find out from objects how to use them, what goal states they help achieve in contrast to avoidance theory, functions may be present but not suggested (trapdoor), or suggested but not present (cardboard chair)

billboarding

technique that exploits the face-forward property of sprites - useful eg. to create a glow or a halo around another image - 3D rendering engines can process "3D sprites" faster than general 3D objects 3D polyhedral models cannot cheaply & realistically handle effects in 3D, they may be oriented as if from a point, or just turn about the axis the same principles can be used to make an object appear to turn to face some other object in a 3D scene, not just the camera

navigation meshes

the parts of 2.5D space that can be traversed are represented with convex polygons - terrain collision detection cheap: only needed if an object intersects the straight-line boundaries - traversal possible within area of a polygon or to an adjacent polygon - mapping from world not as easy as with grids, not as hard as with waypoint graphs - limited 3D is possible but complicates finding the mesh cell

Minkowski Sum

the shape that results from adding one shape to another - as seen in circle-rectangle overlap

sense-think-act: think

thinking is traditionally the heart of AI - if-then rules: simple yet powerful, especially when only a few rules suffice; hard to scale up - search: useful for route finding, chaining actions; can get very expensive in complex search spaces - learning (decision trees, neural networks, etc.): dangerous, not generally simple, not heavily used decisions should not be frequently revisited - leads to indecisive flip-flop behavior

rigging

use of bones to make a skeleton - common to have one "root bone", other bones' positions are relative to it

command hierarchy

used in strategy games, wargames: player and AI each control a host of characters common to have at least 3 levels, though substantially more are quite possible - overall strategy: what battles to fight, objectives to seek, etc. - squad tactics: what resources to commit to objects, coordination at squad-to-squad level - individual combatant: fighting skills, individual movement

one-bone inverse kinematics

useful for several common purposes - pointing character's eyes - pointing game's camera - getting character's foot facing forward and level on ground generally quite trivial - find current orientation and calculate its desired orientation - rotation as transform (matrix), apply to current orientation - rotations can accumulate in undesirable fasion alternatively, start over - have single standard resting orientation - calculate transform from that to desired orientation

machine learning: weakness modification learning

using similar data to avoid repeating mistakes this may not result in greater success, but at least it won't keep failing the same way

interpolation

vertices of skin mesh have their positions influenced by more than one bone skinning may involve deliberately placing some polygons and getting others positioned by formula poses between keyframes calculated by interpolation - rotational movement needs interpolation between keyframes, rotations and positions need to be cascaded through tree of bones color shades might need to be interpolated

learning in sense-think-act

very short-lived NPCs have no need to learn as individuals, but longer lasting ones may benefit from individual learning - remember outcomes of previous actions - spot patterns in player behavior - use memory to influence future decisions (but let them fade away) "smart terrain" places info & memory in world model, not in individual NPCs

graphics rendering

viewpoints, partial occlusions, perspective, haziness, reflections, stereo vision

binary space partitioning trees

well-suited to organizing the polys representing a rigid object partition all the polys in a scene into: - a particular pivot poly and any other coplanar with it - those that lie "to front" of the pivot poly (there may be none) - those that lie "to rear" of it (there may be none) - polys that intersect pivot's plane are cut into two, one behind, one in front - if not convex, or if you insist on triangles, then maybe more than two polys to front are recursively partitioned using one as pivot; likewise, polys to rear (BSPTs)

moment of impact

when two game objects collide, it usually happens between frames not at a frame - repeated binary subdivision of time interval and swept areas (5 iterations usually sufficient) - narrow-phase collision detector invoked up to 5 times

curved shapes

whereas bounding circles can be easily tested against each other for overlap, these shapes must be tested using the idea of Voronoi regions: regions nearest some feature of a shape (an edge or corner)

linear motion extraction

works well if there are no rotations or big changes in acceleration - determine position of root bone in first & last frames of animation - subtract appropriate proportion of total from each pose in animation - supply average linear velocity to game engine - keep residual changes with each pose of animation extracting motion from an animation in this automatic way is better than requiring animator and programmer to agree on motion parameters; changing the animation will naturally cause game logic to adapt appropriately