![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / phantasia|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / phantasia |
1.1 root 1: /*
2: * misc.c Phantasia miscellaneous support routines
3: */
4:
5: #include "include.h"
6:
7: /************************************************************************
8: /
9: / FUNCTION NAME: movelevel()
10: /
11: / FUNCTION: move player to new level
12: /
13: / AUTHOR: E. A. Estes, 12/4/85
14: /
15: / ARGUMENTS: none
16: /
17: / RETURN VALUE: none
18: /
19: / MODULES CALLED: death(), floor(), wmove(), drandom(), waddstr(), explevel()
20: /
21: / GLOBAL INPUTS: Player, *stdscr, *Statptr, Stattable[]
22: /
23: / GLOBAL OUTPUTS: Player, Changed
24: /
25: / DESCRIPTION:
26: / Use lookup table to increment important statistics when
27: / progressing to new experience level.
28: / Players are rested to maximum as a bonus for making a new
29: / level.
30: / Check for council of wise, and being too big to be king.
31: /
32: /************************************************************************/
33:
34: movelevel()
35: {
36: register struct charstats *statptr; /* for pointing into Stattable */
37: double new; /* new level */
38: double inc; /* increment between new and old levels */
39:
40: Changed = TRUE;
41:
42: if (Player.p_type == C_EXPER)
43: /* roll a type to use for increment */
44: statptr = &Stattable[(int) ROLL(C_MAGIC, C_HALFLING - C_MAGIC + 1)];
45: else
46: statptr = Statptr;
47:
48: new = explevel(Player.p_experience);
49: inc = new - Player.p_level;
50: Player.p_level = new;
51:
52: /* add increments to statistics */
53: Player.p_strength += statptr->c_strength.increase * inc;
54: Player.p_mana += statptr->c_mana.increase * inc;
55: Player.p_brains += statptr->c_brains.increase * inc;
56: Player.p_magiclvl += statptr->c_magiclvl.increase * inc;
57: Player.p_maxenergy += statptr->c_energy.increase * inc;
58:
59: /* rest to maximum upon reaching new level */
60: Player.p_energy = Player.p_maxenergy + Player.p_shield;
61:
62: if (Player.p_crowns > 0 && Player.p_level >= 1000.0)
63: /* no longer able to be king -- turn crowns into cash */
64: {
65: Player.p_gold += ((double) Player.p_crowns) * 5000.0;
66: Player.p_crowns = 0;
67: }
68:
69: if (Player.p_level >= 3000.0 && Player.p_specialtype < SC_COUNCIL)
70: /* make a member of the council */
71: {
72: mvaddstr(6, 0, "You have made it to the Council of the Wise.\n");
73: addstr("Good Luck on your search for the Holy Grail.\n");
74:
75: Player.p_specialtype = SC_COUNCIL;
76:
77: /* no rings for council and above */
78: Player.p_ring.ring_type = R_NONE;
79: Player.p_ring.ring_duration = 0;
80:
81: Player.p_lives = 3; /* three extra lives */
82: }
83:
84: if (Player.p_level > 9999.0 && Player.p_specialtype != SC_VALAR)
85: death("Old age");
86: }
87: /* */
88: /************************************************************************
89: /
90: / FUNCTION NAME: descrlocation()
91: /
92: / FUNCTION: return a formatted description of location
93: /
94: / AUTHOR: E. A. Estes, 12/4/85
95: /
96: / ARGUMENTS:
97: / struct player playerp - pointer to player structure
98: / bool shortflag - set if short form is desired
99: /
100: / RETURN VALUE: pointer to string containing result
101: /
102: / MODULES CALLED: fabs(), floor(), sprintf(), distance()
103: /
104: / GLOBAL INPUTS: Databuf[]
105: /
106: / GLOBAL OUTPUTS: none
107: /
108: / DESCRIPTION:
109: / Look at coordinates and return an appropriately formatted
110: / string.
111: /
112: /************************************************************************/
113:
114: char *
115: descrlocation(playerp, shortflag)
116: struct player *playerp;
117: bool shortflag;
118: {
119: double circle; /* corresponding circle for coordinates */
120: register int quadrant; /* quandrant of grid */
121: register char *label; /* pointer to place name */
122: static char *nametable[4][4] = /* names of places */
123: {
124: "Anorien", "Ithilien", "Rohan", "Lorien",
125: "Gondor", "Mordor", "Dunland", "Rovanion",
126: "South Gondor", "Khand", "Eriador", "The Iron Hills",
127: "Far Harad", "Near Harad", "The Northern Waste", "Rhun"
128: };
129:
130: if (playerp->p_specialtype == SC_VALAR)
131: return(" is in Valhala");
132: else if ((circle = CIRCLE(playerp->p_x, playerp->p_y)) >= 1000.0)
133: {
134: if (MAX(fabs(playerp->p_x), fabs(playerp->p_y)) > D_BEYOND)
135: label = "The Point of No Return";
136: else
137: label = "The Ashen Mountains";
138: }
139: else if (circle >= 55)
140: label = "Morannon";
141: else if (circle >= 35)
142: label = "Kennaquahair";
143: else if (circle >= 20)
144: label = "The Dead Marshes";
145: else if (circle >= 9)
146: label = "The Outer Waste";
147: else if (circle >= 5)
148: label = "The Moors Adventurous";
149: else
150: {
151: if (playerp->p_x == 0.0 && playerp->p_y == 0.0)
152: label = "The Lord's Chamber";
153: else
154: {
155: /* this expression is split to prevent compiler loop with some compilers */
156: quadrant = ((playerp->p_x > 0.0) ? 1 : 0);
157: quadrant += ((playerp->p_y >= 0.0) ? 2 : 0);
158: label = nametable[((int) circle) - 1][quadrant];
159: }
160: }
161:
162: if (shortflag)
163: sprintf(Databuf, "%.29s", label);
164: else
165: sprintf(Databuf, " is in %s (%.0f,%.0f)", label, playerp->p_x, playerp->p_y);
166:
167: return(Databuf);
168: }
169: /* */
170: /************************************************************************
171: /
172: / FUNCTION NAME: tradingpost()
173: /
174: / FUNCTION: do trading post stuff
175: /
176: / AUTHOR: E. A. Estes, 12/4/85
177: /
178: / ARGUMENTS: none
179: /
180: / RETURN VALUE: none
181: /
182: / MODULES CALLED: writerecord(), adjuststats(), fabs(), more(), sqrt(),
183: / sleep(), floor(), wmove(), drandom(), wclear(), printw(),
184: / altercoordinates(), infloat(), waddstr(), wrefresh(), mvprintw(), getanswer(),
185: / wclrtoeol(), wclrtobot()
186: /
187: / GLOBAL INPUTS: Menu[], Circle, Player, *stdscr, Fileloc, Nobetter[]
188: /
189: / GLOBAL OUTPUTS: Player
190: /
191: / DESCRIPTION:
192: / Different trading posts have different items.
193: / Merchants cannot be cheated, but they can be dishonest
194: / themselves.
195: /
196: / Shields, swords, and quicksilver are not cumulative. This is
197: / one major area of complaint, but there are two reasons for this:
198: / 1) It becomes MUCH too easy to make very large versions
199: / of these items.
200: / 2) In the real world, one cannot simply weld two swords
201: / together to make a bigger one.
202: /
203: / At one time, it was possible to sell old weapons at half the purchase
204: / price. This resulted in huge amounts of gold floating around,
205: / and the game lost much of its challenge.
206: /
207: / Also, purchasing gems defeats the whole purpose of gold. Gold
208: / is small change for lower level players. They really shouldn't
209: / be able to accumulate more than enough gold for a small sword or
210: / a few books. Higher level players shouldn't even bother to pick
211: / up gold, except maybe to buy mana once in a while.
212: /
213: /************************************************************************/
214:
215: tradingpost()
216: {
217: double numitems; /* number of items to purchase */
218: double cost; /* cost of purchase */
219: double blessingcost; /* cost of blessing */
220: int ch; /* input */
221: register int size; /* size of the trading post */
222: register int loop; /* loop counter */
223: int cheat = 0; /* number of times player has tried to cheat */
224: bool dishonest = FALSE;/* set when merchant is dishonest */
225:
226: Player.p_status = S_TRADING;
227: writerecord(&Player, Fileloc);
228:
229: clear();
230: addstr("You are at a trading post. All purchases must be made with gold.");
231:
232: size = sqrt(fabs(Player.p_x / 100)) + 1;
233: size = MIN(7, size);
234:
235: /* set up cost of blessing */
236: blessingcost = 1000.0 * (Player.p_level + 5.0);
237:
238: /* print Menu */
239: move(7, 0);
240: for (loop = 0; loop < size; ++loop)
241: /* print Menu */
242: {
243: if (loop == 6)
244: cost = blessingcost;
245: else
246: cost = Menu[loop].cost;
247: printw("(%d) %-12s: %6.0f\n", loop + 1, Menu[loop].item, cost);
248: }
249:
250: mvprintw(5, 0, "L:Leave P:Purchase S:Sell Gems ? ");
251:
252: for (;;)
253: {
254: adjuststats(); /* truncate any bad values */
255:
256: /* print some important statistics */
257: mvprintw(1, 0, "Gold: %9.0f Gems: %9.0f Level: %6.0f Charms: %6d\n",
258: Player.p_gold, Player.p_gems, Player.p_level, Player.p_charms);
259: printw("Shield: %9.0f Sword: %9.0f Quicksilver:%3.0f Blessed: %s\n",
260: Player.p_shield, Player.p_sword, Player.p_quksilver,
261: (Player.p_blessing ? " True" : "False"));
262: printw("Brains: %9.0f Mana: %9.0f", Player.p_brains, Player.p_mana);
263:
264: move(5, 36);
265: ch = getanswer("LPS", FALSE);
266: move(15, 0);
267: clrtobot();
268: switch(ch)
269: {
270: case 'L': /* leave */
271: case '\n':
272: altercoordinates(0.0, 0.0, A_NEAR);
273: return;
274:
275: case 'P': /* make purchase */
276: mvaddstr(15, 0, "What what would you like to buy ? ");
277: ch = getanswer(" 1234567", FALSE);
278: move(15, 0);
279: clrtoeol();
280:
281: if (ch - '0' > size)
282: addstr("Sorry, this merchant doesn't have that.");
283: else
284: switch (ch)
285: {
286: case '1':
287: printw("Mana is one per %.0f gold piece. How many do you want (%.0f max) ? ",
288: Menu[0].cost, floor(Player.p_gold / Menu[0].cost));
289: cost = (numitems = floor(infloat())) * Menu[0].cost;
290:
291: if (cost > Player.p_gold || numitems < 0)
292: ++cheat;
293: else
294: {
295: cheat = 0;
296: Player.p_gold -= cost;
297: if (drandom() < 0.02)
298: dishonest = TRUE;
299: else
300: Player.p_mana += numitems;
301: }
302: break;
303:
304: case '2':
305: printw("Shields are %.0f per +1. How many do you want (%.0f max) ? ",
306: Menu[1].cost, floor(Player.p_gold / Menu[1].cost));
307: cost = (numitems = floor(infloat())) * Menu[1].cost;
308:
309: if (numitems == 0.0)
310: break;
311: else if (cost > Player.p_gold || numitems < 0)
312: ++cheat;
313: else if (numitems < Player.p_shield)
314: NOBETTER();
315: else
316: {
317: cheat = 0;
318: Player.p_gold -= cost;
319: if (drandom() < 0.02)
320: dishonest = TRUE;
321: else
322: Player.p_shield = numitems;
323: }
324: break;
325:
326: case '3':
327: printw("A book costs %.0f gp. How many do you want (%.0f max) ? ",
328: Menu[2].cost, floor(Player.p_gold / Menu[2].cost));
329: cost = (numitems = floor(infloat())) * Menu[2].cost;
330:
331: if (cost > Player.p_gold || numitems < 0)
332: ++cheat;
333: else
334: {
335: cheat = 0;
336: Player.p_gold -= cost;
337: if (drandom() < 0.02)
338: dishonest = TRUE;
339: else if (drandom() * numitems > Player.p_level / 10.0
340: && numitems != 1)
341: {
342: printw("\nYou blew your mind!\n");
343: Player.p_brains /= 5;
344: }
345: else
346: {
347: Player.p_brains += floor(numitems) * ROLL(20, 8);
348: }
349: }
350: break;
351:
352: case '4':
353: printw("Swords are %.0f gp per +1. How many + do you want (%.0f max) ? ",
354: Menu[3].cost, floor(Player.p_gold / Menu[3].cost));
355: cost = (numitems = floor(infloat())) * Menu[3].cost;
356:
357: if (numitems == 0.0)
358: break;
359: else if (cost > Player.p_gold || numitems < 0)
360: ++cheat;
361: else if (numitems < Player.p_sword)
362: NOBETTER();
363: else
364: {
365: cheat = 0;
366: Player.p_gold -= cost;
367: if (drandom() < 0.02)
368: dishonest = TRUE;
369: else
370: Player.p_sword = numitems;
371: }
372: break;
373:
374: case '5':
375: printw("A charm costs %.0f gp. How many do you want (%.0f max) ? ",
376: Menu[4].cost, floor(Player.p_gold / Menu[4].cost));
377: cost = (numitems = floor(infloat())) * Menu[4].cost;
378:
379: if (cost > Player.p_gold || numitems < 0)
380: ++cheat;
381: else
382: {
383: cheat = 0;
384: Player.p_gold -= cost;
385: if (drandom() < 0.02)
386: dishonest = TRUE;
387: else
388: Player.p_charms += numitems;
389: }
390: break;
391:
392: case '6':
393: printw("Quicksilver is %.0f gp per +1. How many + do you want (%.0f max) ? ",
394: Menu[5].cost, floor(Player.p_gold / Menu[5].cost));
395: cost = (numitems = floor(infloat())) * Menu[5].cost;
396:
397: if (numitems == 0.0)
398: break;
399: else if (cost > Player.p_gold || numitems < 0)
400: ++cheat;
401: else if (numitems < Player.p_quksilver)
402: NOBETTER();
403: else
404: {
405: cheat = 0;
406: Player.p_gold -= cost;
407: if (drandom() < 0.02)
408: dishonest = TRUE;
409: else
410: Player.p_quksilver = numitems;
411: }
412: break;
413:
414: case '7':
415: if (Player.p_blessing)
416: {
417: addstr("You already have a blessing.");
418: break;
419: }
420:
421: printw("A blessing requires a %.0f gp donation. Still want one ? ", blessingcost);
422: ch = getanswer("NY", FALSE);
423:
424: if (ch == 'Y')
425: if (Player.p_gold < blessingcost)
426: ++cheat;
427: else
428: {
429: cheat = 0;
430: Player.p_gold -= blessingcost;
431: if (drandom() < 0.02)
432: dishonest = TRUE;
433: else
434: Player.p_blessing = TRUE;
435: }
436: break;
437: }
438: break;
439:
440: case 'S': /* sell gems */
441: mvprintw(15, 0, "A gem is worth %.0f gp. How many do you want to sell (%.0f max) ? ",
442: (double) N_GEMVALUE, Player.p_gems);
443: numitems = floor(infloat());
444:
445: if (numitems > Player.p_gems || numitems < 0)
446: ++cheat;
447: else
448: {
449: cheat = 0;
450: Player.p_gems -= numitems;
451: Player.p_gold += numitems * N_GEMVALUE;
452: }
453: }
454:
455: if (cheat == 1)
456: mvaddstr(17, 0, "Come on, merchants aren't stupid. Stop cheating.\n");
457: else if (cheat == 2)
458: {
459: mvaddstr(17, 0, "You had your chance. This merchant happens to be\n");
460: printw("a %.0f level magic user, and you made %s mad!\n",
461: ROLL(Circle * 20.0, 40.0), (drandom() < 0.5) ? "him" : "her");
462: altercoordinates(0.0, 0.0, A_FAR);
463: Player.p_energy /= 2.0;
464: ++Player.p_sin;
465: more(23);
466: return;
467: }
468: else if (dishonest)
469: {
470: mvaddstr(17, 0, "The merchant stole your money!");
471: refresh();
472: altercoordinates(Player.p_x - Player.p_x / 10.0,
473: Player.p_y - Player.p_y / 10.0, A_SPECIFIC);
474: sleep(2);
475: return;
476: }
477: }
478: }
479: /* */
480: /************************************************************************
481: /
482: / FUNCTION NAME: displaystats()
483: /
484: / FUNCTION: print out important player statistics
485: /
486: / AUTHOR: E. A. Estes, 12/4/85
487: /
488: / ARGUMENTS: none
489: /
490: / RETURN VALUE: none
491: /
492: / MODULES CALLED: descrstatus(), descrlocation(), mvprintw()
493: /
494: / GLOBAL INPUTS: Users, Player
495: /
496: / GLOBAL OUTPUTS: none
497: /
498: / DESCRIPTION:
499: / Important player statistics are printed on the screen.
500: /
501: /************************************************************************/
502:
503: displaystats()
504: {
505: mvprintw(0, 0, "%s%s\n", Player.p_name, descrlocation(&Player, FALSE));
506: mvprintw(1, 0, "Level :%7.0f Energy :%9.0f(%9.0f) Mana :%9.0f Users:%3d\n",
507: Player.p_level, Player.p_energy, Player.p_maxenergy + Player.p_shield,
508: Player.p_mana, Users);
509: mvprintw(2, 0, "Quick :%3.0f(%3.0f) Strength:%9.0f(%9.0f) Gold :%9.0f %s\n",
510: Player.p_speed, Player.p_quickness + Player.p_quksilver, Player.p_might,
511: Player.p_strength + Player.p_sword, Player.p_gold, descrstatus(&Player));
512: }
513: /* */
514: /************************************************************************
515: /
516: / FUNCTION NAME: allstatslist()
517: /
518: / FUNCTION: show player items
519: /
520: / AUTHOR: E. A. Estes, 12/4/85
521: /
522: / ARGUMENTS: none
523: /
524: / RETURN VALUE: none
525: /
526: / MODULES CALLED: mvprintw(), descrtype()
527: /
528: / GLOBAL INPUTS: Player
529: /
530: / GLOBAL OUTPUTS: none
531: /
532: / DESCRIPTION:
533: / Print out some player statistics of lesser importance.
534: /
535: /************************************************************************/
536:
537: allstatslist()
538: {
539: static char *flags[] = /* to print value of some bools */
540: {
541: "False",
542: " True"
543: };
544:
545: mvprintw( 8, 0, "Type: %s\n", descrtype(&Player, FALSE));
546:
547: mvprintw(10, 0, "Experience: %9.0f", Player.p_experience);
548: mvprintw(11, 0, "Brains : %9.0f", Player.p_brains);
549: mvprintw(12, 0, "Magic Lvl : %9.0f", Player.p_magiclvl);
550: mvprintw(13, 0, "Sin : %9.5f", Player.p_sin);
551: mvprintw(14, 0, "Poison : %9.5f", Player.p_poison);
552: mvprintw(15, 0, "Gems : %9.0f", Player.p_gems);
553: mvprintw(16, 0, "Age : %9d", Player.p_age);
554: mvprintw(10, 40, "Holy Water: %9d", Player.p_holywater);
555: mvprintw(11, 40, "Amulets : %9d", Player.p_amulets);
556: mvprintw(12, 40, "Charms : %9d", Player.p_charms);
557: mvprintw(13, 40, "Crowns : %9d", Player.p_crowns);
558: mvprintw(14, 40, "Shield : %9.0f", Player.p_shield);
559: mvprintw(15, 40, "Sword : %9.0f", Player.p_sword);
560: mvprintw(16, 40, "Quickslver: %9.0f", Player.p_quksilver);
561:
562: mvprintw(18, 0, "Blessing: %s Ring: %s Virgin: %s Palantir: %s",
563: flags[Player.p_blessing], flags[Player.p_ring.ring_type != R_NONE],
564: flags[Player.p_virgin], flags[Player.p_palantir]);
565: }
566: /* */
567: /************************************************************************
568: /
569: / FUNCTION NAME: descrtype()
570: /
571: / FUNCTION: return a string specifying player type
572: /
573: / AUTHOR: E. A. Estes, 12/4/85
574: /
575: / ARGUMENTS:
576: / struct player playerp - pointer to structure for player
577: / bool shortflag - set if short form is desired
578: /
579: / RETURN VALUE: pointer to string describing player type
580: /
581: / MODULES CALLED: strcpy()
582: /
583: / GLOBAL INPUTS: Databuf[]
584: /
585: / GLOBAL OUTPUTS: Databuf[]
586: /
587: / DESCRIPTION:
588: / Return a string describing the player type.
589: / King, council, valar, supercedes other types.
590: / The first character of the string is '*' if the player
591: / has a crown.
592: / If 'shortflag' is TRUE, return a 3 character string.
593: /
594: /************************************************************************/
595:
596: char *
597: descrtype(playerp, shortflag)
598: struct player *playerp;
599: bool shortflag;
600: {
601: register int type; /* for caluculating result subscript */
602: static char *results[] = /* description table */
603: {
604: " Magic User", " MU",
605: " Fighter", " F ",
606: " Elf", " E ",
607: " Dwarf", " D ",
608: " Halfling", " H ",
609: " Experimento", " EX",
610: " Super", " S ",
611: " King", " K ",
612: " Council of Wise", " CW",
613: " Ex-Valar", " EV",
614: " Valar", " V ",
615: " ? ", " ? "
616: };
617:
618: type = playerp->p_type;
619:
620: switch (playerp->p_specialtype)
621: {
622: case SC_NONE:
623: type = playerp->p_type;
624: break;
625:
626: case SC_KING:
627: type = 7;
628: break;
629:
630: case SC_COUNCIL:
631: type = 8;
632: break;
633:
634: case SC_EXVALAR:
635: type = 9;
636: break;
637:
638: case SC_VALAR:
639: type = 10;
640: break;
641: }
642:
643: type *= 2; /* calculate offset */
644:
645: if (type > 20)
646: /* error */
647: type = 22;
648:
649: if (shortflag)
650: /* use short descriptions */
651: ++type;
652:
653: if (playerp->p_crowns > 0)
654: {
655: strcpy(Databuf, results[type]);
656: Databuf[0] = '*';
657: return(Databuf);
658: }
659: else
660: return(results[type]);
661: }
662: /* */
663: /************************************************************************
664: /
665: / FUNCTION NAME: findname()
666: /
667: / FUNCTION: find location in player file of given name
668: /
669: / AUTHOR: E. A. Estes, 12/4/85
670: /
671: / ARGUMENTS:
672: / char *name - name of character to look for
673: / struct player *playerp - pointer of structure to fill
674: /
675: / RETURN VALUE: location of player if found, -1 otherwise
676: /
677: / MODULES CALLED: fread(), fseek(), strcmp()
678: /
679: / GLOBAL INPUTS: Wizard, *Playersfp
680: /
681: / GLOBAL OUTPUTS: none
682: /
683: / DESCRIPTION:
684: / Search the player file for the player of the given name.
685: / If player is found, fill structure with player data.
686: /
687: /************************************************************************/
688:
689: long
690: findname(name, playerp)
691: register char *name;
692: register struct player *playerp;
693: {
694: long loc = 0; /* location in the file */
695:
696: fseek(Playersfp, 0L, 0);
697: while (fread((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp) == 1)
698: {
699: if (strcmp(playerp->p_name, name) == 0)
700: {
701: if (playerp->p_status != S_NOTUSED || Wizard)
702: /* found it */
703: return(loc);
704: }
705: loc += SZ_PLAYERSTRUCT;
706: }
707:
708: return(-1);
709: }
710: /* */
711: /************************************************************************
712: /
713: / FUNCTION NAME: allocrecord()
714: /
715: / FUNCTION: find space in the player file for a new character
716: /
717: / AUTHOR: E. A. Estes, 12/4/85
718: /
719: / ARGUMENTS: none
720: /
721: / RETURN VALUE: location of free space in file
722: /
723: / MODULES CALLED: initplayer(), writerecord(), fread(), fseek()
724: /
725: / GLOBAL INPUTS: Other, *Playersfp
726: /
727: / GLOBAL OUTPUTS: Player
728: /
729: / DESCRIPTION:
730: / Search the player file for an unused entry. If none are found,
731: / make one at the end of the file.
732: /
733: /************************************************************************/
734:
735: long
736: allocrecord()
737: {
738: long loc = 0L; /* location in file */
739:
740: fseek(Playersfp, 0L, 0);
741: while (fread((char *) &Other, SZ_PLAYERSTRUCT, 1, Playersfp) == 1)
742: {
743: if (Other.p_status == S_NOTUSED)
744: /* found an empty record */
745: return(loc);
746: else
747: loc += SZ_PLAYERSTRUCT;
748: }
749:
750: /* make a new record */
751: initplayer(&Other);
752: Player.p_status = S_OFF;
753: writerecord(&Other, loc);
754:
755: return(loc);
756: }
757: /* */
758: /************************************************************************
759: /
760: / FUNCTION NAME: freerecord()
761: /
762: / FUNCTION: free up a record on the player file
763: /
764: / AUTHOR: E. A. Estes, 2/7/86
765: /
766: / ARGUMENTS:
767: / struct player playerp - pointer to structure to free
768: / long loc - location in file to free
769: /
770: / RETURN VALUE: none
771: /
772: / MODULES CALLED: writerecord()
773: /
774: / GLOBAL INPUTS: none
775: /
776: / GLOBAL OUTPUTS: none
777: /
778: / DESCRIPTION:
779: / Mark structure as not used, and update player file.
780: /
781: /************************************************************************/
782:
783: freerecord(playerp, loc)
784: struct player *playerp;
785: long loc;
786: {
787: playerp->p_name[0] = CH_MARKDELETE;
788: playerp->p_status = S_NOTUSED;
789: writerecord(playerp, loc);
790: }
791: /* */
792: /************************************************************************
793: /
794: / FUNCTION NAME: leavegame()
795: /
796: / FUNCTION: leave game
797: /
798: / AUTHOR: E. A. Estes, 12/4/85
799: /
800: / ARGUMENTS: none
801: /
802: / RETURN VALUE: none
803: /
804: / MODULES CALLED: freerecord(), writerecord(), cleanup()
805: /
806: / GLOBAL INPUTS: Player, Fileloc
807: /
808: / GLOBAL OUTPUTS: Player
809: /
810: / DESCRIPTION:
811: / Mark player as inactive, and cleanup.
812: / Do not save players below level 1.
813: /
814: /************************************************************************/
815:
816: leavegame()
817: {
818:
819: if (Player.p_level < 1.0)
820: /* delete character */
821: freerecord(&Player, Fileloc);
822: else
823: {
824: Player.p_status = S_OFF;
825: writerecord(&Player, Fileloc);
826: }
827:
828: cleanup(TRUE);
829: /*NOTREACHED*/
830: }
831: /* */
832: /************************************************************************
833: /
834: / FUNCTION NAME: death()
835: /
836: / FUNCTION: death routine
837: /
838: / AUTHOR: E. A. Estes, 12/4/85
839: /
840: / ARGUMENTS:
841: / char *how - pointer to string describing cause of death
842: /
843: / RETURN VALUE: none
844: /
845: / MODULES CALLED: freerecord(), enterscore(), more(), exit(), fread(),
846: / fseek(), execl(), fopen(), floor(), wmove(), drandom(), wclear(), strcmp(),
847: / fwrite(), fflush(), printw(), strcpy(), fclose(), waddstr(), cleanup(),
848: / fprintf(), wrefresh(), getanswer(), descrtype()
849: /
850: / GLOBAL INPUTS: Curmonster, Wizard, Player, *stdscr, Fileloc, *Monstfp
851: /
852: / GLOBAL OUTPUTS: Player
853: /
854: / DESCRIPTION:
855: / Kill off current player.
856: / Handle rings, and multiple lives.
857: / Print an appropriate message.
858: / Update scoreboard, lastdead, and let other players know about
859: / the demise of their comrade.
860: /
861: /************************************************************************/
862:
863: death(how)
864: char *how;
865: {
866: FILE *fp; /* for updating various files */
867: int ch; /* input */
868: static char *deathmesg[] =
869: /* add more messages here, if desired */
870: {
871: "You have been wounded beyond repair. ",
872: "You have been disemboweled. ",
873: "You've been mashed, mauled, and spit upon. (You're dead.)\n",
874: "You died! ",
875: "You're a complete failure -- you've died!!\n",
876: "You have been dealt a fatal blow! "
877: };
878:
879: clear();
880:
881: if (strcmp(how, "Stupidity") != 0)
882: {
883: if (Player.p_level > 9999.0)
884: /* old age */
885: addstr("Characters must be retired upon reaching level 10000. Sorry.");
886: else if (Player.p_lives > 0)
887: /* extra lives */
888: {
889: addstr("You should be more cautious. You've been killed.\n");
890: printw("You only have %d more chance(s).\n", --Player.p_lives);
891: more(3);
892: Player.p_energy = Player.p_maxenergy;
893: return;
894: }
895: else if (Player.p_specialtype == SC_VALAR)
896: {
897: addstr("You had your chances, but Valar aren't totally\n");
898: addstr("immortal. You are now left to wither and die . . .\n");
899: more(3);
900: Player.p_brains = Player.p_level / 25.0;
901: Player.p_energy = Player.p_maxenergy /= 5.0;
902: Player.p_quksilver = Player.p_sword = 0.0;
903: Player.p_specialtype = SC_COUNCIL;
904: return;
905: }
906: else if (Player.p_ring.ring_inuse &&
907: (Player.p_ring.ring_type == R_DLREG || Player.p_ring.ring_type == R_NAZREG))
908: /* good ring in use - saved from death */
909: {
910: mvaddstr(4, 0, "Your ring saved you from death!\n");
911: refresh();
912: Player.p_ring.ring_type = R_NONE;
913: Player.p_energy = Player.p_maxenergy / 12.0 + 1.0;
914: if (Player.p_crowns > 0)
915: --Player.p_crowns;
916: return;
917: }
918: else if (Player.p_ring.ring_type == R_BAD
919: || Player.p_ring.ring_type == R_SPOILED)
920: /* bad ring in possession; name idiot after player */
921: {
922: mvaddstr(4, 0,
923: "Your ring has taken control of you and turned you into a monster!\n");
924: fseek(Monstfp, 13L * SZ_MONSTERSTRUCT, 0);
925: fread((char *) &Curmonster, SZ_MONSTERSTRUCT, 1, Monstfp);
926: strcpy(Curmonster.m_name, Player.p_name);
927: fseek(Monstfp, 13L * SZ_MONSTERSTRUCT, 0);
928: fwrite((char *) &Curmonster, SZ_MONSTERSTRUCT, 1, Monstfp);
929: fflush(Monstfp);
930: }
931: }
932:
933: enterscore(); /* update score board */
934:
935: /* put info in last dead file */
936: fp = fopen(_PATH_LASTDEAD, "w");
937: fprintf(fp,"%s (%s, run by %s, level %.0f, killed by %s)",
938: Player.p_name, descrtype(&Player, TRUE),
939: Player.p_login, Player.p_level, how);
940: fclose(fp);
941:
942: /* let other players know */
943: fp = fopen(_PATH_MESS, "w");
944: fprintf(fp, "%s was killed by %s.", Player.p_name, how);
945: fclose(fp);
946:
947: freerecord(&Player, Fileloc);
948:
949: clear();
950: move(10, 0);
951: addstr(deathmesg[(int) ROLL(0.0, (double) sizeof(deathmesg) / sizeof(char *))]);
952: addstr("Care to give it another try ? ");
953: ch = getanswer("NY", FALSE);
954:
955: if (ch == 'Y')
956: {
957: cleanup(FALSE);
958: execl(_PATH_GAMEPROG, "phantasia", "-s",
959: (Wizard ? "-S": (char *) NULL), 0);
960: exit(0);
961: /*NOTREACHED*/
962: }
963:
964: cleanup(TRUE);
965: /*NOTREACHED*/
966: }
967: /* */
968: /************************************************************************
969: /
970: / FUNCTION NAME: writerecord()
971: /
972: / FUNCTION: update structure in player file
973: /
974: / AUTHOR: E. A. Estes, 12/4/85
975: /
976: / ARGUMENTS:
977: / struct player *playerp - pointer to structure to write out
978: / long place - location in file to updata
979: /
980: / RETURN VALUE: none
981: /
982: / MODULES CALLED: fseek(), fwrite(), fflush()
983: /
984: / GLOBAL INPUTS: *Playersfp
985: /
986: / GLOBAL OUTPUTS: none
987: /
988: / DESCRIPTION:
989: / Update location in player file with given structure.
990: /
991: /************************************************************************/
992:
993: writerecord(playerp, place)
994: register struct player *playerp;
995: long place;
996: {
997: fseek(Playersfp, place, 0);
998: fwrite((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp);
999: fflush(Playersfp);
1000: }
1001: /* */
1002: /************************************************************************
1003: /
1004: / FUNCTION NAME: explevel()
1005: /
1006: / FUNCTION: calculate level based upon experience
1007: /
1008: / AUTHOR: E. A. Estes, 12/4/85
1009: /
1010: / ARGUMENTS:
1011: / double experience - experience to calculate experience level from
1012: /
1013: / RETURN VALUE: experience level
1014: /
1015: / MODULES CALLED: pow(), floor()
1016: /
1017: / GLOBAL INPUTS: none
1018: /
1019: / GLOBAL OUTPUTS: none
1020: /
1021: / DESCRIPTION:
1022: / Experience level is a geometric progression. This has been finely
1023: / tuned over the years, and probably should not be changed.
1024: /
1025: /************************************************************************/
1026:
1027: double
1028: explevel(experience)
1029: double experience;
1030: {
1031: if (experience < 1.1e7)
1032: return(floor(pow((experience / 1000.0), 0.4875)));
1033: else
1034: return(floor(pow((experience / 1250.0), 0.4865)));
1035: }
1036: /* */
1037: /************************************************************************
1038: /
1039: / FUNCTION NAME: truncstring()
1040: /
1041: / FUNCTION: truncate trailing blanks off a string
1042: /
1043: / AUTHOR: E. A. Estes, 12/4/85
1044: /
1045: / ARGUMENTS:
1046: / char *string - pointer to null terminated string
1047: /
1048: / RETURN VALUE: none
1049: /
1050: / MODULES CALLED: strlen()
1051: /
1052: / GLOBAL INPUTS: none
1053: /
1054: / GLOBAL OUTPUTS: none
1055: /
1056: / DESCRIPTION:
1057: / Put nul characters in place of spaces at the end of the string.
1058: /
1059: /************************************************************************/
1060:
1061: truncstring(string)
1062: register char *string;
1063: {
1064: register int length; /* length of string */
1065:
1066: length = strlen(string);
1067: while (string[--length] == ' ')
1068: string[length] = '\0';
1069: }
1070: /* */
1071: /************************************************************************
1072: /
1073: / FUNCTION NAME: altercoordinates()
1074: /
1075: / FUNCTION: Alter x, y coordinates and set/check location flags
1076: /
1077: / AUTHOR: E. A. Estes, 12/16/85
1078: /
1079: / ARGUMENTS:
1080: / double xnew, ynew - new x, y coordinates
1081: / int operation - operation to perform with coordinates
1082: /
1083: / RETURN VALUE: none
1084: /
1085: / MODULES CALLED: fabs(), floor(), drandom(), distance()
1086: /
1087: / GLOBAL INPUTS: Circle, Beyond, Player
1088: /
1089: / GLOBAL OUTPUTS: Marsh, Circle, Beyond, Throne, Player, Changed
1090: /
1091: / DESCRIPTION:
1092: / This module is called whenever the player's coordinates are altered.
1093: / If the player is beyond the point of no return, he/she is forced
1094: / to stay there.
1095: /
1096: /************************************************************************/
1097:
1098: altercoordinates(xnew, ynew, operation)
1099: double xnew;
1100: double ynew;
1101: int operation;
1102: {
1103: switch (operation)
1104: {
1105: case A_FORCED: /* move with no checks */
1106: break;
1107:
1108: case A_NEAR: /* pick random coordinates near */
1109: xnew = Player.p_x + ROLL(1.0, 5.0);
1110: ynew = Player.p_y - ROLL(1.0, 5.0);
1111: /* fall through for check */
1112:
1113: case A_SPECIFIC: /* just move player */
1114: if (Beyond && fabs(xnew) < D_BEYOND && fabs(ynew) < D_BEYOND)
1115: /*
1116: * cannot move back from point of no return
1117: * pick the largest coordinate to remain unchanged
1118: */
1119: {
1120: if (fabs(xnew) > fabs(ynew))
1121: xnew = SGN(Player.p_x) * MAX(fabs(Player.p_x), D_BEYOND);
1122: else
1123: ynew = SGN(Player.p_y) * MAX(fabs(Player.p_y), D_BEYOND);
1124: }
1125: break;
1126:
1127: case A_FAR: /* pick random coordinates far */
1128: xnew = Player.p_x + SGN(Player.p_x) * ROLL(50 * Circle, 250 * Circle);
1129: ynew = Player.p_y + SGN(Player.p_y) * ROLL(50 * Circle, 250 * Circle);
1130: break;
1131: }
1132:
1133: /* now set location flags and adjust coordinates */
1134: Circle = CIRCLE(Player.p_x = floor(xnew), Player.p_y = floor(ynew));
1135:
1136: /* set up flags based upon location */
1137: Throne = Marsh = Beyond = FALSE;
1138:
1139: if (Player.p_x == 0.0 && Player.p_y == 0.0)
1140: Throne = TRUE;
1141: else if (Circle < 35 && Circle >= 20)
1142: Marsh = TRUE;
1143: else if (MAX(fabs(Player.p_x), fabs(Player.p_y)) >= D_BEYOND)
1144: Beyond = TRUE;
1145:
1146: Changed = TRUE;
1147: }
1148: /* */
1149: /************************************************************************
1150: /
1151: / FUNCTION NAME: readrecord()
1152: /
1153: / FUNCTION: read a player structure from file
1154: /
1155: / AUTHOR: E. A. Estes, 12/4/85
1156: /
1157: / ARGUMENTS:
1158: / struct player *playerp - pointer to structure to fill
1159: / int loc - location of record to read
1160: /
1161: / RETURN VALUE: none
1162: /
1163: / MODULES CALLED: fread(), fseek()
1164: /
1165: / GLOBAL INPUTS: *Playersfp
1166: /
1167: / GLOBAL OUTPUTS: none
1168: /
1169: / DESCRIPTION:
1170: / Read structure information from player file.
1171: /
1172: /************************************************************************/
1173:
1174: readrecord(playerp, loc)
1175: register struct player *playerp;
1176: long loc;
1177: {
1178: fseek(Playersfp, loc, 0);
1179: fread((char *) playerp, SZ_PLAYERSTRUCT, 1, Playersfp);
1180: }
1181: /* */
1182: /************************************************************************
1183: /
1184: / FUNCTION NAME: adjuststats()
1185: /
1186: / FUNCTION: adjust player statistics
1187: /
1188: / AUTHOR: E. A. Estes, 12/4/85
1189: /
1190: / ARGUMENTS: none
1191: /
1192: / RETURN VALUE: none
1193: /
1194: / MODULES CALLED: death(), floor(), drandom(), explevel(), movelevel()
1195: /
1196: / GLOBAL INPUTS: Player, *Statptr
1197: /
1198: / GLOBAL OUTPUTS: Circle, Player, Timeout
1199: /
1200: / DESCRIPTION:
1201: / Handle adjustment and maximums on various player characteristics.
1202: /
1203: /************************************************************************/
1204:
1205: adjuststats()
1206: {
1207: double dtemp; /* for temporary calculations */
1208:
1209: if (explevel(Player.p_experience) > Player.p_level)
1210: /* move one or more levels */
1211: {
1212: movelevel();
1213: if (Player.p_level > 5.0)
1214: Timeout = TRUE;
1215: }
1216:
1217: if (Player.p_specialtype == SC_VALAR)
1218: /* valar */
1219: Circle = Player.p_level / 5.0;
1220:
1221: /* calculate effective quickness */
1222: dtemp = ((Player.p_gold + Player.p_gems / 2.0) - 1000.0) / Statptr->c_goldtote
1223: - Player.p_level;;
1224: dtemp = MAX(0.0, dtemp); /* gold slows player down */
1225: Player.p_speed = Player.p_quickness + Player.p_quksilver - dtemp;
1226:
1227: /* calculate effective strength */
1228: if (Player.p_poison > 0.0)
1229: /* poison makes player weaker */
1230: {
1231: dtemp = 1.0 - Player.p_poison * Statptr->c_weakness / 800.0;
1232: dtemp = MAX(0.1, dtemp);
1233: }
1234: else
1235: dtemp = 1.0;
1236: Player.p_might = dtemp * Player.p_strength + Player.p_sword;
1237:
1238: /* insure that important things are within limits */
1239: Player.p_quksilver = MIN(99.0, Player.p_quksilver);
1240: Player.p_mana = MIN(Player.p_mana,
1241: Player.p_level * Statptr->c_maxmana + 1000.0);
1242: Player.p_brains = MIN(Player.p_brains,
1243: Player.p_level * Statptr->c_maxbrains + 200.0);
1244: Player.p_charms = MIN(Player.p_charms, Player.p_level + 10.0);
1245:
1246: /*
1247: * some implementations have problems with floating point compare
1248: * we work around it with this stuff
1249: */
1250: Player.p_gold = floor(Player.p_gold) + 0.1;
1251: Player.p_gems = floor(Player.p_gems) + 0.1;
1252: Player.p_mana = floor(Player.p_mana) + 0.1;
1253:
1254: if (Player.p_ring.ring_type != R_NONE)
1255: /* do ring things */
1256: {
1257: /* rest to max */
1258: Player.p_energy = Player.p_maxenergy + Player.p_shield;
1259:
1260: if (Player.p_ring.ring_duration <= 0)
1261: /* clean up expired rings */
1262: switch (Player.p_ring.ring_type)
1263: {
1264: case R_BAD: /* ring drives player crazy */
1265: Player.p_ring.ring_type = R_SPOILED;
1266: Player.p_ring.ring_duration = (short) ROLL(10.0, 25.0);
1267: break;
1268:
1269: case R_NAZREG: /* ring disappears */
1270: Player.p_ring.ring_type = R_NONE;
1271: break;
1272:
1273: case R_SPOILED: /* ring kills player */
1274: death("A cursed ring");
1275: break;
1276:
1277: case R_DLREG: /* this ring doesn't expire */
1278: Player.p_ring.ring_duration = 0;
1279: break;
1280: }
1281: }
1282:
1283: if (Player.p_age / N_AGE > Player.p_degenerated)
1284: /* age player slightly */
1285: {
1286: ++Player.p_degenerated;
1287: if (Player.p_quickness > 23.0)
1288: Player.p_quickness *= 0.99;
1289: Player.p_strength *= 0.97;
1290: Player.p_brains *= 0.95;
1291: Player.p_magiclvl *= 0.97;
1292: Player.p_maxenergy *= 0.95;
1293: Player.p_quksilver *= 0.95;
1294: Player.p_sword *= 0.93;
1295: Player.p_shield *= 0.93;
1296: }
1297: }
1298: /* */
1299: /************************************************************************
1300: /
1301: / FUNCTION NAME: initplayer()
1302: /
1303: / FUNCTION: initialize a character
1304: /
1305: / AUTHOR: E. A. Estes, 12/4/85
1306: /
1307: / ARGUMENTS:
1308: / struct player *playerp - pointer to structure to init
1309: /
1310: / RETURN VALUE: none
1311: /
1312: / MODULES CALLED: floor(), drandom()
1313: /
1314: / GLOBAL INPUTS: none
1315: /
1316: / GLOBAL OUTPUTS: none
1317: /
1318: / DESCRIPTION:
1319: / Put a bunch of default values in the given structure.
1320: /
1321: /************************************************************************/
1322:
1323: initplayer(playerp)
1324: register struct player *playerp;
1325: {
1326: playerp->p_experience =
1327: playerp->p_level =
1328: playerp->p_strength =
1329: playerp->p_sword =
1330: playerp->p_might =
1331: playerp->p_energy =
1332: playerp->p_maxenergy =
1333: playerp->p_shield =
1334: playerp->p_quickness =
1335: playerp->p_quksilver =
1336: playerp->p_speed =
1337: playerp->p_magiclvl =
1338: playerp->p_mana =
1339: playerp->p_brains =
1340: playerp->p_poison =
1341: playerp->p_gems =
1342: playerp->p_sin =
1343: playerp->p_1scratch =
1344: playerp->p_2scratch = 0.0;
1345:
1346: playerp->p_gold = ROLL(50.0, 75.0) + 0.1; /* give some gold */
1347:
1348: playerp->p_x = ROLL(-125.0, 251.0);
1349: playerp->p_y = ROLL(-125.0, 251.0); /* give random x, y */
1350:
1351: /* clear ring */
1352: playerp->p_ring.ring_type = R_NONE;
1353: playerp->p_ring.ring_duration = 0;
1354: playerp->p_ring.ring_inuse = FALSE;
1355:
1356: playerp->p_age = 0L;
1357:
1358: playerp->p_degenerated = 1; /* don't degenerate initially */
1359:
1360: playerp->p_type = C_FIGHTER; /* default */
1361: playerp->p_specialtype = SC_NONE;
1362: playerp->p_lives =
1363: playerp->p_crowns =
1364: playerp->p_charms =
1365: playerp->p_amulets =
1366: playerp->p_holywater =
1367: playerp->p_lastused = 0;
1368: playerp->p_status = S_NOTUSED;
1369: playerp->p_tampered = T_OFF;
1370: playerp->p_istat = I_OFF;
1371:
1372: playerp->p_palantir =
1373: playerp->p_blessing =
1374: playerp->p_virgin =
1375: playerp->p_blindness = FALSE;
1376:
1377: playerp->p_name[0] =
1378: playerp->p_password[0] =
1379: playerp->p_login[0] = '\0';
1380: }
1381: /* */
1382: /************************************************************************
1383: /
1384: / FUNCTION NAME: readmessage()
1385: /
1386: / FUNCTION: read message from other players
1387: /
1388: / AUTHOR: E. A. Estes, 12/4/85
1389: /
1390: / ARGUMENTS: none
1391: /
1392: / RETURN VALUE: none
1393: /
1394: / MODULES CALLED: fseek(), fgets(), wmove(), waddstr(), wclrtoeol()
1395: /
1396: / GLOBAL INPUTS: *stdscr, Databuf[], *Messagefp
1397: /
1398: / GLOBAL OUTPUTS: none
1399: /
1400: / DESCRIPTION:
1401: / If there is a message from other players, print it.
1402: /
1403: /************************************************************************/
1404:
1405: readmessage()
1406: {
1407: move(3, 0);
1408: clrtoeol();
1409: fseek(Messagefp, 0L, 0);
1410: if (fgets(Databuf, SZ_DATABUF, Messagefp) != NULL)
1411: addstr(Databuf);
1412: }
1413: /* */
1414: /************************************************************************
1415: /
1416: / FUNCTION NAME: error()
1417: /
1418: / FUNCTION: process evironment error
1419: /
1420: / AUTHOR: E. A. Estes, 12/4/85
1421: /
1422: / ARGUMENTS:
1423: / char *whichfile - pointer to name of file which caused error
1424: /
1425: / RETURN VALUE: none
1426: /
1427: / MODULES CALLED: wclear(), cleanup()
1428: /
1429: / GLOBAL INPUTS: errno, *stdscr, printw(), printf(), Windows
1430: /
1431: / GLOBAL OUTPUTS: none
1432: /
1433: / DESCRIPTION:
1434: / Print message about offending file, and exit.
1435: /
1436: /************************************************************************/
1437:
1438: error(whichfile)
1439: char *whichfile;
1440: {
1441: extern int errno;
1442: extern printw(), printf();
1443: int (*funcp)();
1444:
1445: if (Windows)
1446: {
1447: funcp = printw;
1448: clear();
1449: }
1450: else
1451: funcp = printf;
1452:
1453: (*funcp)("An unrecoverable error has occurred reading %s. (errno = %d)\n", whichfile, errno);
1454: (*funcp)("Please run 'setup' to determine the problem.\n");
1455: cleanup(TRUE);
1456: /*NOTREACHED*/
1457: }
1458: /* */
1459: /************************************************************************
1460: /
1461: / FUNCTION NAME: distance()
1462: /
1463: / FUNCTION: calculate distance between two points
1464: /
1465: / AUTHOR: E. A. Estes, 12/4/85
1466: /
1467: / ARGUMENTS:
1468: / double x1, y1 - x, y coordinates of first point
1469: / double x2, y2 - x, y coordinates of second point
1470: /
1471: / RETURN VALUE: distance between the two points
1472: /
1473: / MODULES CALLED: sqrt()
1474: /
1475: / GLOBAL INPUTS: none
1476: /
1477: / GLOBAL OUTPUTS: none
1478: /
1479: / DESCRIPTION:
1480: / This function is provided because someone's hypot() library function
1481: / fails if x1 == x2 && y1 == y2.
1482: /
1483: /************************************************************************/
1484:
1485: double
1486: distance(x1, x2, y1, y2)
1487: double x1, x2, y1, y2;
1488: {
1489: double deltax, deltay;
1490:
1491: deltax = x1 - x2;
1492: deltay = y1 - y2;
1493: return(sqrt(deltax * deltax + deltay * deltay));
1494: }
1495:
1496: /* */
1497: /************************************************************************
1498: /
1499: / FUNCTION NAME: ill_sig()
1500: /
1501: / FUNCTION: exit upon trapping an illegal signal
1502: /
1503: / AUTHOR: E. A. Estes, 12/4/85
1504: /
1505: / ARGUMENTS:
1506: / int whichsig - signal which occured to cause jump to here
1507: /
1508: / RETURN VALUE: none
1509: /
1510: / MODULES CALLED: wclear(), printw(), cleanup()
1511: /
1512: / GLOBAL INPUTS: *stdscr
1513: /
1514: / GLOBAL OUTPUTS: none
1515: /
1516: / DESCRIPTION:
1517: / When an illegal signal is caught, print a message, and cleanup.
1518: /
1519: /************************************************************************/
1520:
1521: ill_sig(whichsig)
1522: int whichsig;
1523: {
1524: clear();
1525: if (!(whichsig == SIGINT || whichsig == SIGQUIT))
1526: printw("Error: caught signal # %d.\n", whichsig);
1527: cleanup(TRUE);
1528: /*NOTREACHED*/
1529: }
1530: /* */
1531: /************************************************************************
1532: /
1533: / FUNCTION NAME: descrstatus()
1534: /
1535: / FUNCTION: return a string describing the player status
1536: /
1537: / AUTHOR: E. A. Estes, 3/3/86
1538: /
1539: / ARGUMENTS:
1540: / struct player playerp - pointer to player structure to describe
1541: /
1542: / RETURN VALUE: string describing player's status
1543: /
1544: / MODULES CALLED: none
1545: /
1546: / GLOBAL INPUTS: none
1547: /
1548: / GLOBAL OUTPUTS: none
1549: /
1550: / DESCRIPTION:
1551: / Return verbal description of player status.
1552: / If player status is S_PLAYING, check for low energy and blindness.
1553: /
1554: /************************************************************************/
1555:
1556: char *
1557: descrstatus(playerp)
1558: register struct player *playerp;
1559: {
1560: switch (playerp->p_status)
1561: {
1562: case S_PLAYING:
1563: if (playerp->p_energy < 0.2 * (playerp->p_maxenergy + playerp->p_shield))
1564: return("Low Energy");
1565: else if (playerp->p_blindness)
1566: return("Blind");
1567: else
1568: return("In game");
1569:
1570: case S_CLOAKED:
1571: return("Cloaked");
1572:
1573: case S_INBATTLE:
1574: return("In Battle");
1575:
1576: case S_MONSTER:
1577: return("Encounter");
1578:
1579: case S_TRADING:
1580: return("Trading");
1581:
1582: case S_OFF:
1583: return("Off");
1584:
1585: case S_HUNGUP:
1586: return("Hung up");
1587:
1588: default:
1589: return("");
1590: }
1591: }
1592: /* */
1593: /************************************************************************
1594: /
1595: / FUNCTION NAME: drandom()
1596: /
1597: / FUNCTION: return a random floating point number from 0.0 < 1.0
1598: /
1599: / AUTHOR: E. A. Estes, 2/7/86
1600: /
1601: / ARGUMENTS: none
1602: /
1603: / RETURN VALUE: none
1604: /
1605: / MODULES CALLED: random()
1606: /
1607: / GLOBAL INPUTS: none
1608: /
1609: / GLOBAL OUTPUTS: none
1610: /
1611: / DESCRIPTION:
1612: / Convert random integer from library routine into a floating
1613: / point number, and divide by the largest possible random number.
1614: / We mask large integers with 32767 to handle sites that return
1615: / 31 bit random integers.
1616: /
1617: /************************************************************************/
1618:
1619: double
1620: drandom()
1621: {
1622: if (sizeof(int) != 2)
1623: /* use only low bits */
1624: return((double) (random() & 0x7fff) / 32768.0);
1625: else
1626: return((double) random() / 32768.0);
1627: }
1628: /* */
1629: /************************************************************************
1630: /
1631: / FUNCTION NAME: collecttaxes()
1632: /
1633: / FUNCTION: collect taxes from current player
1634: /
1635: / AUTHOR: E. A. Estes, 2/7/86
1636: /
1637: / ARGUMENTS:
1638: / double gold - amount of gold to tax
1639: / double gems - amount of gems to tax
1640: /
1641: / RETURN VALUE: none
1642: /
1643: / MODULES CALLED: fread(), fseek(), fopen(), floor(), fwrite(), fclose()
1644: /
1645: / GLOBAL INPUTS: Player
1646: /
1647: / GLOBAL OUTPUTS: Player
1648: /
1649: / DESCRIPTION:
1650: / Pay taxes on gold and gems. If the player does not have enough
1651: / gold to pay taxes on the added gems, convert some gems to gold.
1652: / Add taxes to tax data base; add remaining gold and gems to
1653: / player's cache.
1654: /
1655: /************************************************************************/
1656:
1657: collecttaxes(gold, gems)
1658: double gold;
1659: double gems;
1660: {
1661: FILE *fp; /* to update Goldfile */
1662: double dtemp; /* for temporary calculations */
1663: double taxes; /* tax liability */
1664:
1665: /* add to cache */
1666: Player.p_gold += gold;
1667: Player.p_gems += gems;
1668:
1669: /* calculate tax liability */
1670: taxes = N_TAXAMOUNT / 100.0 * (N_GEMVALUE * gems + gold);
1671:
1672: if (Player.p_gold < taxes)
1673: /* not enough gold to pay taxes, must convert some gems to gold */
1674: {
1675: dtemp = floor(taxes / N_GEMVALUE + 1.0); /* number of gems to convert */
1676:
1677: if (Player.p_gems >= dtemp)
1678: /* player has enough to convert */
1679: {
1680: Player.p_gems -= dtemp;
1681: Player.p_gold += dtemp * N_GEMVALUE;
1682: }
1683: else
1684: /* take everything; this should never happen */
1685: {
1686: Player.p_gold += Player.p_gems * N_GEMVALUE;
1687: Player.p_gems = 0.0;
1688: taxes = Player.p_gold;
1689: }
1690: }
1691:
1692: Player.p_gold -= taxes;
1693:
1694: if ((fp = fopen(_PATH_GOLD, "r+")) != NULL)
1695: /* update taxes */
1696: {
1697: dtemp = 0.0;
1698: fread((char *) &dtemp, sizeof(double), 1, fp);
1699: dtemp += floor(taxes);
1700: fseek(fp, 0L, 0);
1701: fwrite((char *) &dtemp, sizeof(double), 1, fp);
1702: fclose(fp);
1703: }
1704: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.