main/robot.h

   1 /* $Id: robot.h,v 1.3 2002-08-02 04:57:19 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15
  16
  17 #ifndef _ROBOT_H
  18 #define _ROBOT_H
  19
  20 #include "vecmat.h"
  21 #include "object.h"
  22 #include "game.h"
  23 #include "cfile.h"
  24
  25 #define MAX_GUNS 8      //should be multiple of 4 for ubyte array
  26
  27 //Animation states
  28 #define AS_REST         0
  29 #define AS_ALERT        1
  30 #define AS_FIRE         2
  31 #define AS_RECOIL       3
  32 #define AS_FLINCH       4
  33 #define N_ANIM_STATES   5
  34
  35 #define RI_CLOAKED_NEVER            0
  36 #define RI_CLOAKED_ALWAYS           1
  37 #define RI_CLOAKED_EXCEPT_FIRING    2
  38
  39 //describes the position of a certain joint
  40 typedef struct jointpos {
  41         short jointnum;
  42         vms_angvec angles;
  43 } __pack__ jointpos;
  44
  45 //describes a list of joint positions
  46 typedef struct jointlist {
  47         short n_joints;
  48         short offset;
  49 } jointlist;
  50
  51 //robot info flags
  52 #define RIF_BIG_RADIUS  1   //pad the radius to fix robots firing through walls
  53 #define RIF_THIEF       2   //this guy steals!
  54
  55 //  Robot information
  56 typedef struct robot_info {
  57         int     model_num;                  // which polygon model?
  58         vms_vector  gun_points[MAX_GUNS];   // where each gun model is
  59         ubyte   gun_submodels[MAX_GUNS];    // which submodel is each gun in?
  60
  61         short   exp1_vclip_num;
  62         short   exp1_sound_num;
  63
  64         short   exp2_vclip_num;
  65         short   exp2_sound_num;
  66
  67         byte    weapon_type;
  68         byte    weapon_type2;   //  Secondary weapon number, -1 means none, otherwise gun #0 fires this weapon.
  69         byte    n_guns;         // how many different gun positions
  70         byte    contains_id;    //  ID of powerup this robot can contain.
  71
  72         byte    contains_count; //  Max number of things this instance can contain.
  73         byte    contains_prob;  //  Probability that this instance will contain something in N/16
  74         byte    contains_type;  //  Type of thing contained, robot or powerup, in bitmaps.tbl, !0=robot, 0=powerup
  75         byte    kamikaze;       //  !0 means commits suicide when hits you, strength thereof. 0 means no.
  76
  77         short   score_value;    //  Score from this robot.
  78         byte    badass;         //  Dies with badass explosion, and strength thereof, 0 means NO.
  79         byte    energy_drain;   //  Points of energy drained at each collision.
  80
  81         fix     lighting;       // should this be here or with polygon model?
  82         fix     strength;       // Initial shields of robot
  83
  84         fix     mass;           // how heavy is this thing?
  85         fix     drag;           // how much drag does it have?
  86
  87         fix     field_of_view[NDL]; // compare this value with forward_vector.dot.vector_to_player, if field_of_view <, then robot can see player
  88         fix     firing_wait[NDL];   //  time in seconds between shots
  89         fix     firing_wait2[NDL];  //  time in seconds between shots
  90         fix     turn_time[NDL];     // time in seconds to rotate 360 degrees in a dimension
  91 // -- unused, mk, 05/25/95  fix fire_power[NDL];    //  damage done by a hit from this robot
  92 // -- unused, mk, 05/25/95  fix shield[NDL];        //  shield strength of this robot
  93         fix     max_speed[NDL];         //  maximum speed attainable by this robot
  94         fix     circle_distance[NDL];   //  distance at which robot circles player
  95
  96         byte    rapidfire_count[NDL];   //  number of shots fired rapidly
  97         byte    evade_speed[NDL];       //  rate at which robot can evade shots, 0=none, 4=very fast
  98         byte    cloak_type;     //  0=never, 1=always, 2=except-when-firing
  99         byte    attack_type;    //  0=firing, 1=charge (like green guy)
 100
 101         ubyte   see_sound;      //  sound robot makes when it first sees the player
 102         ubyte   attack_sound;   //  sound robot makes when it attacks the player
 103         ubyte   claw_sound;     //  sound robot makes as it claws you (attack_type should be 1)
 104         ubyte   taunt_sound;    //  sound robot makes after you die
 105
 106         byte    boss_flag;      //  0 = not boss, 1 = boss.  Is that surprising?
 107         byte    companion;      //  Companion robot, leads you to things.
 108         byte    smart_blobs;    //  how many smart blobs are emitted when this guy dies!
 109         byte    energy_blobs;   //  how many smart blobs are emitted when this guy gets hit by energy weapon!
 110
 111         byte    thief;          //  !0 means this guy can steal when he collides with you!
 112         byte    pursuit;        //  !0 means pursues player after he goes around a corner.  4 = 4/2 pursue up to 4/2 seconds after becoming invisible if up to 4 segments away
 113         byte    lightcast;      //  Amount of light cast. 1 is default.  10 is very large.
 114         byte    death_roll;     //  0 = dies without death roll. !0 means does death roll, larger = faster and louder
 115
 116         //boss_flag, companion, thief, & pursuit probably should also be bits in the flags byte.
 117         ubyte   flags;          // misc properties
 118         ubyte   pad[3];         // alignment
 119
 120         ubyte   deathroll_sound;    // if has deathroll, what sound?
 121         ubyte   glow;               // apply this light to robot itself. stored as 4:4 fixed-point
 122         ubyte   behavior;           //  Default behavior.
 123         ubyte   aim;                //  255 = perfect, less = more likely to miss.  0 != random, would look stupid.  0=45 degree spread.  Specify in bitmaps.tbl in range 0.0..1.0
 124
 125         //animation info
 126         jointlist anim_states[MAX_GUNS+1][N_ANIM_STATES];
 127
 128         int     always_0xabcd;      // debugging
 129
 130 } __pack__ robot_info;
 131
 132
 133 #define MAX_ROBOT_TYPES 85      // maximum number of robot types
 134
 135 #define ROBOT_NAME_LENGTH   16
 136 extern char Robot_names[MAX_ROBOT_TYPES][ROBOT_NAME_LENGTH];
 137
 138 //the array of robots types
 139 extern robot_info Robot_info[];     // Robot info for AI system, loaded from bitmaps.tbl.
 140
 141 //how many kinds of robots
 142 extern  int N_robot_types;      // Number of robot types.  We used to assume this was the same as N_polygon_models.
 143
 144 //test data for one robot
 145 #define MAX_ROBOT_JOINTS 1600
 146 extern jointpos Robot_joints[MAX_ROBOT_JOINTS];
 147 extern int  N_robot_joints;
 148
 149 //given an object and a gun number, return position in 3-space of gun
 150 //fills in gun_point
 151 void calc_gun_point(vms_vector *gun_point,object *obj,int gun_num);
 152 //void calc_gun_point(vms_vector *gun_point,int objnum,int gun_num);
 153
 154 //  Tells joint positions for a gun to be in a specified state.
 155 //  A gun can have associated with it any number of joints.  In order to tell whether a gun is a certain
 156 //  state (such as FIRE or ALERT), you should call this function and check the returned joint positions
 157 //  against the robot's gun's joint positions.  This function should also be called to determine how to
 158 //  move a gun into a desired position.
 159 //  For now (May 30, 1994), it is assumed that guns will linearly interpolate from one joint position to another.
 160 //  There is no ordering of joint movement, so it's impossible to guarantee that a strange starting position won't
 161 //  cause a gun to move through a robot's body, for example.
 162
 163 //  Given:
 164 //      jp_list_ptr     pointer to list of joint angles, on exit, this is pointing at a static array
 165 //      robot_type      type of robot for which to get joint information.  A particular type, not an instance of a robot.
 166 //      gun_num         gun number.  If in 0..Robot_info[robot_type].n_guns-1, then it is a gun, else it refers to non-animating parts of robot.
 167 //      state           state about which to get information.  Legal states in range 0..N_ANIM_STATES-1, defined in robot.h, are:
 168 //                          AS_REST, AS_ALERT, AS_FIRE, AS_RECOIL, AS_FLINCH
 169
 170 //  On exit:
 171 //      Returns number of joints in list.
 172 //      jp_list_ptr is stuffed with a pointer to a static array of joint positions.  This pointer is valid forever.
 173 extern int robot_get_anim_state(jointpos **jp_list_ptr,int robot_type,int gun_num,int state);
 174
 175 #ifdef FAST_FILE_IO
 176 #define robot_info_read_n(ri, n, fp) cfread(ri, sizeof(robot_info), n, fp)
 177 #define jointpos_read_n(jp, n, fp) cfread(jp, sizeof(jointpos), n, fp)
 178 #else
 179 /*
 180  * reads n robot_info structs from a CFILE
 181  */
 182 extern int robot_info_read_n(robot_info *ri, int n, CFILE *fp);
 183
 184 /*
 185  * reads n jointpos structs from a CFILE
 186  */
 187 extern int jointpos_read_n(jointpos *jp, int n, CFILE *fp);
 188 #endif
 189
 190 #endif