1. Introduction

• 1.1 What is QuakeC
  
• 1.2 Contributions
  

2. QuakeC Language

• 2.1 Comments
  
• 2.2 Names
  
• 2.3 New types
  
• 2.4 Definition of variables
  
• 2.5 Definitions of constants
  
• 2.6 Definitions of functions
  
• 2.7 Function declaration
  
• 2.8 Definition of a frame function
  
• 2.9 Conditional construct
  
• 2.10 Loop construct
  
• 2.11 Function calls
  
• 2.12 Logical operations
  
• 2.13 Comparisons
  
• 2.14 Operations on floats or integers
  
• 2.15 Bitwise operations
  

3. Builtin functions

• 3.1 Basic math functions
  
• 3.2 Basic vector maths
  
• 3.3 Sound emission
  
• 3.4 Entity management
  
• 3.5 Move Entities
  
• 3.6 Fights and Shots
  
• 3.7 Collision checking
  
• 3.8 Server related functions
  
• 3.9 Print messages
  
• 3.10 Console
  
• 3.11 Debugging
  
• 3.12 Precaching files
  

4. Defines

• 4.1 Values : temporary entities
  
• 4.2 Values : Sound Channel of entities
  
• 4.3 Values : Sound Attenuation
  
• 4.4 Values : Contents of level areas
  
• 4.5 Values : Entity light effects
  
• 4.6 Values : Existing Items
  
• 4.7 Values : Behavior of solid objects
  
• 4.8 Values : Type of movements
  
• 4.9 Values : Entity can take solid damages
  
• 4.10 Values : Entity dead flag
  
• 4.11 Values : Spawnflags
  

5. Entities

• Static entities
• Temporary entities
• Dynamic entities
• Definition of entity fields
• Technical data
• Appearance of entity
• Position in 3D
• Situation of the entity
• Movement in 3D
• Monster's Behavior
• Automatic Behavior
• Player/Monster stats and damage status
• Player inventory
• Player Fight
• Deathmatch
• Fields used only by Quake-C (User defined)
• World fields
• Quake Ed fields
• Monster Behavior
• Monster state variables
• Object stuff
• Doors
• Miscellaneous

6. Global variables
7. Model pragma
8. Network protocol
9. Network Builtin functions
10. Tips & tricks
11. Basic Types
12. Compilation of Quake-C
13. Execution of Quake-C
14. Examples

• 14.1 Looping between all monster
  
• 14.2 Creating a new entity
  
• 14.3 Setting point of view
  
• 14.4 Teleporting
  
• 14.5 Throwing your Eyes
  
• 14.6 Radar
  

1. Introduction

2. QuakeC Language - Basic constructs

2.1 Comments

2.2 Names

2.3 New types

2.4 Definition of variables

    type variable1, variable2;
    eg:
    float   a,b;

    type variable1 = value;
    eg:
    float a = 2;

2.5 Definitions of constants

2.6 Definitions of functions

    type (type param1, typeparam2, ... ) function =
    {
       ... code ...
    };

    void()      think = {...};
    entity()    FindTarget = {...};
    void(vector destination, float speed, void() callback)      SUB_CalcMove = {...};

2.7 Function declaration

    type (type param1, typeparam2, ... ) function;

2.8 Definition of a frame function

    void() framename = [$framenum, nextthink] { ...code...};

    void() framename =
    {
       self.frame= $framenum;  // the model frame to displayed
       self.nextthink = time + 0.1;   // next frame happens in 1/10 of second
       self.think = nextthink; // the function to call at the next frame
       ...code...
    };

2.9 Conditional construct

    if( expression )
    {
      statements
    }
    else
    {
      statements
    }

2.10 Loop construct

    while( expression )
    {
      statements
    }

    do
    {
      statements
    }while( expression )

2.11 Function calls

    function_name ( parameter1, parameter2,... )

    return( expression )

2.12 Logical operations

     !   // logical not
     &&  // logical and
     ||  // logical or

2.13 Comparisons

     <=    <      >=     >
     ==  // equal, beware at the double = like in C.
     !=  // not equal, like in C.

2.14 Operations on floats or integers

     *  /  -  +

2.15 Bitwise operations

    &   // bitwise and
    |   // bitwise or

3. Builtin functions

3.1 Basic math functions

Function: anglemod

        float anglemod (float angle)

Function: rint

        float rint(float val)

Function: floor

        float floor(float val)

Function: ceil

        float ceil(float val)

Function: fabs

        float fabs(float val)

Function: random

        float random()

Function: ftos

        string ftos(float value)

3.2 Basic vector maths

Function: normalize

        vector normalize(vector v)

Function: vlen

        float vlen(vector v)

Function: vectoyaw

        float vectoyaw(vector v)

Function: vectoangles

        vector vectoangles(vector v)

Function: vtos

        string vtos(vector v)

Function: makevectors

        void makevectors(vector angles)
        angle = 'pitch yaw 0'

        vector  v_forward;  // points forward
        vector  v_up;       // points up
        vector  v_right;    // points toward the right

3.3 Sound emission

Function: sound

        void sound (entity source,
        float channel, string sample,
        float volume, float attenuation)

Function: ambientsound

        void ambientsound(vector
        position, string sample, float
        volume, float attenuation)

3.4 Entity management

Function: spawn

        entity spawn ()

Function: remove

        void remove (entity e)

Function: makestatic

        void makestatic (entity e)

Function: nextent

        entity nextent(entity e)

Function: find

        entity find (entity start,
        .string field, string match)

         e = find( world, classname, "player");

Function: findradius

        entity findradius (vector
        origin, float radius)

          e = findradius( origin, radius)
          while(e)
          {
            T_Damage(e, ... ) // Let God sort his ones!
            e = e.chain
          }

Function: setmodel

        void setmodel (entity e,
        string model)

Function: lightstyle

        void lightstyle(float style,
        string value)

3.5 Move Entities

Function: ChangeYaw

        void ChangeYaw()

Function: walkmove

        float walkmove(float yaw,
        float dist)

Function: droptofloor

        float droptofloor()

Function: setorigin

        void setorigin (entity e,
        vector position)

Function: setsize

        void setsize (entity e,
        vector min, vector max)

Function: movetogoal

        void movetogoal (float step)

3.6 Fights and Shots

Function: aim

        vector aim(entity e,
        float missilespeed)

Function: particle

        void particle(vector origin,
        vector dir, float color,
        float count)

