home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga ACS 1998 #6
/
amigaacscoverdisc1998-061998.iso
/
games
/
descent
/
source
/
lib
/
robot.h
< prev
next >
Wrap
Text File
|
1998-06-08
|
8KB
|
225 lines
/*
* $Source: f:/miner/source/main/rcs/robot.h $
* $Revision: 2.1 $
* $Author: john $
* $Date: 1995/03/07 16:52:00 $
*
* Header for robot.c
*
* $Log: robot.h $
* Revision 2.1 1995/03/07 16:52:00 john
* Fixed robots not moving without edtiro bug.
*
* Revision 2.0 1995/02/27 11:30:59 john
* New version 2.0, which has no anonymous unions, builds with
* Watcom 10.0, and doesn't require parsing BITMAPS.TBL.
*
* Revision 1.25 1994/11/30 14:02:44 mike
* fields for see/attack/claw sounds.
*
* Revision 1.24 1994/10/27 15:55:41 adam
* *** empty log message ***
*
* Revision 1.23 1994/10/20 15:17:03 mike
* Add boss flag.
*
* Revision 1.22 1994/10/20 09:51:00 adam
* *** empty log message ***
*
* Revision 1.21 1994/10/18 10:52:54 mike
* Support robots lunging as an attack_type.
*
* Revision 1.20 1994/10/17 21:19:02 mike
* robot cloaking.
*
* Revision 1.19 1994/09/27 00:03:39 mike
* Add score_value to robot_info struct.
*
* Revision 1.18 1994/09/22 19:01:12 mike
* Move NDL from here to game.h
*
* Revision 1.17 1994/09/22 15:46:55 mike
* Add default contained objects for robots.
*
* Revision 1.16 1994/09/22 10:46:57 mike
* Add difficulty levels.
*
* Revision 1.15 1994/09/15 16:34:16 mike
* Change rapidfire_count to a byte, add evade_speed, dum1, dum2.
*
* Revision 1.14 1994/09/09 14:21:58 matt
* Increased maximum number of games
*
* Revision 1.13 1994/08/25 18:12:13 matt
* Made player's weapons and flares fire from the positions on the 3d model.
* Also added support for quad lasers.
*
* Revision 1.12 1994/08/23 16:37:24 mike
* Add rapidfire_count to robot_info.
*
* Revision 1.11 1994/07/27 19:45:01 mike
* Objects containing objects.
*
* Revision 1.10 1994/07/12 12:40:01 matt
* Revamped physics system
*
* Revision 1.9 1994/06/21 12:17:12 mike
* Add circle_distance to robot_info.
*
* Revision 1.8 1994/06/09 16:22:28 matt
* Moved header for calc_gun_point() here, where it belongs
*
* Revision 1.7 1994/06/08 18:16:23 john
* Bunch of new stuff that basically takes constants out of the code
* and puts them into bitmaps.tbl.
*
* Revision 1.6 1994/06/03 11:38:09 john
* Made robots get their strength for RobotInfo->strength, which
* is read in from bitmaps.tbl
*
* Revision 1.5 1994/05/30 19:43:31 mike
* Add voluminous comment for robot_get_anim_state.
*
* Revision 1.4 1994/05/30 00:03:18 matt
* Got rid of robot render type, and generally cleaned up polygon model
* render objects.
*
* Revision 1.3 1994/05/29 18:46:37 matt
* Added stuff for getting robot animation info for different states
*
* Revision 1.2 1994/05/26 21:09:18 matt
* Moved robot stuff out of polygon model and into robot_info struct
* Made new file, robot.c, to deal with robots
*
* Revision 1.1 1994/05/26 18:02:12 matt
* Initial revision
*
*
*/
#ifndef _ROBOT_H
#define _ROBOT_H
#include "vecmat.h"
#include "object.h"
#include "game.h"
#define MAX_GUNS 8 //should be multiple of 4 for ubyte array
//Animation states
#define AS_REST 0
#define AS_ALERT 1
#define AS_FIRE 2
#define AS_RECOIL 3
#define AS_FLINCH 4
#define N_ANIM_STATES 5
#define RI_CLOAKED_NEVER 0
#define RI_CLOAKED_ALWAYS 1
#define RI_CLOAKED_EXCEPT_FIRING 2
//describes the position of a certain joint
typedef struct jointpos {
short jointnum;
vms_angvec angles;
} jointpos;
//describes a list of joint positions
typedef struct jointlist {
short n_joints;
short offset;
} jointlist;
// Robot information
typedef struct robot_info {
int model_num; // which polygon model?
int n_guns; // how many different gun positions
vms_vector gun_points[MAX_GUNS]; // where each gun model is
ubyte gun_submodels[MAX_GUNS]; // which submodel is each gun in?
short exp1_vclip_num;
short exp1_sound_num;
short exp2_vclip_num;
short exp2_sound_num;
short weapon_type;
byte contains_id; // ID of powerup this robot can contain.
byte contains_count; // Max number of things this instance can contain.
byte contains_prob; // Probability that this instance will contain something in N/16
byte contains_type; // Type of thing contained, robot or powerup, in bitmaps.tbl, !0=robot, 0=powerup
int score_value; // Score from this robot.
fix lighting; // should this be here or with polygon model?
fix strength; // Initial shields of robot
fix mass; // how heavy is this thing?
fix drag; // how much drag does it have?
fix field_of_view[NDL]; // compare this value with forward_vector.dot.vector_to_player, if field_of_view <, then robot can see player
fix firing_wait[NDL]; // time in seconds between shots
fix turn_time[NDL]; // time in seconds to rotate 360 degrees in a dimension
fix fire_power[NDL]; // damage done by a hit from this robot
fix shield[NDL]; // shield strength of this robot
fix max_speed[NDL]; // maximum speed attainable by this robot
fix circle_distance[NDL]; // distance at which robot circles player
byte rapidfire_count[NDL]; // number of shots fired rapidly
byte evade_speed[NDL]; // rate at which robot can evade shots, 0=none, 4=very fast
byte cloak_type; // 0=never, 1=always, 2=except-when-firing
byte attack_type; // 0=firing, 1=charge (like green guy)
byte boss_flag; // 0 = not boss, 1 = boss. Is that surprising?
ubyte see_sound; // sound robot makes when it first sees the player
ubyte attack_sound; // sound robot makes when it attacks the player
ubyte claw_sound; // sound robot makes as it claws you (attack_type should be 1)
//animation info
jointlist anim_states[MAX_GUNS+1][N_ANIM_STATES];
int always_0xabcd; // debugging
} robot_info;
#define MAX_ROBOT_TYPES 30 // maximum number of robot types
#define ROBOT_NAME_LENGTH 16
extern char Robot_names[MAX_ROBOT_TYPES][ROBOT_NAME_LENGTH];
//the array of robots types
extern robot_info Robot_info[]; // Robot info for AI system, loaded from bitmaps.tbl.
//how many kinds of robots
extern int N_robot_types; // Number of robot types. We used to assume this was the same as N_polygon_models.
//test data for one robot
#define MAX_ROBOT_JOINTS 600
extern jointpos Robot_joints[MAX_ROBOT_JOINTS];
extern int N_robot_joints;
//given an object and a gun number, return position in 3-space of gun
//fills in gun_point
void calc_gun_point(vms_vector *gun_point,object *obj,int gun_num);
//void calc_gun_point(vms_vector *gun_point,int objnum,int gun_num);
// Tells joint positions for a gun to be in a specified state.
// A gun can have associated with it any number of joints. In order to tell whether a gun is a certain
// state (such as FIRE or ALERT), you should call this function and check the returned joint positions
// against the robot's gun's joint positions. This function should also be called to determine how to
// move a gun into a desired position.
// For now (May 30, 1994), it is assumed that guns will linearly interpolate from one joint position to another.
// There is no ordering of joint movement, so it's impossible to guarantee that a strange starting position won't
// cause a gun to move through a robot's body, for example.
// Given:
// jp_list_ptr pointer to list of joint angles, on exit, this is pointing at a static array
// robot_type type of robot for which to get joint information. A particular type, not an instance of a robot.
// 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.
// state state about which to get information. Legal states in range 0..N_ANIM_STATES-1, defined in robot.h, are:
// AS_REST, AS_ALERT, AS_FIRE, AS_RECOIL, AS_FLINCH
// On exit:
// Returns number of joints in list.
// jp_list_ptr is stuffed with a pointer to a static array of joint positions. This pointer is valid forever.
extern int robot_get_anim_state(jointpos **jp_list_ptr,int robot_type,int gun_num,int state);
#endif