What can a
client-side bot do?
Understanding what a
client-side bot can do requires understanding to some extent how Quake
works. Most of this information has been kicked around on newsgroups
and other pages to a greater or lesser extent. Of course, hard won
experience provides it to you now.
The single most important
fact about Quake is it uses the BSP tree which describes a level not
only to accelerate rendering, but to accelerate client-server
communication. The key observation is that the server only needs to
tell the client about all the entities that are visible to it, or more
generally potentially visible to it, but the server never needs to tell
the client about all the entities in the map.
The BSP tree divides the
map into a set of leaves, each of which is about the size of a player.
Some leaves are substantially larger, some are substantially smaller,
but most importantly, there are a lot of them. Several hundred for a
typical map. For each of these leaves the server knows what leaves are
potentially visible from that leaf. That is, given that the player's
viewpoint is anywhere in that leaf, looking in any direction, the
server knows the set of leaves which the player might see. This is
almost always a much smaller set of leaves than the entire map.
The server then uses this
visibility information to tell the client about all the entities in the
set of leaves potentially visible to the client. Thus a client can't
track an enemy on the other side of the map, but a client can track an
enemy which it cannot directly see, if it could see that enemy from
somewhere in it's leaf node. This results in the interesting behavior
that a shot can be led to hit an enemy as it rounds a distant corner, a
shot an unassisted human could never make, barring just plain chance.
A number of people have
complained that a client-side bot has 'eyes in the back of its head'.
This is absolutely true. Why? Because one of the most effective ways to
combat the perceptual effects of latency is to reduce rotational
latency (moving your head around). Thus the server tells you about the
entities behind you, so despite high ping times you can spin around and
see them, target them, etc. quite responsively. Don't like it? Take our
word for it, Quake would be unplayable on all but the very fastest,
very lowest ping time servers without it. Don't think client-side quake
bots should take advantage of it? That is a different question. We feel
allowing client-side bots to use all of the information the server
transmits to the best of their ability is entirely fair, and the only
playing field that is level for all. This doesn't mean we think a
client-side bot vs. unassisted human is necessarily a fair fight, it
certainly isn't if you are playing us.
What can't a
client-side bot do?
This is probably the most
important question, since it tells you how we are and how we aren't
Quake is a client/server
program, with a very clear division of labor between the client and the
Draws the set of
entities transmitted to it by the server, and sends periodic updates to
the server about the client's input (facing direction, desired forward
and transverse velocity, pressing the fire key, etc.).
Receives updates from
the clients and computes the physics/dynamics of the game. This
includes determining how players actually move (the server tells the
client its position, not vice versa), determining when shots hit, how
much damage is done, who has what weapons, etc.
No matter how you slice
it, we don't have the same advantages as a server-side bot. We can't
run any faster than you. We can't magically become invincible. We can't
jump any higher, fire any faster, our take a rocket to the face any
better than any other player.
We can, however, see behind
ourselves, predict your path better than you can, make almost magically
accurate shots, and rip through ammo so quickly it is dizzying.