added in_pitch_min and in_pitch_max cvars to limit pitch (default: -90 to +90)
[divverent/darkplaces.git] / sv_move.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // sv_move.c -- monster movement
21
22 #include "quakedef.h"
23
24 #define STEPSIZE        18
25
26 /*
27 =============
28 SV_CheckBottom
29
30 Returns false if any part of the bottom of the entity is off an edge that
31 is not a staircase.
32
33 =============
34 */
35 int c_yes, c_no;
36
37 qboolean SV_CheckBottom (edict_t *ent)
38 {
39         vec3_t  mins, maxs, start, stop;
40         trace_t trace;
41         int             x, y;
42         float   mid, bottom;
43         
44         VectorAdd (ent->v.origin, ent->v.mins, mins);
45         VectorAdd (ent->v.origin, ent->v.maxs, maxs);
46
47 // if all of the points under the corners are solid world, don't bother
48 // with the tougher checks
49 // the corners must be within 16 of the midpoint
50         start[2] = mins[2] - 1;
51         for     (x=0 ; x<=1 ; x++)
52                 for     (y=0 ; y<=1 ; y++)
53                 {
54                         start[0] = x ? maxs[0] : mins[0];
55                         start[1] = y ? maxs[1] : mins[1];
56                         if (SV_PointContents (start) != CONTENTS_SOLID)
57                                 goto realcheck;
58                 }
59
60         c_yes++;
61         return true;            // we got out easy
62
63 realcheck:
64         c_no++;
65 //
66 // check it for real...
67 //
68         start[2] = mins[2];
69         
70 // the midpoint must be within 16 of the bottom
71         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
72         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
73         stop[2] = start[2] - 2*STEPSIZE;
74         trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent);
75
76         if (trace.fraction == 1.0)
77                 return false;
78         mid = bottom = trace.endpos[2];
79         
80 // the corners must be within 16 of the midpoint        
81         for     (x=0 ; x<=1 ; x++)
82                 for     (y=0 ; y<=1 ; y++)
83                 {
84                         start[0] = stop[0] = x ? maxs[0] : mins[0];
85                         start[1] = stop[1] = y ? maxs[1] : mins[1];
86                         
87                         trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent);
88                         
89                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
90                                 bottom = trace.endpos[2];
91                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > STEPSIZE)
92                                 return false;
93                 }
94
95         c_yes++;
96         return true;
97 }
98
99
100 /*
101 =============
102 SV_movestep
103
104 Called by monster program code.
105 The move will be adjusted for slopes and stairs, but if the move isn't
106 possible, no move is done, false is returned, and
107 pr_global_struct->trace_normal is set to the normal of the blocking wall
108 =============
109 */
110 qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
111 {
112         float           dz;
113         vec3_t          oldorg, neworg, end, traceendpos;
114         trace_t         trace;
115         int                     i;
116         edict_t         *enemy;
117
118 // try the move
119         VectorCopy (ent->v.origin, oldorg);
120         VectorAdd (ent->v.origin, move, neworg);
121
122 // flying monsters don't step up
123         if ( (int)ent->v.flags & (FL_SWIM | FL_FLY) )
124         {
125         // try one move with vertical motion, then one without
126                 for (i=0 ; i<2 ; i++)
127                 {
128                         VectorAdd (ent->v.origin, move, neworg);
129                         enemy = PROG_TO_EDICT(ent->v.enemy);
130                         if (i == 0 && enemy != sv.edicts)
131                         {
132                                 dz = ent->v.origin[2] - PROG_TO_EDICT(ent->v.enemy)->v.origin[2];
133                                 if (dz > 40)
134                                         neworg[2] -= 8;
135                                 if (dz < 30)
136                                         neworg[2] += 8;
137                         }
138                         trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, neworg, MOVE_NORMAL, ent);
139
140                         if (trace.fraction == 1)
141                         {
142                                 VectorCopy(trace.endpos, traceendpos);
143                                 if ( ((int)ent->v.flags & FL_SWIM) && SV_PointContents(traceendpos) == CONTENTS_EMPTY )
144                                         return false;   // swim monster left water
145
146                                 VectorCopy (traceendpos, ent->v.origin);
147                                 if (relink)
148                                         SV_LinkEdict (ent, true);
149                                 return true;
150                         }
151
152                         if (enemy == sv.edicts)
153                                 break;
154                 }
155
156                 return false;
157         }
158
159 // push down from a step height above the wished position
160         neworg[2] += STEPSIZE;
161         VectorCopy (neworg, end);
162         end[2] -= STEPSIZE*2;
163
164         trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
165
166         if (trace.allsolid)
167                 return false;
168
169         if (trace.startsolid)
170         {
171                 neworg[2] -= STEPSIZE;
172                 trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
173                 if (trace.allsolid || trace.startsolid)
174                         return false;
175         }
176         if (trace.fraction == 1)
177         {
178         // if monster had the ground pulled out, go ahead and fall
179                 if ( (int)ent->v.flags & FL_PARTIALGROUND )
180                 {
181                         VectorAdd (ent->v.origin, move, ent->v.origin);
182                         if (relink)
183                                 SV_LinkEdict (ent, true);
184                         ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
185 //      Con_Printf ("fall down\n"); 
186                         return true;
187                 }
188
189                 return false;           // walked off an edge
190         }
191
192 // check point traces down for dangling corners
193         VectorCopy (trace.endpos, ent->v.origin);
194         
195         if (!SV_CheckBottom (ent))
196         {
197                 if ( (int)ent->v.flags & FL_PARTIALGROUND )
198                 {       // entity had floor mostly pulled out from underneath it
199                         // and is trying to correct
200                         if (relink)
201                                 SV_LinkEdict (ent, true);
202                         return true;
203                 }
204                 VectorCopy (oldorg, ent->v.origin);
205                 return false;
206         }
207
208         if ( (int)ent->v.flags & FL_PARTIALGROUND )
209         {
210 //              Con_Printf ("back on ground\n"); 
211                 ent->v.flags = (int)ent->v.flags & ~FL_PARTIALGROUND;
212         }
213         ent->v.groundentity = EDICT_TO_PROG(trace.ent);
214
215 // the move is ok
216         if (relink)
217                 SV_LinkEdict (ent, true);
218         return true;
219 }
220
221
222 //============================================================================
223
224 /*
225 ======================
226 SV_StepDirection
227
228 Turns to the movement direction, and walks the current distance if
229 facing it.
230
231 ======================
232 */
233 void PF_changeyaw (void);
234 qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
235 {
236         vec3_t          move, oldorigin;
237         float           delta;
238         
239         ent->v.ideal_yaw = yaw;
240         PF_changeyaw();
241         
242         yaw = yaw*M_PI*2 / 360;
243         move[0] = cos(yaw)*dist;
244         move[1] = sin(yaw)*dist;
245         move[2] = 0;
246
247         VectorCopy (ent->v.origin, oldorigin);
248         if (SV_movestep (ent, move, false))
249         {
250                 delta = ent->v.angles[YAW] - ent->v.ideal_yaw;
251                 if (delta > 45 && delta < 315)
252                 {               // not turned far enough, so don't take the step
253                         VectorCopy (oldorigin, ent->v.origin);
254                 }
255                 SV_LinkEdict (ent, true);
256                 return true;
257         }
258         SV_LinkEdict (ent, true);
259                 
260         return false;
261 }
262
263 /*
264 ======================
265 SV_FixCheckBottom
266
267 ======================
268 */
269 void SV_FixCheckBottom (edict_t *ent)
270 {
271 //      Con_Printf ("SV_FixCheckBottom\n");
272         
273         ent->v.flags = (int)ent->v.flags | FL_PARTIALGROUND;
274 }
275
276
277
278 /*
279 ================
280 SV_NewChaseDir
281
282 ================
283 */
284 #define DI_NODIR        -1
285 void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist)
286 {
287         float           deltax,deltay;
288         float                   d[3];
289         float           tdir, olddir, turnaround;
290
291         olddir = ANGLEMOD((int)(actor->v.ideal_yaw/45)*45);
292         turnaround = ANGLEMOD(olddir - 180);
293
294         deltax = enemy->v.origin[0] - actor->v.origin[0];
295         deltay = enemy->v.origin[1] - actor->v.origin[1];
296         if (deltax>10)
297                 d[1]= 0;
298         else if (deltax<-10)
299                 d[1]= 180;
300         else
301                 d[1]= DI_NODIR;
302         if (deltay<-10)
303                 d[2]= 270;
304         else if (deltay>10)
305                 d[2]= 90;
306         else
307                 d[2]= DI_NODIR;
308
309 // try direct route
310         if (d[1] != DI_NODIR && d[2] != DI_NODIR)
311         {
312                 if (d[1] == 0)
313                         tdir = d[2] == 90 ? 45 : 315;
314                 else
315                         tdir = d[2] == 90 ? 135 : 215;
316                         
317                 if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
318                         return;
319         }
320
321 // try other directions
322         if ( ((rand()&3) & 1) ||  abs(deltay)>abs(deltax))
323         {
324                 tdir=d[1];
325                 d[1]=d[2];
326                 d[2]=tdir;
327         }
328
329         if (d[1]!=DI_NODIR && d[1]!=turnaround 
330         && SV_StepDirection(actor, d[1], dist))
331                         return;
332
333         if (d[2]!=DI_NODIR && d[2]!=turnaround
334         && SV_StepDirection(actor, d[2], dist))
335                         return;
336
337 /* there is no direct path to the player, so pick another direction */
338
339         if (olddir!=DI_NODIR && SV_StepDirection(actor, olddir, dist))
340                         return;
341
342         if (rand()&1)   /*randomly determine direction of search*/
343         {
344                 for (tdir=0 ; tdir<=315 ; tdir += 45)
345                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
346                                         return;
347         }
348         else
349         {
350                 for (tdir=315 ; tdir >=0 ; tdir -= 45)
351                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
352                                         return;
353         }
354
355         if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
356                         return;
357
358         actor->v.ideal_yaw = olddir;            // can't move
359
360 // if a bridge was pulled out from underneath a monster, it may not have
361 // a valid standing position at all
362
363         if (!SV_CheckBottom (actor))
364                 SV_FixCheckBottom (actor);
365
366 }
367
368 /*
369 ======================
370 SV_CloseEnough
371
372 ======================
373 */
374 qboolean SV_CloseEnough (edict_t *ent, edict_t *goal, float dist)
375 {
376         int             i;
377         
378         for (i=0 ; i<3 ; i++)
379         {
380                 if (goal->v.absmin[i] > ent->v.absmax[i] + dist)
381                         return false;
382                 if (goal->v.absmax[i] < ent->v.absmin[i] - dist)
383                         return false;
384         }
385         return true;
386 }
387
388 /*
389 ======================
390 SV_MoveToGoal
391
392 ======================
393 */
394 void SV_MoveToGoal (void)
395 {
396         edict_t         *ent, *goal;
397         float           dist;
398
399         ent = PROG_TO_EDICT(pr_global_struct->self);
400         goal = PROG_TO_EDICT(ent->v.goalentity);
401         dist = G_FLOAT(OFS_PARM0);
402
403         if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
404         {
405                 G_FLOAT(OFS_RETURN) = 0;
406                 return;
407         }
408
409 // if the next step hits the enemy, return immediately
410         if ( PROG_TO_EDICT(ent->v.enemy) != sv.edicts &&  SV_CloseEnough (ent, goal, dist) )
411                 return;
412
413 // bump around...
414         if ( (rand()&3)==1 ||
415         !SV_StepDirection (ent, ent->v.ideal_yaw, dist))
416         {
417                 SV_NewChaseDir (ent, goal, dist);
418         }
419 }
420