Function: checkclient

        entity checkclient()

3.7 Collision checking

Function: traceline

        traceline (vector v1,
        vector v2, float nomonsters,
        entity forent)

        float trace_allsolid;
          // never used
        float trace_startsolid;
          // never used
        float trace_fraction;
          // fraction (percent) of the line
          //    that was traced, before
          // an obstacle was hit. Equal to 1
          //    if no obstacle were found.
        vector trace_endpos;
          // point where line ended or met an
          //    obstacle.
        vector trace_plane_normal;
          // direction vector of trace (?)
        float  trace_plane_dist;
          // distance to impact along direction
          //    vector (?)
        entity trace_ent;
          // entity hit by the line
        float  trace_inopen;
          // boolean, true if line went through
          //    non-water area.
        float  trace_inwater;
          // boolean, true if line went through
          //    water area.

Function: checkpos

    CURRENTLY DISABLED. DO NOT USE.
        scalar checkpos (entity e,
        vector position)

Function: checkbottom

        float checkbottom(entity e)

Function: pointcontents

        float pointcontents(vector pos)

3.8 Server related functions

Function: changelevel

        void changelevel (string mapname)

Function: setspawnparms

        void setspawnparms (entity client)

Function: stuffcmd

        stuffcmd (entity client,
        string text)

        stuffcmd(self, "bf\n");
          // create a flash of
          //    light on the screen.
        stuffcmd(self, "name Buddy\n");
          // name the player Buddy.

3.9 Print messages

Function: bprint

        void bprint (string text)

Function: centerprint

        void centerprint( entity client,
        string text)

Function: sprint

        void sprint (entity client,
        string text)

3.10 Console

Function: localcmd

        void localcmd (string text)

   localcmd("restart\n");
        // restart the level
   localcmd("teamplay 1\n");
        // set deathmatch mode to teamplay
   localcmd("killserver\n");
        // poor server...

Function: dprint

        void dprint (string text)

Function: cvar

        float cvar (string variable)

Function: cvar_set

        float cvar_set (string variable,
        string value)

3.11 Debugging

Function: eprint

        void eprint (entity e)

Function: coredump

        void coredump()

Function: traceon

        void traceon()

Function: traceoff

        void traceoff()

Function: break

        void break()

Function: error

        void error (string text)

Function: objerror

        void objerror (string text)

3.12 Precaching files

Function: precache_file

        void precache_file(string file)

Function: precache_model

        void precache_model(string file)

Function: precache_sound

        void precache_sound(string file)

4. Defines

4.1 Values : temporary entities

// point entity is a small point like entity.
 0    TE_SPIKE           unknown
 1    TE_SUPERSPIKE      superspike hits (spike traps)
 2    TE_GUNSHOT         hit on the wall (Axe, Shotgun)
 3    TE_EXPLOSION       grenade/missile explosion
 4    TE_TAREXPLOSION    explosion of a tarbaby
 7    TE_WIZSPIKE        wizard's hit
 8    TE_KNIGHTSPIKE     hell knight's shot hit
10    TE_LAVASPLASH      Chthon awakes and falls dead
11    TE_TELEPORT        teleport end
// large entity is a 2 dimensional entity.
 5    TE_LIGHTNING1      flash of the Shambler
 6    TE_LIGHTNING2      flash of the Thunderbolt
 9    TE_LIGHTNING3      flash in e1m7 to kill Chthon

4.2 Values : Sound Channel of entities

CHAN_AUTO = 0;   // Create a new sound
CHAN_WEAPON = 1; // Replace entitie's weapon noise
CHAN_VOICE = 2;  // Replace entitie's voice
CHAN_ITEM = 3;   // Replace entitie's item noise
CHAN_BODY = 4;   // Replace entitie's body noise

4.3 Values : Sound Attenuation

ATTN_NONE = 0;    // full volume everywhere in the leve
ATTN_NORM = 1;    // normal
ATTN_IDLE = 2;    // [FIXME]
ATTN_STATIC = 3;  // [FIXME]

4.4 Values : Contents of level areas

CONTENT_EMPTY = -1;   // Empty area
CONTENT_SOLID = -2;   // Totally solid area (rock)
CONTENT_WATER = -3;   // Pool of water
CONTENT_SLIME = -4;   // Pool of slime
CONTENT_LAVA = -5;    // Lava
CONTENT_SKY = -6;     // Sky

4.5 Values : Entity light effects

EF_BRIGHTFIELD = 1;  // Glowing field of dots
EF_MUZZLEFLASH = 2;
EF_BRIGHTLIGHT = 4;
EF_DIMLIGHT = 8;

4.6 Values : Existing Items

IT_AXE = 4096;
IT_SHOTGUN = 1;
IT_SUPER_SHOTGUN = 2;
IT_NAILGUN = 4;
IT_SUPER_NAILGUN = 8;
IT_GRENADE_LAUNCHER = 16;
IT_ROCKET_LAUNCHER = 32;
IT_LIGHTNING = 64;
IT_EXTRA_WEAPON = 128;
IT_SHELLS = 256;
IT_NAILS = 512;
IT_ROCKETS = 1024;
IT_CELLS = 2048;
IT_ARMOR1 = 8192;
IT_ARMOR2 = 16384;
IT_ARMOR3 = 32768;
IT_SUPERHEALTH = 65536;
IT_KEY1 = 131072;
IT_KEY2 = 262144;
IT_INVISIBILITY = 524288;
IT_INVULNERABILITY = 1048576;
IT_SUIT = 2097152;
IT_QUAD = 4194304;

4.7 Values : Behavior of solid objects

SOLID_NOT = 0;                 // no interaction with other objects
                               // inactive triggers
SOLID_TRIGGER = 1;             // touch on edge, but not blocking
                               // active triggers, pickable items
                               // (.MDL models, like armors)
SOLID_BBOX = 2;                // touch on edge, block
                               // pickable items (.BSP models, like ammo box)
                               // grenade, missiles
SOLID_SLIDEBOX = 3;            // touch on edge, but not an onground
                               // most monsters
SOLID_BSP = 4;                 // bsp clip, touch on edge, block
                               // buttons, platforms, doors, missiles

4.8 Values : Type of movements

