![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / games / rogue|
Return to main.c CVS log | Up to [Research Unix] / researchv10no / games / rogue |
1.1 root 1: /*
2: * Rogue
3: * Exploring the dungeons of doom
4: * Copyright (C) 1980 by Michael Toy and Glenn Wichman
5: * All rights reserved
6: *
7: * @(#)main.c 3.27 (Berkeley) 6/15/81
8: */
9:
10: #include <curses.h>
11: #include <signal.h>
12: #include <pwd.h>
13: #include "mach_dep.h"
14: #include "rogue.h"
15:
16: #ifdef CHECKTIME
17: static int num_checks; /* times we've gone over in checkout() */
18: #endif
19:
20: char _sobuf[BUFSIZ];
21:
22: main(argc, argv, envp)
23: char **argv;
24: char **envp;
25: {
26: register char *env;
27: register struct passwd *pw;
28: register struct linked_list *item;
29: register struct object *obj;
30: struct passwd *getpwuid();
31: char *getpass(), *crypt();
32: int quit(), lowtime;
33: long now;
34:
35: setbuf (stdout, _sobuf);
36:
37: /*
38: * check for print-score option
39: */
40: if (argc == 2 && strcmp(argv[1], "-s") == 0)
41: {
42: waswizard = TRUE;
43: score(0, -1);
44: exit(0);
45: }
46: /*
47: * Allow nondeterministic cheating
48: */
49: if (argc >= 2 && strcmp(argv[1], "-c") == 0) {
50: cheating = TRUE;
51: argv++;
52: argc--;
53: }
54: /*
55: * Check to see if he is a wizard
56: */
57: if (argc >= 2 && argv[1][0] == '\0')
58: if (strcmp(PASSWD, crypt(getpass("Wizard's password: "), "C4")) == 0)
59: {
60: wizard = TRUE;
61: argv++;
62: argc--;
63: }
64:
65: /*
66: * get home and options from environment
67: */
68: if ((env = getenv("HOME")) != NULL)
69: strcpy(home, env);
70: else if ((pw = getpwuid(getuid())) != NULL)
71: strcpy(home, pw->pw_dir);
72: else
73: home[0] = '\0';
74: strcat(home, "/");
75:
76: strcpy(file_name, home);
77: strcat(file_name, "rogue.save");
78:
79: if ((env = getenv("ROGUEOPTS")) != NULL)
80: parse_opts(env);
81: if (env == NULL || whoami[0] == '\0')
82: if ((pw = getpwuid(getuid())) == NULL)
83: {
84: printf("Say, who the hell are you?\n");
85: exit(1);
86: }
87: else
88: strucpy(whoami, pw->pw_name, strlen(pw->pw_name));
89: if (env == NULL || fruit[0] == '\0')
90: strcpy(fruit, "slime-mold");
91:
92: #if MAXLOAD|MAXUSERS
93: if (too_much() && !wizard && !author())
94: {
95: printf("Sorry, %s, but the system is too loaded now.\n", whoami);
96: printf("Try again later. Meanwhile, why not enjoy a%s %s?\n",
97: vowelstr(fruit), fruit);
98: exit(1);
99: }
100: #endif
101: if (argc == 2)
102: if (!restore(argv[1], envp)) /* Note: restore will never return */
103: exit(1);
104: time(&now);
105: lowtime = (int) now;
106: dnum = (wizard && getenv("SEED") != NULL ?
107: atoi(getenv("SEED")) :
108: lowtime + getpid());
109: if (wizard)
110: printf("Hello %s, welcome to dungeon #%d", whoami, dnum);
111: else
112: printf("Hello %s, just a moment while I dig the dungeon...", whoami);
113: fflush(stdout);
114: seed = dnum;
115:
116: init_player(); /* Roll up the rogue */
117: init_things(); /* Set up probabilities of things */
118: init_names(); /* Set up names of scrolls */
119: init_colors(); /* Set up colors of potions */
120: init_stones(); /* Set up stone settings of rings */
121: init_materials(); /* Set up materials of wands */
122: initscr(); /* Start up cursor package */
123: setup();
124: /*
125: * Set up windows
126: */
127: cw = newwin(LINES, COLS, 0, 0);
128: mw = newwin(LINES, COLS, 0, 0);
129: hw = newwin(LINES, COLS, 0, 0);
130: waswizard = wizard;
131: new_level(); /* Draw current level */
132: /*
133: * Start up daemons and fuses
134: */
135: daemon(doctor, 0, AFTER);
136: fuse(swander, 0, WANDERTIME, AFTER);
137: daemon(stomach, 0, AFTER);
138: daemon(runners, 0, AFTER);
139: /*
140: * Give the rogue his weaponry. First a mace.
141: */
142: item = new_item(sizeof *obj);
143: obj = (struct object *) ldata(item);
144: obj->o_type = WEAPON;
145: obj->o_which = MACE;
146: init_weapon(obj, MACE);
147: obj->o_hplus = 1;
148: obj->o_dplus = 1;
149: obj->o_flags |= ISKNOW;
150: add_pack(item, TRUE);
151: cur_weapon = obj;
152: /*
153: * Now a +1 bow
154: */
155: item = new_item(sizeof *obj);
156: obj = (struct object *) ldata(item);
157: obj->o_type = WEAPON;
158: obj->o_which = BOW;
159: init_weapon(obj, BOW);
160: obj->o_hplus = 1;
161: obj->o_dplus = 0;
162: obj->o_flags |= ISKNOW;
163: add_pack(item, TRUE);
164: /*
165: * Now some arrows
166: */
167: item = new_item(sizeof *obj);
168: obj = (struct object *) ldata(item);
169: obj->o_type = WEAPON;
170: obj->o_which = ARROW;
171: init_weapon(obj, ARROW);
172: obj->o_count = 25+rnd(15);
173: obj->o_hplus = obj->o_dplus = 0;
174: obj->o_flags |= ISKNOW;
175: add_pack(item, TRUE);
176: /*
177: * And his suit of armor
178: */
179: item = new_item(sizeof *obj);
180: obj = (struct object *) ldata(item);
181: obj->o_type = ARMOR;
182: obj->o_which = RING_MAIL;
183: obj->o_ac = a_class[RING_MAIL] - 1;
184: obj->o_flags |= ISKNOW;
185: cur_armor = obj;
186: add_pack(item, TRUE);
187: /*
188: * Give him some food too
189: */
190: item = new_item(sizeof *obj);
191: obj = (struct object *) ldata(item);
192: obj->o_type = FOOD;
193: obj->o_count = 1;
194: obj->o_which = 0;
195: add_pack(item, TRUE);
196: playit();
197: }
198:
199: /*
200: * endit:
201: * Exit the program abnormally.
202: */
203:
204: endit()
205: {
206: fatal("Ok, if you want to exit that badly, I'll have to allow it\n");
207: }
208:
209: /*
210: * fatal:
211: * Exit the program, printing a message.
212: */
213:
214: fatal(s)
215: char *s;
216: {
217: clear();
218: move(LINES-2, 0);
219: printw("%s", s);
220: draw(stdscr);
221: endwin();
222: exit(0);
223: }
224:
225: /*
226: * rnd:
227: * Pick a very random number.
228: */
229:
230: rnd(range)
231: register int range;
232: {
233: return range == 0 ? 0 : abs(RN) % range;
234: }
235:
236: /*
237: * roll:
238: * roll a number of dice
239: */
240:
241: roll(number, sides)
242: register int number, sides;
243: {
244: register int dtotal = 0;
245:
246: while(number--)
247: dtotal += rnd(sides)+1;
248: return dtotal;
249: }
250: # ifdef SIGTSTP
251: /*
252: * handle stop and start signals
253: */
254: tstp()
255: {
256: mvcur(0, COLS - 1, LINES - 1, 0);
257: endwin();
258: fflush(stdout);
259: kill(0, SIGTSTP);
260: signal(SIGTSTP, tstp);
261: crmode();
262: noecho();
263: clearok(curscr, TRUE);
264: touchwin(cw);
265: draw(cw);
266: raw(); /* flush input */
267: noraw();
268: }
269: # endif
270:
271: setup()
272: {
273: #ifdef CHECKTIME
274: int checkout();
275: #endif
276:
277: #ifndef DUMP
278: signal(SIGHUP, auto_save);
279: signal(SIGILL, auto_save);
280: signal(SIGTRAP, auto_save);
281: signal(SIGIOT, auto_save);
282: signal(SIGEMT, auto_save);
283: signal(SIGFPE, auto_save);
284: signal(SIGBUS, auto_save);
285: signal(SIGSEGV, auto_save);
286: signal(SIGSYS, auto_save);
287: signal(SIGPIPE, auto_save);
288: signal(SIGTERM, auto_save);
289: #endif
290:
291: signal(SIGINT, quit);
292: #ifndef DUMP
293: signal(SIGQUIT, endit);
294: #endif
295: #ifdef SIGTSTP
296: signal(SIGTSTP, tstp);
297: #endif
298: #ifdef CHECKTIME
299: if (!author())
300: {
301: signal(SIGALRM, checkout);
302: alarm(CHECKTIME * 60);
303: num_checks = 0;
304: }
305: #endif
306: crmode(); /* Cbreak mode */
307: noecho(); /* Echo off */
308: }
309:
310: /*
311: * playit:
312: * The main loop of the program. Loop until the game is over,
313: * refreshing things and looking at the proper times.
314: */
315:
316: playit()
317: {
318: register char *opts;
319:
320: /*
321: * set up defaults for slow terminals
322: */
323:
324: #if USG==1
325: if ((_tty.c_cflag & CBAUD) < B1200)
326: #else
327: if (_tty.sg_ospeed < B1200)
328: #endif
329: {
330: terse = TRUE;
331: jump = TRUE;
332: }
333:
334: /*
335: * parse environment declaration of options
336: */
337: if ((opts = getenv("ROGUEOPTS")) != NULL)
338: parse_opts(opts);
339:
340:
341: oldpos = hero;
342: oldrp = roomin(&hero);
343: while (playing)
344: command(); /* Command execution */
345: endit();
346: }
347:
348: #if MAXLOAD|MAXUSERS
349: /*
350: * see if the system is being used too much for this game
351: */
352: too_much()
353: {
354: #ifdef MAXLOAD
355: double avec[3];
356: #else
357: register int cnt;
358: #endif
359:
360: #ifdef MAXLOAD
361: loadav(avec);
362: return (avec[2] > (MAXLOAD / 10.0));
363: #else
364: return (ucount() > MAXUSERS);
365: #endif
366: }
367:
368: /*
369: * see if a user is an author of the program
370: */
371: author()
372: {
373: switch (getuid())
374: {
375: case 24601:
376: return TRUE;
377: default:
378: return FALSE;
379: }
380: }
381: #endif
382:
383: #ifdef CHECKTIME
384: checkout()
385: {
386: static char *msgs[] = {
387: "The load is too high to be playing. Please leave in %d minutes",
388: "Please save your game. You have %d minutes",
389: "Last warning. You have %d minutes to leave",
390: };
391: int checktime;
392:
393: signal(SIGALRM, checkout);
394: if (too_much())
395: {
396: if (num_checks == 3)
397: fatal("Sorry. You took to long. You are dead\n");
398: checktime = CHECKTIME / (num_checks + 1);
399: chmsg(msgs[num_checks++], checktime);
400: alarm(checktime * 60);
401: }
402: else
403: {
404: if (num_checks)
405: {
406: chmsg("The load has dropped back down. You have a reprieve.");
407: num_checks = 0;
408: }
409: alarm(CHECKTIME * 60);
410: }
411: }
412:
413: /*
414: * checkout()'s version of msg. If we are in the middle of a shell, do a
415: * printf instead of a msg to avoid the refresh.
416: */
417: chmsg(fmt, arg)
418: char *fmt;
419: int arg;
420: {
421: if (in_shell)
422: {
423: printf(fmt, arg);
424: putchar('\n');
425: fflush(stdout);
426: }
427: else
428: msg(fmt, arg);
429: }
430: #endif
431:
432: #ifdef LOADAV
433:
434: #include <nlist.h>
435:
436: struct nlist avenrun =
437: {
438: "_avenrun"
439: };
440:
441: loadav(avg)
442: register double *avg;
443: {
444: register int kmem;
445:
446: if ((kmem = open("/dev/kmem", 0)) < 0)
447: goto bad;
448: nlist(NAMELIST, &avenrun);
449: if (avenrun.n_type == 0)
450: {
451: bad:
452: avg[0] = avg[1] = avg[2] = 0.0;
453: return;
454: }
455:
456: lseek(kmem, (long) avenrun.n_value, 0);
457: read(kmem, avg, 3 * sizeof (double));
458: }
459: #endif
460:
461: #ifdef UCOUNT
462:
463: #include <utmp.h>
464:
465: struct utmp buf;
466:
467: ucount()
468: {
469: register struct utmp *up;
470: register FILE *utmp;
471: register int count;
472:
473: if ((utmp = fopen(UTMP, "r")) == NULL)
474: return 0;
475:
476: up = &buf;
477: count = 0;
478:
479: while (fread(up, 1, sizeof (*up), utmp) > 0)
480: if (buf.ut_name[0] != '\0')
481: count++;
482: fclose(utmp);
483: return count;
484: }
485: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.