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