MOVETYPE_NONE = 0;             // never moves
//float MOVETYPE_ANGLENOCLIP = 1;
//float MOVETYPE_ANGLECLIP = 2;
MOVETYPE_WALK = 3;             // Walking players only
MOVETYPE_STEP = 4;             // Walking monster
MOVETYPE_FLY = 5;              // Hovering Flight
                               // meant for flying monsters (and players)
MOVETYPE_TOSS = 6;             // Balistic flight
                               // meant for gibs and the like
MOVETYPE_PUSH = 7;             // Not blocked by the world, push and crush
                               // meant for doors, spikes and crusing platforms
MOVETYPE_NOCLIP = 8;           // Not blocked by the world
MOVETYPE_FLYMISSILE = 9;       // like fly, but size enlarged against monsters
                               // meant for rockets
MOVETYPE_BOUNCE = 10;          // bounce off walls
MOVETYPE_BOUNCEMISSILE = 11    // bounce off walls, but size enlarged against monsters
                               // meant for grenades

4.9 Values : Entity can take solid damages

DAMAGE_NO = 0;                 // Can't be damaged
DAMAGE_YES = 1;                // Grenades don't explode when touching entity
DAMAGE_AIM = 2;                // Grenades explode when touching entity

4.10 Values : Entity dead flag

DEAD_NO = 0;                   // still living
DEAD_DYING = 1;                // dying (helpless)
DEAD_DEAD = 2;                 // really dead
DEAD_RESPAWNABLE = 3;          // dead, but can respawn

4.11 Values : Spawnflags

  DOOR_START_OPEN = 1;         // allow entity to be lighted in
                               //    closed position
  SPAWN_CRUCIFIED= 1;          // for zombie
  PLAT_LOW_TRIGGER = 1;        // for func_plat
  SPAWNFLAG_NOTOUCH= 1;
  SPAWNFLAG_NOMESSAGE= 1;
  PLAYER_ONLY = 1;
  SPAWNFLAG_SUPERSPIKE = 1;    // for spike shooter
  SECRET_OPEN_ONCE = 1;        // secret door, stays open
  PUSH_ONCE = 1;
  WEAPON_SHOTGUN = 1;          // weapon, shotgun
  H_ROTTEN = 1;                // health, rotten (5-10 points)
  WEAPON_BIG2 = 1;             // items
  START_OFF = 1;               // light, is off at start.
  SILENT = 2;
  SPAWNFLAG_LASER = 2;         // for spike shooter
  SECRET_1ST_LEFT = 2;         // secret door, 1st move is left of arrow
  WEAPON_ROCKET = 2;           // weapon, rocket
  H_MEGA = 2;                  // health, mega (100 points)
  DOOR_DONT_LINK = 4;
  SECRET_1ST_DOWN = 4;         // secret door, 1st move is down from arrow
  WEAPON_SPIKES = 4;           // weapon, nailgun
  DOOR_GOLD_KEY = 8;
  SECRET_NO_SHOOT = 8;         // secret door, only opened by trigger
  WEAPON_BIG = 8;              // weapon, super model
  DOOR_SILVER_KEY = 16;
  SECRET_YES_SHOOT = 16;       // secret door, shootable even if targeted
  DOOR_TOGGLE = 32;

5. Entities

Static entities

A static entity doesn't interact with the rest of the game. These are flames (progs/flame.mdl), lights, illusionary objects, and the like. It is never be necessary to reference such an entity, so they don't get an entity reference number.

A static entity will be created by the function :

        makestatic()

(it causes a spawnstatic message to be sent to every client).
A static entity cannot be removed, once created.

The maximum number of static entities is 127.

Temporary entities

A temporary entity is a short life time entity. For instance, Quake uses these entities for hits on the wall (point-like entities) or for the Thunderbolt flash (line-like entities), gun shots, and anything that is not supposed to last more than one frame.

A temporary entity will be created by sending a valid temporary entity message.
A temporary entity doesn't need to be removed, it disappears by itself.

Dynamic entities

A dynamic entity is anything which changes its behaviour or its appearance. These are ammunition boxes, spinning armors, player models and the like.

A dynamic entity will be created by the sequence :

        entity = spawn();
        setmodel( entity, "progs/entity.mdl" );
        setsize( entity, vector_min, vector_max);
        setorigin( entity, position );

It will have to be removed by the function :

        remove( entity );

The maximum number of dynamic entities is 449.

Definition of entity fields

These are the fields that are available in the entity objects (like self, other). Beware that this is not true object oriented programming : there is no protection when accessing those fields, and no guaranty on the validity of values. So if you put garbage there you will probably crash the game.

You can add custom fields (for instance, to store the ammo count of a new weapon you created) but those fields must not be situated among thoses that are common between Quake-C and Quake.exe. Otherwise, Quake.exe would have to be re-compiled. So those fields must be situated after the fake variable called end_sys_fields, in the field definitions.

Fields shared between Quake.exe and Quake-C.

These fields describe the most common entity fields. They are shared between the C code of Quake.exe, and the Quake-C code of PROGS.DAT.

Some of the fields are managed by the C code : you can read their value, but YOU SHOULD NEVER MODIFY THEIR VALUE DIRECTLY (there are special built-in functions for that).

Technical data

        entity  chain;            // next entity, in a chain list of entities
        float   ltime;            // local time for entity
        float   teleport_time;    // to avoid backing up
        float   spawnflags;       // see possible values.

Appearance of entity

        float   modelindex;       // index of model, in the precached list
        string  classname;        // spawn function
        string  model;

The name of the file that contains the entity model.

        float   frame;

This is the index of the currently displayed model frame. Frames must be defined by a $frame construct in the model file, and manipulated in the code as $xxx (where xxx is the name of the frame).

        float   skin;

This is the index of the model skin currently displayed. If your model has more than one skin defined, then this value indicates the skin in use. You can change it freely, as long as it remains in a valid range. For instance, it's used by the armor model to show the yellow, red or green skin.

        float   effects;

This is a flag that defines the special light effects that the entity is subject to. This can supposedly be used to make an entity glow, or to create a glowing field of dots around it.

Position in 3D

        vector  origin;     // position of model
                            //  origin_x, origin_y, origin_z
        vector  mins;       // bounding box extents reletive to origin
                            //  mins_x, mins_y, mins_z
        vector  maxs;       // bounding box extents reletive to origin
                            //  maxs_x, maxs_y, maxs_z
        vector  size;       // maxs - mins
                            //  size_x,size_y,size_z
        vector  absmin;     // origin + mins and maxs
                            //  absmin_x absmin_y absmin_z
        vector  absmax;     // origin + mins and maxs
                            //  absmax_x absmax_y absmax_z
        vector  oldorigin;  // old position
        vector  angles;     // = 'pitch_angle yaw_angle flip_angle'

