2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
24 #define MAX_GUNS 8 //should be multiple of 4 for ubyte array
32 #define N_ANIM_STATES 5
34 #define RI_CLOAKED_NEVER 0
35 #define RI_CLOAKED_ALWAYS 1
36 #define RI_CLOAKED_EXCEPT_FIRING 2
38 //describes the position of a certain joint
39 typedef struct jointpos {
44 //describes a list of joint positions
45 typedef struct jointlist {
51 #define RIF_BIG_RADIUS 1 //pad the radius to fix robots firing through walls
52 #define RIF_THIEF 2 //this guy steals!
55 typedef struct robot_info {
56 int model_num; // which polygon model?
57 vms_vector gun_points[MAX_GUNS]; // where each gun model is
58 ubyte gun_submodels[MAX_GUNS]; // which submodel is each gun in?
67 byte weapon_type2; // Secondary weapon number, -1 means none, otherwise gun #0 fires this weapon.
68 byte n_guns; // how many different gun positions
69 byte contains_id; // ID of powerup this robot can contain.
71 byte contains_count; // Max number of things this instance can contain.
72 byte contains_prob; // Probability that this instance will contain something in N/16
73 byte contains_type; // Type of thing contained, robot or powerup, in bitmaps.tbl, !0=robot, 0=powerup
74 byte kamikaze; // !0 means commits suicide when hits you, strength thereof. 0 means no.
76 short score_value; // Score from this robot.
77 byte badass; // Dies with badass explosion, and strength thereof, 0 means NO.
78 byte energy_drain; // Points of energy drained at each collision.
80 fix lighting; // should this be here or with polygon model?
81 fix strength; // Initial shields of robot
83 fix mass; // how heavy is this thing?
84 fix drag; // how much drag does it have?
86 fix field_of_view[NDL]; // compare this value with forward_vector.dot.vector_to_player, if field_of_view <, then robot can see player
87 fix firing_wait[NDL]; // time in seconds between shots
88 fix firing_wait2[NDL]; // time in seconds between shots
89 fix turn_time[NDL]; // time in seconds to rotate 360 degrees in a dimension
90 // -- unused, mk, 05/25/95 fix fire_power[NDL]; // damage done by a hit from this robot
91 // -- unused, mk, 05/25/95 fix shield[NDL]; // shield strength of this robot
92 fix max_speed[NDL]; // maximum speed attainable by this robot
93 fix circle_distance[NDL]; // distance at which robot circles player
95 byte rapidfire_count[NDL]; // number of shots fired rapidly
96 byte evade_speed[NDL]; // rate at which robot can evade shots, 0=none, 4=very fast
97 byte cloak_type; // 0=never, 1=always, 2=except-when-firing
98 byte attack_type; // 0=firing, 1=charge (like green guy)
100 ubyte see_sound; // sound robot makes when it first sees the player
101 ubyte attack_sound; // sound robot makes when it attacks the player
102 ubyte claw_sound; // sound robot makes as it claws you (attack_type should be 1)
103 ubyte taunt_sound; // sound robot makes after you die
105 byte boss_flag; // 0 = not boss, 1 = boss. Is that surprising?
106 byte companion; // Companion robot, leads you to things.
107 byte smart_blobs; // how many smart blobs are emitted when this guy dies!
108 byte energy_blobs; // how many smart blobs are emitted when this guy gets hit by energy weapon!
110 byte thief; // !0 means this guy can steal when he collides with you!
111 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
112 byte lightcast; // Amount of light cast. 1 is default. 10 is very large.
113 byte death_roll; // 0 = dies without death roll. !0 means does death roll, larger = faster and louder
115 //boss_flag, companion, thief, & pursuit probably should also be bits in the flags byte.
116 ubyte flags; // misc properties
117 ubyte pad[3]; // alignment
119 ubyte deathroll_sound; // if has deathroll, what sound?
120 ubyte glow; // apply this light to robot itself. stored as 4:4 fixed-point
121 ubyte behavior; // Default behavior.
122 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
125 jointlist anim_states[MAX_GUNS+1][N_ANIM_STATES];
127 int always_0xabcd; // debugging
132 #define MAX_ROBOT_TYPES 85 // maximum number of robot types
134 #define ROBOT_NAME_LENGTH 16
135 extern char Robot_names[MAX_ROBOT_TYPES][ROBOT_NAME_LENGTH];
137 //the array of robots types
138 extern robot_info Robot_info[]; // Robot info for AI system, loaded from bitmaps.tbl.
140 //how many kinds of robots
141 extern int N_robot_types; // Number of robot types. We used to assume this was the same as N_polygon_models.
143 //test data for one robot
144 #define MAX_ROBOT_JOINTS 1600
145 extern jointpos Robot_joints[MAX_ROBOT_JOINTS];
146 extern int N_robot_joints;
148 //given an object and a gun number, return position in 3-space of gun
150 void calc_gun_point(vms_vector *gun_point,object *obj,int gun_num);
151 //void calc_gun_point(vms_vector *gun_point,int objnum,int gun_num);
153 // Tells joint positions for a gun to be in a specified state.
154 // A gun can have associated with it any number of joints. In order to tell whether a gun is a certain
155 // state (such as FIRE or ALERT), you should call this function and check the returned joint positions
156 // against the robot's gun's joint positions. This function should also be called to determine how to
157 // move a gun into a desired position.
158 // For now (May 30, 1994), it is assumed that guns will linearly interpolate from one joint position to another.
159 // There is no ordering of joint movement, so it's impossible to guarantee that a strange starting position won't
160 // cause a gun to move through a robot's body, for example.
163 // jp_list_ptr pointer to list of joint angles, on exit, this is pointing at a static array
164 // robot_type type of robot for which to get joint information. A particular type, not an instance of a robot.
165 // 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.
166 // state state about which to get information. Legal states in range 0..N_ANIM_STATES-1, defined in robot.h, are:
167 // AS_REST, AS_ALERT, AS_FIRE, AS_RECOIL, AS_FLINCH
170 // Returns number of joints in list.
171 // jp_list_ptr is stuffed with a pointer to a static array of joint positions. This pointer is valid forever.
172 extern int robot_get_anim_state(jointpos **jp_list_ptr,int robot_type,int gun_num,int state);
175 * reads a robot_info structure from a CFILE
177 extern void robot_info_read(robot_info *ri, CFILE *fp);
180 * reads a jointpos structure from a CFILE
182 extern void jointpos_read(jointpos *jp, CFILE *fp);