![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue|
Return to pack.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue |
1.1 root 1: /*
2: * pack.c
3: *
4: * This source herein may be modified and/or distributed by anybody who
5: * so desires, with the following restrictions:
6: * 1.) No portion of this notice shall be removed.
7: * 2.) Credit shall not be taken for the creation of this source.
8: * 3.) This code is not to be traded, sold, or used for personal
9: * gain or profit.
10: *
11: */
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)pack.c 5.1 (Berkeley) 11/25/87";
15: #endif /* not lint */
16:
17: #include "rogue.h"
18:
19: char *curse_message = "you can't, it appears to be cursed";
20:
21: extern short levitate;
22:
23: object *
24: add_to_pack(obj, pack, condense)
25: object *obj, *pack;
26: {
27: object *op;
28:
29: if (condense) {
30: if (op = check_duplicate(obj, pack)) {
31: free_object(obj);
32: return(op);
33: } else {
34: obj->ichar = next_avail_ichar();
35: }
36: }
37: if (pack->next_object == 0) {
38: pack->next_object = obj;
39: } else {
40: op = pack->next_object;
41:
42: while (op->next_object) {
43: op = op->next_object;
44: }
45: op->next_object = obj;
46: }
47: obj->next_object = 0;
48: return(obj);
49: }
50:
51: take_from_pack(obj, pack)
52: object *obj, *pack;
53: {
54: while (pack->next_object != obj) {
55: pack = pack->next_object;
56: }
57: pack->next_object = pack->next_object->next_object;
58: }
59:
60: /* Note: *status is set to 0 if the rogue attempts to pick up a scroll
61: * of scare-monster and it turns to dust. *status is otherwise set to 1.
62: */
63:
64: object *
65: pick_up(row, col, status)
66: short *status;
67: {
68: object *obj;
69:
70: *status = 1;
71:
72: if (levitate) {
73: message("you're floating in the air!", 0);
74: return((object *) 0);
75: }
76: obj = object_at(&level_objects, row, col);
77: if (!obj) {
78: message("pick_up(): inconsistent", 1);
79: return(obj);
80: }
81: if ( (obj->what_is == SCROL) &&
82: (obj->which_kind == SCARE_MONSTER) &&
83: obj->picked_up) {
84: message("the scroll turns to dust as you pick it up", 0);
85: dungeon[row][col] &= (~OBJECT);
86: vanish(obj, 0, &level_objects);
87: *status = 0;
88: if (id_scrolls[SCARE_MONSTER].id_status == UNIDENTIFIED) {
89: id_scrolls[SCARE_MONSTER].id_status = IDENTIFIED;
90: }
91: return((object *) 0);
92: }
93: if (obj->what_is == GOLD) {
94: rogue.gold += obj->quantity;
95: dungeon[row][col] &= ~(OBJECT);
96: take_from_pack(obj, &level_objects);
97: print_stats(STAT_GOLD);
98: return(obj); /* obj will be free_object()ed in caller */
99: }
100: if (pack_count(obj) >= MAX_PACK_COUNT) {
101: message("pack too full", 1);
102: return((object *) 0);
103: }
104: dungeon[row][col] &= ~(OBJECT);
105: take_from_pack(obj, &level_objects);
106: obj = add_to_pack(obj, &rogue.pack, 1);
107: obj->picked_up = 1;
108: return(obj);
109: }
110:
111: drop()
112: {
113: object *obj, *new;
114: short ch;
115: char desc[DCOLS];
116:
117: if (dungeon[rogue.row][rogue.col] & (OBJECT | STAIRS | TRAP)) {
118: message("there's already something there", 0);
119: return;
120: }
121: if (!rogue.pack.next_object) {
122: message("you have nothing to drop", 0);
123: return;
124: }
125: if ((ch = pack_letter("drop what?", ALL_OBJECTS)) == CANCEL) {
126: return;
127: }
128: if (!(obj = get_letter_object(ch))) {
129: message("no such item.", 0);
130: return;
131: }
132: if (obj->in_use_flags & BEING_WIELDED) {
133: if (obj->is_cursed) {
134: message(curse_message, 0);
135: return;
136: }
137: unwield(rogue.weapon);
138: } else if (obj->in_use_flags & BEING_WORN) {
139: if (obj->is_cursed) {
140: message(curse_message, 0);
141: return;
142: }
143: mv_aquatars();
144: unwear(rogue.armor);
145: print_stats(STAT_ARMOR);
146: } else if (obj->in_use_flags & ON_EITHER_HAND) {
147: if (obj->is_cursed) {
148: message(curse_message, 0);
149: return;
150: }
151: un_put_on(obj);
152: }
153: obj->row = rogue.row;
154: obj->col = rogue.col;
155:
156: if ((obj->quantity > 1) && (obj->what_is != WEAPON)) {
157: obj->quantity--;
158: new = alloc_object();
159: *new = *obj;
160: new->quantity = 1;
161: obj = new;
162: } else {
163: obj->ichar = 'L';
164: take_from_pack(obj, &rogue.pack);
165: }
166: place_at(obj, rogue.row, rogue.col);
167: (void) strcpy(desc, "dropped ");
168: get_desc(obj, desc+8);
169: message(desc, 0);
170: (void) reg_move();
171: }
172:
173: object *
174: check_duplicate(obj, pack)
175: object *obj, *pack;
176: {
177: object *op;
178:
179: if (!(obj->what_is & (WEAPON | FOOD | SCROL | POTION))) {
180: return(0);
181: }
182: if ((obj->what_is == FOOD) && (obj->which_kind == FRUIT)) {
183: return(0);
184: }
185: op = pack->next_object;
186:
187: while (op) {
188: if ((op->what_is == obj->what_is) &&
189: (op->which_kind == obj->which_kind)) {
190:
191: if ((obj->what_is != WEAPON) ||
192: ((obj->what_is == WEAPON) &&
193: ((obj->which_kind == ARROW) ||
194: (obj->which_kind == DAGGER) ||
195: (obj->which_kind == DART) ||
196: (obj->which_kind == SHURIKEN)) &&
197: (obj->quiver == op->quiver))) {
198: op->quantity += obj->quantity;
199: return(op);
200: }
201: }
202: op = op->next_object;
203: }
204: return(0);
205: }
206:
207: next_avail_ichar()
208: {
209: register object *obj;
210: register i;
211: boolean ichars[26];
212:
213: for (i = 0; i < 26; i++) {
214: ichars[i] = 0;
215: }
216: obj = rogue.pack.next_object;
217: while (obj) {
218: ichars[(obj->ichar - 'a')] = 1;
219: obj = obj->next_object;
220: }
221: for (i = 0; i < 26; i++) {
222: if (!ichars[i]) {
223: return(i + 'a');
224: }
225: }
226: return('?');
227: }
228:
229: wait_for_ack()
230: {
231: while (rgetchar() != ' ') ;
232: }
233:
234: pack_letter(prompt, mask)
235: char *prompt;
236: unsigned short mask;
237: {
238: short ch;
239: unsigned short tmask = mask;
240:
241: if (!mask_pack(&rogue.pack, mask)) {
242: message("nothing appropriate", 0);
243: return(CANCEL);
244: }
245: for (;;) {
246:
247: message(prompt, 0);
248:
249: for (;;) {
250: ch = rgetchar();
251: if (!is_pack_letter(&ch, &mask)) {
252: sound_bell();
253: } else {
254: break;
255: }
256: }
257:
258: if (ch == LIST) {
259: check_message();
260: inventory(&rogue.pack, mask);
261: } else {
262: break;
263: }
264: mask = tmask;
265: }
266: check_message();
267: return(ch);
268: }
269:
270: take_off()
271: {
272: char desc[DCOLS];
273: object *obj;
274:
275: if (rogue.armor) {
276: if (rogue.armor->is_cursed) {
277: message(curse_message, 0);
278: } else {
279: mv_aquatars();
280: obj = rogue.armor;
281: unwear(rogue.armor);
282: (void) strcpy(desc, "was wearing ");
283: get_desc(obj, desc+12);
284: message(desc, 0);
285: print_stats(STAT_ARMOR);
286: (void) reg_move();
287: }
288: } else {
289: message("not wearing any", 0);
290: }
291: }
292:
293: wear()
294: {
295: short ch;
296: register object *obj;
297: char desc[DCOLS];
298:
299: if (rogue.armor) {
300: message("your already wearing some", 0);
301: return;
302: }
303: ch = pack_letter("wear what?", ARMOR);
304:
305: if (ch == CANCEL) {
306: return;
307: }
308: if (!(obj = get_letter_object(ch))) {
309: message("no such item.", 0);
310: return;
311: }
312: if (obj->what_is != ARMOR) {
313: message("you can't wear that", 0);
314: return;
315: }
316: obj->identified = 1;
317: (void) strcpy(desc, "wearing ");
318: get_desc(obj, desc + 8);
319: message(desc, 0);
320: do_wear(obj);
321: print_stats(STAT_ARMOR);
322: (void) reg_move();
323: }
324:
325: unwear(obj)
326: object *obj;
327: {
328: if (obj) {
329: obj->in_use_flags &= (~BEING_WORN);
330: }
331: rogue.armor = (object *) 0;
332: }
333:
334: do_wear(obj)
335: object *obj;
336: {
337: rogue.armor = obj;
338: obj->in_use_flags |= BEING_WORN;
339: obj->identified = 1;
340: }
341:
342: wield()
343: {
344: short ch;
345: register object *obj;
346: char desc[DCOLS];
347:
348: if (rogue.weapon && rogue.weapon->is_cursed) {
349: message(curse_message, 0);
350: return;
351: }
352: ch = pack_letter("wield what?", WEAPON);
353:
354: if (ch == CANCEL) {
355: return;
356: }
357: if (!(obj = get_letter_object(ch))) {
358: message("No such item.", 0);
359: return;
360: }
361: if (obj->what_is & (ARMOR | RING)) {
362: sprintf(desc, "you can't wield %s",
363: ((obj->what_is == ARMOR) ? "armor" : "rings"));
364: message(desc, 0);
365: return;
366: }
367: if (obj->in_use_flags & BEING_WIELDED) {
368: message("in use", 0);
369: } else {
370: unwield(rogue.weapon);
371: (void) strcpy(desc, "wielding ");
372: get_desc(obj, desc + 9);
373: message(desc, 0);
374: do_wield(obj);
375: (void) reg_move();
376: }
377: }
378:
379: do_wield(obj)
380: object *obj;
381: {
382: rogue.weapon = obj;
383: obj->in_use_flags |= BEING_WIELDED;
384: }
385:
386: unwield(obj)
387: object *obj;
388: {
389: if (obj) {
390: obj->in_use_flags &= (~BEING_WIELDED);
391: }
392: rogue.weapon = (object *) 0;
393: }
394:
395: call_it()
396: {
397: short ch;
398: register object *obj;
399: struct id *id_table;
400: char buf[MAX_TITLE_LENGTH+2];
401:
402: ch = pack_letter("call what?", (SCROL | POTION | WAND | RING));
403:
404: if (ch == CANCEL) {
405: return;
406: }
407: if (!(obj = get_letter_object(ch))) {
408: message("no such item.", 0);
409: return;
410: }
411: if (!(obj->what_is & (SCROL | POTION | WAND | RING))) {
412: message("surely you already know what that's called", 0);
413: return;
414: }
415: id_table = get_id_table(obj);
416:
417: if (get_input_line("call it:","",buf,id_table[obj->which_kind].title,1,1)) {
418: id_table[obj->which_kind].id_status = CALLED;
419: (void) strcpy(id_table[obj->which_kind].title, buf);
420: }
421: }
422:
423: pack_count(new_obj)
424: object *new_obj;
425: {
426: object *obj;
427: short count = 0;
428:
429: obj = rogue.pack.next_object;
430:
431: while (obj) {
432: if (obj->what_is != WEAPON) {
433: count += obj->quantity;
434: } else if (!new_obj) {
435: count++;
436: } else if ((new_obj->what_is != WEAPON) ||
437: ((obj->which_kind != ARROW) &&
438: (obj->which_kind != DAGGER) &&
439: (obj->which_kind != DART) &&
440: (obj->which_kind != SHURIKEN)) ||
441: (new_obj->which_kind != obj->which_kind) ||
442: (obj->quiver != new_obj->quiver)) {
443: count++;
444: }
445: obj = obj->next_object;
446: }
447: return(count);
448: }
449:
450: boolean
451: mask_pack(pack, mask)
452: object *pack;
453: unsigned short mask;
454: {
455: while (pack->next_object) {
456: pack = pack->next_object;
457: if (pack->what_is & mask) {
458: return(1);
459: }
460: }
461: return(0);
462: }
463:
464: is_pack_letter(c, mask)
465: short *c;
466: unsigned short *mask;
467: {
468: if (((*c == '?') || (*c == '!') || (*c == ':') || (*c == '=') ||
469: (*c == ')') || (*c == ']') || (*c == '/') || (*c == ','))) {
470: switch(*c) {
471: case '?':
472: *mask = SCROL;
473: break;
474: case '!':
475: *mask = POTION;
476: break;
477: case ':':
478: *mask = FOOD;
479: break;
480: case ')':
481: *mask = WEAPON;
482: break;
483: case ']':
484: *mask = ARMOR;
485: break;
486: case '/':
487: *mask = WAND;
488: break;
489: case '=':
490: *mask = RING;
491: break;
492: case ',':
493: *mask = AMULET;
494: break;
495: }
496: *c = LIST;
497: return(1);
498: }
499: return(((*c >= 'a') && (*c <= 'z')) || (*c == CANCEL) || (*c == LIST));
500: }
501:
502: has_amulet()
503: {
504: return(mask_pack(&rogue.pack, AMULET));
505: }
506:
507: kick_into_pack()
508: {
509: object *obj;
510: char desc[DCOLS];
511: short n, stat;
512:
513: if (!(dungeon[rogue.row][rogue.col] & OBJECT)) {
514: message("nothing here", 0);
515: } else {
516: if (obj = pick_up(rogue.row, rogue.col, &stat)) {
517: get_desc(obj, desc);
518: if (obj->what_is == GOLD) {
519: message(desc, 0);
520: free_object(obj);
521: } else {
522: n = strlen(desc);
523: desc[n] = '(';
524: desc[n+1] = obj->ichar;
525: desc[n+2] = ')';
526: desc[n+3] = 0;
527: message(desc, 0);
528: }
529: }
530: if (obj || (!stat)) {
531: (void) reg_move();
532: }
533: }
534: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.