Quirks: setting the angles on a player entity doesn't work.

Situation of the entity

        float   waterlevel;     // 0 = not in water, 1 = feet,
                                //    2 = waist, 3 = eyes
        float   watertype;      // a content value
        entity  groundentity;   // indicates that the entity
                                //    moves on the ground

Since groundentity is used nowhere in progs, it's meaning is just a wild guess from a similar field in messages.

Movement in 3D

        vector  velocity;       // = 'speed_x, speed_y, speed_z'
        vector  avelocity;      // = 'pitch_speed yaw_speed 0',
                                //    angle velocity
        vector  punchangle;     // temp angle adjust from damage
                                //    or recoil
        float   movetype;       // type of movement
        float   yaw_speed;      // rotation speed
        float   solid;          // tell if entity can block the
                                //    movements.

Monster's Behavior

        entity  goalentity;     // Monster's movetarget or enemy
        float   ideal_yaw;      // Monster's ideal direction, on paths
        float   yaw_speed;      // Monster's yaw speed.
        string  target;         // Target of a monster
        string  targetname;     // name of the target

Automatic Behavior

        float   nextthink;      // next time when entity must act
        void()  think;          // function invoked when entity
                                //    must act
        void()  touch;          // function invoked if entity is
                                      touched
        void()  use;            // function invoked if entity is
                                //    used
        void()  blocked;        // function for doors or plats,
                                //    called when can't push

        // ### RWA, addition ###
        entity  other;          // entity that triggered event on
                                //    'self'

        vector  movedir;        // mostly for doors, but also used
                                //    for waterjump
        string  message;        // trigger messages
        float   sounds;         // either a cd track number or sound
                                //    number
        string  noise;          // sound played on entity noise
                                //    channel 1
        string  noise1;         // ...
        string  noise2;
        string  noise3;

Information by Abducted :
When you want an entity to do something specific, after a certain delay (exploding, disapearing, or the like...), you set next thing to that delay (in seconds), and set think to the function to execute.

Information by Greg Lewis :
It seems that the touch function is called before the field is checked, so you can set this type in the touch function, and it will immediatly be taken into account.

Player/Monster stats and damage status

        float   deadflag;       // tells if an entity is dead.
        float   health;         // health level
        float   max_health;     // players maximum health is
                                //    stored here
        float   takedamage;     // indicates if entity can be
                                //    damaged
        float   dmg_take;       // damage is accumulated through
                                //    a frame. and sent as one single
        float   dmg_save;       // message, so the super shotgun
                                //    doesn't generate huge messages
        entity  dmg_inflictor;  // entity that inflicted the damage
                                //    (player, monster, missile, door)

Player inventory

        float   items;          // bit flags
        float   armortype;      // fraction of damage absorbed by armor
        float   armorvalue;     // armor level
        float   weapon;         // one of the IT_SHOTGUN, etc flags
        string  weaponmodel;    // entity model for weapon
        float   weaponframe;    // frame for weapon model
        float   currentammo;    // ammo for current weapon
        float   ammo_shells;    // remaining shells
        float   ammo_nails;     // remaining nails
        float   ammo_rockets;   // remaining rockets and grenades
        float   ammo_cells;     // remaining lightning bolts
        float   impulse;        // weapon changes

When set to 0, the player's weapon doesn't change. When different from zero, this field is interpreted by the Quake-C
impulse command as a request to change weapon (see ImpulseCommand).

Player Fight

        entity  owner;          // Entity that owns this one (missiles,
                                //    bubbles are owned by the player)
        entity  enemy;          // personal enemy (only for monster entities)
        float   button0;        // fire
        float   button1;        // use
        float   button2;        // jump

        vector  view_ofs;       // position of player eye, relative to origin

        float   fixangle;       // set to 1 if you want angles to change now
        vector  v_angle;        // view or targeting angle for players
        float   idealpitch;     // calculated pitch angle for lookup up slopes
        entity  aiment;         // aimed antity?

Deathmatch

        float   frags;          // number of frags
        string  netname;        // name, in network play
        float   colormap;       // colors of shirt and pants
        float   team;           // team number
        float   flags;          // ?

Fields used only by Quake-C (User defined)

These entity fields are used only by Quake-C programs, and are never referenced by the C code of Quake.exe. So you can do whatever you want with the values, so long as it's compatible with what other Quake-C modules do.

If the fields defined here are not suitable for you, you can define new fields, by adding them at the end of the defintion of fields. As a matter of fact, the number of fields in an entity (hence the size of all the instances of entity objects) is determined by Quake-C: in the PROGS.DAT header, a value named entityfields indicates to Quake.exe the size of the entity object.

Beware however that the more field you add, the more each entity will suck memory. Add just one float (4 bytes) and it will take, in memory, 4 bytes time the number of entity.

The best is to share fields between distinct classes of entities, by reusing the same position for another kind of field. If the Quake C Compiler was a real object-oriented compiler, that would be done very safely by single-inheritance (multiple-inheritance would be a deadly mistake). You will also notice that id software has made quite a lousy usage of most of the fields, defining much more than were actually needed, since they are only used by a few entities.

World fields

        string wad;              // name of WAD file
                                 //    with misc graphics
        string map;              // name of the map being
                                 //    played
        float  worldtype;        // see below

worldtype is 0 for a medieval setting, 1 for metal, and 2 for a base setting.
These fields might soon become global variables, so don't rely too much on them.

Quake Ed fields

        string killtarget;
        float light_lev;         // not used by game, but
                                 //    parsed by light util
        float style;

Monster Behaviour

Those functions are called when these specific events happen :

        void() th_stand;         // when stands iddle
        void() th_walk;          // when is walking
        void() th_run;           // when is running
        void() th_missile;       // when a missile comes
        void() th_melee;         // when fighting in melee
        void() th_die;           // when dies

        void(entity attacker, float damage) th_pain;

That function is executed when the monster takes a certain amount of damage from an attacker (a player, or another monster). Will usually cause the monster to turn against the attacker.

