Fix engine not starting on Windows if linked against SDL > 2.0.5
[xonotic/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         prvm_prog_t *prog = SVVM_prog;
39         vec3_t  mins, maxs, start, stop;
40         trace_t trace;
41         int             x, y;
42         float   mid, bottom;
43
44         VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
45         VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, 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_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
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*sv_stepheight.value;
74         trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
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_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
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] > sv_stepheight.value)
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 and false is returned
107 =============
108 */
109 qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
110 {
111         prvm_prog_t *prog = SVVM_prog;
112         float           dz;
113         vec3_t          oldorg, neworg, end, traceendpos, entorigin, entmins, entmaxs;
114         trace_t         trace;
115         int                     i;
116         prvm_edict_t            *enemy;
117
118 // try the move
119         VectorCopy (PRVM_serveredictvector(ent, origin), oldorg);
120         VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);
121         VectorCopy(PRVM_serveredictvector(ent, mins), entmins);
122         VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
123
124 // flying monsters don't step up
125         if ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) )
126         {
127         // try one move with vertical motion, then one without
128                 for (i=0 ; i<2 ; i++)
129                 {
130                         VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);
131                         if (noenemy)
132                                 enemy = prog->edicts;
133                         else
134                         {
135                                 enemy = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy));
136                                 if (i == 0 && enemy != prog->edicts)
137                                 {
138                                         dz = PRVM_serveredictvector(ent, origin)[2] - PRVM_serveredictvector(enemy, origin)[2];
139                                         if (dz > 40)
140                                                 neworg[2] -= 8;
141                                         if (dz < 30)
142                                                 neworg[2] += 8;
143                                 }
144                         }
145                         VectorCopy(PRVM_serveredictvector(ent, origin), entorigin);
146                         trace = SV_TraceBox(entorigin, entmins, entmaxs, neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
147
148                         if (trace.fraction == 1)
149                         {
150                                 VectorCopy(trace.endpos, traceendpos);
151                                 if (((int)PRVM_serveredictfloat(ent, flags) & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
152                                         return false;   // swim monster left water
153
154                                 VectorCopy (traceendpos, PRVM_serveredictvector(ent, origin));
155                                 if (relink)
156                                 {
157                                         SV_LinkEdict(ent);
158                                         SV_LinkEdict_TouchAreaGrid(ent);
159                                 }
160                                 return true;
161                         }
162
163                         if (enemy == prog->edicts)
164                                 break;
165                 }
166
167                 return false;
168         }
169
170 // push down from a step height above the wished position
171         neworg[2] += sv_stepheight.value;
172         VectorCopy (neworg, end);
173         end[2] -= sv_stepheight.value*2;
174
175         trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
176
177         if (trace.startsolid)
178         {
179                 neworg[2] -= sv_stepheight.value;
180                 trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
181                 if (trace.startsolid)
182                         return false;
183         }
184         if (trace.fraction == 1)
185         {
186         // if monster had the ground pulled out, go ahead and fall
187                 if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
188                 {
189                         VectorAdd (PRVM_serveredictvector(ent, origin), move, PRVM_serveredictvector(ent, origin));
190                         if (relink)
191                         {
192                                 SV_LinkEdict(ent);
193                                 SV_LinkEdict_TouchAreaGrid(ent);
194                         }
195                         PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;
196                         return true;
197                 }
198
199                 return false;           // walked off an edge
200         }
201
202 // check point traces down for dangling corners
203         VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));
204
205         if (!SV_CheckBottom (ent))
206         {
207                 if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
208                 {       // entity had floor mostly pulled out from underneath it
209                         // and is trying to correct
210                         if (relink)
211                         {
212                                 SV_LinkEdict(ent);
213                                 SV_LinkEdict_TouchAreaGrid(ent);
214                         }
215                         return true;
216                 }
217                 VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));
218                 return false;
219         }
220
221         if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
222                 PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_PARTIALGROUND;
223
224 // gameplayfix: check if reached pretty steep plane and bail
225         if ( ! ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) ) && sv_gameplayfix_nostepmoveonsteepslopes.integer )
226         {
227                 if (trace.plane.normal[ 2 ] < 0.5)
228                 {
229                         VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));
230                         return false;
231                 }
232         }
233
234         PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
235
236 // the move is ok
237         if (relink)
238         {
239                 SV_LinkEdict(ent);
240                 SV_LinkEdict_TouchAreaGrid(ent);
241         }
242         return true;
243 }
244
245
246 //============================================================================
247
248 /*
249 ======================
250 SV_StepDirection
251
252 Turns to the movement direction, and walks the current distance if
253 facing it.
254
255 ======================
256 */
257 static qboolean SV_StepDirection (prvm_edict_t *ent, float yaw, float dist)
258 {
259         prvm_prog_t *prog = SVVM_prog;
260         vec3_t          move, oldorigin;
261         float           delta;
262
263         PRVM_serveredictfloat(ent, ideal_yaw) = yaw;
264         VM_changeyaw(prog);
265
266         yaw = yaw*M_PI*2 / 360;
267         move[0] = cos(yaw)*dist;
268         move[1] = sin(yaw)*dist;
269         move[2] = 0;
270
271         VectorCopy (PRVM_serveredictvector(ent, origin), oldorigin);
272         if (SV_movestep (ent, move, false, false, false))
273         {
274                 delta = PRVM_serveredictvector(ent, angles)[YAW] - PRVM_serveredictfloat(ent, ideal_yaw);
275                 if (delta > 45 && delta < 315)
276                 {               // not turned far enough, so don't take the step
277                         VectorCopy (oldorigin, PRVM_serveredictvector(ent, origin));
278                 }
279                 SV_LinkEdict(ent);
280                 SV_LinkEdict_TouchAreaGrid(ent);
281                 return true;
282         }
283         SV_LinkEdict(ent);
284         SV_LinkEdict_TouchAreaGrid(ent);
285
286         return false;
287 }
288
289 /*
290 ======================
291 SV_FixCheckBottom
292
293 ======================
294 */
295 static void SV_FixCheckBottom (prvm_edict_t *ent)
296 {
297         prvm_prog_t *prog = SVVM_prog;
298         PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_PARTIALGROUND;
299 }
300
301
302
303 /*
304 ================
305 SV_NewChaseDir
306
307 ================
308 */
309 #define DI_NODIR        -1
310 static void SV_NewChaseDir (prvm_edict_t *actor, prvm_edict_t *enemy, float dist)
311 {
312         prvm_prog_t *prog = SVVM_prog;
313         float           deltax,deltay;
314         float                   d[3];
315         float           tdir, olddir, turnaround;
316
317         olddir = ANGLEMOD((int)(PRVM_serveredictfloat(actor, ideal_yaw)/45)*45);
318         turnaround = ANGLEMOD(olddir - 180);
319
320         deltax = PRVM_serveredictvector(enemy, origin)[0] - PRVM_serveredictvector(actor, origin)[0];
321         deltay = PRVM_serveredictvector(enemy, origin)[1] - PRVM_serveredictvector(actor, origin)[1];
322         if (deltax>10)
323                 d[1]= 0;
324         else if (deltax<-10)
325                 d[1]= 180;
326         else
327                 d[1]= DI_NODIR;
328         if (deltay<-10)
329                 d[2]= 270;
330         else if (deltay>10)
331                 d[2]= 90;
332         else
333                 d[2]= DI_NODIR;
334
335 // try direct route
336         if (d[1] != DI_NODIR && d[2] != DI_NODIR)
337         {
338                 if (d[1] == 0)
339                         tdir = d[2] == 90 ? 45 : 315;
340                 else
341                         tdir = d[2] == 90 ? 135 : 215;
342
343                 if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
344                         return;
345         }
346
347 // try other directions
348         if ( ((rand()&3) & 1) ||  fabs(deltay)>fabs(deltax))
349         {
350                 tdir=d[1];
351                 d[1]=d[2];
352                 d[2]=tdir;
353         }
354
355         if (d[1]!=DI_NODIR && d[1]!=turnaround
356         && SV_StepDirection(actor, d[1], dist))
357                         return;
358
359         if (d[2]!=DI_NODIR && d[2]!=turnaround
360         && SV_StepDirection(actor, d[2], dist))
361                         return;
362
363 /* there is no direct path to the player, so pick another direction */
364
365         if (olddir!=DI_NODIR && SV_StepDirection(actor, olddir, dist))
366                         return;
367
368         if (rand()&1)   /*randomly determine direction of search*/
369         {
370                 for (tdir=0 ; tdir<=315 ; tdir += 45)
371                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
372                                         return;
373         }
374         else
375         {
376                 for (tdir=315 ; tdir >=0 ; tdir -= 45)
377                         if (tdir!=turnaround && SV_StepDirection(actor, tdir, dist) )
378                                         return;
379         }
380
381         if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
382                         return;
383
384         PRVM_serveredictfloat(actor, ideal_yaw) = olddir;               // can't move
385
386 // if a bridge was pulled out from underneath a monster, it may not have
387 // a valid standing position at all
388
389         if (!SV_CheckBottom (actor))
390                 SV_FixCheckBottom (actor);
391
392 }
393
394 /*
395 ======================
396 SV_CloseEnough
397
398 ======================
399 */
400 static qboolean SV_CloseEnough (prvm_edict_t *ent, prvm_edict_t *goal, float dist)
401 {
402         int             i;
403
404         for (i=0 ; i<3 ; i++)
405         {
406                 if (goal->priv.server->areamins[i] > ent->priv.server->areamaxs[i] + dist)
407                         return false;
408                 if (goal->priv.server->areamaxs[i] < ent->priv.server->areamins[i] - dist)
409                         return false;
410         }
411         return true;
412 }
413
414 /*
415 ======================
416 SV_MoveToGoal
417
418 ======================
419 */
420 void VM_SV_MoveToGoal(prvm_prog_t *prog)
421 {
422         prvm_edict_t            *ent, *goal;
423         float           dist;
424
425         VM_SAFEPARMCOUNT(1, SV_MoveToGoal);
426
427         ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
428         goal = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, goalentity));
429         dist = PRVM_G_FLOAT(OFS_PARM0);
430
431         if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
432         {
433                 PRVM_G_FLOAT(OFS_RETURN) = 0;
434                 return;
435         }
436
437 // if the next step hits the enemy, return immediately
438         if ( PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy)) != prog->edicts &&  SV_CloseEnough (ent, goal, dist) )
439                 return;
440
441 // bump around...
442         if ( (rand()&3)==1 ||
443         !SV_StepDirection (ent, PRVM_serveredictfloat(ent, ideal_yaw), dist))
444         {
445                 SV_NewChaseDir (ent, goal, dist);
446         }
447 }
448