Two new cvars for blood particles: decal alpha, decal random scaling (min/max)
[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 #include "prvm_cmds.h"
24
25 /*
26 =============
27 SV_CheckBottom
28
29 Returns false if any part of the bottom of the entity is off an edge that
30 is not a staircase.
31
32 =============
33 */
34 int c_yes, c_no;
35
36 qboolean SV_CheckBottom (prvm_edict_t *ent)
37 {
38         vec3_t  mins, maxs, start, stop;
39         trace_t trace;
40         int             x, y;
41         float   mid, bottom;
42
43         VectorAdd (ent->fields.server->origin, ent->fields.server->mins, mins);
44         VectorAdd (ent->fields.server->origin, ent->fields.server->maxs, maxs);
45
46 // if all of the points under the corners are solid world, don't bother
47 // with the tougher checks
48 // the corners must be within 16 of the midpoint
49         start[2] = mins[2] - 1;
50         for     (x=0 ; x<=1 ; x++)
51                 for     (y=0 ; y<=1 ; y++)
52                 {
53                         start[0] = x ? maxs[0] : mins[0];
54                         start[1] = y ? maxs[1] : mins[1];
55                         if (!(SV_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
56                                 goto realcheck;
57                 }
58
59         c_yes++;
60         return true;            // we got out easy
61
62 realcheck:
63         c_no++;
64 //
65 // check it for real...
66 //
67         start[2] = mins[2];
68
69 // the midpoint must be within 16 of the bottom
70         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
71         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
72         stop[2] = start[2] - 2*sv_stepheight.value;
73         trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent));
74
75         if (trace.fraction == 1.0)
76                 return false;
77         mid = bottom = trace.endpos[2];
78
79 // the corners must be within 16 of the midpoint
80         for     (x=0 ; x<=1 ; x++)
81                 for     (y=0 ; y<=1 ; y++)
82                 {
83                         start[0] = stop[0] = x ? maxs[0] : mins[0];
84                         start[1] = stop[1] = y ? maxs[1] : mins[1];
85
86                         trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent));
87
88                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
89                                 bottom = trace.endpos[2];
90                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
91                                 return false;
92                 }
93
94         c_yes++;
95         return true;
96 }
97
98
99 /*
100 =============
101 SV_movestep
102
103 Called by monster program code.
104 The move will be adjusted for slopes and stairs, but if the move isn't
105 possible, no move is done and false is returned
106 =============
107 */
108 qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
109 {
110         float           dz;
111         vec3_t          oldorg, neworg, end, traceendpos;
112         trace_t         trace;
113         int                     i;
114         prvm_edict_t            *enemy;
115
116 // try the move
117         VectorCopy (ent->fields.server->origin, oldorg);
118         VectorAdd (ent->fields.server->origin, move, neworg);
119
120 // flying monsters don't step up
121         if ( (int)ent->fields.server->flags & (FL_SWIM | FL_FLY) )
122         {
123         // try one move with vertical motion, then one without
124                 for (i=0 ; i<2 ; i++)
125                 {
126                         VectorAdd (ent->fields.server->origin, move, neworg);
127                         if (noenemy)
128                                 enemy = prog->edicts;
129                         else
130                         {
131                                 enemy = PRVM_PROG_TO_EDICT(ent->fields.server->enemy);
132                                 if (i == 0 && enemy != prog->edicts)
133                                 {
134                                         dz = ent->fields.server->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.server->enemy)->fields.server->origin[2];
135                                         if (dz > 40)
136                                                 neworg[2] -= 8;
137                                         if (dz < 30)
138                                                 neworg[2] += 8;
139                                 }
140                         }
141                         trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
142
143                         if (trace.fraction == 1)
144                         {
145                                 VectorCopy(trace.endpos, traceendpos);
146                                 if (((int)ent->fields.server->flags & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
147                                         return false;   // swim monster left water
148
149                                 VectorCopy (traceendpos, ent->fields.server->origin);
150                                 if (relink)
151                                 {
152                                         SV_LinkEdict(ent);
153                                         SV_LinkEdict_TouchAreaGrid(ent);
154                                 }
155                                 return true;
156                         }
157
158                         if (enemy == prog->edicts)
159                                 break;
160                 }
161
162                 return false;
163         }
164
165 // push down from a step height above the wished position
166         neworg[2] += sv_stepheight.value;
167         VectorCopy (neworg, end);
168         end[2] -= sv_stepheight.value*2;
169
170         trace = SV_TraceBox(neworg, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
171
172         if (trace.startsolid)
173         {
174                 neworg[2] -= sv_stepheight.value;
175                 trace = SV_TraceBox(neworg, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
176                 if (trace.startsolid)
177                         return false;
178         }
179         if (trace.fraction == 1)
180         {
181         // if monster had the ground pulled out, go ahead and fall
182                 if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
183                 {
184                         VectorAdd (ent->fields.server->origin, move, ent->fields.server->origin);
185                         if (relink)
186                         {
187                                 SV_LinkEdict(ent);
188                                 SV_LinkEdict_TouchAreaGrid(ent);
189                         }
190                         ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
191                         return true;
192                 }
193
194                 return false;           // walked off an edge
195         }
196
197 // check point traces down for dangling corners
198         VectorCopy (trace.endpos, ent->fields.server->origin);
199
200         if (!SV_CheckBottom (ent))
201         {
202                 if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
203                 {       // entity had floor mostly pulled out from underneath it
204                         // and is trying to correct
205                         if (relink)
206                         {
207                                 SV_LinkEdict(ent);
208                                 SV_LinkEdict_TouchAreaGrid(ent);
209                         }
210                         return true;
211                 }
212                 VectorCopy (oldorg, ent->fields.server->origin);
213                 return false;
214         }
215
216         if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
217                 ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_PARTIALGROUND;
218
219         ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
220
221 // the move is ok
222         if (relink)
223         {
224                 SV_LinkEdict(ent);
225                 SV_LinkEdict_TouchAreaGrid(ent);
226         }
227         return true;
228 }
229
230
231 //============================================================================
232
233 /*
234 ======================
235 SV_StepDirection
236
237 Turns to the movement direction, and walks the current distance if
238 facing it.
239
240 ======================
241 */
242 void VM_changeyaw (void);
243 qboolean SV_StepDirection (prvm_edict_t *ent, float yaw, float dist)
244 {
245         vec3_t          move, oldorigin;
246         float           delta;
247
248         ent->fields.server->ideal_yaw = yaw;
249         VM_changeyaw();
250
251         yaw = yaw*M_PI*2 / 360;
252         move[0] = cos(yaw)*dist;
253         move[1] = sin(yaw)*dist;
254         move[2] = 0;
255
256         VectorCopy (ent->fields.server->origin, oldorigin);
257         if (SV_movestep (ent, move, false, false, false))
258         {
259                 delta = ent->fields.server->angles[YAW] - ent->fields.server->ideal_yaw;
260                 if (delta > 45 && delta < 315)
261                 {               // not turned far enough, so don't take the step
262                         VectorCopy (oldorigin, ent->fields.server->origin);
263                 }
264                 SV_LinkEdict(ent);
265                 SV_LinkEdict_TouchAreaGrid(ent);
266                 return true;
267         }
268         SV_LinkEdict(ent);
269         SV_LinkEdict_TouchAreaGrid(ent);
270
271         return false;
272 }
273
274 /*
275 ======================
276 SV_FixCheckBottom
277
278 ======================
279 */
280 void SV_FixCheckBottom (prvm_edict_t *ent)
281 {
282         ent->fields.server->flags = (int)ent->fields.server->flags | FL_PARTIALGROUND;
283 }
284
285
286
287 /*
288 ================
289 SV_NewChaseDir
290
291 ================
292 */
293 #define DI_NODIR        -1
294 void SV_NewChaseDir (prvm_edict_t *actor, prvm_edict_t *enemy, float dist)
295 {
296         float           deltax,deltay;
297         float                   d[3];
298         float           tdir, olddir, turnaround;
299
300         olddir = ANGLEMOD((int)(actor->fields.server->ideal_yaw/45)*45);
301         turnaround = ANGLEMOD(olddir - 180);
302
303         deltax = enemy->fields.server->origin[0] - actor->fields.server->origin[0];
304         deltay = enemy->fields.server->origin[1] - actor->fields.server->origin[1];
305         if (deltax>10)
306                 d[1]= 0;
307         else if (deltax<-10)
308                 d[1]= 180;
309         else
310                 d[1]= DI_NODIR;
311         if (deltay<-10)
312                 d[2]= 270;
313         else if (deltay>10)
314                 d[2]= 90;
315         else
316                 d[2]= DI_NODIR;
317
318 // try direct route
319         if (d[1] != DI_NODIR && d[2] != DI_NODIR)
320         {
321                 if (d[1] == 0)
322                         tdir = d[2] == 90 ? 45 : 315;
323                 else
324                         tdir = d[2] == 90 ? 135 : 215;
325
326                 if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
327                         return;
328         }
329
330 // try other directions
331         if ( ((rand()&3) & 1) ||  fabs(deltay)>fabs(deltax))
332         {
333                 tdir=d[1];
334                 d[1]=d[2];
335                 d[2]=tdir;
336         }
337
338         if (d[1]!=DI_NODIR && d[1]!=turnaround
339         && SV_StepDirection(actor, d[1], dist))
340                         return;
341
342         if (d[2]!=DI_NODIR && d[2]!=turnaround
343         && SV_StepDirection(actor, d[2], dist))
344                         return;
345
346 /* there is no direct path to the player, so pick another direction */
347
348         if (olddir!=DI_NODIR && SV_StepDirection(actor, olddir, dist))
349                         return;
350
351         if (rand()&1)   /*randomly determine direction of search*/
352         {
353                 for (tdir=0 ; tdir<=315 ; tdir += 45)
354                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
355                                         return;
356         }
357         else
358         {
359                 for (tdir=315 ; tdir >=0 ; tdir -= 45)
360                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
361                                         return;
362         }
363
364         if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
365                         return;
366
367         actor->fields.server->ideal_yaw = olddir;               // can't move
368
369 // if a bridge was pulled out from underneath a monster, it may not have
370 // a valid standing position at all
371
372         if (!SV_CheckBottom (actor))
373                 SV_FixCheckBottom (actor);
374
375 }
376
377 /*
378 ======================
379 SV_CloseEnough
380
381 ======================
382 */
383 qboolean SV_CloseEnough (prvm_edict_t *ent, prvm_edict_t *goal, float dist)
384 {
385         int             i;
386
387         for (i=0 ; i<3 ; i++)
388         {
389                 if (goal->priv.server->areamins[i] > ent->priv.server->areamaxs[i] + dist)
390                         return false;
391                 if (goal->priv.server->areamaxs[i] < ent->priv.server->areamins[i] - dist)
392                         return false;
393         }
394         return true;
395 }
396
397 /*
398 ======================
399 SV_MoveToGoal
400
401 ======================
402 */
403 void SV_MoveToGoal (void)
404 {
405         prvm_edict_t            *ent, *goal;
406         float           dist;
407
408         VM_SAFEPARMCOUNT(1, SV_MoveToGoal);
409
410         ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
411         goal = PRVM_PROG_TO_EDICT(ent->fields.server->goalentity);
412         dist = PRVM_G_FLOAT(OFS_PARM0);
413
414         if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
415         {
416                 PRVM_G_FLOAT(OFS_RETURN) = 0;
417                 return;
418         }
419
420 // if the next step hits the enemy, return immediately
421         if ( PRVM_PROG_TO_EDICT(ent->fields.server->enemy) != prog->edicts &&  SV_CloseEnough (ent, goal, dist) )
422                 return;
423
424 // bump around...
425         if ( (rand()&3)==1 ||
426         !SV_StepDirection (ent, ent->fields.server->ideal_yaw, dist))
427         {
428                 SV_NewChaseDir (ent, goal, dist);
429         }
430 }
431