Monster state variables

        entity oldenemy;               // mad at this player before
                                       //    taking damage
        float  speed;
        float  lefty;
        float  search_time;
        float  attack_state;

        float   pausetime;
        entity  movetarget;

        Player Only

        float   walkframe;
        float   attack_finished;
        float   pain_finished;         // time when pain sound
                                       //    is finished
        float   invincible_finished;
        float   invisible_finished;
        float   super_damage_finished;
        float   radsuit_finished;
        float   invincible_time;       // time when player cease
                                       //    to be invincible
        float   invincible_sound;
        float   invisible_time;        // time when player cease
                                       //    to be invisible
        float   invisible_sound;
        float   super_time;            // time when quad shot expires?
        float   super_sound;
        float   rad_time;
        float   fly_sound;
        float   axhitme;               // TRUE if hit by axe
        float   show_hostile;          // set to time+0.2 whenever a
                                       //    client fires a weapon or
                                       //    takes damage.  Used to alert.
                                       // monsters that otherwise would
                                       //    let the player go
        float   jump_flag;             // player jump flag
        float   swim_flag;             // player swimming sound flag
        float   air_finished;          // when time > air_finished, start
                                       //    drowning
        float   bubble_count;          // keeps track of the number of bubbles
        string  deathtype;             // keeps track of how the player died

Object stuff

        string  mdl;            // model name?
        vector  mangle;         // angle at start. 'pitch roll yaw'
        vector  oldorigin;      // only used by secret door
        float   t_length;
        float   t_width;

Doors

        vector  dest;
        vector  dest1;
        vector  dest2;
        float   wait;           // time from firing to restarting
        float   delay;          // time from activation to firing
        entity  trigger_field;  // door's trigger entity
        string  noise4;
        float   aflag;
        float   dmg;            // damage done by door when hit

Miscellaneous

        float   cnt;            // counter
        void()  think1;
        vector  finaldest;
        vector  finalangle;
        //
        // triggers
        //
        float   count;          // for counting triggers
        //
        // plats / doors / buttons
        //
        float   lip;
        float   state;
        vector  pos1;
        vector  pos2;           // top and bottom positions
        float   height;
        //
        // sounds
        //
        float   waitmin;
        float   waitmax;
        float   distance;
        float   volume;

Variable : world

the server's world object, which holds all global state for the server, like the deathmatch flags and the body ques.

Variable : time

  float time;               // in seconds

The current game time, a floating point value in seconds. Note that because the entities in the world are simulated sequentially, time is NOT strictly increasing. An impact late in one entity's time slice may set time higher than the think function of the next entity. The difference is limited to 0.1 seconds.

Variable : frametime

  float frametime;           // in seconds

No idea what this can be. Used only when jumping in water.

Variable : self

 entity self;

The entity that is subject to the current function.

Variable : other

 entity other;

The object concerned by an impact, not used for thinks.

Variable : force_retouch

  float force_retouch;  // counter

Force all entities to touch triggers next frame. this is needed because non-moving things don't normally scan for triggers, and when a trigger is created (like a teleport trigger), it needs to catch everything.
It is decremented each frame, so it is usually set to 2 to guarantee everything is touched.

Variable : mapname

  string mapname;

Name of the level map currently being played, like "start".

Variable : deathmatch

  float deathmatch;  // a boolean value, 0 or 1

True if playing deathmatch.

Variable : coop

  float coop;  // a boolean value, 0 or 1

True if playing cooperative.

Variable : teamplay

  float teamplay;  // a boolean value, 0 or 1

True if playing by teams.

Variable : serverflags

  float serverflags;  // bit fields

Propagated from level to level, and used to keep track of the completed episodes. If serverflag & ( 1 << e) is true, then episode e was already completed. Generally equal to player.spawnflags & 15.

Variable : total_secrets

  float total_secrets;  // counter

Number of secrets found by the players. Affected only by trigger_secret.

Variable : found_secrets

  float found_secrets;  // counter

Number of secrets found.

Variable : total_monsters

  float total_monsters;  // counter

Total number of monsters that were spawned, since the begining of the level.

Variable : killed_monsters

  float killed_monsters;  // counter

Store the total number of monsters killed.

Variable : parm1...parm16

  float parm1; // items bit flag (IT_SHOTGUN | IT_AXE )
  float parm2; // health
  float parm3; // armorvalue
  float parm4, parm5, parm6, parm7; // ammo
  float parm8; // weapon
  float parm9; // armortype*100
  float parm10, parm11, parm12, parm13, parm14, parm15, parm16;

Those parameters seem to be a bit of hack. They are used when a client connects. Spawnparms are used to encode information about clients across server level changes.

Functions that are mandatory in Quake-C

Misc

        void main();

Only used for testing progs.

        void StartFrame();

Called at the start of each frame.

Behavior of players

        void PlayerPreThink();

Called with self=player, for every frame, before physics are run.

        void PlayerPostThink();

Called with self=player, for every frame, after physics are run.

Management of network game clients

        void ClientKill();

Called when a player suicides.

        void ClientConnect();

Called when a player connects to a server, but also, for every player, when a new level starts. It is used to announces the new player to every other players.

        void PutClientInServer();

Call after setting the parm1... parm16.

        void ClientDisconnect();

Called when a player disconnects from a server Announce that the player has left the game.

        void SetNewParms();

Called when a client first connects to a server. Sets parm1...parm16 so that they can be saved off for restarts.

        void SetChangeParms();

Call to set parms for self so they can?

7. Model pragma

Model name

        $modelname name

name is the name of the model file defining the object.
ex: $name armor

directory

        $cd dir

Specify the directory where your model file (.MDL) is located.
ex: $cd /evil/models/armor

Special animation flags

        $flags  rotation

This field is not interpreted by Quake-C, but it's useful for the program modelgen that generates the models.
Rotation of the object.
ex: $flags 8
Possible values for the flags : 8, the object keeps rotating, like armors.
Other values are not known yet.

Origin

        $origin x y z

This field is not interpreted by Quake-C, but it's useful for the program modelgen that generates the models. Location of the object within the bounding box, in the quake editor.
ex: $origin 0 0 8

Scale factor

        $scale number

This field is not interpreted by Quake-C, but it's useful for the program modelgen that generates the models. Number comes from the texmake number that is generated.
You can use different values if you want.
ex: $scale 4

Base

        $base  object

This field is not interpreted by Quake-C, but it's useful for the program modelgen that generates the models. Object is the name of a model file, that will be used as a kind of starting position, for animation.

Skin file

        $skin  skinfile

