Branch data Line data Source code
1 : : /* copyright (c) 1987,1988,1989 by Laurence Raphael Brothers */
2 : : /* utils.c */
3 : :
4 : : /* Random utility functions called from all over */
5 : :
6 : : #ifndef MSDOS_SUPPORTED_ANTIQUE
7 : : #include <sys/types.h>
8 : : #include <sys/time.h>
9 : : #include <sys/wait.h>
10 : : #include <unistd.h>
11 : : int setreuid(uid_t ruid, uid_t euid);
12 : : #include <stdlib.h>
13 : : #endif
14 : :
15 : : #include "glob.h"
16 : :
17 : 18 : void setPlayerXY(int x, int y)
18 : : {
19 : 18 : Player.x = x;
20 : 18 : Player.y = y;
21 : 18 : }
22 : :
23 : : /* x and y on level? */
24 : 239342 : int inbounds(int x, int y)
25 : : {
26 [ + + ]: 239342 : if (Current_Environment != E_COUNTRYSIDE)
27 : : {
28 [ + + ][ + + ]: 238108 : return((x>=0)&&(y>=0)&&(x<(Level->level_width))&&(y<(Level->level_length)));
[ + + ][ + + ]
29 : : }
30 : : else
31 [ + + ][ + - ]: 1234 : return((x>=0)&&(y>=0)&&(x<COUNTRY_WIDTH)&&(y<COUNTRY_LENGTH));
[ + - ][ + - ]
32 : : }
33 : :
34 : : /* RANDFUNCTION is defined in odefs.h */
35 : 23069 : unsigned random_range(unsigned k)
36 : : {
37 [ + - ]: 23069 : return( k==0 ? 0 : (int) (RANDFUNCTION() % k) ) ;
38 : : /*return( k==0 ? 0 : (int) ((RANDFUNCTION()%10000)*k)/10000); */
39 : : }
40 : :
41 : :
42 : : /* modify absolute y coord relative to which part of level we are on */
43 : 65495 : int screenmody(int y)
44 : : {
45 : 65495 : return(y-ScreenOffset);
46 : : }
47 : :
48 : : /* modify absolute x coord relative to which part of level we are on */
49 : : /* PGM - horizontal scrolling */
50 : 47761 : int screenmodx(int x)
51 : : {
52 : 47761 : return(x-ScreenXOffset);
53 : : }
54 : :
55 : : /* this could be optimized; is it neccessary? PGM */
56 : 50290 : int offscreen(int x, int y)
57 : : {
58 : :
59 : : /* PGM : The Country not acually being a level, it is naturally a
60 : : * special case... PGM */
61 : :
62 : 50290 : int width = COUNTRY_WIDTH;
63 : 50290 : int length = COUNTRY_LENGTH;
64 : :
65 : : int xyes, yyes;
66 : :
67 [ + + ]: 50290 : if (Current_Environment != E_COUNTRYSIDE)
68 : : {
69 : 49013 : width = Level->level_width;
70 : 49013 : length = Level->level_length;
71 : : }
72 : :
73 [ + - ]: 50290 : yyes = ((y<0)||
74 [ + + ]: 50290 : (y<ScreenOffset) ||
75 [ + - ][ - + ]: 100580 : (y>ScreenOffset+ScreenLength-1) ||
76 : : (y>length));
77 : :
78 [ + + ]: 50290 : xyes = ((x<0)||
79 [ + - ]: 48892 : (x<ScreenXOffset) ||
80 [ + - ][ - + ]: 100580 : (x>ScreenXOffset+ScreenWidth-1) ||
81 : : (x>width));
82 : :
83 [ + + ][ + + ]: 50290 : return ( xyes || yyes );
84 : : }
85 : :
86 : :
87 : : /* always hit on a natural 0; never hit on a natural 19 */
88 : 17 : int hitp(int hit, int ac)
89 : : {
90 : 17 : int roll = random_range(20);
91 [ + + ]: 17 : if (roll == 0) return(TRUE);
92 [ + + ]: 15 : else if (roll == 19) return(FALSE);
93 : 13 : else return((roll < (hit - ac)) ? TRUE : FALSE );
94 : : }
95 : :
96 : :
97 : : /* number of moves from x1,y1 to x2,y2 */
98 : 14013 : int distance(int x1, int y1, int x2, int y2)
99 : : {
100 : 14013 : return(max(abs(x2-x1),abs(y2-y1)));
101 : : }
102 : :
103 : :
104 : : /* can you shoot, or move monsters through a spot? */
105 : 483 : int unblocked(int x, int y)
106 : : {
107 [ + - ][ + + ]: 483 : if ((! inbounds(x,y)) ||
108 [ + - ]: 476 : (Level->site[x][y].creature != NULL) ||
109 [ + - ]: 476 : (Level->site[x][y].locchar == WALL) ||
110 [ + - ]: 476 : (Level->site[x][y].locchar == PORTCULLIS) ||
111 [ + + ]: 476 : (Level->site[x][y].locchar == STATUE) ||
112 [ + - ]: 346 : (Level->site[x][y].locchar == HEDGE) ||
113 [ + - ]: 346 : (Level->site[x][y].locchar == CLOSED_DOOR) ||
114 [ + + ]: 346 : loc_statusp(x,y,SECRET) ||
115 [ + + ]: 40 : ((x==Player.x) && (y==Player.y)))
116 : 164 : return(FALSE);
117 : : else
118 : 319 : return(TRUE);
119 : : }
120 : :
121 : :
122 : : /* do monsters want to move through a spot */
123 : 723 : int m_unblocked(pmt m, int x, int y)
124 : : {
125 [ + - ][ + + ]: 723 : if ((! inbounds(x,y)) || ((x==Player.x) && (y==Player.y)))
[ - + ]
126 : 0 : return(FALSE);
127 [ + - ][ - + ]: 723 : else if ((Level->site[x][y].creature != NULL) ||
128 : 0 : (Level->site[x][y].locchar == SPACE)) return(FALSE);
129 [ - + ]: 723 : else if (m_statusp(m,ONLYSWIM))
130 : 0 : return(Level->site[x][y].locchar == WATER);
131 [ - + ]: 723 : else if (loc_statusp(x,y,SECRET)) {
132 [ # # ]: 0 : if (m->movef == M_MOVE_SMART) {
133 [ # # ]: 0 : if (los_p(x, y, Player.x, Player.y)) {
134 : 0 : mprint("You see a secret door swing open!");
135 : 0 : lreset(x, y, SECRET);
136 : 0 : lset(x, y, CHANGED);
137 : : }
138 : : else
139 : 0 : mprint("You hear a door creak open, and then close again.");
140 : : /* smart monsters would close secret doors behind them if the */
141 : : /* player didn't see them using it */
142 : 0 : return(TRUE);
143 : : }
144 : : else
145 : 0 : return(m_statusp(m,INTANGIBLE));
146 : : }
147 [ + + ][ - + ]: 723 : else if ((Level->site[x][y].locchar == FLOOR) ||
148 : 649 : (Level->site[x][y].locchar == OPEN_DOOR))
149 : 74 : return(TRUE);
150 [ + - ][ + - ]: 649 : else if ((Level->site[x][y].locchar == PORTCULLIS) ||
151 [ - + ]: 649 : (Level->site[x][y].locchar == WALL) ||
152 : 649 : (Level->site[x][y].locchar == STATUE))
153 : 0 : return(m_statusp(m,INTANGIBLE));
154 [ + + ]: 649 : else if (Level->site[x][y].locchar==WATER)
155 [ + - ]: 84 : return(m_statusp(m,SWIMMING) ||
156 [ + - ]: 38 : m_statusp(m,ONLYSWIM) ||
157 [ + + ][ - + ]: 84 : m_statusp(m,INTANGIBLE) ||
158 : 38 : m_statusp(m,FLYING));
159 [ - + ]: 603 : else if (Level->site[x][y].locchar == CLOSED_DOOR) {
160 [ # # ]: 0 : if (m->movef==M_MOVE_SMART) {
161 : 0 : mprint("You hear a door creak open.");
162 : 0 : Level->site[x][y].locchar = OPEN_DOOR;
163 : 0 : lset(x, y, CHANGED);
164 : 0 : return(TRUE);
165 : : }
166 [ # # ]: 0 : else if (random_range(m->dmg) > random_range(100)) {
167 : 0 : mprint("You hear a door shattering.");
168 : 0 : Level->site[x][y].locchar = RUBBLE;
169 : 0 : lset(x, y, CHANGED);
170 : 0 : return(TRUE);
171 : : }
172 : 0 : else return(m_statusp(m,INTANGIBLE));
173 : : }
174 [ - + ]: 603 : else if (Level->site[x][y].locchar == LAVA)
175 [ # # ]: 0 : return((m_immunityp(m,FLAME) &&
176 [ # # ]: 0 : m_statusp(m,SWIMMING)) ||
177 [ # # ][ # # ]: 0 : m_statusp(m,INTANGIBLE) ||
178 : 0 : m_statusp(m,FLYING));
179 [ - + ]: 603 : else if (Level->site[x][y].locchar == FIRE)
180 [ # # ][ # # ]: 0 : return(m_statusp(m,INTANGIBLE) ||
181 : 0 : m_immunityp(m,FLAME));
182 [ + - ][ + + ]: 603 : else if ((Level->site[x][y].locchar == TRAP) ||
183 [ - + ]: 8 : (Level->site[x][y].locchar == HEDGE) ||
184 : 8 : (Level->site[x][y].locchar == ABYSS))
185 [ + - ]: 1190 : return((m->movef == M_MOVE_CONFUSED) ||
186 [ + - ][ - + ]: 1190 : m_statusp(m,INTANGIBLE) ||
187 : 595 : m_statusp(m,FLYING));
188 : 8 : else return(TRUE);
189 : : }
190 : :
191 : :
192 : :
193 : : /* can you see through a spot? */
194 : 195184 : int view_unblocked(int x, int y)
195 : : {
196 [ - + ]: 195184 : if (! inbounds(x,y)) return(FALSE);
197 [ + + ][ + - ]: 195184 : else if ((Level->site[x][y].locchar == WALL) ||
198 [ + + ]: 165180 : (Level->site[x][y].locchar == STATUE) ||
199 [ + - ]: 155653 : (Level->site[x][y].locchar == HEDGE) ||
200 [ + + ]: 155653 : (Level->site[x][y].locchar == FIRE) ||
201 [ - + ]: 143490 : (Level->site[x][y].locchar == CLOSED_DOOR) ||
202 : 143490 : loc_statusp(x,y,SECRET))
203 : 51694 : return(FALSE);
204 : : else
205 : 143490 : return(TRUE);
206 : : }
207 : :
208 : :
209 : : #ifndef MSDOS_SUPPORTED_ANTIQUE
210 : : /* 8 moves in Dirs */
211 : 15 : void initdirs(void)
212 : : {
213 : 15 : Dirs[0][0] = 1;
214 : 15 : Dirs[0][1] = 1;
215 : 15 : Dirs[0][2] = -1;
216 : 15 : Dirs[0][3] = -1;
217 : 15 : Dirs[0][4] = 1;
218 : 15 : Dirs[0][5] = -1;
219 : 15 : Dirs[0][6] = 0;
220 : 15 : Dirs[0][7] = 0;
221 : 15 : Dirs[0][8] = 0;
222 : 15 : Dirs[1][0] = 1;
223 : 15 : Dirs[1][1] = -1;
224 : 15 : Dirs[1][2] = 1;
225 : 15 : Dirs[1][3] = -1;
226 : 15 : Dirs[1][4] = 0;
227 : 15 : Dirs[1][5] = 0;
228 : 15 : Dirs[1][6] = 1;
229 : 15 : Dirs[1][7] = -1;
230 : 15 : Dirs[1][8] = 0;
231 : 15 : }
232 : : #endif
233 : :
234 : :
235 : :
236 : :
237 : :
238 : : /* do_los moves pyx along a lineofsight from x1 to x2 */
239 : : /* x1 and x2 are pointers because as a side effect they are changed */
240 : : /* to the final location of the pyx */
241 : 0 : void do_los(Symbol pyx, int *x1, int *y1, int x2, int y2)
242 : : {
243 : : int dx,dy,ox,oy;
244 : : int major, minor;
245 : : int error, delta, step;
246 : : int blocked;
247 : :
248 [ # # ]: 0 : if (x2 - *x1 < 0) dx = 5;
249 [ # # ]: 0 : else if (x2 - *x1 > 0) dx = 4;
250 : 0 : else dx = -1;
251 [ # # ]: 0 : if (y2 - *y1 < 0) dy = 7;
252 [ # # ]: 0 : else if (y2 - *y1 > 0) dy = 6;
253 : 0 : else dy = -1;
254 [ # # ]: 0 : if (abs(x2 - *x1) > abs(y2 - *y1)) {
255 : 0 : major = dx;
256 : 0 : minor = dy;
257 : 0 : step = abs(x2 - *x1);
258 : 0 : delta = 2*abs(y2 - *y1);
259 : : }
260 : : else {
261 : 0 : major = dy;
262 : 0 : minor = dx;
263 : 0 : step = abs(y2 - *y1);
264 : 0 : delta = 2*abs(x2 - *x1);
265 : : }
266 [ # # ]: 0 : if (major == -1) /* x1,y2 already == x2,y2 */
267 : 0 : return;
268 : 0 : error = 0;
269 : : do {
270 : 0 : ox = *x1; oy = *y1;
271 : 0 : *x1 += Dirs[0][major];
272 : 0 : *y1 += Dirs[1][major];
273 : 0 : error += delta;
274 [ # # ]: 0 : if (error > step) { /* don't need to check that minor >= 0 */
275 : 0 : *x1 += Dirs[0][minor];
276 : 0 : *y1 += Dirs[1][minor];
277 : 0 : error -= 2*step;
278 : : }
279 : 0 : blocked = !unblocked(*x1,*y1);
280 [ # # ][ # # ]: 0 : if (error < 0 && (*x1 != x2 || *y1 != y2) && blocked) {
[ # # ][ # # ]
281 : 0 : *x1 -= Dirs[0][minor];
282 : 0 : *y1 -= Dirs[1][minor];
283 : 0 : error += 2*step;
284 : 0 : blocked = !unblocked(*x1,*y1);
285 : : }
286 : 0 : Level->site[*x1][*y1].showchar = pyx;
287 : 0 : plotchar(pyx,*x1,*y1);
288 : 0 : plotspot(ox,oy,TRUE);
289 : 0 : usleep(50000);
290 [ # # ][ # # ]: 0 : } while ((*x1 != x2 || *y1 != y2) && !blocked);
[ # # ]
291 : 0 : plotspot(*x1,*y1,TRUE);
292 : 0 : levelrefresh();
293 : : }
294 : :
295 : :
296 : : /* This is the same as do_los, except we stop before hitting nonliving
297 : : obstructions */
298 : 0 : void do_object_los(Symbol pyx, int *x1, int *y1, int x2, int y2)
299 : : {
300 : : int dx,dy,ox,oy;
301 : : int major, minor;
302 : : int error, delta, step;
303 : : int blocked;
304 : :
305 [ # # ]: 0 : if (x2 - *x1 < 0) dx = 5;
306 [ # # ]: 0 : else if (x2 - *x1 > 0) dx = 4;
307 : 0 : else dx = -1;
308 [ # # ]: 0 : if (y2 - *y1 < 0) dy = 7;
309 [ # # ]: 0 : else if (y2 - *y1 > 0) dy = 6;
310 : 0 : else dy = -1;
311 [ # # ]: 0 : if (abs(x2 - *x1) > abs(y2 - *y1)) {
312 : 0 : major = dx;
313 : 0 : minor = dy;
314 : 0 : step = abs(x2 - *x1);
315 : 0 : delta = 2*abs(y2 - *y1);
316 : : }
317 : : else {
318 : 0 : major = dy;
319 : 0 : minor = dx;
320 : 0 : step = abs(y2 - *y1);
321 : 0 : delta = 2*abs(x2 - *x1);
322 : : }
323 [ # # ]: 0 : if (major == -1) /* x1,y2 already == x2,y2 */
324 : 0 : return;
325 : 0 : error = 0;
326 : : do {
327 : 0 : ox = *x1; oy = *y1;
328 : 0 : *x1 += Dirs[0][major];
329 : 0 : *y1 += Dirs[1][major];
330 : 0 : error += delta;
331 [ # # ]: 0 : if (error > step) { /* don't need to check that minor >= 0 */
332 : 0 : *x1 += Dirs[0][minor];
333 : 0 : *y1 += Dirs[1][minor];
334 : 0 : error -= 2*step;
335 : : }
336 : 0 : blocked = !unblocked(*x1,*y1);
337 [ # # ][ # # ]: 0 : if (error < 0 && (*x1 != x2 || *y1 != y2) && blocked) {
[ # # ][ # # ]
338 : 0 : *x1 -= Dirs[0][minor];
339 : 0 : *y1 -= Dirs[1][minor];
340 : 0 : error += 2*step;
341 : 0 : blocked = !unblocked(*x1,*y1);
342 : : }
343 : 0 : plotspot(ox,oy,TRUE);
344 [ # # ]: 0 : if (unblocked(*x1,*y1)) {
345 : 0 : plotchar(pyx,*x1,*y1);
346 : 0 : Level->site[*x1][*y1].showchar = pyx;
347 : 0 : usleep(50000);
348 : : }
349 [ # # ][ # # ]: 0 : } while ((*x1 != x2 || *y1 != y2) && !blocked);
[ # # ]
350 [ # # ][ # # ]: 0 : if (Level->site[*x1][*y1].creature == NULL && blocked) {
351 : 0 : *x1 = ox;
352 : 0 : *y1 = oy;
353 : : }
354 : 0 : plotspot(*x1,*y1,TRUE);
355 : 0 : levelrefresh();
356 : : }
357 : :
358 : :
359 : : /* los_p checks to see whether there is an unblocked los from x1,y1 to x2,y2 */
360 : 144 : int los_p(int x1, int y1, int x2, int y2)
361 : : {
362 : : int dx,dy;
363 : : int major, minor;
364 : : int error, delta, step;
365 : : int blocked;
366 : :
367 [ + + ]: 144 : if (x2-x1 < 0) dx = 5;
368 [ + + ]: 115 : else if (x2-x1 > 0) dx = 4;
369 : 3 : else dx = -1;
370 [ + + ]: 144 : if (y2-y1 < 0) dy = 7;
371 [ + + ]: 75 : else if (y2-y1 > 0) dy = 6;
372 : 14 : else dy = -1;
373 [ + + ]: 144 : if (abs(x2-x1) > abs(y2-y1)) {
374 : 134 : major = dx;
375 : 134 : minor = dy;
376 : 134 : step = abs(x2 - x1);
377 : 134 : delta = 2*abs(y2 - y1);
378 : : }
379 : : else {
380 : 10 : major = dy;
381 : 10 : minor = dx;
382 : 10 : step = abs(y2 - y1);
383 : 10 : delta = 2*abs(x2 - x1);
384 : : }
385 [ - + ]: 144 : if (major == -1) /* x1,y2 already == x2,y2 */
386 : 0 : return TRUE;
387 : 144 : error = 0;
388 : : do {
389 : 463 : x1 += Dirs[0][major];
390 : 463 : y1 += Dirs[1][major];
391 : 463 : error += delta;
392 [ + + ]: 463 : if (error > step) { /* don't need to check that minor >= 0 */
393 : 117 : x1 += Dirs[0][minor];
394 : 117 : y1 += Dirs[1][minor];
395 : 117 : error -= 2*step;
396 : : }
397 : 463 : blocked = !unblocked(x1,y1);
398 [ + + ][ + + ]: 463 : if (error < 0 && (x1 != x2 || y1 != y2) && blocked) {
[ + - ][ + + ]
399 : 20 : x1 -= Dirs[0][minor];
400 : 20 : y1 -= Dirs[1][minor];
401 : 20 : error += 2*step;
402 : 20 : blocked = !unblocked(x1,y1);
403 : : }
404 [ + + ][ + + ]: 463 : } while ((x1 != x2 || y1 != y2) && !blocked);
[ + + ]
405 [ + + ][ + + ]: 144 : return((x1==x2) && (y1==y2));
406 : : }
407 : :
408 : :
409 : : /* view_los_p sees through monsters */
410 : 41679 : int view_los_p(int x1, int y1, int x2, int y2)
411 : : {
412 : : int dx,dy;
413 : : int major, minor;
414 : : int error, delta, step;
415 : : int blocked;
416 : :
417 [ + + ]: 41679 : if (x2-x1 < 0) dx = 5;
418 [ + + ]: 24729 : else if (x2-x1 > 0) dx = 4;
419 : 1878 : else dx = -1;
420 [ + + ]: 41679 : if (y2-y1 < 0) dy = 7;
421 [ + + ]: 25390 : else if (y2-y1 > 0) dy = 6;
422 : 1887 : else dy = -1;
423 [ + + ]: 41679 : if (abs(x2-x1) > abs(y2-y1)) {
424 : 31124 : major = dx;
425 : 31124 : minor = dy;
426 : 31124 : step = abs(x2 - x1);
427 : 31124 : delta = 2*abs(y2 - y1);
428 : : }
429 : : else {
430 : 10555 : major = dy;
431 : 10555 : minor = dx;
432 : 10555 : step = abs(y2 - y1);
433 : 10555 : delta = 2*abs(x2 - x1);
434 : : }
435 [ + + ]: 41679 : if (major == -1) /* x1,y2 already == x2,y2 */
436 : 3 : return TRUE;
437 : 41676 : error = 0;
438 : : do {
439 : 175256 : x1 += Dirs[0][major];
440 : 175256 : y1 += Dirs[1][major];
441 : 175256 : error += delta;
442 [ + + ]: 175256 : if (error > step) {
443 : 49175 : x1 += Dirs[0][minor];
444 : 49175 : y1 += Dirs[1][minor];
445 : 49175 : error -= 2*step;
446 : : }
447 : 175256 : blocked = !view_unblocked(x1,y1);
448 [ + + ][ + + ]: 175256 : if (error < 0 && (x1 != x2 || y1 != y2) && blocked) {
[ + - ][ + + ]
449 : 19928 : x1 -= Dirs[0][minor];
450 : 19928 : y1 -= Dirs[1][minor];
451 : 19928 : error += 2*step;
452 : 19928 : blocked = !view_unblocked(x1,y1);
453 : : }
454 [ + + ][ + + ]: 175256 : } while ((x1 != x2 || y1 != y2) && !blocked);
[ + + ]
455 [ + + ][ + + ]: 41676 : return((x1==x2) && (y1==y2));
456 : : }
457 : :
458 : : #ifndef MSDOS_SUPPORTED_ANTIQUE
459 : : /* returns the command direction from the index into Dirs */
460 : 0 : char inversedir(int dirindex)
461 : : {
462 [ # # # # : 0 : switch (dirindex) {
# # # #
# ]
463 : 0 : case 0:return('n');
464 : 0 : case 1:return('u');
465 : 0 : case 2:return('b');
466 : 0 : case 3:return('y');
467 : 0 : case 4:return('l');
468 : 0 : case 5:return('h');
469 : 0 : case 6:return('j');
470 : 0 : case 7:return('k');
471 : 0 : default:return('\0');
472 : : }
473 : : }
474 : : #endif
475 : :
476 : :
477 : 8 : long calc_points(void)
478 : : {
479 : : int i;
480 : 8 : long points=0;
481 : :
482 [ - + ]: 8 : if (gamestatusp(SPOKE_TO_DRUID)) points += 50;
483 [ - + ]: 8 : if (gamestatusp(COMPLETED_CAVES)) points += 100;
484 [ - + ]: 8 : if (gamestatusp(COMPLETED_SEWERS)) points += 200;
485 [ - + ]: 8 : if (gamestatusp(COMPLETED_CASTLE)) points += 300;
486 [ - + ]: 8 : if (gamestatusp(COMPLETED_ASTRAL)) points += 400;
487 [ - + ]: 8 : if (gamestatusp(COMPLETED_VOLCANO)) points += 500;
488 [ - + ]: 8 : if (gamestatusp(KILLED_DRAGONLORD)) points += 100;
489 [ - + ]: 8 : if (gamestatusp(KILLED_EATER)) points += 100;
490 [ - + ]: 8 : if (gamestatusp(KILLED_LAWBRINGER)) points += 100;
491 : :
492 : 8 : points += Player.xp/50;
493 : :
494 : 8 : points += Player.cash/500;
495 : :
496 [ + + ]: 136 : for (i=0;i<MAXITEMS;i++)
497 [ + + ]: 128 : if (Player.possessions[i] != NULL)
498 : 12 : points += Player.possessions[i]->level*(Player.possessions[i]->known+1);
499 : :
500 [ + + ]: 216 : for (i=0;i<MAXPACK;i++)
501 [ - + ]: 208 : if (Player.pack[i] != NULL)
502 : 0 : points += Player.pack[i]->level*(Player.pack[i]->known+1);
503 : :
504 [ + + ]: 88 : for (i=0;i<NUMRANKS;i++) {
505 [ - + ]: 80 : if (Player.rank[i] == 5) points += 500;
506 : 80 : else points += 20*Player.rank[i];
507 : : }
508 : :
509 [ + + ]: 8 : if (Player.hp < 1)
510 : 4 : points = (points / 2);
511 : :
512 [ - + ]: 4 : else if (Player.rank[ADEPT])
513 : 0 : points *= 10;
514 : :
515 : 8 : return(points);
516 : : }
517 : :
518 : :
519 : : /* returns the 24 hour clock hour */
520 : 684 : int hour(void)
521 : : {
522 : 684 : return((int)(((Time+720) / 60) % 24));
523 : : }
524 : :
525 : : /* returns 0, 10, 20, 30, 40, or 50 */
526 : 294 : int showminute(void)
527 : : {
528 : 294 : return((int)((Time % 60)/10)*10);
529 : : }
530 : :
531 : : /* returns the 12 hour clock hour */
532 : 147 : int showhour(void)
533 : : {
534 : : int showtime;
535 [ + + ][ + + ]: 147 : if ((hour() == 0) || (hour() == 12)) showtime = 12;
536 : 129 : else showtime = (hour() % 12);
537 : 147 : return(showtime);
538 : : }
539 : :
540 : : /* nighttime is defined from 9 PM to 6AM */
541 : 8 : int nighttime(void)
542 : : {
543 [ + - ][ - + ]: 8 : return((hour() > 20) || (hour() < 7));
544 : : }
545 : :
546 : 9 : char *getarticle(char *str)
547 : : {
548 [ + - ][ + - ]: 9 : if ((str[0]=='a') || (str[0]=='A') ||
[ + - ]
549 [ + - ][ + - ]: 9 : (str[0]=='e') || (str[0]=='E') ||
550 [ + - ][ + - ]: 9 : (str[0]=='i') || (str[0]=='I') ||
551 [ + - ][ + - ]: 9 : (str[0]=='o') || (str[0]=='O') ||
552 [ + - ][ + - ]: 9 : (str[0]=='u') || (str[0]=='U') ||
553 [ - + ][ # # ]: 9 : (((str[0]=='h') || (str[0]=='H')) &&
554 [ # # ]: 0 : ((str[1]=='i') || (str[1]=='e'))))
555 : 0 : return("an ");
556 : 9 : else return("a ");
557 : : }
558 : :
559 : 294 : int day(void)
560 : : {
561 : 294 : return ((Date % 30) + 1);
562 : : }
563 : :
564 : 147 : char *ordinal(int number)
565 : : {
566 [ + - ][ + - ]: 147 : if ((number == 11) || (number == 12) || (number == 13)) return("th");
[ + + ]
567 [ - - - + ]: 141 : else switch(number % 10) {
568 : 0 : case 1:return("st");
569 : 0 : case 2:return("nd");
570 : 0 : case 3:return("rd");
571 : 141 : default: return("th");
572 : : }
573 : : }
574 : :
575 : 294 : char *month(void)
576 : : {
577 [ - - - - : 294 : switch((Date % 360) / 30) {
- - + - -
- - + -
- ]
578 : 0 : case 0: return("Freeze");
579 : 0 : case 1: return("Ice");
580 : 0 : case 2: return("Mud");
581 : 0 : case 3: return("Storm");
582 : 0 : case 4: return("Breeze");
583 : 0 : case 5: return("Light");
584 : 292 : case 6: return("Flame");
585 : 0 : case 7: return("Broil");
586 : 0 : case 8: return("Cool");
587 : 0 : case 9: return("Haunt");
588 : 0 : case 10: return("Chill");
589 : 2 : case 11: return("Dark");
590 : 0 : case 12: return("Twixt");
591 : 0 : default: return("***Error***");
592 : : }
593 : : }
594 : :
595 : : /* finds floor space on level with buildaux not equal to baux,
596 : : sets x,y there. There must *be* floor space somewhere on level */
597 : :
598 : 0 : static int spaceok (int x_idx, int y_idx, int baux)
599 : : {
600 [ # # ]: 0 : if (FLOOR != Level->site[x_idx][y_idx].locchar) return FALSE;
601 [ # # ]: 0 : if (Level->site[x_idx][y_idx].creature) return FALSE;
602 [ # # ]: 0 : if (loc_statusp(x_idx, y_idx, SECRET)) return FALSE;
603 [ # # ]: 0 : if (Level->site[x_idx][y_idx].buildaux == baux) return FALSE;
604 : :
605 : 0 : return TRUE;
606 : : }
607 : :
608 : 0 : static int findspace_method_one (int * x_idx, int * y_idx, struct level * lev, int baux)
609 : : {
610 : 0 : int count = 0;
611 : :
612 [ # # ]: 0 : for (count = 0; count < (lev->level_width * lev->level_length / 4); ++count)
613 : : {
614 : 0 : *x_idx = random_range(lev->level_width);
615 : 0 : *y_idx = random_range(lev->level_length);
616 [ # # ]: 0 : if (spaceok(*x_idx, *y_idx, baux))
617 : 0 : return TRUE;
618 : : }
619 : :
620 : 0 : return FALSE;
621 : : }
622 : :
623 : 0 : static int findspace_method_two (int * x_out, int * y_out, struct level * lev, int baux)
624 : : {
625 : : int x_start, x_idx;
626 : : int y_start, y_idx;
627 : :
628 : : int x_dir, y_dir;
629 : :
630 : 0 : x_idx = x_start = random_range(lev->level_width);
631 : 0 : y_idx = y_start = random_range(lev->level_length);
632 : :
633 : 0 : x_dir = random_range(2);
634 : 0 : y_dir = random_range(2);
635 : :
636 [ # # ]: 0 : if (random_range(2))
637 : : {
638 [ # # ]: 0 : if (x_dir)
639 : : {
640 [ # # ]: 0 : if (y_dir)
641 : : {
642 : : // case 0: X in outer loop, decrement X, decrement Y
643 : : do
644 : : {
645 : : do
646 : : {
647 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
648 : 0 : goto found_space;
649 : :
650 : 0 : --y_idx;
651 [ # # ]: 0 : if (y_idx == -1)
652 : 0 : y_idx = lev->level_length - 1;
653 : : }
654 [ # # ]: 0 : while (y_idx != y_start);
655 : :
656 : 0 : --x_idx;
657 [ # # ]: 0 : if (x_idx == -1)
658 : 0 : x_idx = lev->level_width - 1;
659 : : }
660 [ # # ]: 0 : while (x_idx != x_start);
661 : : }
662 : : else
663 : : {
664 : : // case 1: X in outer loop, decrement X, increment Y
665 : : do
666 : : {
667 : : do
668 : : {
669 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
670 : 0 : goto found_space;
671 : :
672 : 0 : ++y_idx;
673 [ # # ]: 0 : if (y_idx == lev->level_length)
674 : 0 : y_idx = 0;
675 : : }
676 [ # # ]: 0 : while (y_idx != y_start);
677 : :
678 : 0 : --x_idx;
679 [ # # ]: 0 : if (x_idx == -1)
680 : 0 : x_idx = lev->level_width - 1;
681 : : }
682 [ # # ]: 0 : while (x_idx != x_start);
683 : : }
684 : : }
685 : : else
686 : : {
687 [ # # ]: 0 : if (y_dir)
688 : : {
689 : : // case 2: X in outer loop, increment X, decrement Y
690 : : do
691 : : {
692 : : do
693 : : {
694 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
695 : 0 : goto found_space;
696 : :
697 : 0 : --y_idx;
698 [ # # ]: 0 : if (y_idx == -1)
699 : 0 : y_idx = lev->level_length - 1;
700 : : }
701 [ # # ]: 0 : while (y_idx != y_start);
702 : :
703 : 0 : ++x_idx;
704 [ # # ]: 0 : if (x_idx == lev->level_width)
705 : 0 : x_idx = 0;
706 : : }
707 [ # # ]: 0 : while (x_idx != x_start);
708 : : }
709 : : else
710 : : {
711 : : // case 3: X in outer loop, increment X, increment Y
712 : : do
713 : : {
714 : : do
715 : : {
716 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
717 : 0 : goto found_space;
718 : :
719 : 0 : ++y_idx;
720 [ # # ]: 0 : if (y_idx == lev->level_length)
721 : 0 : y_idx = 0;
722 : : }
723 [ # # ]: 0 : while (y_idx != y_start);
724 : :
725 : 0 : ++x_idx;
726 [ # # ]: 0 : if (x_idx == lev->level_width)
727 : 0 : x_idx = 0;
728 : : }
729 [ # # ]: 0 : while (x_idx != x_start);
730 : : }
731 : : }
732 : : }
733 : : else
734 : : {
735 [ # # ]: 0 : if (y_dir)
736 : : {
737 [ # # ]: 0 : if (x_dir)
738 : : {
739 : : // case 4: Y in outer loop, decrement X, decrement Y
740 : : do
741 : : {
742 : : do
743 : : {
744 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
745 : 0 : goto found_space;
746 : :
747 : 0 : --x_idx;
748 [ # # ]: 0 : if (x_idx == -1)
749 : 0 : x_idx = lev->level_width - 1;
750 : : }
751 [ # # ]: 0 : while (x_idx != x_start);
752 : :
753 : 0 : --y_idx;
754 [ # # ]: 0 : if (y_idx == -1)
755 : 0 : y_idx = lev->level_length - 1;
756 : : }
757 [ # # ]: 0 : while (y_idx != y_start);
758 : : }
759 : : else
760 : : {
761 : : // case 5: Y in outer loop, decrement X, increment Y
762 : : do
763 : : {
764 : : do
765 : : {
766 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
767 : 0 : goto found_space;
768 : :
769 : 0 : ++x_idx;
770 [ # # ]: 0 : if (x_idx == lev->level_width)
771 : 0 : x_idx = 0;
772 : : }
773 [ # # ]: 0 : while (x_idx != x_start);
774 : :
775 : 0 : --y_idx;
776 [ # # ]: 0 : if (y_idx == -1)
777 : 0 : y_idx = lev->level_length - 1;
778 : : }
779 [ # # ]: 0 : while (y_idx != y_start);
780 : : }
781 : : }
782 : : else
783 : : {
784 [ # # ]: 0 : if (x_dir)
785 : : {
786 : : // case 6: Y in outer loop, increment X, decrement Y
787 : : do
788 : : {
789 : : do
790 : : {
791 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
792 : 0 : goto found_space;
793 : :
794 : 0 : --x_idx;
795 [ # # ]: 0 : if (x_idx == -1)
796 : 0 : x_idx = lev->level_width - 1;
797 : : }
798 [ # # ]: 0 : while (x_idx != x_start);
799 : :
800 : 0 : ++y_idx;
801 [ # # ]: 0 : if (y_idx == lev->level_length)
802 : 0 : y_idx = 0;
803 : : }
804 [ # # ]: 0 : while (y_idx != y_start);
805 : : }
806 : : else
807 : : {
808 : : // case 7: Y in outer loop, increment X, increment Y
809 : : do
810 : : {
811 : : do
812 : : {
813 [ # # ]: 0 : if (spaceok(x_idx, y_idx, baux))
814 : 0 : goto found_space;
815 : :
816 : 0 : ++x_idx;
817 [ # # ]: 0 : if (x_idx == lev->level_width)
818 : 0 : x_idx = 0;
819 : : }
820 [ # # ]: 0 : while (x_idx != x_start);
821 : :
822 : 0 : ++y_idx;
823 [ # # ]: 0 : if (y_idx == lev->level_length)
824 : 0 : y_idx = 0;
825 : : }
826 [ # # ]: 0 : while (y_idx != y_start);
827 : : }
828 : : }
829 : : }
830 : :
831 : 0 : return FALSE;
832 : :
833 : : found_space:
834 : 0 : *x_out = x_idx;
835 : 0 : *y_out = y_idx;
836 : 0 : return TRUE;
837 : : }
838 : :
839 : 0 : void findspace (int * x_out, int * y_out, int baux)
840 : : {
841 : : /* try to quickly find a space by sampling randomly */
842 [ # # ]: 0 : if (findspace_method_one(x_out, y_out, Level, baux))
843 : 0 : return;
844 : :
845 : : /* examine every space on the level */
846 [ # # ]: 0 : if (findspace_method_two(x_out, y_out, Level, baux))
847 : 0 : return;
848 : :
849 : : /* this could theoretically happen but if it does, it's an error */
850 : 0 : assert(FALSE);
851 : : }
852 : :
853 : : /* finds floor space on level with buildaux not equal to baux,
854 : : sets x,y there. Return false is no such space exists on the level. */
855 : 0 : int try_findspace (int * x_out, int * y_out, int baux)
856 : : {
857 : : /* try to quickly find a space by sampling randomly */
858 [ # # ]: 0 : if (findspace_method_one(x_out, y_out, Level, baux))
859 : 0 : return TRUE;
860 : :
861 : : /* examine every space on the level */
862 [ # # ]: 0 : if (findspace_method_two(x_out, y_out, Level, baux))
863 : 0 : return TRUE;
864 : :
865 : 0 : return FALSE;
866 : : }
867 : :
868 : : /* is prefix a prefix of s? */
869 : 0 : int strprefix(char *prefix, char *s)
870 : : {
871 : 0 : int i=0,matched=TRUE;
872 [ # # ]: 0 : if (strlen(prefix) > strlen(s)) return(FALSE);
873 : : else {
874 [ # # ][ # # ]: 0 : while (matched && (i<strlen(prefix))) {
875 : 0 : matched = (prefix[i] == s[i]);
876 : 0 : i++;
877 : : }
878 : 0 : return(matched);
879 : : }
880 : : }
881 : :
882 : : /* WSS - Maybe I'm not understanding something here, but isn't "strmem" just */
883 : : /* WSS - a lame version of the standard library function strchr? */
884 : :
885 : : /* is character c a member of string s */
886 : 0 : int strmem(char c, char *s)
887 : : {
888 : 0 : int i,found=FALSE;
889 [ # # ][ # # ]: 0 : for(i=0;((i<strlen(s)) && (! found));i++)
890 : 0 : found = (s[i] == c);
891 : 0 : return(found);
892 : : }
893 : :
894 : 72 : void calc_weight(void)
895 : : {
896 : 72 : int i,weight=0;
897 : :
898 [ + + ]: 1152 : for(i=1;i<MAXITEMS;i++)
899 [ + + ]: 1080 : if (Player.possessions[i] != NULL)
900 : 355 : weight += Player.possessions[i]->weight * Player.possessions[i]->number;
901 [ + + ][ - + ]: 72 : if ((Player.possessions[O_WEAPON_HAND] != NULL) &&
902 : 69 : (Player.possessions[O_READY_HAND] == Player.possessions[O_WEAPON_HAND]))
903 : 0 : weight -= Player.possessions[O_READY_HAND]->weight *
904 : 0 : Player.possessions[O_READY_HAND]->number;
905 [ + + ]: 1944 : for(i=0;i<MAXPACK;i++)
906 [ - + ]: 1872 : if (Player.pack[i] != NULL)
907 : 0 : weight += Player.pack[i]->weight *
908 : 0 : Player.pack[i]->number;
909 : 72 : Player.itemweight = weight;
910 : 72 : dataprint();
911 : 72 : }
912 : :
913 : : char joinString[256], temp[256];
914 : 72 : char *strjoin(char*one, char*two)
915 : : {
916 [ - + ]: 72 : assert(one != two);
917 [ - + ]: 72 : if (joinString == one) goto DirectJoin;
918 [ - + ]: 72 : if (joinString == two) {strcpy(temp,two); two = temp;}
919 : 72 : strcpy(joinString,one);
920 : : DirectJoin:
921 : 72 : strcat(joinString,two);
922 : 72 : return joinString;
923 : : }
924 : :
925 : : /* returns true if its ok to get rid of a level */
926 : 22 : int ok_to_free(plv level)
927 : : {
928 [ + + ]: 22 : if (level == NULL) return(FALSE);
929 [ - + ]: 30 : else return((level->environment != E_CITY) &&
930 [ + + ][ # # ]: 30 : (level->environment != E_VILLAGE) &&
931 : 0 : (level->environment != Current_Dungeon));
932 : : }
933 : :
934 : : /* DAG frees object; if flag true, final free, free any allocated corpse string */
935 : 42 : void free_obj( pob obj, int flag )
936 : : {
937 [ + - ][ + + ]: 42 : if ( flag && (obj->id == CORPSEID) && (obj->level & ALLOC) )
[ - + ]
938 : 0 : free( obj->objstr );
939 : 42 : free( (char *) obj );
940 : 42 : }
941 : :
942 : 66 : pob copy_obj ( pob obj )
943 : : {
944 : : pob new;
945 : 66 : new = ((pob) checkmalloc(sizeof(objtype)));
946 : 66 : *new = *obj;
947 [ + + ][ - + ]: 66 : if ( (obj->id == CORPSEID) && (obj->level & ALLOC) )
948 : : {
949 : 0 : new->objstr = new->cursestr = new->truename = salloc( obj->objstr );
950 : : }
951 : 66 : return new;
952 : : }
953 : :
954 : 30 : void free_objlist(pol pobjlist)
955 : : {
956 : : pol tmp;
957 : :
958 [ + + ]: 49 : while (pobjlist) {
959 : 19 : free_obj( (tmp = pobjlist)->thing, TRUE );
960 : 19 : pobjlist = pobjlist->next;
961 : 19 : free(tmp);
962 : : }
963 : 30 : }
964 : :
965 : 3 : void free_mons_and_objs(pml mlist)
966 : : {
967 : : pml tmp;
968 : :
969 [ + + ]: 29 : while (mlist) {
970 : 26 : free_objlist((tmp = mlist)->m->possessions);
971 : : /* DAG free the monstring & corpsestr if allocated */
972 [ - + ]: 26 : if ( m_statusp( tmp->m, ALLOC ) )
973 : : {
974 : 0 : free( tmp->m->monstring );
975 : 0 : free( tmp->m->corpsestr );
976 : : }
977 : 26 : free(tmp->m);
978 : 26 : mlist = mlist->next;
979 : 26 : free(tmp);
980 : : }
981 : 3 : }
982 : :
983 : : /* Free up monsters and items on a level*/
984 : 3 : void free_level(plv level)
985 : : {
986 : : int i,j;
987 : :
988 : 3 : free_mons_and_objs(level->mlist);
989 [ + + ]: 195 : for (i = 0; i < level->level_width; i++)
990 [ + + ]: 3264 : for (j = 0; j < level->level_length; j++)
991 [ + + ]: 3072 : if (level->site[i][j].things) {
992 : 1 : free_objlist(level->site[i][j].things);
993 : 1 : level->site[i][j].things = NULL;
994 : : }
995 : : #ifndef SAVE_LEVELS
996 : 3 : free(level);
997 : : #endif
998 : 3 : }
999 : :
1000 : : /* malloc function that checks its return value - if NULL, tries to free */
1001 : : /* some memory... */
1002 : 3357 : void *checkmalloc(unsigned int bytes)
1003 : : {
1004 : 3357 : void *ptr = malloc(bytes);
1005 : : struct level *curr, **prev, **oldest;
1006 : :
1007 [ + - ]: 3357 : if (ptr)
1008 : 3357 : return ptr;
1009 [ # # ]: 0 : for (curr = Dungeon, oldest = prev = &Dungeon; curr; curr = curr->next) {
1010 [ # # ]: 0 : if ((*oldest)->last_visited > curr->last_visited)
1011 : 0 : oldest = prev;
1012 : 0 : prev = &(curr->next);
1013 : : }
1014 [ # # ][ # # ]: 0 : if (*oldest && *oldest != Level) {
1015 : 0 : curr = *oldest;
1016 : 0 : *oldest = (*oldest)->next;
1017 : 0 : free_level(curr);
1018 : 0 : ptr = malloc(bytes);
1019 : : }
1020 [ # # ]: 0 : if (ptr)
1021 : 0 : return ptr;
1022 : : else {
1023 : 0 : print1("Out of memory! Saving and quitting.");
1024 : 0 : morewait();
1025 : 0 : save(FALSE, TRUE);
1026 : 0 : endgraf();
1027 : 0 : exit(0);
1028 : : }
1029 : : }
1030 : :
1031 : : /* alloc just enough string space for str, strcpy, and return pointer */
1032 : 91 : char *salloc(char *str)
1033 : : {
1034 : 91 : char *s=checkmalloc((unsigned)(strlen(str)+1));
1035 : 91 : strcpy(s,str);
1036 : 91 : return(s);
1037 : : }
1038 : :
1039 : : #ifdef MSDOS
1040 : : /* ****Moved here from another file**** */
1041 : : /* reads a string from a file. If it is a line with more than 80 char's,
1042 : : then remainder of line to \n is consumed */
1043 : : void filescanstring(FILE *fd, char *fstr)
1044 : : {
1045 : : int i= -1;
1046 : : int byte='x';
1047 : : while ((i<80) && (byte != '\n') && (byte != EOF)) {
1048 : : i++;
1049 : : byte=fgetc(fd);
1050 : : fstr[i] = byte;
1051 : : }
1052 : : if (byte != '\n')
1053 : : while((byte!='\n') && (byte != EOF))
1054 : : byte=fgetc(fd);
1055 : : fstr[i]=0;
1056 : : }
1057 : : #endif
1058 : :
1059 : : #ifdef MSDOS_SUPPORTED_ANTIQUE
1060 : : /* ****Moved here from another file**** */
1061 : : /* returns a "level of difficulty" based on current environment
1062 : : and depth in dungeon. Is somewhat arbitrary. value between 1 and 10.
1063 : : May not actually represent real difficulty, but instead level
1064 : : of items, monsters encountered. */
1065 : : int difficulty(void)
1066 : : {
1067 : : int depth = 1;
1068 : : if (Level != NULL) depth = Level->depth;
1069 : : switch(Current_Environment) {
1070 : : case E_COUNTRYSIDE: return(7);
1071 : : case E_CITY: return(3);
1072 : : case E_VILLAGE: return(1);
1073 : : case E_TACTICAL_MAP: return(7);
1074 : : case E_SEWERS: return(depth/6)+3;
1075 : : case E_CASTLE: return(depth/4)+4;
1076 : : case E_CAVES: return(depth/3)+1;
1077 : : case E_VOLCANO: return(depth/4)+5;
1078 : : case E_ASTRAL: return(8);
1079 : : case E_ARENA: return(5);
1080 : : case E_HOVEL: return(3);
1081 : : case E_MANSION: return(7);
1082 : : case E_HOUSE: return(5);
1083 : : case E_DLAIR: return(9);
1084 : : case E_ABYSS: return(10);
1085 : : case E_STARPEAK: return(9);
1086 : : case E_CIRCLE: return(8);
1087 : : case E_MAGIC_ISLE: return(8);
1088 : : case E_TEMPLE: return(8);
1089 : :
1090 : : /* PGM why is this duplicated in lev.c ? */
1091 : : case E_PALACE: /* varies by phase of moon */
1092 : : {
1093 : : int diff = 0;
1094 : : switch(Phase/2) {
1095 : : case 0: diff = 0; break;
1096 : : case 1: case 11: diff = 1; break;
1097 : : case 2: case 10: diff = 2; break;
1098 : : case 3: case 9: diff = 3; break;
1099 : : case 4: case 8: diff = 5; break;
1100 : : case 5: case 7: diff = 6; break;
1101 : : case 6: diff = 7; break;
1102 : : }
1103 : : return( min( ((depth+diff)/3)+4,9));
1104 : : }
1105 : : default: return(3);
1106 : : }
1107 : : }
1108 : : #endif
1109 : :
1110 : 0 : char cryptkey(char *fname)
1111 : : {
1112 : 0 : int pos, key = 0;
1113 : :
1114 [ # # ]: 0 : for (pos = 0; fname[pos]; pos++)
1115 : 0 : key += 3*(fname[pos] - ' ');
1116 : 0 : return (key&0xff);
1117 : : }
1118 : :
1119 : : int game_uid;
1120 : : int user_uid;
1121 : :
1122 : 15 : void init_perms(void)
1123 : : {
1124 : : #if (defined(BSD) || defined(SYSV)) && !defined(__DJGPP__)
1125 : 15 : user_uid = getuid();
1126 : 15 : game_uid = geteuid();
1127 : : #endif
1128 : 15 : }
1129 : :
1130 : : /*
1131 : : #ifdef BSD
1132 : : void setreuid(int, int);
1133 : : #endif
1134 : : */
1135 : :
1136 : 26 : void change_to_user_perms(void)
1137 : : {
1138 : : #if (defined( BSD ) || defined( SYSV )) && !defined(__EMX__) && !defined(__DJGPP__)
1139 : : #ifdef BSD
1140 : 26 : setreuid(game_uid, user_uid);
1141 : : #else /* SYSV */
1142 : : seteuid(user_uid);
1143 : : #endif /* BSD */
1144 : : #endif /* BSD || SYSV */
1145 : 26 : }
1146 : :
1147 : 165 : void change_to_game_perms(void)
1148 : : {
1149 : : #if (defined( BSD ) || defined( SYSV )) && !defined(__EMX__) && !defined(__DJGPP__)
1150 : : #ifdef BSD
1151 : 165 : setreuid(user_uid, game_uid);
1152 : : #else /* SYSV */
1153 : : seteuid(game_uid);
1154 : : #endif /* BSD */
1155 : : #endif /* BSD || SYSV */
1156 : 165 : }
1157 : :
1158 : : #ifdef NO_USLEEP
1159 : : void usleep(int usecs)
1160 : : {
1161 : : fd_set null;
1162 : : struct timeval timeout;
1163 : :
1164 : : FD_ZERO(&null);
1165 : : timeout.tv_usec = usecs;
1166 : : timeout.tv_sec = 0;
1167 : : select(0, &null, &null, &null, &timeout);
1168 : : }
1169 : : #endif
|
