![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to state.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / rogue4|
Return to state.c CVS log | Up to [contributed] / early-roguelike / rogue4 |
1.1 rubenllo 1: /*
2: state.c - Portable Rogue Save State Code
3:
4: Copyright (C) 1999, 2000, 2005 Nicholas J. Kisseberth
5:
6: Redistribution and use in source and binary forms, with or without
7: modification, are permitted provided that the following conditions
8: are met:
9: 1. Redistributions of source code must retain the above copyright
10: notice, this list of conditions and the following disclaimer.
11: 2. Redistributions in binary form must reproduce the above copyright
12: notice, this list of conditions and the following disclaimer in the
13: documentation and/or other materials provided with the distribution.
14: 3. Neither the name(s) of the author(s) nor the names of other contributors
15: may be used to endorse or promote products derived from this software
16: without specific prior written permission.
17:
18: THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS ``AS IS'' AND
19: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE
22: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: SUCH DAMAGE.
29: */
30:
31: /************************************************************************/
32: /* Save State Code */
33: /************************************************************************/
34:
35: #define RSID_STATS 0xABCD0001
36: #define RSID_THING 0xABCD0002
37: #define RSID_THING_NULL 0xDEAD0002
38: #define RSID_OBJECT 0xABCD0003
39: #define RSID_MAGICITEMS 0xABCD0004
40: #define RSID_KNOWS 0xABCD0005
41: #define RSID_GUESSES 0xABCD0006
42: #define RSID_OBJECTLIST 0xABCD0007
43: #define RSID_BAGOBJECT 0xABCD0008
44: #define RSID_MONSTERLIST 0xABCD0009
45: #define RSID_MONSTERSTATS 0xABCD000A
46: #define RSID_MONSTERS 0xABCD000B
47: #define RSID_TRAP 0xABCD000C
48: #define RSID_WINDOW 0xABCD000D
49: #define RSID_DAEMONS 0xABCD000E
50: #define RSID_IWEAPS 0xABCD000F
51: #define RSID_IARMOR 0xABCD0010
52: #define RSID_SPELLS 0xABCD0011
53: #define RSID_ILIST 0xABCD0012
54: #define RSID_HLIST 0xABCD0013
55: #define RSID_DEATHTYPE 0xABCD0014
56: #define RSID_CTYPES 0XABCD0015
57: #define RSID_COORDLIST 0XABCD0016
58: #define RSID_ROOMS 0XABCD0017
59:
60:
61:
62: #include <curses.h>
63: #include <sys/stat.h>
64: #include <stdio.h>
65: #include <stdlib.h>
66: #include <assert.h>
67: #include <string.h>
68: #include "rogue.h"
69:
70: #define READSTAT ((format_error == 0) && (read_error == 0))
71: #define WRITESTAT (write_error == 0)
72:
73: int rs_write_int(FILE *savef, int c);
74: int rs_read_int(FILE *inf, int *i);
75:
76: int read_error = FALSE;
77: int write_error = FALSE;
78: int format_error = FALSE;
79: int end_of_file = FALSE;
80: int big_endian = 0;
81:
82: void *
83: get_list_item(THING *l, int i)
84: {
85: int count = 0;
86:
87: while(l != NULL)
88: {
89: if (count == i)
90: return(l);
91:
92: l = l->l_next;
93:
94: count++;
95: }
96:
97: return(NULL);
98: }
99:
100: int
101: find_list_ptr(THING *l, void *ptr)
102: {
103: int count = 0;
104:
105: while(l != NULL)
106: {
107: if (l == ptr)
108: return(count);
109:
110: l = l->l_next;
111: count++;
112: }
113:
114: return(-1);
115: }
116:
117: int
118: list_size(THING *l)
119: {
120: int count = 0;
121:
122: while(l != NULL)
123: {
124: if (l == NULL)
125: return(count);
126:
127: count++;
128:
129: l = l->l_next;
130: }
131:
132: return(count);
133: }
134:
135: int
136: rs_write(FILE *savef, void *ptr, int size)
137: {
138: if (!write_error)
139: encwrite(ptr,size,savef);
140:
141: if (0)
142: write_error = TRUE;
143:
144: assert(write_error == 0);
145:
146: return(WRITESTAT);
147: }
148:
149: int
150: rs_write_char(FILE *savef, char c)
151: {
152: rs_write(savef, &c, 1);
153:
154: return(WRITESTAT);
155: }
156:
157: int
158: rs_write_boolean(FILE *savef, bool c)
159: {
160: unsigned char buf = (c == 0) ? 0 : 1;
161:
162: rs_write(savef, &buf, 1);
163:
164: return(WRITESTAT);
165: }
166:
167: int
168: rs_write_booleans(FILE *savef, bool *c, int count)
169: {
170: int n = 0;
171:
172: rs_write_int(savef,count);
173:
174: for(n = 0; n < count; n++)
175: rs_write_boolean(savef,c[n]);
176:
177: return(WRITESTAT);
178: }
179:
180: int
181: rs_write_shint(FILE *savef, shint c)
182: {
183: unsigned char buf = c;
184:
185: rs_write(savef, &buf, 1);
186:
187: return(WRITESTAT);
188: }
189:
190: int
191: rs_write_short(FILE *savef, short c)
192: {
193: unsigned char bytes[2];
194: unsigned char *buf = (unsigned char *) &c;
195:
196: if (big_endian)
197: {
198: bytes[1] = buf[0];
199: bytes[0] = buf[1];
200: buf = bytes;
201: }
202:
203: rs_write(savef, buf, 2);
204:
205: return(WRITESTAT);
206: }
207:
208: int
209: rs_write_shorts(FILE *savef, short *c, int count)
210: {
211: int n = 0;
212:
213: rs_write_int(savef,count);
214:
215: for(n = 0; n < count; n++)
216: rs_write_short(savef,c[n]);
217:
218: return(WRITESTAT);
219: }
220:
221: int
222: rs_write_ushort(FILE *savef, unsigned short c)
223: {
224: unsigned char bytes[2];
225: unsigned char *buf = (unsigned char *) &c;
226:
227: if (big_endian)
228: {
229: bytes[1] = buf[0];
230: bytes[0] = buf[1];
231: buf = bytes;
232: }
233:
234: rs_write(savef, buf, 2);
235:
236: return(WRITESTAT);
237: }
238:
239: int
240: rs_write_int(FILE *savef, int c)
241: {
242: unsigned char bytes[4];
243: unsigned char *buf = (unsigned char *) &c;
244:
245: if (big_endian)
246: {
247: bytes[3] = buf[0];
248: bytes[2] = buf[1];
249: bytes[1] = buf[2];
250: bytes[0] = buf[3];
251: buf = bytes;
252: }
253:
254: rs_write(savef, buf, 4);
255:
256: return(WRITESTAT);
257: }
258:
259: int
260: rs_write_ints(FILE *savef, int *c, int count)
261: {
262: int n = 0;
263:
264: rs_write_int(savef,count);
265:
266: for(n = 0; n < count; n++)
267: rs_write_int(savef,c[n]);
268:
269: return(WRITESTAT);
270: }
271:
272: int
273: rs_write_uint(FILE *savef, unsigned int c)
274: {
275: unsigned char bytes[4];
276: unsigned char *buf = (unsigned char *) &c;
277:
278: if (big_endian)
279: {
280: bytes[3] = buf[0];
281: bytes[2] = buf[1];
282: bytes[1] = buf[2];
283: bytes[0] = buf[3];
284: buf = bytes;
285: }
286:
287: rs_write(savef, buf, 4);
288:
289: return(WRITESTAT);
290: }
291:
292: int
293: rs_write_long(FILE *savef, long c)
294: {
295: int c2;
296: unsigned char bytes[4];
297: unsigned char *buf = (unsigned char *)&c;
298:
299: if (sizeof(long) == 8)
300: {
301: c2 = c;
302: buf = (unsigned char *) &c2;
303: }
304:
305: if (big_endian)
306: {
307: bytes[3] = buf[0];
308: bytes[2] = buf[1];
309: bytes[1] = buf[2];
310: bytes[0] = buf[3];
311: buf = bytes;
312: }
313:
314: rs_write(savef, buf, 4);
315:
316: return(WRITESTAT);
317: }
318:
319: int
320: rs_write_longs(FILE *savef, long *c, int count)
321: {
322: int n = 0;
323:
324: rs_write_int(savef,count);
325:
326: for(n = 0; n < count; n++)
327: rs_write_long(savef,c[n]);
328:
329: return(WRITESTAT);
330: }
331:
332: int
333: rs_write_ulong(FILE *savef, unsigned long c)
334: {
335: unsigned int c2;
336: unsigned char bytes[4];
337: unsigned char *buf = (unsigned char *)&c;
338:
339: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
340: {
341: c2 = c;
342: buf = (unsigned char *) &c2;
343: }
344:
345: if (big_endian)
346: {
347: bytes[3] = buf[0];
348: bytes[2] = buf[1];
349: bytes[1] = buf[2];
350: bytes[0] = buf[3];
351: buf = bytes;
352: }
353:
354: rs_write(savef, buf, 4);
355:
356: return(WRITESTAT);
357: }
358:
359: int
360: rs_write_ulongs(FILE *savef, unsigned long *c, int count)
361: {
362: int n = 0;
363:
364: rs_write_int(savef,count);
365:
366: for(n = 0; n < count; n++)
367: rs_write_ulong(savef,c[n]);
368:
369: return(WRITESTAT);
370: }
371:
372: int
373: rs_write_string(FILE *savef, char *s)
374: {
375: int len = 0;
376:
377: len = (s == NULL) ? 0 : strlen(s) + 1;
378:
379: rs_write_int(savef, len);
380: rs_write(savef, s, len);
381:
382: return(WRITESTAT);
383: }
384:
385: int
386: rs_write_string_index(FILE *savef, const char *master[], int max,
387: const char *str)
388: {
389: int i;
390:
391: for(i = 0; i < max; i++)
392: {
393: if (str == master[i])
394: {
395: rs_write_int(savef,i);
396: return(WRITESTAT);
397: }
398: }
399:
400: rs_write_int(savef,-1);
401:
402: return(WRITESTAT);
403: }
404:
405: int
406: rs_write_strings(FILE *savef, char *s[], int count)
407: {
408: int len = 0;
409: int n = 0;
410:
411: rs_write_int(savef,count);
412:
413: for(n = 0; n < count; n++)
414: {
415: len = (s[n] == NULL) ? 0L : strlen(s[n]) + 1;
416: rs_write_int(savef, len);
417: rs_write(savef, s[n], len);
418: }
419:
420: return(WRITESTAT);
421: }
422:
423: int
424: rs_read(FILE *inf, void *ptr, int size)
425: {
426: int actual;
427:
428: end_of_file = FALSE;
429:
430: if (!read_error && !format_error)
431: {
432: actual = encread(ptr, size, inf);
433:
434: if ((actual == 0) && (size != 0))
435: end_of_file = TRUE;
436: }
437:
438: if (read_error)
439: {
440: printf("read error has occurred. restore short-circuited.\n");
441: abort();
442: }
443:
444: if (format_error)
445: {
446: printf("game format invalid. restore short-circuited.\n");
447: abort();
448: }
449:
450: return(READSTAT);
451: }
452:
453: int
454: rs_read_char(FILE *inf, char *c)
455: {
456: rs_read(inf, c, 1);
457:
458: return(READSTAT);
459: }
460: int
461: rs_read_uchar(FILE *inf, unsigned char *c)
462: {
463: rs_read(inf, c, 1);
464:
465: return(READSTAT);
466: }
467:
468: int
469: rs_read_boolean(FILE *inf, bool *i)
470: {
471: unsigned char buf;
472:
473: rs_read(inf, &buf, 1);
474:
475: *i = (bool) buf;
476:
477: return(READSTAT);
478: }
479:
480: int
481: rs_read_booleans(FILE *inf, bool *i, int count)
482: {
483: int n = 0, value = 0;
484:
485: if (rs_read_int(inf,&value) != 0)
486: {
487: if (value != count)
488: {
489: printf("Invalid booleans block. %d != requested %d\n",value,count);
490: format_error = TRUE;
491: }
492: else
493: {
494: for(n = 0; n < value; n++)
495: rs_read_boolean(inf, &i[n]);
496: }
497: }
498:
499: return(READSTAT);
500: }
501:
502: int
503: rs_read_shint(FILE *inf, shint *i)
504: {
505: unsigned char buf;
506:
507: rs_read(inf, &buf, 1);
508:
509: *i = (shint) buf;
510:
511: return(READSTAT);
512: }
513:
514: int
515: rs_read_short(FILE *inf, short *i)
516: {
517: unsigned char bytes[2];
518: short input;
519: unsigned char *buf = (unsigned char *)&input;
520:
521: rs_read(inf, &input, 2);
522:
523: if (big_endian)
524: {
525: bytes[1] = buf[0];
526: bytes[0] = buf[1];
527: buf = bytes;
528: }
529:
530: *i = *((short *) buf);
531:
532: return(READSTAT);
533: }
534:
535: int
536: rs_read_shorts(FILE *inf, short *i, int count)
537: {
538: int n = 0, value = 0;
539:
540: if (rs_read_int(inf,&value) != 0)
541: {
542: if (value != count)
543: format_error = TRUE;
544: else
545: {
546: for(n = 0; n < value; n++)
547: rs_read_short(inf, &i[n]);
548: }
549: }
550:
551: return(READSTAT);
552: }
553:
554: int
555: rs_read_ushort(FILE *inf, unsigned short *i)
556: {
557: unsigned char bytes[2];
558: unsigned short input;
559: unsigned char *buf = (unsigned char *)&input;
560:
561: rs_read(inf, &input, 2);
562:
563: if (big_endian)
564: {
565: bytes[1] = buf[0];
566: bytes[0] = buf[1];
567: buf = bytes;
568: }
569:
570: *i = *((unsigned short *) buf);
571:
572: return(READSTAT);
573: }
574:
575: int
576: rs_read_int(FILE *inf, int *i)
577: {
578: unsigned char bytes[4];
579: int input;
580: unsigned char *buf = (unsigned char *)&input;
581:
582: rs_read(inf, &input, 4);
583:
584: if (big_endian)
585: {
586: bytes[3] = buf[0];
587: bytes[2] = buf[1];
588: bytes[1] = buf[2];
589: bytes[0] = buf[3];
590: buf = bytes;
591: }
592:
593: *i = *((int *) buf);
594:
595: return(READSTAT);
596: }
597:
598: int
599: rs_read_ints(FILE *inf, int *i, int count)
600: {
601: int n = 0, value = 0;
602:
603: if (rs_read_int(inf,&value) != 0)
604: {
605: if (value != count)
606: format_error = TRUE;
607: else
608: {
609: for(n = 0; n < value; n++)
610: rs_read_int(inf, &i[n]);
611: }
612: }
613:
614: return(READSTAT);
615: }
616:
617: int
618: rs_read_uint(FILE *inf, unsigned int *i)
619: {
620: unsigned char bytes[4];
621: int input;
622: unsigned char *buf = (unsigned char *)&input;
623:
624: rs_read(inf, &input, 4);
625:
626: if (big_endian)
627: {
628: bytes[3] = buf[0];
629: bytes[2] = buf[1];
630: bytes[1] = buf[2];
631: bytes[0] = buf[3];
632: buf = bytes;
633: }
634:
635: *i = *((unsigned int *) buf);
636:
637: return(READSTAT);
638: }
639:
640: int
641: rs_read_long(FILE *inf, long *i)
642: {
643: unsigned char bytes[4];
644: long input;
645: unsigned char *buf = (unsigned char *) &input;
646:
647: rs_read(inf, &input, 4);
648:
649: if (big_endian)
650: {
651: bytes[3] = buf[0];
652: bytes[2] = buf[1];
653: bytes[1] = buf[2];
654: bytes[0] = buf[3];
655: buf = bytes;
656: }
657:
658: *i = *((long *) buf);
659:
660: return(READSTAT);
661: }
662:
663: int
664: rs_read_longs(FILE *inf, long *i, int count)
665: {
666: int n = 0, value = 0;
667:
668: if (rs_read_int(inf,&value) != 0)
669: {
670: if (value != count)
671: format_error = TRUE;
672: else
673: {
674: for(n = 0; n < value; n++)
675: rs_read_long(inf, &i[n]);
676: }
677: }
678:
679: return(READSTAT);
680: }
681:
682: int
683: rs_read_ulong(FILE *inf, unsigned long *i)
684: {
685: unsigned char bytes[4];
686: unsigned long input;
687: unsigned char *buf = (unsigned char *) &input;
688:
689: rs_read(inf, &input, 4);
690:
691: if (big_endian)
692: {
693: bytes[3] = buf[0];
694: bytes[2] = buf[1];
695: bytes[1] = buf[2];
696: bytes[0] = buf[3];
697: buf = bytes;
698: }
699:
700: *i = *((unsigned long *) buf);
701:
702: return(READSTAT);
703: }
704:
705: int
706: rs_read_ulongs(FILE *inf, unsigned long *i, int count)
707: {
708: int n = 0, value = 0;
709:
710: if (rs_read_int(inf,&value) != 0)
711: {
712: if (value != count)
713: format_error = TRUE;
714: else
715: {
716: for(n = 0; n < value; n++)
717: rs_read_ulong(inf, &i[n]);
718: }
719: }
720:
721: return(READSTAT);
722: }
723:
724: int
725: rs_read_string(FILE *inf, char *s, int max)
726: {
727: int len = 0;
728:
729: if (rs_read_int(inf, &len) != FALSE)
730: {
731: if (len > max)
732: {
733: printf("String too long to restore. %d > %d\n",len,max);
734: printf("Sorry, invalid save game format\n");
735: format_error = TRUE;
736: }
737:
738: rs_read(inf, s, len);
739: }
740:
741: return(READSTAT);
742: }
743:
744: int
745: rs_read_new_string(FILE *inf, char **s)
746: {
747: int len=0;
748: char *buf=0;
749:
750: if (rs_read_int(inf, &len) != 0)
751: {
752: if (len == 0)
753: *s = NULL;
754: else
755: {
756: buf = malloc(len);
757:
758: if (buf == NULL)
759: read_error = TRUE;
760: else
761: {
762: rs_read(inf, buf, len);
763: *s = buf;
764: }
765: }
766: }
767:
768: return(READSTAT);
769: }
770:
771: int
772: rs_read_string_index(FILE *inf, const char *master[], int maxindex,
773: const char **str)
774: {
775: int i;
776:
777: if (rs_read_int(inf,&i) != 0)
778: {
779: if (i > maxindex)
780: {
781: printf("String index is out of range. %d > %d\n", i, maxindex);
782: printf("Sorry, invalid save game format\n");
783: format_error = TRUE;
784: }
785: else if (i >= 0)
786: *str = master[i];
787: else
788: *str = NULL;
789: }
790:
791: return(READSTAT);
792: }
793:
794: int
795: rs_read_strings(FILE *inf, char **s, int count, int max)
796: {
797: int n = 0;
798: int value = 0;
799:
800: if (rs_read_int(inf,&value) != 0)
801: {
802: if (value != count)
803: {
804: printf("Incorrect number of strings in block. %d > %d.",
805: value, count);
806: printf("Sorry, invalid save game format");
807: format_error = TRUE;
808: }
809: else
810: {
811: for(n = 0; n < value; n++)
812: {
813: rs_read_string(inf, s[n], max);
814: }
815: }
816: }
817:
818: return(READSTAT);
819: }
820:
821: int
822: rs_read_new_strings(FILE *inf, char **s, int count)
823: {
824: int len = 0;
825: int n = 0;
826: int value = 0;
827:
828: if (rs_read_int(inf,&value) != 0)
829: {
830: if (value != count)
831: {
832: printf("Incorrect number of new strings in block. %d > %d.",
833: value,count);abort();
834: printf("Sorry, invalid save game format");
835: format_error = TRUE;
836: }
837: else
838: for(n=0; n<value; n++)
839: {
840: rs_read_int(inf, &len);
841:
842: if (len == 0)
843: s[n]=0;
844: else
845: {
846: s[n] = malloc(len);
847: rs_read(inf,s[n],len);
848: }
849: }
850: }
851:
852: return(READSTAT);
853: }
854:
855: /******************************************************************************/
856:
857: int
858: rs_write_str_t(FILE *savef, str_t st)
859: {
860: rs_write_uint(savef,st);
861:
862: return(WRITESTAT);
863: }
864:
865: int
866: rs_read_str_t(FILE *inf, str_t *st)
867: {
868: rs_read_uint(inf,st);
869:
870: return(READSTAT);
871: }
872:
873: int
874: rs_write_coord(FILE *savef, coord c)
875: {
876: rs_write_shint(savef, c.x);
877: rs_write_shint(savef, c.y);
878:
879: return(WRITESTAT);
880: }
881:
882: int
883: rs_read_coord(FILE *inf, coord *c)
884: {
885: rs_read_shint(inf,&c->x);
886: rs_read_shint(inf,&c->y);
887:
888: return(READSTAT);
889: }
890:
891: int
892: rs_write_window(FILE *savef, WINDOW *win)
893: {
894: int row,col,height,width;
895: width = getmaxx(win);
896: height = getmaxy(win);
897:
898: rs_write_int(savef,RSID_WINDOW);
899: rs_write_int(savef,height);
900: rs_write_int(savef,width);
901:
902: for(row=0;row<height;row++)
903: for(col=0;col<width;col++)
904: rs_write_int(savef, mvwinch(win,row,col));
905:
906: return(WRITESTAT);
907: }
908:
909: int
910: rs_read_window(FILE *inf, WINDOW *win)
911: {
912: int id,row,col,maxlines,maxcols,value,width,height;
913:
914: width = getmaxx(win);
915: height = getmaxy(win);
916:
917: if (rs_read_int(inf, &id) != 0)
918: {
919: if (id != RSID_WINDOW)
920: {
921: printf("Invalid head id. %x != %x(RSID_WINDOW)\n", id, RSID_WINDOW);
922: printf("Sorry, invalid save game format");
923: format_error = TRUE;
924: }
925: else
926: {
927: rs_read_int(inf,&maxlines);
928: rs_read_int(inf,&maxcols);
929: if (maxlines > height)
930: abort();
931: if (maxcols > width)
932: abort();
933:
934: for(row=0;row<maxlines;row++)
935: for(col=0;col<maxcols;col++)
936: {
937: rs_read_int(inf, &value);
938: mvwaddch(win,row,col,value);
939: }
940: }
941: }
942:
943: return(READSTAT);
944: }
945:
946: int
947: rs_write_daemons(FILE *savef, struct delayed_action *d_list, int count)
948: {
949: int i = 0;
950: int func = 0;
951:
952: rs_write_int(savef, RSID_DAEMONS);
953: rs_write_int(savef, count);
954:
955: for(i = 0; i < count; i++)
956: {
957: if (d_list[i].d_func == rollwand)
958: func = 1;
959: else if (d_list[i].d_func == doctor)
960: func = 2;
961: else if (d_list[i].d_func == stomach)
962: func = 3;
963: else if (d_list[i].d_func == runners)
964: func = 4;
965: else if (d_list[i].d_func == swander)
966: func = 5;
967: else if (d_list[i].d_func == nohaste)
968: func = 6;
969: else if (d_list[i].d_func == unconfuse)
970: func = 7;
971: else if (d_list[i].d_func == unsee)
972: func = 8;
973: else if (d_list[i].d_func == sight)
974: func = 9;
975: else if (d_list[i].d_func == turn_see_off)
976: func = 10;
977: else
978: func = 0;
979:
980: rs_write_int(savef, d_list[i].d_type);
981: rs_write_int(savef, func);
982: rs_write_int(savef, d_list[i].d_arg);
983: rs_write_int(savef, d_list[i].d_time);
984: }
985:
986: return(WRITESTAT);
987: }
988:
989: int
990: rs_read_daemons(FILE *inf, struct delayed_action *d_list, int count)
991: {
992: int i = 0;
993: int func = 0;
994: int value = 0;
995: int id = 0;
996:
997: if (d_list == NULL)
998: printf("HELP THERE ARE NO DAEMONS\n");
999:
1000: if (rs_read_int(inf, &id) != 0)
1001: {
1002: if (id != RSID_DAEMONS)
1003: {
1004: printf("Invalid id. %x != %x(RSID_DAEMONS)\n", id, RSID_DAEMONS);
1005: printf("Sorry, invalid save game format");
1006: format_error = TRUE;
1007: }
1008: else if (rs_read_int(inf, &value) != 0)
1009: {
1010: if (value > count)
1011: {
1012: printf("Incorrect number of daemons in block. %d > %d.",
1013: value, count);
1014: printf("Sorry, invalid save game format");
1015: format_error = TRUE;
1016: }
1017: else
1018: {
1019: for(i=0; i < value; i++)
1020: {
1021: func = 0;
1022: rs_read_int(inf, &d_list[i].d_type);
1023: rs_read_int(inf, &func);
1024: rs_read_int(inf, &d_list[i].d_arg);
1025: rs_read_int(inf, &d_list[i].d_time);
1026:
1027: switch(func)
1028: {
1029: case 1: d_list[i].d_func = rollwand;
1030: break;
1031: case 2: d_list[i].d_func = doctor;
1032: break;
1033: case 3: d_list[i].d_func = stomach;
1034: break;
1035: case 4: d_list[i].d_func = runners;
1036: break;
1037: case 5: d_list[i].d_func = swander;
1038: break;
1039: case 6: d_list[i].d_func = nohaste;
1040: break;
1041: case 7: d_list[i].d_func = unconfuse;
1042: break;
1043: case 8: d_list[i].d_func = unsee;
1044: break;
1045: case 9: d_list[i].d_func = sight;
1046: break;
1047: case 10: d_list[i].d_func = turn_see_off;
1048: break;
1049: default:d_list[i].d_func = NULL;
1050: break;
1051: }
1052:
1053: if (d_list[i].d_func == NULL)
1054: {
1055: d_list[i].d_type = 0;
1056: d_list[i].d_arg = 0;
1057: d_list[i].d_time = 0;
1058: }
1059: }
1060: }
1061: }
1062: }
1063:
1064: return(READSTAT);
1065: }
1066:
1067: int
1068: rs_write_magic_items(FILE *savef, struct magic_item *i, int count)
1069: {
1070: int n;
1071:
1072: rs_write_int(savef, RSID_MAGICITEMS);
1073: rs_write_int(savef, count);
1074:
1075: for(n = 0; n < count; n++)
1076: {
1077: /* mi_name is constant, defined at compile time in all cases */
1078: rs_write_shint(savef,i[n].mi_prob);
1079: rs_write_short(savef,i[n].mi_worth);
1080: }
1081:
1082: return(WRITESTAT);
1083: }
1084:
1085: int
1086: rs_read_magic_items(FILE *inf, struct magic_item *mi, int count)
1087: {
1088: int id;
1089: int n;
1090: int value;
1091:
1092: if (rs_read_int(inf, &id) != 0)
1093: {
1094: if (id != RSID_MAGICITEMS)
1095: {
1096: printf("Invalid id. %x != %x(RSID_MAGICITEMS)\n",
1097: id, RSID_MAGICITEMS);
1098: printf("Sorry, invalid save game format");
1099: format_error = TRUE;
1100: }
1101: else if (rs_read_int(inf, &value) != 0)
1102: {
1103: if (value > count)
1104: {
1105: printf("Incorrect number of magic items in block. %d > %d.",
1106: value, count);
1107: printf("Sorry, invalid save game format");
1108: format_error = TRUE;
1109: }
1110: else
1111: {
1112: for(n = 0; n < value; n++)
1113: {
1114: /* mi_name is constant, defined at compile time in all cases */
1115: rs_read_shint(inf,&mi[n].mi_prob);
1116: rs_read_short(inf,&mi[n].mi_worth);
1117: }
1118: }
1119: }
1120: }
1121:
1122: return(READSTAT);
1123: }
1124:
1125: int
1126: rs_write_room(FILE *savef, struct room *r)
1127: {
1128: rs_write_coord(savef, r->r_pos);
1129: rs_write_coord(savef, r->r_max);
1130: rs_write_coord(savef, r->r_gold);
1131: rs_write_int(savef, r->r_goldval);
1132: rs_write_short(savef, r->r_flags);
1133: rs_write_shint(savef, r->r_nexits);
1134: rs_write_coord(savef, r->r_exit[0]);
1135: rs_write_coord(savef, r->r_exit[1]);
1136: rs_write_coord(savef, r->r_exit[2]);
1137: rs_write_coord(savef, r->r_exit[3]);
1138: rs_write_coord(savef, r->r_exit[4]);
1139: rs_write_coord(savef, r->r_exit[5]);
1140: rs_write_coord(savef, r->r_exit[6]);
1141: rs_write_coord(savef, r->r_exit[7]);
1142: rs_write_coord(savef, r->r_exit[8]);
1143: rs_write_coord(savef, r->r_exit[9]);
1144: rs_write_coord(savef, r->r_exit[10]);
1145: rs_write_coord(savef, r->r_exit[11]);
1146:
1147: return(WRITESTAT);
1148: }
1149:
1150: int
1151: rs_write_rooms(FILE *savef, struct room r[], int count)
1152: {
1153: int n = 0;
1154:
1155: rs_write_int(savef, count);
1156:
1157: for(n=0; n<count; n++)
1158: rs_write_room(savef, &r[n]);
1159:
1160: return(WRITESTAT);
1161: }
1162:
1163: int
1164: rs_read_room(FILE *inf, struct room *r)
1165: {
1166: rs_read_coord(inf,&r->r_pos);
1167: rs_read_coord(inf,&r->r_max);
1168: rs_read_coord(inf,&r->r_gold);
1169: rs_read_int(inf,&r->r_goldval);
1170: rs_read_short(inf,&r->r_flags);
1171: rs_read_shint(inf,&r->r_nexits);
1172: rs_read_coord(inf,&r->r_exit[0]);
1173: rs_read_coord(inf,&r->r_exit[1]);
1174: rs_read_coord(inf,&r->r_exit[2]);
1175: rs_read_coord(inf,&r->r_exit[3]);
1176: rs_read_coord(inf,&r->r_exit[4]);
1177: rs_read_coord(inf,&r->r_exit[5]);
1178: rs_read_coord(inf,&r->r_exit[6]);
1179: rs_read_coord(inf,&r->r_exit[7]);
1180: rs_read_coord(inf,&r->r_exit[8]);
1181: rs_read_coord(inf,&r->r_exit[9]);
1182: rs_read_coord(inf,&r->r_exit[10]);
1183: rs_read_coord(inf,&r->r_exit[11]);
1184:
1185: return(READSTAT);
1186: }
1187:
1188: int
1189: rs_read_rooms(FILE *inf, struct room *r, int count)
1190: {
1191: int value = 0, n = 0;
1192:
1193: if (rs_read_int(inf,&value) != 0)
1194: {
1195: if (value > count)
1196: {
1197: printf("Incorrect number of rooms in block. %d > %d.",
1198: value,count);
1199: printf("Sorry, invalid save game format");
1200: format_error = TRUE;
1201: }
1202: else
1203: for(n = 0; n < value; n++)
1204: rs_read_room(inf,&r[n]);
1205: }
1206:
1207: return(READSTAT);
1208: }
1209:
1210: int
1211: rs_write_room_reference(FILE *savef, struct room *rp)
1212: {
1213: int i, room = -1;
1214:
1215: for (i = 0; i < MAXROOMS; i++)
1216: if (&rooms[i] == rp)
1217: room = i;
1218:
1219: rs_write_int(savef, room);
1220:
1221: return(WRITESTAT);
1222: }
1223:
1224: int
1225: rs_read_room_reference(FILE *inf, struct room **rp)
1226: {
1227: int i;
1228:
1229: rs_read_int(inf, &i);
1230:
1231: if (i >= 0 && i < MAXROOMS)
1232: *rp = &rooms[i];
1233: else
1234: *rp = NULL;
1235:
1236: return(READSTAT);
1237: }
1238:
1239: int
1240: rs_write_stats(FILE *savef, struct stats *s)
1241: {
1242: rs_write_int(savef, RSID_STATS);
1243: rs_write_str_t(savef, s->s_str);
1244: rs_write_long(savef, s->s_exp);
1245: rs_write_shint(savef, s->s_lvl);
1246: rs_write_shint(savef, s->s_arm);
1247: rs_write_short(savef, s->s_hpt);
1248: rs_write(savef, s->s_dmg, sizeof(s->s_dmg));
1249: rs_write_shint(savef,s->s_maxhp);
1250:
1251: return(WRITESTAT);
1252: }
1253:
1254: int
1255: rs_read_stats(FILE *inf, struct stats *s)
1256: {
1257: int id;
1258:
1259: rs_read_int(inf, &id);
1260:
1261: rs_read_str_t(inf,&s->s_str);
1262: rs_read_long(inf,&s->s_exp);
1263: rs_read_shint(inf,&s->s_lvl);
1264: rs_read_shint(inf,&s->s_arm);
1265: rs_read_short(inf,&s->s_hpt);
1266: rs_read(inf,s->s_dmg,sizeof(s->s_dmg));
1267: rs_read_shint(inf,&s->s_maxhp);
1268:
1269: return(READSTAT);
1270: }
1271:
1272: int
1273: rs_write_object(FILE *savef, THING *o)
1274: {
1275: rs_write_int(savef, RSID_OBJECT);
1276: rs_write_shint(savef, o->_o._o_type);
1277: rs_write_coord(savef, o->_o._o_pos);
1278: rs_write_char(savef, o->_o._o_launch);
1279: rs_write(savef, o->_o._o_damage, sizeof(o->_o._o_damage));
1280: rs_write(savef, o->_o._o_hurldmg, sizeof(o->_o._o_hurldmg));
1281: rs_write_shint(savef, o->_o._o_count);
1282: rs_write_shint(savef, o->_o._o_which);
1283: rs_write_shint(savef, o->_o._o_hplus);
1284: rs_write_shint(savef, o->_o._o_dplus);
1285: rs_write_short(savef, o->_o._o_ac);
1286: rs_write_short(savef, o->_o._o_flags);
1287: rs_write_shint(savef, o->_o._o_group);
1288:
1289: return(WRITESTAT);
1290: }
1291:
1292: int
1293: rs_read_object(FILE *inf, THING *o)
1294: {
1295: int id;
1296:
1297: if (rs_read_int(inf, &id) != 0)
1298: {
1299: if (id != RSID_OBJECT)
1300: {
1301: printf("Invalid id. %x != %x(RSID_OBJECT)\n",
1302: id,RSID_OBJECT);
1303: printf("Sorry, invalid save game format");
1304: format_error = TRUE;
1305: }
1306: else
1307: {
1308: rs_read_shint(inf, &o->_o._o_type);
1309: rs_read_coord(inf, &o->_o._o_pos);
1310: rs_read_char(inf, &o->_o._o_launch);
1311: rs_read(inf, &o->_o._o_damage, sizeof(o->_o._o_damage));
1312: rs_read(inf, &o->_o._o_hurldmg, sizeof(o->_o._o_hurldmg));
1313: rs_read_shint(inf, &o->_o._o_count);
1314: rs_read_shint(inf, &o->_o._o_which);
1315: rs_read_shint(inf, &o->_o._o_hplus);
1316: rs_read_shint(inf, &o->_o._o_dplus);
1317: rs_read_short(inf, &o->_o._o_ac);
1318: rs_read_short(inf, &o->_o._o_flags);
1319: rs_read_shint(inf, &o->_o._o_group);
1320: }
1321: }
1322:
1323: return(READSTAT);
1324: }
1325:
1326: int
1327: rs_write_object_list(FILE *savef, THING *l)
1328: {
1329: rs_write_int(savef, RSID_OBJECTLIST);
1330: rs_write_int(savef, list_size(l));
1331:
1332: while (l != NULL)
1333: {
1334: rs_write_object(savef, l);
1335: l = l->l_next;
1336: }
1337:
1338: return(WRITESTAT);
1339: }
1340:
1341: int
1342: rs_read_object_list(FILE *inf, THING **list)
1343: {
1344: int id;
1345: int i, cnt;
1346: THING *l = NULL, *previous = NULL, *head = NULL;
1347:
1348: if (rs_read_int(inf,&id) != 0)
1349: {
1350: if (rs_read_int(inf,&cnt) != 0)
1351: {
1352: for (i = 0; i < cnt; i++)
1353: {
1354: l = new_item();
1355: memset(l,0,sizeof(THING));
1356: l->l_prev = previous;
1357: if (previous != NULL)
1358: previous->l_next = l;
1359: rs_read_object(inf,l);
1360: if (previous == NULL)
1361: head = l;
1362: previous = l;
1363: }
1364:
1365: if (l != NULL)
1366: l->l_next = NULL;
1367:
1368: *list = head;
1369: }
1370: else
1371: format_error = TRUE;
1372: }
1373: else
1374: format_error = TRUE;
1375:
1376:
1377: return(READSTAT);
1378: }
1379:
1380: int
1381: rs_write_object_reference(FILE *savef, THING *list, THING *item)
1382: {
1383: int i;
1384:
1385: i = find_list_ptr(list, item);
1386:
1387: rs_write_int(savef, i);
1388:
1389: return(WRITESTAT);
1390: }
1391:
1392: int
1393: rs_read_object_reference(FILE *inf, THING *list, THING **item)
1394: {
1395: int i;
1396:
1397: rs_read_int(inf, &i);
1398:
1399: *item = get_list_item(list,i);
1400:
1401: return(READSTAT);
1402: }
1403:
1404: int
1405: find_thing_coord(THING *monlist, coord *c)
1406: {
1407: THING *mitem;
1408: THING *tp;
1409: int i = 0;
1410:
1411: for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
1412: {
1413: tp = mitem;
1414:
1415: if (c == &tp->t_pos)
1416: return(i);
1417:
1418: i++;
1419: }
1420:
1421: return(-1);
1422: }
1423:
1424: int
1425: find_room_coord(struct room *rmlist, coord *c, int n)
1426: {
1427: int i = 0;
1428:
1429: for(i = 0; i < n; i++)
1430: if(&rmlist[i].r_gold == c)
1431: return(i);
1432:
1433: return(-1);
1434: }
1435:
1436: int
1437: find_object_coord(THING *objlist, coord *c)
1438: {
1439: THING *oitem;
1440: THING *obj;
1441: int i = 0;
1442:
1443: for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
1444: {
1445: obj = oitem;
1446:
1447: if (c == &obj->o_pos)
1448: return(i);
1449:
1450: i++;
1451: }
1452:
1453: return(-1);
1454: }
1455:
1456: int
1457: rs_write_thing(FILE *savef, THING *t)
1458: {
1459: int i = -1;
1460:
1461: if (t == NULL)
1462: {
1463: rs_write_int(savef, RSID_THING_NULL);
1464: return(WRITESTAT);
1465: }
1466:
1467: rs_write_int(savef, RSID_THING);
1468:
1469: rs_write_coord(savef, t->_t._t_pos);
1470: rs_write_boolean(savef, t->_t._t_turn);
1471: rs_write_char(savef, t->_t._t_type);
1472: rs_write_char(savef, t->_t._t_disguise);
1473: rs_write_char(savef, t->_t._t_oldch);
1474:
1475: /*
1476: t_dest can be:
1477: 0,0: NULL
1478: 0,1: location of hero
1479: 1,i: location of a thing (monster)
1480: 2,i: location of an object
1481: 3,i: location of gold in a room
1482:
1483: We need to remember what we are chasing rather than
1484: the current location of what we are chasing.
1485: */
1486:
1487: if (t->t_dest == &hero)
1488: {
1489: rs_write_int(savef,0);
1490: rs_write_int(savef,1);
1491: }
1492: else if (t->t_dest != NULL)
1493: {
1494: i = find_thing_coord(mlist, t->t_dest);
1495:
1496: if (i >=0 )
1497: {
1498: rs_write_int(savef,1);
1499: rs_write_int(savef,i);
1500: }
1501: else
1502: {
1503: i = find_object_coord(lvl_obj, t->t_dest);
1504:
1505: if (i >= 0)
1506: {
1507: rs_write_int(savef,2);
1508: rs_write_int(savef,i);
1509: }
1510: else
1511: {
1512: i = find_room_coord(rooms, t->t_dest, MAXROOMS);
1513:
1514: if (i >= 0)
1515: {
1516: rs_write_int(savef,3);
1517: rs_write_int(savef,i);
1518: }
1519: else
1520: {
1521: rs_write_int(savef, 0);
1522: rs_write_int(savef,1); /* chase the hero anyway */
1523: }
1524: }
1525: }
1526: }
1527: else
1528: {
1529: rs_write_int(savef,0);
1530: rs_write_int(savef,0);
1531: }
1532:
1533: rs_write_short(savef, t->_t._t_flags);
1534: rs_write_stats(savef, &t->_t._t_stats);
1535: rs_write_room_reference(savef, t->_t._t_room);
1536: rs_write_object_list(savef, t->_t._t_pack);
1537:
1538: return(WRITESTAT);
1539: }
1540:
1541: void
1542: rs_fix_thing(THING *t)
1543: {
1544: THING *item;
1545: THING *tp;
1546:
1547: if (t->t_reserved < 0)
1548: return;
1549:
1550: item = get_list_item(mlist,t->t_reserved);
1551:
1552: if (item != NULL)
1553: {
1554: tp = item;
1555: t->t_dest = &tp->t_pos;
1556: }
1557: }
1558:
1559: void
1560: rs_fix_thing_list(THING *list)
1561: {
1562: THING *item;
1563:
1564: for(item = list; item != NULL; item = item->l_next)
1565: rs_fix_thing(item);
1566: }
1567:
1568: int
1569: rs_read_thing(FILE *inf, THING *t)
1570: {
1571: int id;
1572: int listid = 0, index = -1;
1573: THING *item;
1574:
1575: if (rs_read_int(inf, &id) != 0)
1576: {
1577: if (id != RSID_THING)
1578: format_error = TRUE;
1579: else
1580: {
1581: rs_read_coord(inf,&t->_t._t_pos);
1582: rs_read_boolean(inf,&t->_t._t_turn);
1583: rs_read_uchar(inf,&t->_t._t_type);
1584: rs_read_char(inf,&t->_t._t_disguise);
1585: rs_read_char(inf,&t->_t._t_oldch);
1586:
1587: /*
1588: t_dest can be (listid,index):
1589: 0,0: NULL
1590: 0,1: location of hero
1591: 1,i: location of a thing (monster)
1592: 2,i: location of an object
1593: 3,i: location of gold in a room
1594:
1595: We need to remember what we are chasing rather than
1596: the current location of what we are chasing.
1597: */
1598:
1599: rs_read_int(inf, &listid);
1600: rs_read_int(inf, &index);
1601: t->_t._t_reserved = -1;
1602:
1603: if (listid == 0) /* hero or NULL */
1604: {
1605: if (index == 1)
1606: t->_t._t_dest = &hero;
1607: else
1608: t->_t._t_dest = NULL;
1609: }
1610: else if (listid == 1) /* monster/thing */
1611: {
1612: t->_t._t_dest = NULL;
1613: t->_t._t_reserved = index;
1614: }
1615: else if (listid == 2) /* object */
1616: {
1617: THING *obj;
1618:
1619: item = get_list_item(lvl_obj, index);
1620:
1621: if (item != NULL)
1622: {
1623: obj = item;
1624: t->_t._t_dest = &obj->o_pos;
1625: }
1626: }
1627: else if (listid == 3) /* gold */
1628: {
1629: t->_t._t_dest = &rooms[index].r_gold;
1630: }
1631: else
1632: t->_t._t_dest = NULL;
1633:
1634: rs_read_short(inf,&t->_t._t_flags);
1635: rs_read_stats(inf,&t->_t._t_stats);
1636: rs_read_room_reference(inf, &t->_t._t_room);
1637: rs_read_object_list(inf,&t->_t._t_pack);
1638: }
1639: }
1640: else
1641: format_error = TRUE;
1642:
1643: return(READSTAT);
1644: }
1645:
1646: int
1647: rs_write_thing_list(FILE *savef, THING *l)
1648: {
1649: int cnt = 0;
1650:
1651: rs_write_int(savef, RSID_MONSTERLIST);
1652:
1653: cnt = list_size(l);
1654:
1655: rs_write_int(savef, cnt);
1656:
1657: if (cnt < 1)
1658: return(WRITESTAT);
1659:
1660: while (l != NULL) {
1661: rs_write_thing(savef, l);
1662: l = l->l_next;
1663: }
1664:
1665: return(WRITESTAT);
1666: }
1667:
1668: int
1669: rs_read_thing_list(FILE *inf, THING **list)
1670: {
1671: int id;
1672: int i, cnt;
1673: THING *l = NULL, *previous = NULL, *head = NULL;
1674:
1675: if (rs_read_int(inf,&id) != 0)
1676: {
1677: if (id != RSID_MONSTERLIST)
1678: {
1679: printf("Invalid id. %x != %x(RSID_MONSTERLIST)\n",
1680: id,RSID_MONSTERLIST);
1681: printf("Sorry, invalid save game format");
1682: format_error = TRUE;
1683: }
1684: else if (rs_read_int(inf,&cnt) != 0)
1685: {
1686: for (i = 0; i < cnt; i++)
1687: {
1688: l = new_item();
1689: l->l_prev = previous;
1690: if (previous != NULL)
1691: previous->l_next = l;
1692: rs_read_thing(inf,l);
1693: if (previous == NULL)
1694: head = l;
1695: previous = l;
1696: }
1697:
1698:
1699: if (l != NULL)
1700: l->l_next = NULL;
1701:
1702: *list = head;
1703: }
1704: }
1705: else
1706: format_error = TRUE;
1707:
1708: return(READSTAT);
1709: }
1710:
1711: int
1712: rs_write_monsters(FILE *savef, struct monster *m, int count)
1713: {
1714: int n;
1715:
1716: rs_write_int(savef, RSID_MONSTERS);
1717: rs_write_int(savef, count);
1718:
1719: for(n=0;n<count;n++)
1720: {
1721: /*
1722: rs_write(savef, m[n].m_name, sizeof(m[n].m_name));
1723: rs_write_char(savef, m[n].m_carry);
1724: rs_write_short(savef, m[n].m_flags);
1725: */
1726: rs_write_stats(savef, &m[n].m_stats);
1727: }
1728:
1729: return(WRITESTAT);
1730: }
1731:
1732: int
1733: rs_read_monsters(FILE *inf, struct monster *m, int count)
1734: {
1735: int id = 0, value = 0, n = 0;
1736:
1737: if (rs_read_int(inf, &id) != 0)
1738: {
1739: if (id != RSID_MONSTERS)
1740: {
1741: printf("Invalid id. %x != %x(RSID_MONSTERS)\n",
1742: id,RSID_MONSTERS);
1743: printf("Sorry, invalid save game format");
1744: format_error = TRUE;
1745: }
1746: else if (rs_read_int(inf, &value) != 0)
1747: {
1748: for(n=0;n<value;n++)
1749: {
1750: /*
1751: rs_read(inf,m[n].m_name,sizeof(m[n].m_name));
1752: rs_read_char(inf, &m[n].m_carry);
1753: rs_read_short(inf, &m[n].m_flags);
1754: */
1755: rs_read_stats(inf, &m[n].m_stats);
1756: }
1757: }
1758: else
1759: format_error = TRUE;
1760: }
1761:
1762: return(READSTAT);
1763: }
1764:
1765: int
1766: rs_write_scrolls(FILE *savef)
1767: {
1768: int i;
1769:
1770: for(i = 0; i < MAXSCROLLS; i++)
1771: {
1772: rs_write_string(savef,s_names[i]);
1773: rs_write_boolean(savef,s_know[i]);
1774: rs_write_string(savef,s_guess[i]);
1775: }
1776:
1777: return(WRITESTAT);
1778: }
1779:
1780: int
1781: rs_read_scrolls(FILE *inf)
1782: {
1783: int i;
1784:
1785: for(i = 0; i < MAXSCROLLS; i++)
1786: {
1787: rs_read_new_string(inf,&s_names[i]);
1788: rs_read_boolean(inf,&s_know[i]);
1789: rs_read_new_string(inf,&s_guess[i]);
1790: }
1791:
1792: return(READSTAT);
1793: }
1794:
1795: int
1796: rs_write_potions(FILE *savef)
1797: {
1798: int i;
1799:
1800: for(i = 0; i < MAXPOTIONS; i++)
1801: {
1802: rs_write_string_index(savef,rainbow,NCOLORS,p_colors[i]);
1803: rs_write_boolean(savef,p_know[i]);
1804: rs_write_string(savef,p_guess[i]);
1805: }
1806:
1807: return(WRITESTAT);
1808: }
1809:
1810: int
1811: rs_read_potions(FILE *inf)
1812: {
1813: int i;
1814:
1815: for(i = 0; i < MAXPOTIONS; i++)
1816: {
1817: rs_read_string_index(inf,rainbow,NCOLORS,&p_colors[i]);
1818: rs_read_boolean(inf,&p_know[i]);
1819: rs_read_new_string(inf,&p_guess[i]);
1820: }
1821:
1822: return(READSTAT);
1823: }
1824:
1825:
1826: int
1827: rs_write_rings(FILE *savef)
1828: {
1829: int i;
1830: const char *stones_list[NSTONES];
1831:
1832: for(i = 0; i < NSTONES; i++)
1833: stones_list[i] = stones[i].st_name;
1834:
1835: for(i = 0; i < MAXRINGS; i++)
1836: {
1837: rs_write_string_index(savef,stones_list,NSTONES,r_stones[i]);
1838: rs_write_boolean(savef,r_know[i]);
1839: rs_write_string(savef,r_guess[i]);
1840: }
1841:
1842: return(WRITESTAT);
1843: }
1844:
1845: int
1846: rs_read_rings(FILE *inf)
1847: {
1848: int i;
1849: const char *stones_list[NSTONES];
1850:
1851: for(i = 0; i < NSTONES; i++)
1852: stones_list[i] = stones[i].st_name;
1853:
1854: for(i = 0; i < MAXRINGS; i++)
1855: {
1856: rs_read_string_index(inf,stones_list,NSTONES,&r_stones[i]);
1857: rs_read_boolean(inf,&r_know[i]);
1858: rs_read_new_string(inf,&r_guess[i]);
1859: }
1860:
1861: return(READSTAT);
1862: }
1863:
1864: int
1865: rs_write_sticks(FILE *savef)
1866: {
1867: int i;
1868:
1869: for (i = 0; i < MAXSTICKS; i++)
1870: {
1871: if (strcmp(ws_type[i],"staff") == 0)
1872: {
1873: rs_write_int(savef,0);
1874: rs_write_string_index(savef, wood, NWOOD, ws_made[i]);
1875: }
1876: else
1877: {
1878: rs_write_int(savef,1);
1879: rs_write_string_index(savef, metal, NMETAL, ws_made[i]);
1880: }
1881: rs_write_boolean(savef, ws_know[i]);
1882: rs_write_string(savef, ws_guess[i]);
1883: }
1884:
1885: return(WRITESTAT);
1886: }
1887:
1888: int
1889: rs_read_sticks(FILE *inf)
1890: {
1891: int i = 0, list = 0;
1892:
1893: for(i = 0; i < MAXSTICKS; i++)
1894: {
1895: rs_read_int(inf,&list);
1896: if (list == 0)
1897: {
1898: rs_read_string_index(inf,wood,NWOOD,&ws_made[i]);
1899: ws_type[i] = "staff";
1900: }
1901: else
1902: {
1903: rs_read_string_index(inf,metal,NMETAL,&ws_made[i]);
1904: ws_type[i] = "wand";
1905: }
1906: rs_read_boolean(inf, &ws_know[i]);
1907: rs_read_new_string(inf, &ws_guess[i]);
1908: }
1909:
1910: return(READSTAT);
1911: }
1912:
1913: /******************************************************************************/
1914: int
1915: rs_write_thing_reference(FILE *savef, THING *list, THING *item)
1916: {
1917: int i;
1918:
1919: if (item == NULL)
1920: rs_write_int(savef,-1);
1921: else
1922: {
1923: i = find_list_ptr(list, item);
1924:
1925: assert(i >= 0);
1926:
1927: rs_write_int(savef, i);
1928: }
1929:
1930: return(WRITESTAT);
1931: }
1932:
1933: int
1934: rs_read_thing_reference(FILE *inf, THING *list, THING **item)
1935: {
1936: int i;
1937:
1938: rs_read_int(inf, &i);
1939:
1940: if (i == -1)
1941: *item = NULL;
1942: else
1943: {
1944: *item = get_list_item(list,i);
1945:
1946: assert(item != NULL);
1947: }
1948:
1949: return(READSTAT);
1950: }
1951:
1952: int
1953: rs_write_thing_references(FILE *savef, THING *list, THING *items[], int count)
1954: {
1955: int i;
1956:
1957: for(i = 0; i < count; i++)
1958: rs_write_thing_reference(savef,list,items[i]);
1959:
1960: return(WRITESTAT);
1961: }
1962:
1963: int
1964: rs_read_thing_references(FILE *inf, THING *list, THING *items[], int count)
1965: {
1966: int i;
1967:
1968: for(i = 0; i < count; i++)
1969: rs_read_thing_reference(inf,list,&items[i]);
1970:
1971: return(WRITESTAT);
1972: }
1973:
1974: int
1975: rs_save_file(FILE *savef)
1976: {
1977: int endian = 0x01020304;
1978: big_endian = ( *((char *)&endian) == 0x01 );
1979:
1980: rs_write_boolean(savef, after);
1981: rs_write_boolean(savef, noscore);
1982: rs_write_boolean(savef, amulet);
1983: rs_write_boolean(savef, askme);
1984: rs_write_boolean(savef, door_stop);
1985: rs_write_boolean(savef, fight_flush);
1986: rs_write_boolean(savef, firstmove);
1987: rs_write_boolean(savef, in_shell);
1988: rs_write_boolean(savef, jump);
1989: rs_write_boolean(savef, passgo);
1990: rs_write_boolean(savef, playing);
1991: rs_write_boolean(savef, running);
1992: rs_write_boolean(savef, save_msg);
1993: rs_write_boolean(savef, slow_invent);
1994: rs_write_boolean(savef, terse);
1995: #ifdef WIZARD
1996: rs_write_boolean(savef, wizard);
1997: #else
1998: rs_write_boolean(savef, 0);
1999: #endif
2000: rs_write_char(savef, take);
2001: rs_write(savef, prbuf, MAXSTR);
2002: rs_write_char(savef, runch);
2003:
2004: rs_write_scrolls(savef);
2005: rs_write_potions(savef);
2006: rs_write_rings(savef);
2007: rs_write_sticks(savef);
2008:
2009: rs_write_string(savef, release);
2010: rs_write(savef, whoami, MAXSTR);
2011: rs_write(savef, fruit, MAXSTR);
2012:
2013: rs_write(savef, _level, MAXLINES*MAXCOLS);
2014: rs_write(savef, _flags, MAXLINES*MAXCOLS);
2015:
2016: rs_write_int(savef, max_level);
2017: rs_write_int(savef, ntraps);
2018: rs_write_int(savef, dnum);
2019: rs_write_int(savef, level);
2020: rs_write_int(savef, purse);
2021: rs_write_int(savef, no_move);
2022: rs_write_int(savef, no_command);
2023: rs_write_int(savef, inpack);
2024: rs_write_int(savef, lastscore);
2025: rs_write_int(savef, no_food);
2026: rs_write_int(savef, count);
2027: rs_write_int(savef, fung_hit);
2028: rs_write_int(savef, quiet);
2029: rs_write_int(savef, food_left);
2030: rs_write_int(savef, group);
2031: rs_write_int(savef, hungry_state);
2032:
2033: /* rs_write_ints(savef, a_chances, MAXARMORS); *//* constant */
2034: /* rs_write_ints(savef, a_class, MAXARMORS); *//* constant */
2035:
2036: rs_write_long(savef, seed);
2037: rs_write_coord(savef, oldpos);
2038: rs_write_coord(savef, delta);
2039:
2040: rs_write_thing(savef, &player);
2041: rs_write_object_reference(savef, player.t_pack, cur_armor);
2042: rs_write_object_reference(savef, player.t_pack, cur_weapon);
2043: rs_write_object_reference(savef, player.t_pack, cur_ring[0]);
2044: rs_write_object_reference(savef, player.t_pack, cur_ring[1]);
2045:
2046: rs_write_object_list(savef, lvl_obj);
2047: rs_write_thing_list(savef, mlist);
2048: rs_write_thing_references(savef, mlist, _monst, MAXLINES*MAXCOLS);
2049:
2050: rs_write_window(savef, stdscr);
2051: rs_write_stats(savef,&max_stats);
2052:
2053: rs_write_rooms(savef, rooms, MAXROOMS);
2054: rs_write_room_reference(savef, oldrp);
2055: rs_write_rooms(savef, passages, MAXPASS);
2056:
2057: rs_write_monsters(savef,monsters,26);
2058: rs_write_magic_items(savef, things, NUMTHINGS);
2059: rs_write_magic_items(savef, s_magic, MAXSCROLLS);
2060: rs_write_magic_items(savef, p_magic, MAXPOTIONS);
2061: rs_write_magic_items(savef, r_magic, MAXRINGS);
2062: rs_write_magic_items(savef, ws_magic, MAXSTICKS);
2063:
2064: rs_write_coord(savef, ch_ret); /* 5.2-chase.c */
2065: rs_write_char(savef,countch); /* 5.2-command.c*/
2066: rs_write_char(savef,direction); /* 5.2-command.c*/
2067: rs_write_char(savef,newcount); /* 5.2-command.c*/
2068: rs_write_daemons(savef, &d_list[0], 20); /* 5.2-daemon.c */
2069: rs_write_int(savef,between); /* 5.2-daemons.c*/
2070: rs_write(savef,lvl_mons,sizeof(lvl_mons)); /* 5.2-monsters.c*/
2071: rs_write(savef,wand_mons,sizeof(wand_mons)); /* 5.2-monsters.c*/
2072: rs_write_coord(savef, nh); /* 5.2-move.c */
2073: rs_write_boolean(savef, got_genocide); /* 5.2-things.c */
2074:
2075: return(WRITESTAT);
2076: }
2077:
2078: int
2079: rs_restore_file(FILE *inf)
2080: {
2081: bool junk;
2082: THING *mitem;
2083: int endian = 0x01020304;
2084: big_endian = ( *((char *)&endian) == 0x01 );
2085:
2086: rs_read_boolean(inf, &after);
2087: rs_read_boolean(inf, &noscore);
2088: rs_read_boolean(inf, &amulet);
2089: rs_read_boolean(inf, &askme);
2090: rs_read_boolean(inf, &door_stop);
2091: rs_read_boolean(inf, &fight_flush);
2092: rs_read_boolean(inf, &firstmove);
2093: rs_read_boolean(inf, &in_shell);
2094: rs_read_boolean(inf, &jump);
2095: rs_read_boolean(inf, &passgo);
2096: rs_read_boolean(inf, &playing);
2097: rs_read_boolean(inf, &running);
2098: rs_read_boolean(inf, &save_msg);
2099: rs_read_boolean(inf, &slow_invent);
2100: rs_read_boolean(inf, &terse);
2101: #ifdef WIZARD
2102: rs_read_boolean(inf, &wizard);
2103: #else
2104: rs_read_boolean(inf, &junk);
2105: #endif
2106: rs_read_char(inf, &take);
2107: rs_read(inf, prbuf, MAXSTR);
2108: rs_read_char(inf, &runch);
2109:
2110: rs_read_scrolls(inf);
2111: rs_read_potions(inf);
2112: rs_read_rings(inf);
2113: rs_read_sticks(inf);
2114:
2115: rs_read_new_string(inf, &release);
2116: rs_read(inf, whoami, MAXSTR);
2117: rs_read(inf, fruit, MAXSTR);
2118:
2119: rs_read(inf, _level, MAXLINES*MAXCOLS);
2120: rs_read(inf, _flags, MAXLINES*MAXCOLS);
2121:
2122: rs_read_int(inf, &max_level);
2123: rs_read_int(inf, &ntraps);
2124: rs_read_int(inf, &dnum);
2125: rs_read_int(inf, &level);
2126: rs_read_int(inf, &purse);
2127: rs_read_int(inf, &no_move);
2128: rs_read_int(inf, &no_command);
2129: rs_read_int(inf, &inpack);
2130: rs_read_int(inf, &lastscore);
2131: rs_read_int(inf, &no_food);
2132: rs_read_int(inf, &count);
2133: rs_read_int(inf, &fung_hit);
2134: rs_read_int(inf, &quiet);
2135: rs_read_int(inf, &food_left);
2136: rs_read_int(inf, &group);
2137: rs_read_int(inf, &hungry_state);
2138:
2139: rs_read_long(inf, &seed);
2140: rs_read_coord(inf, &oldpos);
2141: rs_read_coord(inf, &delta);
2142:
2143: rs_read_thing(inf, &player);
2144: rs_read_object_reference(inf, player.t_pack, &cur_armor);
2145: rs_read_object_reference(inf, player.t_pack, &cur_weapon);
2146: rs_read_object_reference(inf, player.t_pack, &cur_ring[0]);
2147: rs_read_object_reference(inf, player.t_pack, &cur_ring[1]);
2148:
2149: rs_read_object_list(inf, &lvl_obj);
2150: rs_read_thing_list(inf, &mlist);
2151: rs_fix_thing(&player);
2152: rs_fix_thing_list(mlist);
2153: rs_read_thing_references(inf,mlist,_monst,MAXLINES*MAXCOLS);
2154:
2155: rs_read_window(inf, stdscr);
2156: rs_read_stats(inf, &max_stats);
2157:
2158: rs_read_rooms(inf, rooms, MAXROOMS);
2159: rs_read_room_reference(inf, &oldrp);
2160: rs_read_rooms(inf, passages, MAXPASS);
2161:
2162: rs_read_monsters(inf,monsters,26);
2163: rs_read_magic_items(inf, things, NUMTHINGS);
2164: rs_read_magic_items(inf, s_magic, MAXSCROLLS);
2165: rs_read_magic_items(inf, p_magic, MAXPOTIONS);
2166: rs_read_magic_items(inf, r_magic, MAXRINGS);
2167: rs_read_magic_items(inf, ws_magic, MAXSTICKS);
2168:
2169: rs_read_coord(inf, &ch_ret); /* 5.2-chase.c */
2170: rs_read_char(inf,&countch); /* 5.2-command.c */
2171: rs_read_char(inf,&direction); /* 5.2-command.c */
2172: rs_read_char(inf,&newcount); /* 5.2-command.c */
2173: rs_read_daemons(inf, d_list, 20); /* 5.2-daemon.c */
2174: rs_read_int(inf,&between); /* 5.2-daemons.c */
2175: rs_read(inf, lvl_mons, sizeof(lvl_mons)); /* 5.2-monsters.c */
2176: rs_read(inf, wand_mons, sizeof(wand_mons)); /* 5.2-monsters.c */
2177: rs_read_coord(inf, &nh); /* 5.2-move.c */
2178: rs_read_boolean(inf, &got_genocide); /* 5.2-things.c */
2179:
2180: if (proom == NULL)
2181: proom = roomin(&hero);
2182: for (mitem = mlist; mitem != NULL; mitem = mitem->l_next) {
2183: if (mitem->t_room == NULL)
2184: mitem->t_room = roomin(&(mitem->t_pos));
2185: }
2186:
2187: return(READSTAT);
2188: }