This field is not interpreted by Quake-C, but it's useful for the program modelgen that generates the models. Skinfile is the name (without extension) of the .lbm file that defines the skin of the object, as generated by the program texmake.

Frame definitions

        $frame  frame1 frame2 ...

This defines several animation frames of the object.
For every animation frame defined, you must also define a Quake-C function, that will be called during this animation frame. For instance :

        $frame walk1 walk2 walk3 walk4
        void() man_walk1 = [ $walk1, man_walk2 ] { ... some code ... };
        void() man_walk2 = [ $walk2, man_walk3 ] { ... some code ... };
        void() man_walk3 = [ $walk3, man_walk4 ] { ... some code ... };
        void() man_walk4 = [ $walk4, man_walk1 ] { ... some code ... };

In the brackets, the first parameter defines the name of the frame (as found in the model file), and the second parameter defined the function that is to be executed in the next frame (by setting the value of self.nextthink).

8. Network protocol

Definitions related to protocol messages

Values : How messages are sent

        MSG_BROADCAST = 0;  // unreliable message, sent to all
        MSG_ONE = 1;       // reliable message, sent to msg_entity
        MSG_ALL = 2;       // reliable message, sent to all
        MSG_INIT = 3;   // write to the init string

Use unreliable (but fast) messages, when it's of no importance that a client misses the message.
Examples : sound, explosions, monster deaths, taunts....
Use reliable messages when it's very important that every client sees the message, or a game incoherency might happen.
Examples : shots, player deaths, door moves, game ends ... and CD track changes!.

Values: Type of message

These are some of message types defined in the Quake network protocol.

        SVC_SETVIEWPORT = 5;
        SVC_SETANGLES = 10;
        SVC_TEMPENTITY = 23;
        SVC_KILLEDMONSTER = 27;
        SVC_FOUNDSECRET = 28;
        SVC_INTERMISSION = 30;
        SVC_FINALE = 31;
        SVC_CDTRACK = 32;
        SVC_SELLSCREEN = 33;
        SVC_UPDATE = 128;

Some message structures

Message : Set View Position

        msg_entity = player
        WriteByte (MSG_ONE, SVC_SETVIEWPORT);
        WriteEntity( MSG_ONE, camera);

This message is meant for a single client player. It sets the view position to the position of the entity camera.

Message : Set View Angles

        msg_entity = player
        WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
        WriteAngle( MSG_ONE, camera.angles_x);
        WriteAngle( MSG_ONE, camera.angles_y);
        WriteAngle( MSG_ONE, camera.angles_z);

This message is meant for a single client player. It set the orientation of it's view to the same orientation than the entity camera.

Message : Temporary Entity

        WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
        WriteByte (MSG_BROADCAST, entityname);
        WriteCoord (MSG_BROADCAST, origin_x);
        WriteCoord (MSG_BROADCAST, origin_y);
        WriteCoord (MSG_BROADCAST, origin_z);

Message : Set CD Track

        WriteByte (MSG_ALL, SVC_CDTRACK);
        WriteByte (MSG_ALL, val1);        // CD start track
        WriteByte (MSG_ALL, val2);        // CD end track

Message : Final Message

        WriteByte (MSG_ALL, SVC_FINALE);
        WriteString (MSG_ALL, "any text you like\n");

Message : Sell Screen

        WriteByte (MSG_ALL, SVC_SELLSCREEN);

Shows the infamous sell screen (like you needed it to understand).

Message : Inter Mission

        WriteByte (MSG_ALL, SVC_INTERMISSION);

Shows the inter mission camera view.

Message : Killed Monster

        WriteByte (MSG_ALL, SVC_KILLEDMONSTER);

Increase by one the count of killed monsters, as available to the client. Can be displayed with showscores.

Message : Found Secrets

        WriteByte (MSG_ALL, SVC_FOUNDSECRET);

Increase by one the count of secrets founds.

Message: Update Entity

This message has a rather complex structure. I already generated some valid update messages, but since the message structure seems highly susceptible to change in the next versions of Quake, I would recommend that you never use such messages : as a matter of fact, Quake itslef is very capable of generating all the required messages... unless you start creating deathmatch cameras or the like.

9. Network Builtin functions

Global variable for network messages

Variable : msg_entity

        entity  msg_entity;

If you want to send a message to just one entity e, then set msg_entity= e and send the message with flag MSG_ONE, instead of MSG_ALL.
Never used. Maybe it doesn't even work.

Builtin functions for composing network messages

10. Tips & tricks

The names of variable and functions must be unique.

The names of functions, variables and fields must be unique. For instance, you cannot define a variable with the same name as a field. However, local variables can be defined more than once (they had better!).

Composition of function is not supported

Since all the functions use a single parameter marshaling area, and a single global variable to store their reture result, you should NEVER try to call a function within another function call.
Example : printing the coordinate of entity self

    sprintf(self, vtos( self.origin ));

will fail miserably (sending the message somewhere in hell), so it should be replaced by :

    text = vtos( self.origin );
    sprintf(self, text);

Unfortunately, this also applies to operators :

   sum = anglestovec( 45) + anglestovec( 90);

will fail an should be replaced by :

   sum = anglestovec( 45);
   sum = sum + anglestovec( 90);

Actually, Quake-C is rather lame as a compiler, and you will probably make hundred of little mistakes like that, that the compiler will not warn you of. But remember Quake-C was built for "performance", not ease of use. And also that it wasn't designed by people from the MIT. Remember also that you got it for free... you can always get gcc (the Gnu C Compiler) for the same price ;-)

You cannot initialise variable with default values.

If you give a default value to a quake-C variable, this variable will be considered as a constant. And since the value of constants is not supposed to change, your program may not work properly after that.

Coordinates are relative to the world.

All the geometry (coordinate positions, directions, angles) are relative to the world. They are never relative to a given object. To know the direction an object is facing, you have to require calculation of the v_front vector (respectively v_right and v_up for the right, and the top).

Frequently Asked Questions about Quake-C

How do I change the viewpoint?

You would like that a given player sees through the eyes of another entity. This commonly happens at the end of the level (all players see through a camera), or when the player head is severed (gibbed), or when a player is invisible (he only exists as his eyes).

But the example above work by changing the player entity, and what you want is probably just to see through a camera (Duke3D) or a missile (Descent).

