Makefile and conf.h fixes
[btb/d2x.git] / main / robot.c
1 /*
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.
12 */
13
14 #ifdef HAVE_CONFIG_H
15 #include <conf.h>
16 #endif
17
18 #include <stdio.h>
19
20 #include "error.h"
21
22 #include "inferno.h"
23
24 #include "robot.h"
25 #include "object.h"
26 #include "polyobj.h"
27 #include "mono.h"
28
29 int     N_robot_types = 0;
30 int     N_robot_joints = 0;
31
32 //      Robot stuff
33 robot_info Robot_info[MAX_ROBOT_TYPES];
34
35 //Big array of joint positions.  All robots index into this array
36
37 #define deg(a) ((int) (a) * 32768 / 180)
38
39 //test data for one robot
40 jointpos Robot_joints[MAX_ROBOT_JOINTS] = {
41
42 //gun 0
43                                         {2,{deg(-30),0,0}},             //rest (2 joints)
44                                         {3,{deg(-40),0,0}},
45
46                                         {2,{deg(0),0,0}},                       //alert
47                                         {3,{deg(0),0,0}},
48                 
49                                         {2,{deg(0),0,0}},                       //fire
50                                         {3,{deg(0),0,0}},
51                 
52                                         {2,{deg(50),0,0}},              //recoil
53                                         {3,{deg(-50),0,0}},
54                 
55                                         {2,{deg(10),0,deg(70)}},                //flinch
56                                         {3,{deg(0),deg(20),0}},
57                 
58 //gun 1
59                                         {4,{deg(-30),0,0}},             //rest (2 joints)
60                                         {5,{deg(-40),0,0}},
61
62                                         {4,{deg(0),0,0}},                       //alert
63                                         {5,{deg(0),0,0}},
64                 
65                                         {4,{deg(0),0,0}},                       //fire
66                                         {5,{deg(0),0,0}},
67                 
68                                         {4,{deg(50),0,0}},              //recoil
69                                         {5,{deg(-50),0,0}},
70                 
71                                         {4,{deg(20),0,deg(-50)}},       //flinch
72                                         {5,{deg(0),0,deg(20)}},
73                 
74 //rest of body (the head)
75
76                                         {1,{deg(70),0,0}},              //rest (1 joint, head)
77
78                                         {1,{deg(0),0,0}},                       //alert
79                 
80                                         {1,{deg(0),0,0}},                       //fire
81                 
82                                         {1,{deg(0),0,0}},                       //recoil
83
84                                         {1,{deg(-20),deg(15),0}},                       //flinch
85
86
87 };
88
89 //given an object and a gun number, return position in 3-space of gun
90 //fills in gun_point
91 void calc_gun_point(vms_vector *gun_point,object *obj,int gun_num)
92 {
93         polymodel *pm;
94         robot_info *r;
95         vms_vector pnt;
96         vms_matrix m;
97         int mn;                         //submodel number
98
99         Assert(obj->render_type==RT_POLYOBJ || obj->render_type==RT_MORPH);
100         Assert(obj->id < N_robot_types);
101
102         r = &Robot_info[obj->id];
103         pm =&Polygon_models[r->model_num];
104
105         if (gun_num >= r->n_guns)
106         {
107                 mprintf((1, "Bashing gun num %d to 0.\n", gun_num));
108                 //Int3();
109                 gun_num = 0;
110         }
111
112 //      Assert(gun_num < r->n_guns);
113
114         pnt = r->gun_points[gun_num];
115         mn = r->gun_submodels[gun_num];
116
117         //instance up the tree for this gun
118         while (mn != 0) {
119                 vms_vector tpnt;
120
121                 vm_angles_2_matrix(&m,&obj->rtype.pobj_info.anim_angles[mn]);
122                 vm_transpose_matrix(&m);
123                 vm_vec_rotate(&tpnt,&pnt,&m);
124
125                 vm_vec_add(&pnt,&tpnt,&pm->submodel_offsets[mn]);
126
127                 mn = pm->submodel_parents[mn];
128         }
129
130         //now instance for the entire object
131
132         vm_copy_transpose_matrix(&m,&obj->orient);
133         vm_vec_rotate(gun_point,&pnt,&m);
134         vm_vec_add2(gun_point,&obj->pos);
135         
136 }
137
138 //fills in ptr to list of joints, and returns the number of joints in list
139 //takes the robot type (object id), gun number, and desired state
140 int robot_get_anim_state(jointpos **jp_list_ptr,int robot_type,int gun_num,int state)
141 {
142
143         Assert(gun_num <= Robot_info[robot_type].n_guns);
144
145         *jp_list_ptr = &Robot_joints[Robot_info[robot_type].anim_states[gun_num][state].offset];
146
147         return Robot_info[robot_type].anim_states[gun_num][state].n_joints;
148
149 }
150
151
152 //for test, set a robot to a specific state
153 void set_robot_state(object *obj,int state)
154 {
155         int g,j,jo;
156         robot_info *ri;
157         jointlist *jl;
158
159         Assert(obj->type == OBJ_ROBOT);
160
161         ri = &Robot_info[obj->id];
162
163         for (g=0;g<ri->n_guns+1;g++) {
164
165                 jl = &ri->anim_states[g][state];
166
167                 jo = jl->offset;
168
169                 for (j=0;j<jl->n_joints;j++,jo++) {
170                         int jn;
171
172                         jn = Robot_joints[jo].jointnum;
173
174                         obj->rtype.pobj_info.anim_angles[jn] = Robot_joints[jo].angles;
175
176                 }
177         }
178 }
179
180 #include "mono.h"
181
182 //--unused-- int cur_state=0;
183
184 //--unused-- test_anim_states()
185 //--unused-- {
186 //--unused--    set_robot_state(&Objects[1],cur_state);
187 //--unused-- 
188 //--unused--    mprintf(0,"Robot in state %d\n",cur_state);
189 //--unused-- 
190 //--unused--    cur_state = (cur_state+1)%N_ANIM_STATES;
191 //--unused-- 
192 //--unused-- }
193
194 //set the animation angles for this robot.  Gun fields of robot info must
195 //be filled in.
196 void robot_set_angles(robot_info *r,polymodel *pm,vms_angvec angs[N_ANIM_STATES][MAX_SUBMODELS])
197 {
198         int m,g,state;
199         int gun_nums[MAX_SUBMODELS];                    //which gun each submodel is part of
200
201         for (m=0;m<pm->n_models;m++)
202                 gun_nums[m] = r->n_guns;                //assume part of body...
203
204         gun_nums[0] = -1;               //body never animates, at least for now
205
206         for (g=0;g<r->n_guns;g++) {
207                 m = r->gun_submodels[g];
208
209                 while (m != 0) {
210                         gun_nums[m] = g;                                //...unless we find it in a gun
211                         m = pm->submodel_parents[m];
212                 }
213         }
214
215         for (g=0;g<r->n_guns+1;g++) {
216
217                 //mprintf(0,"Gun %d:\n",g);
218
219                 for (state=0;state<N_ANIM_STATES;state++) {
220
221                         //mprintf(0," State %d:\n",state);
222
223                         r->anim_states[g][state].n_joints = 0;
224                         r->anim_states[g][state].offset = N_robot_joints;
225
226                         for (m=0;m<pm->n_models;m++) {
227                                 if (gun_nums[m] == g) {
228                                         //mprintf(0,"  Joint %d: %x %x %x\n",m,angs[state][m].pitch,angs[state][m].bank,angs[state][m].head);
229                                         Robot_joints[N_robot_joints].jointnum = m;
230                                         Robot_joints[N_robot_joints].angles = angs[state][m];
231                                         r->anim_states[g][state].n_joints++;
232                                         N_robot_joints++;
233                                         Assert(N_robot_joints < MAX_ROBOT_JOINTS);
234                                 }
235                         }
236                 }
237         }
238
239 }
240
241