![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trader.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / srogue|
Return to trader.c CVS log | Up to [contributed] / early-roguelike / srogue |
1.1 rubenllo 1: /*
2: * Anything to do with trading posts & mazes
3: *
4: * @(#)trader.c 9.0 (rdk) 7/17/84
5: *
6: * Super-Rogue
7: * Copyright (C) 1984 Robert D. Kindelberger
8: * All rights reserved.
9: *
10: * See the file LICENSE.TXT for full copyright and licensing information.
11: */
12:
13: #include <stdlib.h>
14: #include <string.h>
15: #include "rogue.h"
16: #include "rogue.ext"
17:
18: #define NOTPRICED -1
19:
20: bool open_market(void);
21: void trans_line(void);
22: void draw_maze(void);
23: int findcells(int y, int x);
24: void rmwall(int newy, int newx, int oldy, int oldx);
25: void crankout(void);
26:
27: /*
28: * do_post:
29: * Put a trading post room and stuff on the screen
30: */
31: void
32: do_post(void)
33: {
34: struct coord tp;
35: reg int i;
36: reg struct room *rp;
37: reg struct object *op;
38: reg struct linked_list *ll;
39:
40: free_list(lvl_obj); /* throw old items away */
41:
42: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++) {
43: rp->r_goldval = 0; /* no gold */
44: rp->r_nexits = 0; /* no exits */
45: rp->r_flags = ISGONE; /* kill all rooms */
46: }
47: rp = &rooms[0]; /* point to only room */
48: rp->r_flags = 0; /* this room NOT gone */
49: rp->r_max.x = 40;
50: rp->r_max.y = 10; /* 10 * 40 room */
51: rp->r_pos.x = (COLS - rp->r_max.x) / 2; /* center horizontal */
52: rp->r_pos.y = 1; /* 2nd line */
53: draw_room(rp); /* draw the only room */
54: i = roll(4,10); /* 10 to 40 items */
55: for (; i > 0 ; i--) { /* place all the items */
56: ll = new_thing(FALSE, ANYTHING); /* get something */
57: attach(lvl_obj, ll);
58: op = OBJPTR(ll);
59: setoflg(op, ISPOST); /* object in trading post */
60: tp = *rnd_pos(rp);
61: op->o_pos = tp;
62: mvaddch(tp.y,tp.x,op->o_type);
63: }
64: trader = 0;
65: wmove(cw,12,0);
66: waddstr(cw,"Welcome to Friendly Fiend's Flea Market\n\r");
67: waddstr(cw,"=======================================\n\r");
68: waddstr(cw,"$: Prices object that you stand upon.\n\r");
69: waddstr(cw,"#: Buys the object that you stand upon.\n\r");
70: waddstr(cw,"%: Trades in something in your pack for gold.\n\r");
71: trans_line();
72: }
73:
74: /*
75: * price_it:
76: * Price the object that the hero stands on
77: */
78: bool
79: price_it(void)
80: {
81: static char *bargain[] = {
82: "great bargain",
83: "quality product",
84: "exceptional find",
85: };
86: reg struct linked_list *item;
87: reg struct object *obj;
88: reg int worth;
89:
90: if (!open_market()) /* after buying hours */
91: return FALSE;
92: if ((item = find_obj(hero.y,hero.x)) == NULL)
93: return FALSE;
94: obj = OBJPTR(item);
95: if (curprice == NOTPRICED) {
96: worth = get_worth(obj);
97: worth += 50 - rnd(100);
98: if (worth < 25)
99: worth = 25;
100: worth *= 3; /* slightly expensive */
101: curprice = worth; /* save price */
102: strcpy(curpurch, obj->o_typname); /* save item */
103: }
104: msg("That %s is a %s for only %d pieces of gold", curpurch,
105: bargain[rnd(3)], curprice);
106: return TRUE;
107: }
108:
109: /*
110: * buy_it:
111: * Buy the item on which the hero stands
112: */
113: void
114: buy_it(void)
115: {
116: reg int wh;
117:
118: if (purse <= 0) {
119: msg("You have no money.");
120: return;
121: }
122: if (curprice < 0) { /* if not yet priced */
123: wh = price_it();
124: if (!wh) /* nothing to price */
125: return;
126: msg("Do you want to buy it? ");
127: do {
128: wh = readchar();
129: if (isupper(wh))
130: wh = tolower(wh);
131: if (wh == ESCAPE || wh == 'n') {
132: msg("");
133: return;
134: }
135: } until(wh == 'y');
136: }
137: mpos = 0;
138: if (curprice > purse) {
139: msg("You can't afford to buy that %s !",curpurch);
140: return;
141: }
142: /*
143: * See if the hero has done all his transacting
144: */
145: if (!open_market())
146: return;
147: /*
148: * The hero bought the item here
149: */
150: mpos = 0;
151: wh = add_pack(NULL,FALSE); /* try to put it in his pack */
152: if (wh) { /* he could get it */
153: purse -= curprice; /* take his money */
154: ++trader; /* another transaction */
155: trans_line(); /* show remaining deals */
156: curprice = NOTPRICED;
157: curpurch[0] = '\0';
158: }
159: }
160:
161: /*
162: * sell_it:
163: * Sell an item to the trading post
164: */
165: void
166: sell_it(void)
167: {
168: reg struct linked_list *item;
169: reg struct object *obj;
170: reg int wo, ch;
171:
172: if (!open_market()) /* after selling hours */
173: return;
174:
175: if ((item = get_item("sell",0)) == NULL)
176: return;
177: obj = OBJPTR(item);
178: wo = get_worth(obj);
179: if (wo <= 0) {
180: mpos = 0;
181: msg("We don't buy those.");
182: return;
183: }
184: if (wo < 25)
185: wo = 25;
186: msg("Your %s is worth %d pieces of gold.", obj->o_typname, wo);
187: msg("Do you want to sell it? ");
188: do {
189: ch = readchar();
190: if (isupper(ch))
191: ch = tolower(ch);
192: if (ch == ESCAPE || ch == 'n') {
193: msg("");
194: return;
195: }
196: } until (ch == 'y');
197: mpos = 0;
198: if (drop(item) == TRUE) { /* drop this item */
199: nochange = FALSE; /* show gold value */
200: purse += wo; /* give him his money */
201: ++trader; /* another transaction */
202: wo = obj->o_count;
203: obj->o_count = 1;
204: msg("Sold %s",inv_name(obj,TRUE));
205: obj->o_count = wo;
206: trans_line(); /* show remaining deals */
207: }
208: }
209:
210: /*
211: * open_market:
212: * Retruns TRUE when ok do to transacting
213: */
214: bool
215: open_market(void)
216: {
217: if (trader >= MAXPURCH) {
218: msg("The market is closed. The stairs are that-a-way.");
219: return FALSE;
220: }
221: else
222: return TRUE;
223: }
224:
225: /*
226: * get_worth:
227: * Calculate an objects worth in gold
228: */
229: int
230: get_worth(struct object *obj)
231: {
232: reg int worth, wh;
233:
234: worth = 0;
235: wh = obj->o_which;
236: switch (obj->o_type) {
237: case FOOD:
238: worth = 2;
239: when WEAPON:
240: if (wh < MAXWEAPONS) {
241: worth = w_magic[wh].mi_worth;
242: worth *= (2 + (4 * obj->o_hplus + 4 * obj->o_dplus));
243: }
244: when ARMOR:
245: if (wh < MAXARMORS) {
246: worth = a_magic[wh].mi_worth;
247: worth *= (1 + (10 * (armors[wh].a_class - obj->o_ac)));
248: }
249: when SCROLL:
250: if (wh < MAXSCROLLS)
251: worth = s_magic[wh].mi_worth;
252: when POTION:
253: if (wh < MAXPOTIONS)
254: worth = p_magic[wh].mi_worth;
255: when RING:
256: if (wh < MAXRINGS) {
257: worth = r_magic[wh].mi_worth;
258: if (magring(obj)) {
259: if (obj->o_ac > 0)
260: worth += obj->o_ac * 40;
261: else
262: worth = 50;
263: }
264: }
265: when STICK:
266: if (wh < MAXSTICKS) {
267: worth = ws_magic[wh].mi_worth;
268: worth += 20 * obj->o_charges;
269: }
270: when AMULET:
271: worth = 1000;
272: otherwise:
273: worth = 0;
274: }
275: if (worth < 0)
276: worth = 0;
277: if (o_on(obj, ISPROT)) /* 300% more for protected */
278: worth *= 3;
279: if (o_on(obj, ISBLESS)) /* 50% more for blessed */
280: worth = worth * 3 / 2;
281: return worth;
282: }
283:
284: /*
285: * trans_line:
286: * Show how many transactions the hero has left
287: */
288: void
289: trans_line(void)
290: {
291: sprintf(prbuf,"You have %d transactions remaining.",MAXPURCH-trader);
292: mvwaddstr(cw, LINES - 4, 0, prbuf);
293: }
294:
295: /*
296: * domaze:
297: * Draw the maze on this level.
298: */
299: void
300: do_maze(void)
301: {
302: struct coord tp;
303: reg int i, least;
304: reg struct room *rp;
305: bool treas;
306:
307: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++) {
308: rp->r_goldval = 0;
309: rp->r_nexits = 0; /* no exits */
310: rp->r_flags = ISGONE; /* kill all rooms */
311: }
312: rp = &rooms[0]; /* point to only room */
313: rp->r_flags = ISDARK; /* mazes always dark */
314: rp->r_pos.x = 0; /* room fills whole screen */
315: rp->r_pos.y = 1;
316: rp->r_max.x = COLS - 1;
317: rp->r_max.y = LINES - 2;
318: rp->r_goldval = 500 + (rnd(10) + 1) * GOLDCALC;
319: draw_maze(); /* put maze into window */
320: rp->r_gold = *rnd_pos(rp);
321: mvaddch(rp->r_gold.y, rp->r_gold.x, GOLD);
322: if (rnd(100) < 3) { /* 3% for treasure maze level */
323: treas = TRUE;
324: least = 6;
325: rp->r_flags |= ISTREAS;
326: }
327: else { /* normal maze level */
328: least = 1;
329: treas = FALSE;
330: }
331: for (i = 0; i < level + least; i++)
332: if (treas || rnd(100) < 50) /* put in some little buggers */
333: add_mon(rp, treas);
334: }
335:
336: struct cell {
337: char y_pos;
338: char x_pos;
339: };
340: struct bordercells {
341: unsigned char num_pos; /* number of frontier cells next to you */
342: struct cell conn[4]; /* the y,x position of above cell */
343: } mborder;
344:
345: char *frontier, *bits;
346: char *moffset(int y, int x);
347: char *foffset(int y, int x);
348: int tlines, tcols;
349:
350: /*
351: * draw_maze:
352: * Generate and draw the maze on the screen
353: */
354: void
355: draw_maze(void)
356: {
357: reg int i, j, more;
358: reg char *ptr;
359:
360: tlines = (LINES - 3) / 2;
361: tcols = (COLS - 1) / 2;
362: bits = ALLOC((LINES - 3) * (COLS - 1));
363: frontier = ALLOC(tlines * tcols);
364: ptr = frontier;
365: while (ptr < (frontier + (tlines * tcols)))
366: *ptr++ = TRUE;
367: for (i = 0; i < LINES - 3; i++) {
368: for (j = 0; j < COLS - 1; j++) {
369: if (i % 2 == 1 && j % 2 == 1)
370: *moffset(i, j) = FALSE; /* floor */
371: else
372: *moffset(i, j) = TRUE; /* wall */
373: }
374: }
375: for (i = 0; i < tlines; i++) {
376: for (j = 0; j < tcols; j++) {
377: do
378: more = findcells(i,j);
379: while(more != 0);
380: }
381: }
382: crankout();
383: FREE(frontier);
384: FREE(bits);
385: }
386:
387: /*
388: * moffset:
389: * Calculate memory address for bits
390: */
391: char *
392: moffset(int y, int x)
393: {
394: char *ptr;
395:
396: ptr = bits + (y * (COLS - 1)) + x;
397: return ptr;
398: }
399:
400: /*
401: * foffset:
402: * Calculate memory address for frontier
403: */
404: char *
405: foffset(int y, int x)
406: {
407: char *ptr;
408:
409: ptr = frontier + (y * tcols) + x;
410: return ptr;
411: }
412:
413: /*
414: * findcells:
415: * Figure out cells to open up
416: */
417: int
418: findcells(int y, int x)
419: {
420: reg int rtpos, i;
421:
422: *foffset(y, x) = FALSE;
423: mborder.num_pos = 0;
424: if (y < tlines - 1) { /* look below */
425: if (*foffset(y + 1, x)) {
426: mborder.conn[mborder.num_pos].y_pos = y + 1;
427: mborder.conn[mborder.num_pos].x_pos = x;
428: mborder.num_pos += 1;
429: }
430: }
431: if (y > 0) { /* look above */
432: if (*foffset(y - 1, x)) {
433: mborder.conn[mborder.num_pos].y_pos = y - 1;
434: mborder.conn[mborder.num_pos].x_pos = x;
435: mborder.num_pos += 1;
436:
437: }
438: }
439: if (x < tcols - 1) { /* look right */
440: if (*foffset(y, x + 1)) {
441: mborder.conn[mborder.num_pos].y_pos = y;
442: mborder.conn[mborder.num_pos].x_pos = x + 1;
443: mborder.num_pos += 1;
444: }
445: }
446: if (x > 0) { /* look left */
447: if (*foffset(y, x - 1)) {
448: mborder.conn[mborder.num_pos].y_pos = y;
449: mborder.conn[mborder.num_pos].x_pos = x - 1;
450: mborder.num_pos += 1;
451:
452: }
453: }
454: if (mborder.num_pos == 0) /* no neighbors available */
455: return 0;
456: else {
457: i = rnd(mborder.num_pos);
458: rtpos = mborder.num_pos - 1;
459: rmwall(mborder.conn[i].y_pos, mborder.conn[i].x_pos, y, x);
460: return rtpos;
461: }
462: }
463:
464: /*
465: * rmwall:
466: * Removes appropriate walls from the maze
467: */
468: void
469: rmwall(int newy, int newx, int oldy, int oldx)
470: {
471: reg int xdif,ydif;
472:
473: xdif = newx - oldx;
474: ydif = newy - oldy;
475:
476: *moffset((oldy * 2) + ydif + 1, (oldx * 2) + xdif + 1) = FALSE;
477: findcells(newy, newx);
478: }
479:
480:
481: /*
482: * crankout:
483: * Does actual drawing of maze to window
484: */
485: void
486: crankout(void)
487: {
488: reg int x, y, i;
489:
490: for (y = 0; y < LINES - 3; y++) {
491: move(y + 1, 0);
492: for (x = 0; x < COLS - 1; x++) {
493: if (*moffset(y, x)) { /* here is a wall */
494: if (y == 0 || y == LINES - 4) /* top or bottom line */
495: addch('-');
496: else if (x == 0 || x == COLS - 2) /* left | right side */
497: addch('|');
498: else if (y % 2 == 0 && x % 2 == 0) {
499: if (*moffset(y, x - 1) || *moffset(y, x + 1))
500: addch('-');
501: else
502: addch('|');
503: }
504: else if (y % 2 == 0)
505: addch('-');
506: else
507: addch('|');
508: }
509: else
510: addch(FLOOR);
511: }
512: }
513: }