This operation is known in the Quake network protocol as a setview message. But nowhere it's defined in Quake-C, and there's no function to change the view port. So the solution is to encode a set view port message, followed by a set view angles message (to take the orientation of the camera).

This works fine, except that if, for some reason, the entity you are using as a camera was not previously declared to the client, then the view port will be set to '0 0 0', which is usually somewhere in the void.

How do I teleport a player into another server

A trick by Steven Lang ([email protected])

    // In the slipgate touch function
    // other = entity that touched
    if(other.classname == "player")
      stuffcmd(other, "connect server.address\n");  // send command

When the slipgate is touched, the entity jumps to another server.

Trouble : the player stats and weapons won't be preserved, and the player would be dumped to the console if the other server was full or not available.
That's why John Carmack, will rewrite the code of Quake.exe to implement his Quake World proposal, and advanced server with all kinds of goodies... permission lists, ability to block an IP, etc. (info from quake-c list).

How do I manipulate strings in Quake-C ?

Well, you can have any kind of strings, as long as they cannot be changed.

"In Ford we trust" (Brave New World).

Mind you, pr_comp.c, defines only operations = == != on strings.

How to read string variables, or text messages ?

Well, if you know, tell, that would make a nice addition to this specs.

How do I move an entity in Quake-C ?

You have better not touch it's position, else some stuff in the C code might not be valid anymore. So you call the setposition() built-in function.

How to change the velocity of an entity (make it bounce off walls) ?

Information by Greg Lewis.
It seems that an entity's velocity can't be changed in the Touch function of the entity.
Making the calculations there will be of no use. So just set entity .movetype to MOVETYPE_BOUNCE, entity.nextthink to 0.1 (to let it bounce off), and set entity.think to the name of a function that, when called 0.1 second later, will set entity.velocity to the right direction.

How to calculate the direction a player is facing?

Assuming the player is self, the entity field self.angles contains the orientation angles of the player (as set by moving the mouse).

Then the function makeverctors( self.angles) will calculate three vectors, that point in the direction the player is facing, but also to the right of the player (strafing direction) and to the direction the player is standing.

Note that those vectors are normalised to 1, so if you want to know what lays 100 units in front of the player, use self.origin + 100 * facing.

How to send a message to a client when he logs in ?

It has been noticed that using a sprint() in function ClientConnect just plain doesn't send any message at all. Maybe the client is not ready to receive messages at this point.

However, Doug Keenan has reported he could send such a text message by putting the sprint() close to the begining of the ClientConnect function. It doesn't work at the end, apparently.

Writing Quake-C code

1. Please put comments in your code

Of course, the real gurus don't need comments. They understand raw Quake-C, even compiled. They can even imagine all the parts of your code before they read them. Even before you write them. But actually, they seldom read your code. Only normal people do.

2. Please tag the begining and end of your modifications, if you are fixing a code from someone else

Also put a date, and put a reason for the fix.
Example :

           // Patch by Nezu The Unworthy  8/3/96
           // Gimme a chance to win a deathmatch
           if(self.name != "nezu")
             self.frag = self.frag - 10;
           // Patch End

3. Creating new elements

Each time you create a new function, a new variable or a new field, please give it a name that will not conflict with function or variable defined by others.
A rather sure way to do this is to prefix every name with some abvreviated module name, or you initials, or whatever rare combination of three or four letter.
Example :

         void() NTU_think =  // Nezu The Unworthy starts thinking
         {
            self.skin = 1;   // turn red and boil
         };

4. Implementing new functions

Each time you implement some set of related functions, you should create a new Quake-C module, and give it a name different from the existing ones.
Please do not use one of the module names used by Id Software, this would be confusing. Try to be original, else we might end-up with two hundred modules called impulse.qc.

5. When you want to distribute some modified Quake-C programs :

Include a file_id.diz file explaining in 5 lines what your patch does, and where it should be stored in the archives (this file is to be read by system administrators).
Include a readme.txt file explaining in details what your patch does, how it does it, and what common files you had to modify.
Include the .qc modules that you created from scratch.
For the modules you modified, please let them pass through the utilities diff (see below), so that the original file can be patched the utility patch. Even if it has been modified since. Do not distribute modified .qc modules. Future versions of Quake will contain different code, and all your work would then be lost.

6. Compile and distribute

You should compile and distribute a version of your code, as a single PROGS.DAT file, to be used by those who just wanna have fun. Don't forget them, they largely overnumber the people who directly deal with Quake-C.

7. Upload your Quake-C patches to the primary quake ftp site at ftp.cdrom.com

Maybe if it's good enough it will also appear in the Quake-C code repository.

Using Diff and Patch

To make a diff :

• Start with yourdir/ with an entire working set of .qc files, and v101qc/ with the virgin qc files from Id Software,
• diff -ur --new-file v101qc yourdir > patchfil

To patch with a diff :

• Copy everything in v101qc (or yourdir if you want to add these patches to your already-customized setup) to newdir,
• Change to newdir
• Patch -p1 < patchfil
• Look for any "rejected" patches and apply them by hand using your favorite 2-window text editor. These should be few or none if the author kept his changes well-structured or you patched from exactly the same source he diffed from.

11. Basic Types

Simple Types

Type : void

An empty result, mostly used for definition of procedures (i.e. functions that return no result at all).

Type : float

A floating point value.

Floats are also used to store booleans (TRUE, FALSE) or integer values linke counters, or bit flags.

    Valid syntax: 12  1.6   0.5   -100
    Invalid syntax: .5

A parsing ambiguity is present with negative constants. "a-5" will be parsed as "a", then "-5", causing an error. Separate the - from the digits with a space "a - 5" to get the proper behavior.

Type : vector

A vector, made of 3 float coordinates.
Used to represent positions or directions in 3D space.
Valid syntax : '0 0 0' or '20.5 -10 0.00001'

Note the simple quotes around the vector. Do not use double quotes, they are reserved for strings.

If you declare a vector foobar, then you can access it's x, y and z fields with : foobar_x, foobar_y, foobar_z.

Type : string

Represents a character string.
Used to indicate file names, or messages to be broadcast to players.
Valid syntax: "maps/jrwiz1.bsp" or "ouch!\n".
Use \n for newline.

Type : entity

The reference of an entity in the game, like things, players, monsters.
For instance, this is the type of the entities self and other.

The entity type is a structured type, made of fields.
A description of each field is available.

Field types

• float field_name;
• string field_name;
• vector field_name;
• entity field_name;

12. Compilation of Quake-C

    // in headers
    void()      MyFunction;             // the prototype
    // later
    void()      MyFunction =            // the initialization
    { dprint ("we're here\n"); };

13. Execution of Quake-C

14. Examples

14.1 Looping between all monster

float() Pet_FindTarget =
{
	local entity	client;
	local float	r;
        local entity head, selected;
	local float dist;



        dist = 10000;
	selected = world;
	head = findradius(self.origin, 10000);
	while(head)
	{
		if( (head.health > 1) && (head != self) && (head != self.owner))
		{
			traceline(self.origin,head.origin,TRUE,self);
			if ( (trace_fraction >= 1) && (vlen(head.origin - self.origin) < dist)
                                && (head.owner != self.owner))
			{
				selected = head;
				dist = vlen(head.origin - self.origin);
			}
		}
		head = head.chain;
	}
	if (selected != world)
	{
		sprint (self.owner,"Pet attacking -> ");
		if (selected.classname == "player")
		{
			sprint (self.owner,selected.netname);
			sprint (selected,self.owner.netname);
			sprint (selected," sent one of his minions after you!\n");
		}
		else
			sprint (self.owner,selected.classname);
		sprint (self.owner,"\n");
                self.enemy = selected;
                FoundTarget ();

                return TRUE;
	}


    if (self.goalentity != self.owner)
    {
        self.goalentity = self.owner;
        self.think = self.th_run;
    }
    self.ideal_yaw = vectoyaw(self.owner.origin - self.origin);
    self.nextthink = time+0.1;
    return FALSE;
};

14.2 Creating a new entity

void(entity myself) ActivateHolo =
{
	local entity	newholo;

	newholo = spawn();
	newholo.solid = SOLID_NOT;
	newholo.movetype = MOVETYPE_NOCLIP;
	newholo.origin = myself.origin;
	newholo.angles = myself.angles;
	newholo.colormap = myself.colormap;
	setmodel (newholo, "progs/player.mdl");
	newholo.classname = "holo";
	newholo.owner=myself;
	newholo.frame=13;
	newholo.nextthink = time + 8;
	newholo.think = RemoveHolo;
	myself.currentammo = myself.ammo_cells = myself.ammo_cells - 10;
	myself.items = myself.items | IT_HOLO;
	stuffcmd (newholo.owner, "bf\n");
	sprint(newholo.owner,"holograph activated\n");
};

14.3 Setting point of view

void(entity me, entity camera) NezuSetViewPoint =
{
  // Set view point
  msg_entity = me;                         // target of message
  WriteByte (MSG_ONE, SVC_SETVIEWPORT);    // 5 = SVC_SETVIEWPORT;
  WriteEntity (MSG_ONE, camera);           // view port
  // Also set angles, otherwise it feels strange
  // NezuSetViewAngle(me, camera.angles);
  WriteByte (MSG_ONE, SVC_SETVIEWANGLES);  // 10 = SVC_SETVIEWANGLES
  WriteAngle(MSG_ONE, camera.angles_x);    // tilt
  WriteAngle(MSG_ONE, camera.angles_y);    // yaw
  WriteAngle(MSG_ONE, camera.angles_z);    // flip
};

14.4 Teleporting

void() Teleport_to_bomb =
{
	local entity oldself,bdest;

	bdest=spawn();
	bdest.origin = self.telebomb.origin + '0 0 27';

	// Blow up the bomb...
	oldself=self;
	self=self.telebomb;
	GrenadeExplode();
	self=oldself;


	// Teleport to the bomb's old location

	if(self.health <= 0)  {
		remove(bdest);
		return;
	}

	// Recreating the "teleport_touch" function here, once again

	spawn_tfog (bdest.origin);

	spawn_tfog (bdest.origin);
	spawn_tdeath (bdest.origin,self);

	setorigin (self,bdest.origin);

	self.teleport_time = time + 1;  // Longer teleport recovery time
	self.flags = self.flags - self.flags & FL_ONGROUND;

	remove(bdest);
};

14.5 Throwing your eyes

        if (self.impulse == 254)
        {
                local vector v;

                eyes = spawn();
                setmodel (eyes,"progs/eyes.mdl");
                eyes.movetype = MOVETYPE_BOUNCE;
                eyes.solid = SOLID_BBOX;
                eyes.effects = eyes.effects | EF_DIMLIGHT;
                msg_entity = self;

                WriteByte (MSG_ONE, SVC_SETVIEWPORT);
                WriteEntity (MSG_ONE, eyes);
                WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
                WriteAngle(MSG_ONE, self.angles_x);
                WriteAngle(MSG_ONE, self.angles_y);
                WriteAngle(MSG_ONE, self.angles_z);

                makevectors (self.v_angle);

                if (self.v_angle_x)
	                eyes.velocity = v_forward*600 + v_up * 200 + crandom()*v_right*10 + crandom()*v_up*10;
                else
                {
	                eyes.velocity = aim(self, 10000);
                        eyes.velocity = eyes.velocity * 600;
                        eyes.velocity_z = 200;
                }

                eyes.avelocity = '300 300 300';

                eyes.angles = vectoangles(eyes.velocity);

                setsize (eyes, '-3 -3 -3', '3 3 3');
                setorigin (eyes, self.origin);

        }
        if (self.impulse == 253)
        {
                local vector v;

                msg_entity = self;
                WriteByte (MSG_ONE, SVC_SETVIEWPORT);
                WriteEntity (MSG_ONE, self);
                WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
                v = vectoangles(eyes.origin - self.origin);
                WriteAngle(MSG_ONE, v_x);
                WriteAngle(MSG_ONE, v_y);
                WriteAngle(MSG_ONE, v_z);
                remove(eyes);
        }

14.6 Radar

if (cvar("temp1")==1)
{
   local entity head,selected;
   local float min,dist;

   if (radar_time==0) radar_time=time;
      if (time>=radar_time)
      {
         min=2000;
         head = findradius(self.origin,1000);
         selected = world;

         while (head)
         {
            dist = vlen(self.origin - head.origin);
            if( (head.health > 1) && (head != self) && (head != self.owner) && (dist<min) )
            {
               min=dist;
               selected=head;
            }
            head = head.chain;
         }
         sound (selected, CHAN_AUTO, "radar.wav", 1, ATTN_NORM);
         radar_time = min / 600;
         radar_time = radar_time + time;
      }
}