![[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 / xrogue|
Return to state.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 rubenllo 1: /*
2: state.c - Portable Rogue Save State Code
3:
4: Copyright (C) 2000 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: #define RSXR_STATS 0xABCD0001
32: #define RSXR_THING 0xABCD0002
33: #define RSXR_OBJECT 0xABCD0003
34: #define RSXR_MAGICITEMS 0xABCD0004
35: #define RSXR_KNOWS 0xABCD0005
36: #define RSXR_GUESSES 0xABCD0006
37: #define RSXR_OBJECTLIST 0xABCD0007
38: #define RSXR_BAGOBJECT 0xABCD0008
39: #define RSXR_MONSTERLIST 0xABCD0009
40: #define RSXR_MONSTERSTATS 0xABCD000A
41: #define RSXR_MONSTERS 0xABCD000B
42: #define RSXR_TRAP 0xABCD000C
43: #define RSXR_WINDOW 0xABCD000D
44: #define RSXR_DAEMONS 0xABCD000E
45: #define RSXR_IWEAPS 0xABCD000F
46: #define RSXR_IARMOR 0xABCD0010
47: #define RSXR_SPELLS 0xABCD0011
48: #define RSXR_ILIST 0xABCD0012
49: #define RSXR_HLIST 0xABCD0013
50: #define RSXR_DEATHTYPE 0xABCD0014
51: #define RSXR_CTYPES 0XABCD0015
52: #define RSXR_COORDLIST 0XABCD0016
53: #define RSXR_ROOMS 0XABCD0017
54:
55: #ifdef HAVE_CONFIG_H
56: #include "config.h"
57: #endif
58:
59: #if defined(_WIN32)
60: #include <Windows.h>
61: #include <Lmcons.h>
62: #include <shlobj.h>
63: #include <Shlwapi.h>
64: #undef MOUSE_MOVED
65: #elif defined(__DJGPP__)
66: #include <process.h>
67: #else
68: #include <pwd.h>
69: #include <sys/wait.h>
70: #include <sys/utsname.h>
71: #include <unistd.h>
72: #endif
73:
74: #include <stdlib.h>
75: #include <string.h>
76: #include <curses.h>
77: #include <sys/stat.h>
78: #include <stdio.h>
79: #include <stdarg.h>
80: #include <assert.h>
81: #include <fcntl.h>
82: #include <limits.h>
83: #include <time.h>
84: #include <signal.h>
85: #include "rogue.h"
86: #include "mach_dep.h"
87:
88: #if defined(_WIN32)
89: #include <process.h>
90: #endif
91:
92: #ifdef HAVE_ARPA_INET_H
93: #include <arpa/inet.h>
94: #endif
95:
96: int md_fileno(FILE *fp);
97:
98: #define READSTAT ((format_error == 0) && (read_error == 0))
99: #define WRITESTAT (write_error == 0)
100:
101: int read_error = FALSE;
102: int write_error = FALSE;
103: int format_error = FALSE;
104:
105: int save_debug = FALSE;
106: #define DBG(x) {if (save_debug) rsPrintf x;}
107:
108: bool rs_read_new_string(FILE *inf, char **s);
109: int find_list_ptr(struct linked_list *l, void *ptr);
110: bool rs_write_coord_list(FILE *savef, struct linked_list *l);
111: bool rs_read_coord_list(FILE *inf, struct linked_list **list);
112: int list_size(struct linked_list *l);
113: bool rs_write_object_list(FILE *savef, struct linked_list *l);
114: bool rs_read_object_list(FILE *inf, struct linked_list **list);
115:
116: int
117: rsPrintf(char *fmt, ...)
118: {
119: va_list ap;
120:
121: va_start(ap, fmt);
122: vfprintf(stderr,fmt, ap);
123: va_end(ap);
124:
125: return(0);
126: }
127:
128:
129: void *
130: get_list_item(struct linked_list *l, int i)
131: {
132: int count = 0;
133:
134: while(l != NULL)
135: {
136: if (count == i)
137: return(l->l_data);
138:
139: l = l->l_next;
140:
141: count++;
142: }
143:
144: return(NULL);
145: }
146:
147: bool
148: rs_write(FILE *savef, void *ptr, size_t size)
149: {
150: size_t i = 0;
151:
152: if (!write_error)
153: i = ENCWRITE(ptr,size,savef);
154: if (i != size)
155: write_error = TRUE;
156:
157: assert(write_error == 0);
158: return(WRITESTAT);
159: }
160:
161: int end_of_file = FALSE;
162:
163: bool
164: rs_read(FILE *inf, void *ptr, size_t size)
165: {
166: int actual;
167: end_of_file =FALSE;
168: if (!read_error && !format_error)
169: {
170: actual = ENCREAD(ptr, size, inf);
171:
172: if ((actual == 0) && (size != 0))
173: end_of_file = TRUE;
174: }
175:
176: if (read_error){
177: printf("read error has occurred. restore short-circuited.\n");abort();}
178: if (format_error)
179: {printf("game format invalid. restore short-circuited.\n");abort();}
180:
181: return(READSTAT);
182: }
183:
184: int big_endian = 0;
185:
186: bool
187: rs_write_uint(FILE *savef, unsigned int c)
188: {
189: char bytes[4];
190: char *buf = (char *) &c;
191:
192: if (big_endian)
193: {
194: bytes[3] = buf[0];
195: bytes[2] = buf[1];
196: bytes[1] = buf[2];
197: bytes[0] = buf[3];
198: buf = bytes;
199: }
200:
201: rs_write(savef, buf, 4);
202:
203: return(WRITESTAT);
204: }
205:
206: bool
207: rs_write_int(FILE *savef, int c)
208: {
209: char bytes[4];
210: char *buf = (char *) &c;
211:
212: if (big_endian)
213: {
214: bytes[3] = buf[0];
215: bytes[2] = buf[1];
216: bytes[1] = buf[2];
217: bytes[0] = buf[3];
218: buf = bytes;
219: }
220:
221: rs_write(savef, buf, 4);
222:
223: return(WRITESTAT);
224: }
225:
226: bool
227: rs_write_ulong(FILE *savef, unsigned long c)
228: {
229: unsigned int c2;
230: char bytes[4];
231: char *buf = (char *)&c;
232:
233: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
234: {
235: c2 = c;
236: buf = (char *) &c2;
237: }
238:
239: if (big_endian)
240: {
241: bytes[3] = buf[0];
242: bytes[2] = buf[1];
243: bytes[1] = buf[2];
244: bytes[0] = buf[3];
245: buf = bytes;
246: }
247:
248: rs_write(savef, buf, 4);
249:
250: return(WRITESTAT);
251: }
252:
253: bool
254: rs_write_long(FILE *savef, long c)
255: {
256: int c2;
257: char bytes[4];
258: char *buf = (char *)&c;
259:
260: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
261: {
262: c2 = c;
263: buf = (char *) &c2;
264: }
265:
266: if (big_endian)
267: {
268: bytes[3] = buf[0];
269: bytes[2] = buf[1];
270: bytes[1] = buf[2];
271: bytes[0] = buf[3];
272: buf = bytes;
273: }
274:
275: rs_write(savef, buf, 4);
276:
277: return(WRITESTAT);
278: }
279:
280: bool
281: rs_write_boolean(FILE *savef, bool c)
282: {
283: char buf;
284:
285: if (c == 0)
286: buf = 0;
287: else
288: buf = 1;
289:
290: rs_write(savef, &buf, 1);
291:
292: return(WRITESTAT);
293: }
294:
295: bool
296: rs_read_int(FILE *inf, int *i)
297: {
298: char bytes[4];
299: int input;
300: char *buf = (char *)&input;
301:
302: rs_read(inf, &input, 4);
303:
304: if (big_endian)
305: {
306: bytes[3] = buf[0];
307: bytes[2] = buf[1];
308: bytes[1] = buf[2];
309: bytes[0] = buf[3];
310: buf = bytes;
311: }
312:
313: *i = *((int *) buf);
314:
315: return(READSTAT);
316: }
317:
318: bool
319: rs_read_uint(FILE *inf, unsigned int *i)
320: {
321: char bytes[4];
322: int input;
323: char *buf = (char *)&input;
324:
325: rs_read(inf, &input, 4);
326:
327: if (big_endian)
328: {
329: bytes[3] = buf[0];
330: bytes[2] = buf[1];
331: bytes[1] = buf[2];
332: bytes[0] = buf[3];
333: buf = bytes;
334: }
335:
336: *i = *((int *) buf);
337:
338: return(READSTAT);
339: }
340:
341: bool
342: rs_read_ulong(FILE *inf, unsigned long *i)
343: {
344: char bytes[4];
345: unsigned long input;
346: char *buf = (char *) &input;
347:
348: rs_read(inf, &input, 4);
349:
350: if (big_endian)
351: {
352: bytes[3] = buf[0];
353: bytes[2] = buf[1];
354: bytes[1] = buf[2];
355: bytes[0] = buf[3];
356: buf = bytes;
357: }
358:
359: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
360: *i = *((unsigned int *) buf);
361: else
362: *i = *((unsigned long *) buf);
363: return(READSTAT);
364: }
365:
366: bool
367: rs_read_long(FILE *inf, long *i)
368: {
369: char bytes[4];
370: long input;
371: char *buf = (char *) &input;
372:
373: rs_read(inf, &input, 4);
374:
375: if (big_endian)
376: {
377: bytes[3] = buf[0];
378: bytes[2] = buf[1];
379: bytes[1] = buf[2];
380: bytes[0] = buf[3];
381: buf = bytes;
382: }
383:
384: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
385: *i = *((int *) buf);
386: else
387: *i = *((long *) buf);
388: return(READSTAT);
389: }
390:
391: bool
392: rs_read_boolean(FILE *inf, bool *i)
393: {
394: char buf;
395:
396: rs_read(inf, &buf, 1);
397:
398: *i = buf;
399:
400: return(READSTAT);
401: }
402:
403: bool
404: rs_write_ints(FILE *savef, int *c, int count)
405: {
406: int n=0;
407:
408: rs_write_int(savef,count);
409:
410: for(n=0;n<count;n++)
411: rs_write_int(savef,c[n]);
412:
413: return(WRITESTAT);
414: }
415:
416: bool
417: rs_write_short(FILE *savef, short c)
418: {
419: char bytes[2];
420: char *buf = (char *) &c;
421:
422: if (big_endian)
423: {
424: bytes[1] = buf[0];
425: bytes[0] = buf[1];
426: buf = bytes;
427: }
428:
429: rs_write(savef, buf, 2);
430:
431: return(WRITESTAT);
432: }
433:
434: bool
435: rs_read_short(FILE *inf, short *s)
436: {
437: char bytes[2];
438: short input;
439: char *buf = (char *)&input;
440:
441: rs_read(inf, &input, 2);
442:
443: if (big_endian)
444: {
445: bytes[1] = buf[0];
446: bytes[0] = buf[1];
447: buf = bytes;
448: }
449:
450: *s = *((short *) buf);
451: return(READSTAT);
452: }
453:
454:
455: bool
456: rs_write_shorts(FILE *savef, short *c, int count)
457: {
458: int n=0;
459:
460: rs_write_int(savef,count);
461:
462: for(n=0;n<count;n++)
463: rs_write_short(savef,c[n]);
464:
465: return(WRITESTAT);
466: }
467:
468: bool
469: rs_write_longs(FILE *savef, long *c, int count)
470: {
471: int n=0;
472:
473: rs_write_int(savef,count);
474:
475: for(n=0;n<count;n++)
476: rs_write_long(savef,c[n]);
477:
478: return(WRITESTAT);
479: }
480:
481: bool
482: rs_write_ulongs(FILE *savef, unsigned long *c, int count)
483: {
484: int n=0;
485:
486: rs_write_int(savef,count);
487:
488: for(n=0;n<count;n++)
489: rs_write_ulong(savef,c[n]);
490:
491: return(WRITESTAT);
492: }
493:
494: bool
495: rs_write_booleans(FILE *savef, bool *c, int count)
496: {
497: int n=0;
498:
499: rs_write_int(savef,count);
500:
501: for(n=0;n<count;n++)
502: rs_write_boolean(savef,c[n]);
503:
504: return(WRITESTAT);
505: }
506:
507: bool
508: rs_read_ints(FILE *inf, int *i, int count)
509: {
510: int n=0,value=0;
511:
512: if (rs_read_int(inf,&value) != 0)
513: {
514: if (value != count)
515: format_error = TRUE;
516: else
517: {
518: for(n=0;n<value;n++)
519: rs_read_int(inf, &i[n]);
520: }
521: }
522:
523: return(READSTAT);
524: }
525:
526: bool
527: rs_read_shorts(FILE *inf, short *i, int count)
528: {
529: int n=0,value=0;
530:
531: if (rs_read_int(inf,&value) != 0)
532: {
533: if (value != count)
534: format_error = TRUE;
535: else
536: {
537: for(n=0;n<value;n++)
538: rs_read_short(inf, &i[n]);
539: }
540: }
541:
542: return(READSTAT);
543: }
544:
545: bool
546: rs_read_longs(FILE *inf, long *i, int count)
547: {
548: int n=0,value=0;
549:
550: if (rs_read_int(inf,&value) != 0)
551: {
552: if (value != count)
553: format_error = TRUE;
554: else
555: {
556: for(n=0;n<value;n++)
557: rs_read_long(inf, &i[n]);
558: }
559: }
560:
561: return(READSTAT);
562: }
563:
564: bool
565: rs_read_ulongs(FILE *inf, unsigned long *i, int count)
566: {
567: int n=0,value=0;
568:
569: if (rs_read_int(inf,&value) != 0)
570: {
571: if (value != count)
572: format_error = TRUE;
573: else
574: {
575: for(n=0;n<value;n++)
576: rs_read_ulong(inf, &i[n]);
577: }
578: }
579:
580: return(READSTAT);
581: }
582:
583: bool
584: rs_read_booleans(FILE *inf, bool *i, int count)
585: {
586: int n=0,value=0;
587:
588: if (rs_read_int(inf,&value) != 0)
589: {
590: if (value != count)
591: format_error = TRUE;
592: else
593: {
594: for(n=0;n<value;n++)
595: rs_read_boolean(inf, &i[n]);
596: }
597: }
598:
599: return(READSTAT);
600: }
601:
602: bool
603: rs_write_levtype(FILE *savef, LEVTYPE c)
604: {
605: int lt;
606:
607: switch(c)
608: {
609: case NORMLEV: lt = 1; break;
610: case POSTLEV: lt = 2; break;
611: case MAZELEV: lt = 3; break;
612: case OUTSIDE: lt = 4; break;
613: case STARTLEV: lt = 5; break;
614: default: lt = -1; break;
615: }
616:
617: rs_write_int(savef,lt);
618:
619: return(WRITESTAT);
620: }
621:
622: bool
623: rs_read_levtype(FILE *inf, LEVTYPE *l)
624: {
625: int lt;
626:
627: rs_read_int(inf, <);
628:
629: switch(lt)
630: {
631: case 1: *l = NORMLEV; break;
632: case 2: *l = POSTLEV; break;
633: case 3: *l = MAZELEV; break;
634: case 4: *l = OUTSIDE; break;
635: case 5: *l = STARTLEV; break;
636: default: *l = NORMLEV; break;
637: }
638:
639: return(READSTAT);
640: }
641:
642: bool
643: rs_write_char(FILE *savef, char c)
644: {
645: rs_write(savef, &c, 1);
646: DBG(("%c",c));
647:
648: return(WRITESTAT);
649: }
650:
651: bool
652: rs_read_char(FILE *inf, char *c)
653: {
654: rs_read(inf, c, 1);
655:
656: return(READSTAT);
657: }
658:
659: bool
660: rs_write_uchar(FILE *savef, unsigned char c)
661: {
662: rs_write(savef, &c, 1);
663: DBG(("%c",c));
664:
665: return(WRITESTAT);
666: }
667:
668: bool
669: rs_read_uchar(FILE *inf, unsigned char *c)
670: {
671: rs_read(inf, c, 1);
672:
673: return(READSTAT);
674: }
675:
676: bool
677: rs_write_string(FILE *savef, char *s)
678: {
679: int len = 0;
680:
681: len = (s == NULL) ? 0 : (int) strlen(s) + 1;
682:
683: rs_write_uint(savef, (unsigned int) len);
684: rs_write(savef, s, len);
685:
686: return(WRITESTAT);
687: }
688:
689: bool
690: rs_read_string_index(FILE *inf, struct words master[], int maxindex, char **str)
691: {
692: int i;
693:
694: if (rs_read_int(inf,&i) != 0)
695: {
696: if (i > maxindex)
697: {
698: printf("String index is out of range. %d > %d\n",
699: i, maxindex);
700: printf("Sorry, invalid save game format\n");
701: format_error = TRUE;
702: }
703: else if (i >= 0)
704: *str = master[i].w_string;
705: else
706: *str = NULL;
707: }
708: return(READSTAT);
709: }
710:
711: bool
712: rs_write_string_index(FILE *savef, struct words master[], int maxindex, char *str)
713: {
714: int i;
715:
716: for(i = 0; i < maxindex; i++)
717: {
718: if (str == master[i].w_string)
719: {
720: rs_write_int(savef,i);
721: return(WRITESTAT);
722: }
723: }
724:
725: rs_write_int(savef,-1);
726: return(WRITESTAT);
727: }
728:
729: bool
730: rs_read_scrolls(FILE *inf)
731: {
732: int i;
733:
734: for(i = 0; i < MAXSCROLLS; i++)
735: {
736: rs_read_new_string(inf,&s_names[i]);
737: rs_read_boolean(inf,&s_know[i]);
738: rs_read_new_string(inf,&s_guess[i]);
739: }
740:
741: return(READSTAT);
742: }
743:
744: bool
745: rs_write_scrolls(FILE *savef)
746: {
747: int i;
748:
749: for(i = 0; i < MAXSCROLLS; i++)
750: {
751: rs_write_string(savef,s_names[i]);
752: rs_write_boolean(savef,s_know[i]);
753: rs_write_string(savef,s_guess[i]);
754: }
755: return(WRITESTAT);
756: }
757:
758: bool
759: rs_read_potions(FILE *inf)
760: {
761: int i;
762:
763: for(i = 0; i < MAXPOTIONS; i++)
764: {
765: rs_read_string_index(inf,rainbow,NCOLORS,&p_colors[i]);
766: rs_read_boolean(inf,&p_know[i]);
767: rs_read_new_string(inf,&p_guess[i]);
768: }
769:
770: return(READSTAT);
771: }
772:
773: bool
774: rs_write_potions(FILE *savef)
775: {
776: int i;
777:
778: for(i = 0; i < MAXPOTIONS; i++)
779: {
780: rs_write_string_index(savef,rainbow,NCOLORS,p_colors[i]);
781: rs_write_boolean(savef,p_know[i]);
782: rs_write_string(savef,p_guess[i]);
783: }
784:
785: return(WRITESTAT);
786: }
787:
788: bool
789: rs_read_rings(FILE *inf)
790: {
791: int i;
792:
793: for(i = 0; i < MAXRINGS; i++)
794: {
795: rs_read_string_index(inf,stones,NSTONES,&r_stones[i]);
796: rs_read_boolean(inf,&r_know[i]);
797: rs_read_new_string(inf,&r_guess[i]);
798: }
799:
800: return(READSTAT);
801: }
802:
803: bool
804: rs_write_rings(FILE *savef)
805: {
806: int i;
807:
808: for(i = 0; i < MAXRINGS; i++)
809: {
810: rs_write_string_index(savef,stones,NSTONES,r_stones[i]);
811: rs_write_boolean(savef,r_know[i]);
812: rs_write_string(savef,r_guess[i]);
813: }
814:
815: return(WRITESTAT);
816: }
817:
818: bool
819: rs_read_misc(FILE *inf)
820: {
821: int i;
822:
823: for(i = 0; i < MAXMM; i++)
824: {
825: rs_read_boolean(inf,&m_know[i]);
826: rs_read_new_string(inf,&m_guess[i]);
827: }
828:
829: return(READSTAT);
830: }
831:
832: bool
833: rs_write_misc(FILE *savef)
834: {
835: int i;
836:
837: for(i = 0; i < MAXMM; i++)
838: {
839: rs_write_boolean(savef,m_know[i]);
840: rs_write_string(savef,m_guess[i]);
841: }
842:
843: return(WRITESTAT);
844: }
845:
846: bool
847: rs_write_sticks(FILE *savef)
848: {
849: int i;
850:
851: for (i = 0; i < MAXSTICKS; i++)
852: {
853: if (strcmp(ws_type[i],"staff") == 0)
854: {
855: rs_write_int(savef,0);
856: rs_write_string_index(savef, wood, NWOOD, ws_made[i]);
857: }
858: else
859: {
860: rs_write_int(savef,1);
861: rs_write_string_index(savef, metal, NMETAL, ws_made[i]);
862: }
863: rs_write_boolean(savef, ws_know[i]);
864: rs_write_string(savef, ws_guess[i]);
865: }
866:
867: return(WRITESTAT);
868: }
869:
870: bool
871: rs_read_sticks(FILE *inf)
872: {
873: int i = 0, list = 0;
874:
875: for(i = 0; i < MAXSTICKS; i++)
876: {
877: rs_read_int(inf,&list);
878: if (list == 0)
879: {
880: rs_read_string_index(inf,wood,NWOOD,&ws_made[i]);
881: ws_type[i] = "staff";
882: }
883: else
884: {
885: rs_read_string_index(inf,metal,NMETAL,&ws_made[i]);
886: ws_type[i] = "wand";
887: }
888: rs_read_boolean(inf, &ws_know[i]);
889: rs_read_new_string(inf, &ws_guess[i]);
890: }
891:
892: return(READSTAT);
893: }
894:
895: bool
896: rs_read_string(FILE *inf, char *s, int max)
897: {
898: int len = 0;
899:
900: if (rs_read_int(inf, &len) != FALSE)
901: {
902: if (len > max)
903: {
904: printf("String too long to restore. %d > %d\n",len,max);
905: printf("Sorry, invalid save game format\n");
906: format_error = TRUE;
907: }
908:
909: rs_read(inf, s, len);
910: }
911:
912: return(READSTAT);
913: }
914:
915: bool
916: rs_read_new_string(FILE *inf, char **s)
917: {
918: int len=0;
919: char *buf=0;
920:
921: if (rs_read_int(inf, &len) != 0)
922: {
923: if (len == 0)
924: *s = NULL;
925: else
926: {
927: buf = malloc(len);
928:
929: if (buf == NULL)
930: read_error = TRUE;
931: else
932: {
933: rs_read(inf, buf, len);
934: *s = buf;
935: }
936: }
937: }
938:
939: return(READSTAT);
940: }
941:
942: bool
943: rs_write_strings(FILE *savef, char *s[], int count)
944: {
945: int len = 0;
946: int n = 0;
947:
948: rs_write_int(savef,count);
949:
950: for(n = 0; n < count; n++)
951: {
952: len = (s[n] == NULL) ? 0L : (int) strlen(s[n]) + 1;
953: rs_write_int(savef, len);
954: rs_write(savef, s[n], len);
955: DBG(("%s",s[n]));
956: }
957:
958: return(WRITESTAT);
959: }
960:
961: bool
962: rs_write_words(FILE *savef, struct words *w, int count)
963: {
964: int n = 0;
965:
966: rs_write_int(savef,count);
967:
968: for(n = 0; n < count; n++)
969: {
970: rs_write(savef, w[n].w_string, sizeof(w[n].w_string));
971: DBG(("%s",w[n].w_string));
972: }
973:
974: return(WRITESTAT);
975: }
976:
977: bool
978: rs_read_words(FILE *inf, struct words *w, int count)
979: {
980: int n = 0;
981: int value = 0;
982:
983: rs_read_int(inf,&value);
984:
985: if (value != count)
986: {
987: printf("Incorrect number of words in block. %d != %d.",
988: value,count);
989: printf("Sorry, invalid save game format");
990: format_error = TRUE;
991: }
992: else for(n = 0; n < count; n++)
993: {
994: rs_read(inf, w[n].w_string, sizeof(w[n].w_string));
995: }
996:
997: return(READSTAT);
998: }
999:
1000: bool
1001: rs_read_new_strings(FILE *inf, char **s, int count)
1002: {
1003: int len = 0;
1004: int n = 0;
1005: int value = 0;
1006:
1007: if (rs_read_int(inf,&value) != 0)
1008: {
1009: if (value != count)
1010: {
1011: printf("Incorrect number of strings in block. %d > %d.",
1012: value,count);
1013: printf("Sorry, invalid save game format");
1014: format_error = TRUE;
1015: }
1016: else
1017: for(n=0; n<value; n++)
1018: {
1019: rs_read_int(inf, &len);
1020:
1021: if (len == 0)
1022: s[n]=0;
1023: else
1024: {
1025: s[n] = malloc(len);
1026: rs_read(inf,s[n],len);
1027: }
1028: }
1029: }
1030:
1031: return(READSTAT);
1032: }
1033:
1034: bool
1035: rs_write_coord(FILE *savef, coord *c)
1036: {
1037: DBG(("X ="));
1038: rs_write_int(savef, c->x);
1039: DBG(("Y ="));
1040: rs_write_int(savef, c->y);
1041:
1042: return(WRITESTAT);
1043: }
1044:
1045: bool
1046: rs_read_coord(FILE *inf, coord *c)
1047: {
1048: rs_read_int(inf,&c->x);
1049: rs_read_int(inf,&c->y);
1050:
1051: return(READSTAT);
1052: }
1053:
1054: /* Assigns a number to an alchemy jug associated with a fuse, so it can be
1055: * found and reassociated when restoring.
1056: * 1 - 31: slot in pack
1057: * 32+ : on floor
1058: * Hopefully monsters do not pick them up.
1059: */
1060: int number_alchemy_jug(struct object *obj) {
1061: struct object *tobj = NULL;
1062: struct linked_list *item;
1063: int i = 1;
1064: for (item = pack; item != NULL; item = next(item), i++) {
1065: tobj = OBJPTR(item);
1066: if (tobj == obj &&
1067: tobj->o_type == MM &&
1068: tobj->o_which== MM_JUG)
1069: break;
1070: }
1071: if (item == NULL) {
1072: for (item = lvl_obj, i = 32; item != NULL; item = next(item), i++) {
1073: tobj = OBJPTR(item);
1074: if (tobj == obj &&
1075: tobj->o_type == MM &&
1076: tobj->o_which== MM_JUG)
1077: break;
1078: }
1079: }
1080: if (item == NULL)
1081: return 0;
1082: return i;
1083: }
1084:
1085: /* Takes an alchemy jug number and tracks down the object. */
1086: struct object *find_alchemy_jug(int n) {
1087: struct object *tobj;
1088: struct linked_list *item;
1089:
1090: if (n <= 0) {
1091: return NULL;
1092: }
1093: else if (n < 32) {
1094: item = pack;
1095: n -= 1;
1096: }
1097: else if (n < 1024) {
1098: item = lvl_obj;
1099: n -= 32;
1100: }
1101: else {
1102: /* This is likely a bug, not 1024 actual items on the floor. */
1103: return NULL;
1104: }
1105: while (item != NULL && n > 0) {
1106: item = next(item);
1107: n--;
1108: }
1109: if (item == NULL)
1110: return NULL;
1111: tobj = OBJPTR(item);
1112: if (tobj->o_type != MM || tobj->o_which != MM_JUG)
1113: return NULL;
1114: return tobj;
1115: }
1116:
1117: bool
1118: rs_write_daemons(FILE *savef, struct delayed_action *d_list,int count)
1119: {
1120: int i = 0;
1121: int func = 0;
1122:
1123: DBG(("Daemons\n"));
1124: rs_write_int(savef, RSXR_DAEMONS);
1125: rs_write_int(savef, count);
1126:
1127: for(i=0; i < count; i++)
1128: {
1129: if (d_list[i].d_func == rollwand)
1130: func = 1;
1131: else if (d_list[i].d_func == doctor)
1132: func = 2;
1133: else if (d_list[i].d_func == stomach)
1134: func = 3;
1135: else if (d_list[i].d_func == trap_look)
1136: func = 4;
1137: else if (d_list[i].d_func == eat_gold)
1138: func = 5;
1139: else if (d_list[i].d_func == ring_search)
1140: func = 6;
1141: else if (d_list[i].d_func == ring_teleport)
1142: func = 7;
1143: else if (d_list[i].d_func == fumble)
1144: func = 8;
1145: else if (d_list[i].d_func == strangle)
1146: func = 9;
1147: else if (d_list[i].d_func == unconfuse)
1148: func = 10;
1149: else if (d_list[i].d_func == swander)
1150: func = 11;
1151: else if (d_list[i].d_func == spell_recovery)
1152: func = 12;
1153: else if (d_list[i].d_func == chant_recovery)
1154: func = 13;
1155: else if (d_list[i].d_func == prayer_recovery)
1156: func = 14;
1157: else if (d_list[i].d_func == cure_disease)
1158: func = 15;
1159: else if (d_list[i].d_func == unstink)
1160: func = 16;
1161: else if (d_list[i].d_func == res_strength)
1162: func = 17;
1163: else if (d_list[i].d_func == undance)
1164: func = 18;
1165: else if (d_list[i].d_func == suffocate)
1166: func = 19;
1167: else if (d_list[i].d_func == wghtchk)
1168: func = 20;
1169: else if (d_list[i].d_func == dust_appear)
1170: func = 21;
1171: else if (d_list[i].d_func == unchoke)
1172: func = 22;
1173: else if (d_list[i].d_func == sight)
1174: func = 23;
1175: else if (d_list[i].d_func == changeclass)
1176: func = 24;
1177: else if (d_list[i].d_func == cloak_charge)
1178: func = 25;
1179: else if (d_list[i].d_func == quill_charge)
1180: func = 26;
1181: else if (d_list[i].d_func == nohaste)
1182: func = 27;
1183: else if (d_list[i].d_func == noslow)
1184: func = 28;
1185: else if (d_list[i].d_func == unclrhead)
1186: func = 29;
1187: else if (d_list[i].d_func == unsee)
1188: func = 30;
1189: else if (d_list[i].d_func == unphase)
1190: func = 31;
1191: else if (d_list[i].d_func == land)
1192: func = 32;
1193: else if (d_list[i].d_func == appear)
1194: func = 33;
1195: else if (d_list[i].d_func == unskill)
1196: func = 34;
1197: else if (d_list[i].d_func == nofire)
1198: func = 35;
1199: else if (d_list[i].d_func == nocold)
1200: func = 36;
1201: else if (d_list[i].d_func == nobolt)
1202: func = 37;
1203: else if (d_list[i].d_func == alchemy)
1204: func = 38;
1205: else if (d_list[i].d_func == NULL)
1206: func = 0;
1207: else
1208: func = -1;
1209:
1210: rs_write_int(savef, d_list[i].d_type);
1211: rs_write_int(savef, func);
1212:
1213: if (d_list[i].d_func == doctor)
1214: rs_write_int(savef, 1);
1215: else if (d_list[i].d_func == eat_gold)
1216: {
1217: int index;
1218: index = find_list_ptr(player.t_pack,d_list[i].d_arg.vp);
1219: rs_write_int(savef,index);
1220: }
1221: else if (d_list[i].d_func == changeclass)
1222: {
1223: rs_write_int(savef, d_list[i].d_arg.i);
1224: }
1225: else if (d_list[i].d_func == cloak_charge)
1226: {
1227: int index;
1228: index = find_list_ptr(player.t_pack,d_list[i].d_arg.vp);
1229: rs_write_int(savef,index);
1230: }
1231: else if (d_list[i].d_func == alchemy)
1232: {
1233: rs_write_int(savef, number_alchemy_jug((void *) d_list[i].d_arg.vp));
1234: }
1235: else
1236: rs_write_int(savef, d_list[i].d_arg.i);
1237:
1238: rs_write_int(savef, d_list[i].d_time);
1239: }
1240:
1241: return(WRITESTAT);
1242: }
1243:
1244: bool
1245: rs_read_daemons(FILE *inf, struct delayed_action *d_list, int count)
1246: {
1247: int i = 0;
1248: int func = 0;
1249: int value = 0;
1250: int id = 0;
1251: int dummy = 0;
1252:
1253: if (d_list == NULL)
1254: printf("HELP THERE ARE NO DAEMONS\n");
1255:
1256: if (rs_read_int(inf, &id) != 0)
1257: {
1258: if (id != RSXR_DAEMONS)
1259: {
1260: printf("Invalid id. %x != %x(RSXR_DAEMONS)\n",
1261: id,RSXR_DAEMONS);
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 daemons in block. %d > %d.",
1270: value,count);
1271: printf("Sorry, invalid save game format");
1272: format_error = TRUE;
1273: }
1274: else
1275: {
1276: for(i=0; i < value; i++)
1277: {
1278: func = 0;
1279: rs_read_int(inf, &d_list[i].d_type);
1280: rs_read_int(inf, &func);
1281:
1282: switch(func)
1283: {
1284: case 1: d_list[i].d_func = rollwand;
1285: break;
1286: case 2: d_list[i].d_func = doctor;
1287: break;
1288: case 3: d_list[i].d_func = stomach;
1289: break;
1290: case 4: d_list[i].d_func = trap_look;
1291: break;
1292: case 5: d_list[i].d_func = eat_gold;
1293: break;
1294: case 6: d_list[i].d_func = ring_search;
1295: break;
1296: case 7: d_list[i].d_func = ring_teleport;
1297: break;
1298: case 8: d_list[i].d_func = fumble;
1299: break;
1300: case 9: d_list[i].d_func = strangle;
1301: break;
1302: case 10: d_list[i].d_func = unconfuse;
1303: break;
1304: case 11: d_list[i].d_func = swander;
1305: break;
1306: case 12: d_list[i].d_func = spell_recovery;
1307: break;
1308: case 13: d_list[i].d_func = chant_recovery;
1309: break;
1310: case 14: d_list[i].d_func = prayer_recovery;
1311: break;
1312: case 15: d_list[i].d_func = cure_disease;
1313: break;
1314: case 16: d_list[i].d_func = unstink;
1315: break;
1316: case 17: d_list[i].d_func = res_strength;
1317: break;
1318: case 18: d_list[i].d_func = undance;
1319: break;
1320: case 19: d_list[i].d_func = suffocate;
1321: break;
1322: case 20: d_list[i].d_func = wghtchk;
1323: break;
1324: case 21: d_list[i].d_func = dust_appear;
1325: break;
1326: case 22: d_list[i].d_func = unchoke;
1327: break;
1328: case 23: d_list[i].d_func = sight;
1329: break;
1330: case 24: d_list[i].d_func = changeclass;
1331: break;
1332: case 25: d_list[i].d_func = cloak_charge;
1333: break;
1334: case 26: d_list[i].d_func = quill_charge;
1335: break;
1336: case 27: d_list[i].d_func = nohaste;
1337: break;
1338: case 28: d_list[i].d_func = noslow;
1339: break;
1340: case 29: d_list[i].d_func = unclrhead;
1341: break;
1342: case 30: d_list[i].d_func = unsee;
1343: break;
1344: case 31: d_list[i].d_func = unphase;
1345: break;
1346: case 32: d_list[i].d_func = land;
1347: break;
1348: case 33: d_list[i].d_func = appear;
1349: break;
1350: case 34: d_list[i].d_func = unskill;
1351: break;
1352: case 35: d_list[i].d_func = nofire;
1353: break;
1354: case 36: d_list[i].d_func = nocold;
1355: break;
1356: case 37: d_list[i].d_func = nobolt;
1357: break;
1358: case 38: d_list[i].d_func = alchemy;
1359: break;
1360: case 0:
1361: case -1:
1362: default: d_list[i].d_func = NULL;
1363: break;
1364: }
1365:
1366: if (d_list[i].d_func == doctor)
1367: {
1368: rs_read_int(inf, &dummy);
1369: d_list[i].d_arg.vp = (void *)&player;
1370: }
1371: else if (d_list[i].d_func == eat_gold)
1372: {
1373: rs_read_int(inf, &dummy);
1374: d_list[i].d_arg.vp = get_list_item(player.t_pack,dummy);
1375: if (d_list[i].d_arg.vp == NULL)
1376: d_list[i].d_type = 0;
1377: }
1378: else if (d_list[i].d_func == changeclass)
1379: {
1380: rs_read_int(inf, &d_list[i].d_arg.i);
1381: }
1382: else if (d_list[i].d_func == cloak_charge)
1383: {
1384: rs_read_int(inf, &dummy);
1385: d_list[i].d_arg.vp = get_list_item(player.t_pack,dummy);
1386: if (d_list[i].d_arg.vp == NULL)
1387: d_list[i].d_type = 0;
1388: }
1389: else if (d_list[i].d_func == alchemy)
1390: {
1391: rs_read_int(inf, &dummy);
1392: d_list[i].d_arg.vp = (void *) find_alchemy_jug(dummy);
1393: if (d_list[i].d_arg.vp == NULL)
1394: d_list[i].d_type = 0;
1395: }
1396: else
1397: rs_read_int(inf, &d_list[i].d_arg.i);
1398:
1399: rs_read_int(inf, &d_list[i].d_time);
1400:
1401: if (d_list[i].d_func == NULL)
1402: {
1403: d_list[i].d_time = 0;
1404: d_list[i].d_arg.vp = NULL;
1405: d_list[i].d_type = 0;
1406: }
1407:
1408: }
1409: }
1410: }
1411: }
1412:
1413: return(READSTAT);
1414: }
1415:
1416: bool
1417: rs_write_rooms(FILE *savef, struct room r[], int count)
1418: {
1419: int n = 0,i = -1;
1420: struct linked_list *l;
1421:
1422: DBG(("Rooms\n"));
1423: rs_write_int(savef, RSXR_ROOMS);
1424: rs_write_int(savef, count);
1425:
1426: for(n=0; n<count; n++)
1427: {
1428: rs_write_coord(savef, &r[n].r_pos);
1429: rs_write_coord(savef, &r[n].r_max);
1430: rs_write_long(savef, r[n].r_flags);
1431: rs_write_coord_list(savef, r[n].r_exit);
1432:
1433: l = r[n].r_fires;
1434: i = list_size(l);
1435:
1436: rs_write_int(savef, i);
1437:
1438: if (i >0)
1439: while (l != NULL)
1440: {
1441: i = find_list_ptr(mlist,l->l_data);
1442: rs_write_int(savef,i);
1443: l = l->l_next;
1444: }
1445: }
1446: return(WRITESTAT);
1447: }
1448:
1449: bool
1450: rs_read_rooms(FILE *inf, struct room *r, int count)
1451: {
1452: int value = 0, n = 0, i = 0, index = 0, id = 0;
1453: struct linked_list *fires=NULL, *item = NULL;
1454:
1455: if (rs_read_int(inf,&id) != 0)
1456: {
1457: if (id != RSXR_ROOMS)
1458: {
1459: printf("Invalid id. %x != %x(RSXR_ROOMS)\n",
1460: id,RSXR_ROOMS);
1461: printf("Sorry, invalid save game format");
1462: format_error = TRUE;
1463: }
1464: else if (rs_read_int(inf,&value) != 0)
1465: {
1466: if (value != count)
1467: {
1468: printf("Incorrect number of rooms in block. %d > %d.",
1469: value,count);
1470: printf("Sorry, invalid save game format");
1471: format_error = TRUE;
1472: }
1473: else
1474: {
1475: for(n=0; n<value; n++)
1476: {
1477: rs_read_coord(inf,&r[n].r_pos);
1478: rs_read_coord(inf,&r[n].r_max);
1479: rs_read_long(inf,&r[n].r_flags);
1480: rs_read_coord_list(inf, &r[n].r_exit);
1481:
1482: rs_read_int(inf, &i);
1483: fires = NULL;
1484: while (i>0)
1485: {
1486: rs_read_int(inf,&index);
1487:
1488: if (index >= 0)
1489: {
1490: void *data;
1491: data = get_list_item(mlist,index);
1492: item = creat_item();
1493: item->l_data = data;
1494: if (fires == NULL)
1495: fires = item;
1496: else
1497: attach(fires,item);
1498: }
1499: i--;
1500: }
1501: r[n].r_fires=fires;
1502: }
1503: }
1504: }
1505: }
1506:
1507: return(READSTAT);
1508: }
1509:
1510: bool
1511: rs_write_object(FILE *savef, struct object *o)
1512: {
1513: rs_write_int(savef, RSXR_OBJECT);
1514: rs_write_int(savef, o->o_type);
1515: rs_write_coord(savef, &o->o_pos);
1516: rs_write_char(savef, o->o_launch);
1517: rs_write(savef, o->o_damage, sizeof(o->o_damage));
1518: rs_write(savef, o->o_hurldmg, sizeof(o->o_hurldmg));
1519: rs_write_int(savef, o->o_count);
1520: rs_write_int(savef, o->o_which);
1521: rs_write_int(savef, o->o_hplus);
1522: rs_write_int(savef, o->o_dplus);
1523: rs_write_int(savef, o->o_ac);
1524: rs_write_long(savef, o->o_flags);
1525: rs_write_int(savef, o->o_group);
1526: rs_write_int(savef, o->o_weight);
1527: rs_write(savef, o->o_mark, MARKLEN);
1528:
1529: DBG(("Object\n"));
1530: DBG((" SaveID : %X\n",RSXR_OBJECT));
1531: DBG((" Type : %d\n",o->o_type));
1532: DBG((" Pos : %d %d\n",o->o_pos.x,o->o_pos.y));
1533: DBG((" Launch : %c\n",o->o_launch));
1534: DBG((" Damage : %s\n",o->o_damage));
1535: DBG((" Hurl : %s\n",o->o_hurldmg));
1536: DBG((" Count : %d\n",o->o_count));
1537: DBG((" Which : %d\n",o->o_which));
1538: DBG((" HPlus : %d\n",o->o_hplus));
1539: DBG((" DPlus : %d\n",o->o_dplus));
1540: DBG((" AC : %d\n",o->o_ac));
1541: DBG((" Flags : %X\n",o->o_flags));
1542: DBG((" Group : %d\n",o->o_group));
1543: DBG((" Weight : %d\n",o->o_weight));
1544: DBG((" Mark : %s\n",o->o_mark));
1545: if (o->contents == NULL)
1546: {
1547: DBG((" Contents: None\n"));
1548: }
1549: else
1550: {
1551: DBG((" CONTENTS\n"));
1552: }
1553:
1554: rs_write_object_list(savef, o->contents);
1555:
1556: if (o->contents != NULL)
1557: DBG((" END_CONTENTS\n"));
1558:
1559: return(WRITESTAT);
1560: }
1561:
1562: bool
1563: rs_read_object(FILE *inf, struct object *o)
1564: {
1565: int id;
1566:
1567: if (rs_read_int(inf, &id) != 0)
1568: {
1569: if (id != RSXR_OBJECT)
1570: {
1571: printf("Invalid id. %x != %x(RSXR_OBJECT)\n", id,RSXR_OBJECT);
1572: printf("Sorry, invalid save game format");
1573: format_error = TRUE;
1574: }
1575: else
1576: {
1577: rs_read_int(inf, &o->o_type);
1578: rs_read_coord(inf, &o->o_pos);
1579: rs_read_char(inf, &o->o_launch);
1580: rs_read(inf, o->o_damage,sizeof(o->o_damage));
1581: rs_read(inf, o->o_hurldmg,sizeof(o->o_hurldmg));
1582: rs_read_int(inf, &o->o_count);
1583: rs_read_int(inf, &o->o_which);
1584: rs_read_int(inf, &o->o_hplus);
1585: rs_read_int(inf, &o->o_dplus);
1586: rs_read_int(inf,&o->o_ac);
1587: rs_read_long(inf,&o->o_flags);
1588: rs_read_int(inf,&o->o_group);
1589: rs_read_int(inf, &o->o_weight);
1590: rs_read(inf, o->o_mark, MARKLEN);
1591: rs_read_object_list(inf,&o->contents);
1592:
1593: }
1594: }
1595:
1596: return(READSTAT);
1597: }
1598:
1599: bool
1600: rs_write_stats(FILE *savef, struct stats *s)
1601: {
1602: DBG(("Stats\n"));
1603: rs_write_int(savef, RSXR_STATS);
1604:
1605: rs_write_short(savef, s->s_str);
1606: rs_write_short(savef, s->s_intel);
1607: rs_write_short(savef, s->s_wisdom);
1608: rs_write_short(savef, s->s_dext);
1609: rs_write_short(savef, s->s_const);
1610: rs_write_short(savef, s->s_charisma);
1611: rs_write_ulong(savef, s->s_exp);
1612: rs_write_int(savef, s->s_lvladj);
1613: rs_write_int(savef, s->s_lvl);
1614: rs_write_int(savef, s->s_arm);
1615: rs_write_int(savef, s->s_hpt);
1616: rs_write_int(savef, s->s_pack);
1617: rs_write_int(savef, s->s_carry);
1618: rs_write(savef, s->s_dmg, sizeof(s->s_dmg));
1619:
1620: return(WRITESTAT);
1621: }
1622:
1623: bool
1624: rs_read_stats(FILE *inf, struct stats *s)
1625: {
1626: int id;
1627:
1628: if (rs_read_int(inf, &id) != 0)
1629: {
1630: if (id != RSXR_STATS)
1631: {
1632: printf("Invalid id. %x != %x(RSXR_STATS)\n", id,RSXR_STATS);
1633: printf("Sorry, invalid save game format");
1634: format_error = TRUE;
1635: }
1636: else
1637: {
1638: rs_read_short(inf,&s->s_str);
1639: rs_read_short(inf,&s->s_intel);
1640: rs_read_short(inf,&s->s_wisdom);
1641: rs_read_short(inf,&s->s_dext);
1642: rs_read_short(inf,&s->s_const);
1643: rs_read_short(inf,&s->s_charisma);
1644: rs_read_ulong(inf,&s->s_exp);
1645: rs_read_int(inf,&s->s_lvladj);
1646: rs_read_int(inf,&s->s_lvl);
1647: rs_read_int(inf,&s->s_arm);
1648: rs_read_int(inf,&s->s_hpt);
1649: rs_read_int(inf,&s->s_pack);
1650: rs_read_int(inf,&s->s_carry);
1651: rs_read(inf,s->s_dmg,sizeof(s->s_dmg));
1652: }
1653: }
1654:
1655: return(READSTAT);
1656: }
1657:
1658: bool
1659: rs_write_mstats(FILE *savef, struct mstats *s)
1660: {
1661: DBG(("M-Stats\n"));
1662: rs_write_int(savef, RSXR_STATS);
1663: rs_write_short(savef, s->ms_str);
1664: /*printf(" Strength: %d\n",s->ms_str);*/
1665: rs_write_short(savef, s->ms_dex);
1666: rs_write_short(savef, s->ms_move);
1667: rs_write_ulong(savef, s->ms_exp);
1668: rs_write_short(savef, s->ms_lvl);
1669: rs_write_short(savef, s->ms_arm);
1670: rs_write(savef, s->ms_hpt, sizeof(s->ms_hpt));
1671: rs_write(savef, s->ms_dmg, sizeof(s->ms_dmg));
1672: /*printf(" Damage: %s\n",s->ms_dmg);*/
1673:
1674: return(WRITESTAT);
1675: }
1676:
1677: bool
1678: rs_read_mstats(FILE *inf, struct mstats *s)
1679: {
1680: int id;
1681:
1682: if (rs_read_int(inf, &id) != 0)
1683: {
1684: if (id != RSXR_STATS)
1685: {
1686: printf("Invalid id. %x != %x(RSXR_STATS)\n", id,RSXR_STATS);
1687: printf("Sorry, invalid save game format");
1688: format_error = TRUE;
1689: }
1690: else
1691: {
1692: rs_read_short(inf,&s->ms_str);
1693: /*printf(" Strength: %d\n",s->ms_str);*/
1694: rs_read_short(inf,&s->ms_dex);
1695: /*printf(" Dexterity: %d\n",s->ms_dex);*/
1696: rs_read_short(inf,&s->ms_move);
1697: /*printf(" Moves: %d\n",s->ms_move);*/
1698: rs_read_ulong(inf,&s->ms_exp);
1699: /*printf(" Experience: %d\n",s->ms_exp);*/
1700: rs_read_short(inf,&s->ms_lvl);
1701: /*printf(" Level: %d\n",s->ms_lvl);*/
1702: rs_read_short(inf,&s->ms_arm);
1703: /*printf(" Armor: %d\n",s->ms_arm);*/
1704: rs_read(inf,s->ms_hpt,sizeof(s->ms_hpt));
1705: /*printf(" HP: %s\n",s->ms_hpt);*/
1706: rs_read(inf,s->ms_dmg,sizeof(s->ms_dmg));
1707: /*printf(" Damage: %s\n",s->ms_dmg);*/
1708: }
1709: }
1710:
1711: return(READSTAT);
1712: }
1713:
1714: bool
1715: rs_write_init_weps(FILE *savef, struct init_weps *w, int count)
1716: {
1717: int i;
1718:
1719: DBG(("Init-Weps\n"));
1720: rs_write_int(savef, RSXR_IWEAPS);
1721: rs_write_int(savef, count);
1722:
1723: for(i=0;i<count;i++)
1724: {
1725: rs_write(savef, w[i].w_name, sizeof(w[i].w_name));
1726: rs_write(savef, w[i].w_dam, sizeof(w[i].w_dam));
1727: rs_write(savef, w[i].w_hrl, sizeof(w[i].w_hrl));
1728: rs_write_char(savef, w[i].w_launch);
1729: rs_write_int(savef, w[i].w_flags);
1730: rs_write_int(savef, w[i].w_rate);
1731: rs_write_int(savef, w[i].w_wght);
1732: rs_write_int(savef, w[i].w_worth);
1733: }
1734: return(WRITESTAT);
1735: }
1736:
1737: bool
1738: rs_read_init_weps(FILE *inf, struct init_weps *w,int count)
1739: {
1740: int id,value,i;
1741:
1742: rs_read_int(inf, &id);
1743: rs_read_int(inf, &value);
1744:
1745: if (value != count)
1746: {
1747: printf("Incorrect number of init_weps in block. %d != %d.",
1748: value,count);
1749: printf("Sorry, invalid save game format");
1750: format_error = TRUE;
1751: }
1752: else for (i = 0; i < count; i++)
1753: {
1754: rs_read(inf, w[i].w_name, sizeof(w[i].w_name));
1755: rs_read(inf, w[i].w_dam, sizeof(w[i].w_dam));
1756: rs_read(inf, w[i].w_hrl, sizeof(w[i].w_hrl));
1757: rs_read_char(inf, &w[i].w_launch);
1758: rs_read_int(inf, &w[i].w_flags);
1759: rs_read_int(inf, &w[i].w_rate);
1760: rs_read_int(inf, &w[i].w_wght);
1761: rs_read_int(inf, &w[i].w_worth);
1762: }
1763: return(READSTAT);
1764: }
1765:
1766: bool
1767: rs_write_init_armor(FILE *savef, struct init_armor *a, int count)
1768: {
1769: int i;
1770: DBG(("Init-Armor\n"));
1771: rs_write_int(savef, RSXR_IARMOR);
1772: rs_write_int(savef, count);
1773: for(i=0;i<count;i++)
1774: {
1775: rs_write(savef, a[i].a_name, sizeof(a[i].a_name));
1776: rs_write_int(savef, a[i].a_prob);
1777: rs_write_int(savef, a[i].a_class);
1778: rs_write_int(savef, a[i].a_worth);
1779: rs_write_int(savef, a[i].a_wght);
1780: }
1781: return(WRITESTAT);
1782: }
1783:
1784: bool
1785: rs_read_init_armor(FILE *inf, struct init_armor *a,int count)
1786: {
1787: int id,value,i;
1788:
1789: rs_read_int(inf, &id);
1790: rs_read_int(inf, &value);
1791:
1792: for(i=0;i<count;i++)
1793: {
1794: rs_read(inf, a[i].a_name, sizeof(a[i].a_name));
1795: rs_read_int(inf, &a[i].a_prob);
1796: rs_read_int(inf, &a[i].a_class);
1797: rs_read_int(inf, &a[i].a_worth);
1798: rs_read_int(inf, &a[i].a_wght);
1799: }
1800:
1801: return(READSTAT);
1802: }
1803:
1804: bool
1805: rs_write_spells(FILE *savef, struct spells *s, int count)
1806: {
1807: int i;
1808: DBG(("Spells\n"));
1809: rs_write_int(savef, RSXR_SPELLS);
1810: rs_write_int(savef, count);
1811: for(i=0;i<count;i++)
1812: {
1813: rs_write_short(savef, s[i].s_which);
1814: rs_write_short(savef, s[i].s_cost);
1815: rs_write_short(savef, s[i].s_type);
1816: rs_write_int(savef, s[i].s_flag);
1817: }
1818: return(WRITESTAT);
1819: }
1820:
1821: bool
1822: rs_read_spells(FILE *inf, struct spells *s,int count)
1823: {
1824: int id,value,i;
1825:
1826: rs_read_int(inf, &id);
1827: rs_read_int(inf, &value);
1828:
1829: for(i=0;i<count;i++)
1830: {
1831: rs_read_short(inf, &s[i].s_which);
1832: rs_read_short(inf, &s[i].s_cost);
1833: rs_read_short(inf, &s[i].s_type);
1834: rs_read_int(inf, &s[i].s_flag);
1835: }
1836: return(READSTAT);
1837: }
1838:
1839: bool
1840: rs_write_item_list(FILE *savef, struct item_list *i)
1841: {
1842: DBG(("Item List\n"));
1843: rs_write_int(savef, RSXR_ILIST);
1844: rs_write_char(savef, i->item_ch);
1845: rs_write(savef, i->item_desc, sizeof(i->item_desc));
1846: return(WRITESTAT);
1847: }
1848:
1849: bool
1850: rs_read_item_list(FILE *inf, struct item_list *i)
1851: {
1852: int id;
1853:
1854: rs_read_int(inf, &id);
1855:
1856: rs_read_uchar(inf, &i->item_ch);
1857: rs_read(inf, i->item_desc,sizeof(i->item_desc));
1858: return(READSTAT);
1859: }
1860:
1861: bool
1862: rs_write_h_list(FILE *savef, struct h_list *h)
1863: {
1864: DBG(("H List\n"));
1865: rs_write_int(savef, RSXR_HLIST);
1866: rs_write_char(savef, h->h_ch);
1867: rs_write(savef, h->h_desc, sizeof(h->h_desc));
1868: return(WRITESTAT);
1869: }
1870:
1871: bool
1872: rs_read_h_list(FILE *inf, struct h_list *h)
1873: {
1874: int id;
1875:
1876: rs_read_int(inf, &id);
1877:
1878: rs_read_char(inf, &h->h_ch);
1879: rs_read(inf, h->h_desc,sizeof(h->h_desc));
1880: return(READSTAT);
1881: }
1882:
1883: bool
1884: rs_write_death_types(FILE *savef, struct death_type *d,int count)
1885: {
1886: int i;
1887:
1888: DBG(("Death Types\n"));
1889: rs_write_int(savef, RSXR_DEATHTYPE);
1890: rs_write_int(savef, count);
1891:
1892: for(i=0; i < count; i++)
1893: {
1894: rs_write_int(savef, d[i].reason);
1895: rs_write(savef, d[i].name, sizeof(d[i].name));
1896: }
1897: return(WRITESTAT);
1898: }
1899:
1900: bool
1901: rs_read_death_types(FILE *inf, struct death_type *d, int count)
1902: {
1903: int id,value,i;
1904:
1905: rs_read_int(inf, &id);
1906: rs_read_int(inf, &value);
1907: if (value != count)
1908: {
1909: printf("Incorrect number of death_types in block. %d > %d.",
1910: value,count);
1911: printf("Sorry, invalid save game format");
1912: format_error = TRUE;
1913: }
1914: else for(i=0;i < count;i++)
1915: {
1916: rs_read_int(inf, &d[i].reason);
1917: rs_read(inf, d[i].name,sizeof(d[i].name));
1918: }
1919: return(READSTAT);
1920: }
1921:
1922: bool
1923: rs_write_character_types(FILE *savef, struct character_types *c, int count)
1924: {
1925: int i;
1926:
1927: DBG(("Character Types\n"));
1928: rs_write_int(savef, RSXR_CTYPES);
1929: rs_write_int(savef,count);
1930:
1931: for(i=0;i<count;i++)
1932: {
1933: rs_write(savef, c[i].name, sizeof(c[i].name));
1934: rs_write_long(savef, c[i].start_exp);
1935: rs_write_long(savef, c[i].cap);
1936: rs_write_int(savef, c[i].hit_pts);
1937: rs_write_int(savef, c[i].base);
1938: rs_write_int(savef, c[i].max_lvl);
1939: rs_write_int(savef, c[i].factor);
1940: rs_write_int(savef, c[i].offset);
1941: rs_write_int(savef, c[i].range);
1942: }
1943: return(WRITESTAT);
1944: }
1945:
1946: bool
1947: rs_read_character_types(FILE *inf, struct character_types *c,int count)
1948: {
1949: int id,value,i;
1950:
1951: rs_read_int(inf, &id);
1952: rs_read_int(inf, &value);
1953:
1954: if (value != count)
1955: {
1956: printf("Incorrect number of character types in block. %d > %d.",
1957: value,count);
1958: printf("Sorry, invalid save game format");
1959: format_error = TRUE;
1960: }
1961: else for (i = 0; i < count; i++)
1962: {
1963: rs_read(inf, c[i].name,sizeof(c[i].name));
1964: rs_read_long(inf, &c[i].start_exp);
1965: rs_read_long(inf, &c[i].cap);
1966: rs_read_int(inf, &c[i].hit_pts);
1967: rs_read_int(inf, &c[i].base);
1968: rs_read_int(inf, &c[i].max_lvl);
1969: rs_read_int(inf, &c[i].factor);
1970: rs_read_int(inf, &c[i].offset);
1971: rs_read_int(inf, &c[i].range);
1972: }
1973: return(READSTAT);
1974: }
1975:
1976: bool
1977: rs_write_traps(FILE *savef, struct trap *trap,int count)
1978: {
1979: int n;
1980:
1981: DBG(("Traps\n"));
1982: rs_write_int(savef, RSXR_TRAP);
1983: rs_write_int(savef, count);
1984:
1985: for(n=0; n<count; n++)
1986: {
1987: rs_write_char(savef, trap[n].tr_type);
1988: rs_write_char(savef, trap[n].tr_show);
1989: rs_write_coord(savef, &trap[n].tr_pos);
1990: rs_write_long(savef, trap[n].tr_flags);
1991: }
1992: return(WRITESTAT);
1993: }
1994:
1995: bool
1996: rs_read_traps(FILE *inf, struct trap *trap, int count)
1997: {
1998: int id = 0, value = 0, n = 0;
1999:
2000: if (rs_read_int(inf,&id) != 0)
2001: {
2002: if (id != RSXR_TRAP)
2003: {
2004: printf("Invalid id. %x != %x(RSXR_TRAP)\n",
2005: id,RSXR_TRAP);
2006: printf("Sorry, invalid save game format");
2007: format_error = TRUE;
2008: }
2009: else if (rs_read_int(inf,&value) != 0)
2010: {
2011: if (value != count)
2012: {
2013: printf("Incorrect number of traps in block. %d > %d.",
2014: value,count);
2015: printf("Sorry, invalid save game format\n");
2016: format_error = TRUE;
2017: }
2018: else
2019: {
2020: for(n=0;n<value;n++)
2021: {
2022: rs_read_uchar(inf,&trap[n].tr_type);
2023: rs_read_uchar(inf,&trap[n].tr_show);
2024: rs_read_coord(inf,&trap[n].tr_pos);
2025: rs_read_long(inf,&trap[n].tr_flags);
2026: }
2027: }
2028: }
2029: else
2030: format_error = TRUE;
2031: }
2032:
2033: return(READSTAT);
2034: }
2035:
2036: bool
2037: rs_write_monsters(FILE * savef, struct monster * m, int count)
2038: {
2039: int n;
2040:
2041: DBG(("Monsters\n"));
2042: rs_write_int(savef, RSXR_MONSTERS);
2043: rs_write_int(savef, count);
2044:
2045: for(n=0;n<count;n++)
2046: {
2047: rs_write(savef, m[n].m_name, sizeof(m[n].m_name));
2048: /*printf("Monster: %s/%d/%d\n",m[n].m_name,sizeof(m[n].m_name),strlen(m[n].m_name));*/
2049: rs_write_short(savef, m[n].m_carry);
2050: rs_write_boolean(savef, m[n].m_normal);
2051: rs_write_boolean(savef, m[n].m_wander);
2052: rs_write_char(savef, m[n].m_appear);
2053: rs_write(savef, m[n].m_intel,sizeof(m[n].m_intel));
2054: rs_write_longs(savef, m[n].m_flags, MAXFLAGS);
2055: rs_write(savef, m[n].m_typesum,sizeof(m[n].m_typesum));
2056: rs_write_short(savef, m[n].m_numsum);
2057: rs_write_short(savef, m[n].m_add_exp);
2058:
2059: rs_write_mstats(savef, &m[n].m_stats);
2060: }
2061:
2062: return(WRITESTAT);
2063: }
2064:
2065: bool
2066: rs_read_monsters(FILE *inf, struct monster *m, int count)
2067: {
2068: int id = 0, value = 0, n = 0;
2069: char buffer[1024];
2070:
2071: if (rs_read_int(inf, &id) != 0)
2072: {
2073: if (id != RSXR_MONSTERS)
2074: {
2075: printf("Invalid id. %x != %x(RSXR_MONSTERS)\n",
2076: id,RSXR_MONSTERS);
2077: printf("Sorry, invalid save game format");
2078: format_error = TRUE;
2079: }
2080: else if (rs_read_int(inf, &value) != 0)
2081: {
2082: if (value != count)
2083: { printf("Incorrect number of monsters in block. %d != %d.",
2084: value,count);
2085: printf("Sorry, invalid save game format\n");
2086: format_error = TRUE;
2087:
2088: }
2089: else for(n=0;n<value;n++)
2090: {
2091: rs_read(inf, buffer,sizeof(m[n].m_name));
2092: assert( strcmp(buffer,m[n].m_name) == 0);
2093: /*printf("Monster: %s\n",m[n].m_name);*/
2094: rs_read_short(inf, &m[n].m_carry);
2095: /*printf(" Carry: %d\n",m[n].m_carry); */
2096: rs_read_boolean(inf, &m[n].m_normal);
2097: /*printf(" Normal: %d\n",m[n].m_normal);*/
2098: rs_read_boolean(inf, &m[n].m_wander);
2099: /*printf(" Wander: %d\n",m[n].m_wander);*/
2100: rs_read_char(inf, &m[n].m_appear);
2101: /*printf(" Appears: %c\n",m[n].m_appear);*/
2102: rs_read(inf, m[n].m_intel,sizeof(m[n].m_intel));
2103: /*printf(" Intelligence: %s\n",m[n].m_intel);*/
2104: rs_read_longs(inf, m[n].m_flags, MAXFLAGS);
2105: /*printf(" Flags: %X\n",m[n].m_flags);*/
2106: rs_read(inf, m[n].m_typesum, sizeof(m[n].m_typesum));
2107: /*printf(" Summons: %s\n",m[n].m_typesum);*/
2108: rs_read_short(inf, &m[n].m_numsum);
2109: /*printf(" # Summons: %d\n",m[n].m_numsum);*/
2110: rs_read_short(inf, &m[n].m_add_exp);
2111: /*printf(" Experience: %d\n",m[n].m_add_exp);*/
2112: rs_read_mstats(inf, &m[n].m_stats);
2113:
2114: }
2115: }
2116: else
2117: format_error = TRUE;
2118: }
2119:
2120: return(READSTAT);
2121: }
2122:
2123: /*****************************************************************************/
2124:
2125: bool
2126: rs_write_coord_list(FILE *savef, struct linked_list *l)
2127: {
2128: DBG(("Coordinate List\n"));
2129: rs_write_int(savef, RSXR_COORDLIST);
2130: rs_write_int(savef, list_size(l));
2131:
2132: while (l != NULL)
2133: {
2134: rs_write_coord(savef, (coord *) l->l_data);
2135: l = l->l_next;
2136: }
2137:
2138: return(WRITESTAT);
2139: }
2140:
2141: bool
2142: rs_read_coord_list(FILE *inf, struct linked_list **list)
2143: {
2144: int id;
2145: int i, cnt;
2146: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
2147:
2148: if (rs_read_int(inf,&id) != 0)
2149: {
2150: if (id != RSXR_COORDLIST)
2151: {
2152: printf("Invalid id. %x != %x(RSXR_COORDLIST)\n",
2153: id,RSXR_COORDLIST);
2154: printf("Sorry, invalid save game format");
2155: format_error = TRUE;
2156: }
2157: else if (rs_read_int(inf,&cnt) != 0)
2158: {
2159: for (i = 0; i < cnt; i++)
2160: {
2161: l = new_item(sizeof(coord));
2162: l->l_prev = previous;
2163: if (previous != NULL)
2164: previous->l_next = l;
2165: rs_read_coord(inf,(coord *) l->l_data);
2166: if (previous == NULL)
2167: head = l;
2168: previous = l;
2169: }
2170:
2171: if (l != NULL)
2172: l->l_next = NULL;
2173:
2174: *list = head;
2175: }
2176: else
2177: format_error = TRUE;
2178: }
2179: else
2180: format_error = TRUE;
2181:
2182: return(READSTAT);
2183: }
2184:
2185: bool
2186: rs_write_object_list(FILE *savef, struct linked_list *l)
2187: {
2188: DBG(("Object List\n"));
2189: rs_write_int(savef, RSXR_OBJECTLIST);
2190: rs_write_int(savef, list_size(l));
2191:
2192: while (l != NULL)
2193: {
2194: rs_write_object(savef, (struct object *) l->l_data);
2195: l = l->l_next;
2196: }
2197:
2198: return(WRITESTAT);
2199: }
2200:
2201: bool
2202: rs_read_object_list(FILE *inf, struct linked_list **list)
2203: {
2204: int id;
2205: int i, cnt;
2206: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
2207:
2208: if (rs_read_int(inf,&id) != 0)
2209: {
2210: if (rs_read_int(inf,&cnt) != 0)
2211: {
2212: for (i = 0; i < cnt; i++)
2213: {
2214: l = new_item(sizeof(struct object));
2215: memset(l->l_data,0,sizeof(struct object));
2216: l->l_prev = previous;
2217: if (previous != NULL)
2218: previous->l_next = l;
2219: rs_read_object(inf,(struct object *) l->l_data);
2220: if (previous == NULL)
2221: head = l;
2222: previous = l;
2223: }
2224:
2225: if (l != NULL)
2226: l->l_next = NULL;
2227:
2228: *list = head;
2229: }
2230: else
2231: format_error = TRUE;
2232: }
2233: else
2234: format_error = TRUE;
2235:
2236:
2237: return(READSTAT);
2238: }
2239:
2240: int
2241: find_thing_coord(monlist, c)
2242: struct linked_list *monlist;
2243: coord *c;
2244: {
2245: struct linked_list *mitem;
2246: struct thing *tp;
2247: int i = 0;
2248:
2249: for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
2250: {
2251: tp = THINGPTR(mitem);
2252: if (c == &tp->t_pos)
2253: return(i);
2254: i++;
2255: }
2256:
2257: return(-1);
2258: }
2259:
2260: int
2261: find_object_coord(objlist, c)
2262: struct linked_list *objlist;
2263: coord *c;
2264: {
2265: struct linked_list *oitem;
2266: struct object *obj;
2267: int i = 0;
2268:
2269: for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
2270: {
2271: obj = OBJPTR(oitem);
2272: if (c == &obj->o_pos)
2273: return(i);
2274: i++;
2275: }
2276:
2277: return(-1);
2278: }
2279:
2280: bool
2281: rs_write_thing(FILE *savef, struct thing *t)
2282: {
2283: int i = -1;
2284:
2285: DBG(("Thing\n"));
2286: rs_write_int(savef, RSXR_THING);
2287: rs_write_boolean(savef,t->t_wasshot);
2288: rs_write_char(savef, t->t_type);
2289: rs_write_char(savef, t->t_disguise);
2290: rs_write_char(savef, t->t_oldch);
2291: rs_write_short(savef, t->t_ctype);
2292: rs_write_short(savef, t->t_index);
2293: rs_write_short(savef, t->t_no_move);
2294: rs_write_short(savef, t->t_quiet);
2295: rs_write_short(savef, t->t_movement);
2296: rs_write_short(savef, t->t_action);
2297: rs_write_short(savef, t->t_artifact);
2298: rs_write_short(savef, t->t_wand);
2299: rs_write_short(savef, t->t_summon);
2300: rs_write_short(savef, t->t_cast);
2301: rs_write_short(savef, t->t_breathe);
2302:
2303: rs_write_string(savef,t->t_name);
2304: rs_write_coord(savef, &t->t_doorgoal);
2305:
2306: if (t->t_dest == &hero)
2307: {
2308: rs_write_int(savef,0);
2309: rs_write_int(savef,1);
2310: }
2311: else if (t->t_dest != NULL)
2312: {
2313: i = find_thing_coord(mlist, t->t_dest);
2314:
2315: if (i >= 0)
2316: {
2317: rs_write_int(savef,1);
2318: rs_write_int(savef,i);
2319: }
2320: else
2321: {
2322: i = find_object_coord(lvl_obj, t->t_dest);
2323:
2324: if (i >= 0)
2325: {
2326: rs_write_int(savef,2);
2327: rs_write_int(savef,i);
2328: }
2329: else
2330: {
2331: rs_write_int(savef,0);
2332: rs_write_int(savef,1); /* chase the hero anyway */
2333: }
2334: }
2335: }
2336: else
2337: {
2338: rs_write_int(savef,0);
2339: rs_write_int(savef,0);
2340: }
2341:
2342: rs_write_coord(savef, &t->t_pos);
2343: rs_write_coord(savef, &t->t_oldpos);
2344: rs_write_coord(savef, &t->t_newpos);
2345: rs_write_ulongs(savef, t->t_flags, 16);
2346:
2347: DBG(("Thing\n"));
2348: DBG((" SaveID : %X\n",RSXR_THING));
2349: DBG((" Name : %s\n",t->t_name));
2350: DBG((" WasShot : %d\n",t->t_wasshot));
2351: DBG((" Type : %c(%d)\n",t->t_type,t->t_type));
2352: DBG((" Disguise: %c(%d)\n",t->t_disguise,t->t_disguise));
2353: DBG((" OldCh : %c(%d)\n",t->t_oldch,t->t_oldch));
2354: DBG((" CType : %d\n",t->t_ctype));
2355: DBG((" Index : %d\n",t->t_index));
2356: DBG((" NoMove : %d\n",t->t_no_move));
2357: DBG((" Quiet : %d\n",t->t_quiet));
2358: DBG((" Movement: %d\n",t->t_movement));
2359: DBG((" Action : %d\n",t->t_action));
2360: DBG((" Artifact: %d\n",t->t_artifact));
2361: DBG((" Wand : %d\n",t->t_wand));
2362: DBG((" Summon : %d\n",t->t_summon));
2363: DBG((" Cast : %d\n",t->t_cast));
2364: DBG((" Breathe : %d\n",t->t_breathe));
2365: DBG((" DoorGoal: %d %d\n",t->t_doorgoal.x,t->t_doorgoal.y));
2366: if (t->t_dest)
2367: {
2368: DBG((" Dest : %d %d\n",t->t_dest->x,t->t_dest->y));
2369: }
2370: else
2371: {
2372: DBG((" Dest : None\n"));
2373: }
2374: DBG((" Pos : %d %d\n",t->t_pos.x,t->t_pos.y));
2375: DBG((" OldPos : %d %d\n",t->t_oldpos.x,t->t_oldpos.y));
2376: DBG((" NewPos : %d %d\n",t->t_newpos.x,t->t_newpos.y));
2377: DBG((" Flags : "));
2378: { int i; for(i=0;i<16;i++) {DBG(("%d ",t->t_flags[i]));} DBG(("\n")); }
2379:
2380: rs_write_object_list(savef, t->t_pack);
2381: i = -1;
2382: if (t->t_using != NULL)
2383: i = find_list_ptr(t->t_pack, t->t_using->l_data);
2384: rs_write_int(savef, i);
2385: rs_write_stats(savef, &t->t_stats);
2386: rs_write_stats(savef, &t->maxstats);
2387:
2388: return(WRITESTAT);
2389: }
2390:
2391: void
2392: rs_fix_thing(struct thing *t)
2393: {
2394: struct linked_list *item;
2395: struct thing *tp;
2396:
2397: if (t->t_reserved < 0)
2398: return;
2399:
2400: item = get_list_item(mlist,t->t_reserved);
2401:
2402: if (item != NULL)
2403: {
2404: tp = THINGPTR(item);
2405: t->t_dest = &tp->t_pos;
2406: }
2407: }
2408:
2409: bool
2410: rs_read_thing(FILE *inf, struct thing *t)
2411: {
2412: int id;
2413: int listid = 0, index = -1;
2414: struct linked_list *item;
2415:
2416: if (rs_read_int(inf, &id) != 0)
2417: {
2418: if (id != RSXR_THING)
2419: format_error = TRUE;
2420: else
2421: {
2422: rs_read_boolean(inf,&t->t_wasshot);
2423: rs_read_uchar(inf, &t->t_type);
2424: rs_read_uchar(inf, &t->t_disguise);
2425: rs_read_uchar(inf, &t->t_oldch);
2426: rs_read_short(inf, &t->t_ctype);
2427: rs_read_short(inf, &t->t_index);
2428: rs_read_short(inf, &t->t_no_move);
2429: rs_read_short(inf, &t->t_quiet);
2430: rs_read_short(inf, &t->t_movement);
2431: rs_read_short(inf, &t->t_action);
2432: rs_read_short(inf, &t->t_artifact);
2433: rs_read_short(inf, &t->t_wand);
2434: rs_read_short(inf, &t->t_summon);
2435: rs_read_short(inf, &t->t_cast);
2436: rs_read_short(inf, &t->t_breathe);
2437: rs_read_new_string(inf,&t->t_name);
2438: rs_read_coord(inf,&t->t_doorgoal);
2439:
2440: rs_read_int(inf,&listid);
2441: rs_read_int(inf,&index);
2442: t->t_reserved = -1;
2443: if (listid == 0)
2444: {
2445: if (index == 1)
2446: t->t_dest = &hero;
2447: else
2448: t->t_dest = NULL;
2449: }
2450: else if (listid == 1)
2451: {
2452: t->t_dest = NULL;
2453: t->t_reserved = index;
2454: }
2455: else if (listid == 2)
2456: {
2457: struct object *obj;
2458: item = get_list_item(lvl_obj,index);
2459: if (item != NULL)
2460: {
2461: obj = OBJPTR(item);
2462: t->t_dest = &obj->o_pos;
2463: }
2464: }
2465: else
2466: t->t_dest = NULL;
2467:
2468: rs_read_coord(inf,&t->t_pos);
2469: rs_read_coord(inf,&t->t_oldpos);
2470: rs_read_coord(inf,&t->t_newpos);
2471: rs_read_ulongs(inf,t->t_flags,16);
2472: rs_read_object_list(inf,&t->t_pack);
2473: rs_read_int(inf,&index);
2474: t->t_using = get_list_item(t->t_pack, index);
2475: rs_read_stats(inf,&t->t_stats);
2476: rs_read_stats(inf,&t->maxstats);
2477: }
2478: }
2479: else format_error = TRUE;
2480:
2481: return(READSTAT);
2482: }
2483:
2484: int
2485: find_list_ptr(struct linked_list *l, void *ptr)
2486: {
2487: int count = 0;
2488:
2489: while(l != NULL)
2490: {
2491: if (l->l_data == ptr)
2492: return(count);
2493:
2494: l = l->l_next;
2495: count++;
2496: }
2497:
2498: return(-1);
2499: }
2500:
2501:
2502: int
2503: list_size(struct linked_list *l)
2504: {
2505: int count = 0;
2506:
2507: while(l != NULL)
2508: {
2509: if (l->l_data == NULL)
2510: return(count);
2511:
2512: count++;
2513:
2514: l = l->l_next;
2515: }
2516:
2517: return(count);
2518: }
2519:
2520:
2521: bool
2522: rs_write_monster_list(FILE *savef, struct linked_list *l)
2523: {
2524: int cnt = 0;
2525:
2526: DBG(("Monster List\n"));
2527: rs_write_int(savef, RSXR_MONSTERLIST);
2528:
2529: cnt = list_size(l);
2530:
2531: rs_write_int(savef, cnt);
2532:
2533: if (cnt < 1)
2534: return(WRITESTAT);
2535:
2536: while (l != NULL) {
2537: rs_write_thing(savef, (struct thing *)l->l_data);
2538: l = l->l_next;
2539: }
2540:
2541: return(WRITESTAT);
2542: }
2543:
2544: void
2545: rs_fix_monster_list(struct linked_list *list)
2546: {
2547: struct linked_list *item;
2548:
2549: for(item = list; item != NULL; item = item->l_next)
2550: rs_fix_thing(THINGPTR(item));
2551: }
2552:
2553: bool
2554: rs_read_monster_list(FILE *inf, struct linked_list **list)
2555: {
2556: int id;
2557: int i, cnt;
2558: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
2559:
2560: if (rs_read_int(inf,&id) != 0)
2561: {
2562: if (id != RSXR_MONSTERLIST)
2563: {
2564: printf("Invalid id. %x != %x(RSXR_MONSTERLIST)\n",
2565: id,RSXR_MONSTERLIST);
2566: printf("Sorry, invalid save game format");
2567: format_error = TRUE;
2568: }
2569: else if (rs_read_int(inf,&cnt) != 0)
2570: {
2571: for (i = 0; i < cnt; i++)
2572: {
2573: l = new_item(sizeof(struct thing));
2574: l->l_prev = previous;
2575: if (previous != NULL)
2576: previous->l_next = l;
2577: rs_read_thing(inf,(struct thing *)l->l_data);
2578: if (previous == NULL)
2579: head = l;
2580: previous = l;
2581: }
2582:
2583:
2584: if (l != NULL)
2585: l->l_next = NULL;
2586:
2587: *list = head;
2588: }
2589: }
2590: else format_error = TRUE;
2591:
2592: return(READSTAT);
2593: }
2594:
2595: bool
2596: rs_write_magic_items(FILE *savef, struct magic_item *i, int count)
2597: {
2598: int n;
2599:
2600: DBG(("Magic Items\n"));
2601: rs_write_int(savef, RSXR_MAGICITEMS);
2602: rs_write_int(savef, count);
2603:
2604: for(n=0;n<count;n++)
2605: {
2606: rs_write(savef,i[n].mi_name,sizeof(i[n].mi_name));
2607: rs_write_int(savef,i[n].mi_prob);
2608: rs_write_int(savef,i[n].mi_worth);
2609: rs_write_int(savef,i[n].mi_curse);
2610: rs_write_int(savef,i[n].mi_bless);
2611: }
2612:
2613: return(WRITESTAT);
2614: }
2615:
2616: bool
2617: rs_read_magic_items(FILE *inf, struct magic_item *mi, int count)
2618: {
2619: int id;
2620: int n;
2621: int value;
2622:
2623: if (rs_read_int(inf, &id) != 0)
2624: {
2625: if (id != RSXR_MAGICITEMS)
2626: {
2627: printf("Invalid id. %x != %x(RSXR_MAGICITEMS)\n",
2628: id,RSXR_MAGICITEMS);
2629: printf("Sorry, invalid save game format");
2630: format_error = TRUE;
2631: }
2632: else if (rs_read_int(inf, &value) != 0)
2633: {
2634: if (value > count)
2635: {
2636: printf("Incorrect number of magic items in block. %d > %d.",
2637: value,count);
2638: printf("Sorry, invalid save game format");
2639: format_error = TRUE;
2640: }
2641: else
2642: {
2643: for(n = 0; n < value; n++)
2644: {
2645: rs_read(inf,mi[n].mi_name,sizeof(mi[n].mi_name));
2646: rs_read_int(inf,&mi[n].mi_prob);
2647: rs_read_int(inf,&mi[n].mi_worth);
2648: rs_read_int(inf,&mi[n].mi_curse);
2649: rs_read_int(inf,&mi[n].mi_bless);
2650: }
2651: }
2652: }
2653: }
2654:
2655: return(READSTAT);
2656: }
2657:
2658: bool
2659: rs_write_window(FILE *savef, WINDOW *win)
2660: {
2661: int row,col,height,width;
2662: width = getmaxx(win);
2663: height = getmaxy(win);
2664: DBG(("Window\n"));
2665: rs_write_int(savef,height);
2666: rs_write_int(savef,width);
2667:
2668: for(row=0;row<height;row++)
2669: for(col=0;col<width;col++)
2670: rs_write_int(savef, mvwinch(win,row,col));
2671:
2672: return(WRITESTAT);
2673: }
2674:
2675: bool
2676: rs_read_window(FILE *inf, WINDOW *win)
2677: {
2678: int row,col,maxlines,maxcols,value,width,height;
2679:
2680: width = getmaxx(win);
2681: height = getmaxy(win);
2682:
2683: rs_read_int(inf,&maxlines);
2684: rs_read_int(inf,&maxcols);
2685: if (maxlines > height)
2686: abort();
2687: if (maxcols > width)
2688: abort();
2689:
2690: for(row=0;row<maxlines;row++)
2691: for(col=0;col<maxcols;col++)
2692: {
2693: rs_read_int(inf, &value);
2694: if ((value == '-') || (value == 196))
2695: value = HORZWALL;
2696: else if ((value == '|') || (value == 179))
2697: value = VERTWALL;
2698: mvwaddch(win,row,col,value);
2699: }
2700:
2701: return(READSTAT);
2702: }
2703:
2704: bool
2705: rs_save_file(FILE *savef)
2706: {
2707: int i, weapon, armor, ring, misc, room = -1;
2708: int endian = 0x01020304;
2709: big_endian = ( *((char *)&endian) == 0x01 );
2710:
2711: rs_write_thing(savef, &player); /* rogue.c */
2712: rs_write_object_list(savef, lvl_obj); /* rogue.c */
2713: rs_write_monster_list(savef, mlist); /* rogue.c */
2714: rs_write_monster_list(savef, tlist); /* rogue.c */
2715:
2716: rs_write_traps(savef, traps, MAXTRAPS); /* rogue.c */
2717:
2718: armor = find_list_ptr(player.t_pack, cur_armor);
2719: rs_write_int(savef, armor); /* rogue.c */
2720:
2721: for (i = 0; i < NUM_FINGERS; i++)
2722: {
2723: ring = find_list_ptr(player.t_pack, cur_ring[i]);
2724: rs_write_int(savef, ring); /* rogue.c */
2725: }
2726:
2727: for (i = 0; i < NUM_MM; i++)
2728: {
2729: misc = find_list_ptr(player.t_pack, cur_misc[i]);
2730: rs_write_int(savef, misc); /* rogue.c */
2731: }
2732:
2733: for (i=0; i<MAXRELIC; i++)
2734: rs_write_int(savef,cur_relic[i]); /* rogue.c */
2735:
2736:
2737: rs_write_rooms(savef, rooms, MAXROOMS); /* rogue.c */
2738:
2739: for (i = 0; i < MAXROOMS; i++)
2740: if (&rooms[i] == oldrp)
2741: room = i;
2742: rs_write_int(savef, room); /* rogue.c */
2743:
2744: weapon = find_list_ptr(player.t_pack, cur_weapon);
2745: rs_write_int(savef, weapon); /* rogue..c */
2746: rs_write_int(savef,char_type);
2747: rs_write_int(savef,foodlev);
2748: rs_write_int(savef,ntraps);
2749: rs_write_int(savef,trader);
2750: rs_write_int(savef,curprice);
2751: rs_write_int(savef,seed);
2752: rs_write_int(savef,max_level);
2753: rs_write_int(savef,cur_max);
2754: rs_write_int(savef,prev_max);
2755: rs_write_int(savef,move_free);
2756: rs_write_int(savef,mpos);
2757: rs_write_int(savef,level);
2758: rs_write_long(savef,purse);
2759: rs_write_int(savef,inpack);
2760: rs_write_int(savef,total);
2761: rs_write_int(savef,no_food);
2762: rs_write_int(savef,foods_this_level);
2763: rs_write_int(savef,count);
2764: rs_write_int(savef,food_left);
2765: rs_write_int(savef,group);
2766: rs_write_int(savef,hungry_state);
2767: rs_write_int(savef,infest_dam);
2768: rs_write_int(savef,lost_str);
2769: rs_write_int(savef,lastscore);
2770: rs_write_int(savef,hold_count);
2771: rs_write_int(savef,trap_tries);
2772: rs_write_int(savef,chant_time);
2773: rs_write_int(savef,pray_time);
2774: rs_write_int(savef,spell_power);
2775: rs_write_long(savef,turns);
2776: rs_write_int(savef,quest_item);
2777: rs_write_int(savef,cols);
2778: rs_write_int(savef,lines);
2779: rs_write_int(savef,nfloors);
2780: rs_write(savef,curpurch,LINELEN);
2781: rs_write_char(savef,PLAYER);
2782: rs_write_char(savef,take);
2783: rs_write_int(savef,1234);/*checkpoint*/
2784: rs_write(savef,prbuf,LINELEN*2);
2785: rs_write_int(savef,1234);/*checkpoint*/
2786: rs_write_char(savef,runch);
2787: rs_write_int(savef,1234);/*checkpoint*/
2788: rs_write_scrolls(savef);
2789: rs_write_potions(savef);
2790: rs_write_rings(savef);
2791: rs_write_sticks(savef);
2792: rs_write_misc(savef);
2793: rs_write_int(savef,1234);/*checkpoint*/
2794: rs_write(savef,whoami,LINELEN);
2795: rs_write_window(savef, cw);
2796: rs_write_window(savef, hw);
2797: rs_write_window(savef, mw);
2798: rs_write_window(savef, msgw);
2799: rs_write_window(savef, stdscr);
2800: rs_write_boolean(savef,pool_teleport);
2801: rs_write_boolean(savef,inwhgt);
2802: rs_write_boolean(savef,after);
2803: rs_write_boolean(savef,waswizard);
2804: rs_write_boolean(savef, playing); /* rogue.h/init.c */
2805: rs_write_boolean(savef, running); /* rogue.h/init.c */
2806: rs_write_boolean(savef, wizard); /* rogue.h/init.c */
2807: rs_write_boolean(savef, notify); /* rogue.h/init.c */
2808: rs_write_boolean(savef, fight_flush); /* rogue.h/init.c */
2809: rs_write_boolean(savef, terse); /* rogue.h/init.c */
2810: rs_write_boolean(savef, auto_pickup); /* rogue.h/init.c */
2811: rs_write_boolean(savef, def_attr); /* rogue.h/init.c */
2812: rs_write_boolean(savef, menu_overlay); /* rogue.h/init.c */
2813: rs_write_boolean(savef, door_stop); /* rogue.h/init.c */
2814: rs_write_boolean(savef, jump); /* rogue.h/init.c */
2815: rs_write_boolean(savef, slow_invent); /* rogue.h/init.c */
2816: rs_write_boolean(savef, firstmove); /* rogue.h/init.c */
2817: rs_write_boolean(savef, askme); /* rogue.h/init.c */
2818: rs_write_boolean(savef, in_shell); /* rogue.h/init.c */
2819: rs_write_boolean(savef, daytime); /* rogue.h/init.c */
2820: rs_write_boolean(savef, funfont); /* rogue.h/init.c */
2821: rs_write_levtype(savef,levtype);
2822: rs_write_character_types(savef,char_class,NUM_CHARTYPES);
2823: rs_write_words(savef,abilities,NUMABILITIES);
2824: for(i=0;i<9;i++)
2825: rs_write_coord(savef,&grid[i]);
2826: rs_write_death_types(savef,deaths,DEATHNUM);
2827: rs_write_init_weps(savef,weaps,MAXWEAPONS);
2828: rs_write_init_armor(savef,armors,MAXARMORS);
2829: rs_write_magic_items(savef, things, NUMTHINGS); /* rogue.h/init.c */
2830: rs_write_magic_items(savef, s_magic, MAXSCROLLS); /* rogue.h/init.c */
2831: rs_write_magic_items(savef, p_magic, MAXPOTIONS); /* rogue.h/init.c */
2832: rs_write_magic_items(savef, r_magic, MAXRINGS); /* rogue.h/init.c */
2833: rs_write_magic_items(savef, ws_magic, MAXSTICKS); /* rogue.h/init.c */
2834: rs_write_magic_items(savef, m_magic, MAXMM); /* rogue.h/init.c */
2835: rs_write_magic_items(savef, rel_magic, MAXRELIC); /* rogue.h/init.c */
2836: rs_write_magic_items(savef, foods, MAXFOODS); /* rogue.h/init.c */
2837: rs_write_spells(savef,magic_spells,MAXSPELLS);
2838: rs_write_spells(savef,cleric_spells,MAXPRAYERS);
2839: rs_write_spells(savef,druid_spells,MAXCHANTS);
2840: rs_write_spells(savef,quill_scrolls,MAXQUILL);
2841:
2842: rs_write_int(savef,mf_count); /* actions.c */
2843: rs_write_int(savef,mf_jmpcnt); /* actions.c */
2844: rs_write_daemons(savef, d_list, MAXDAEMONS); /* daemon.c */
2845: rs_write_daemons(savef, f_list, MAXFUSES); /* daemon.c */
2846: rs_write_int(savef,demoncnt); /* daemon.c */
2847: rs_write_int(savef,fusecnt); /* daemon.c */
2848: rs_write_int(savef,killed_chance); /* fight.c */
2849: rs_write_words(savef,rainbow,NCOLORS); /* init.c */
2850: rs_write_words(savef,sylls,NSYLLS); /* init.c */
2851: rs_write_words(savef,stones,NSTONES); /* init.c */
2852: rs_write_words(savef,wood,NWOOD); /* init.c */
2853: rs_write_words(savef,metal,NMETAL); /* init.c */
2854: rs_write_monsters(savef,monsters,
2855: sizeof(monsters)/sizeof(struct monster)); /* mons_def.c */
2856: rs_write_coord(savef,&move_nh); /* move.c */
2857: return(WRITESTAT);
2858: }
2859:
2860: bool
2861: rs_restore_file(FILE *inf)
2862: {
2863: int weapon, armor, ring, misc, room = -1,i,checkpoint;
2864: int endian = 0x01020304;
2865: big_endian = ( *((char *)&endian) == 0x01 );
2866:
2867: rs_read_thing(inf, &player); /* rogue.h */
2868: rs_read_object_list(inf, &lvl_obj); /* rogue.h/init.c */
2869: rs_read_monster_list(inf, &mlist); /* rogue.h/init.c */
2870: rs_read_monster_list(inf, &tlist); /* rogue.h/init.c */
2871: rs_fix_thing(&player);
2872: rs_fix_monster_list(mlist);
2873: rs_read_traps(inf, traps, MAXTRAPS);
2874:
2875:
2876: rs_read_int(inf, &armor); /* rogue.h */
2877: cur_armor = get_list_item(player.t_pack,armor);
2878:
2879: for(i = 0; i < NUM_FINGERS; i++)
2880: {
2881: rs_read_int(inf,&ring);
2882: cur_ring[i] = get_list_item(player.t_pack,ring);
2883: }
2884:
2885: for(i = 0; i < NUM_MM; i++)
2886: {
2887: rs_read_int(inf,&misc);
2888: cur_misc[i] = get_list_item(player.t_pack,misc);
2889: }
2890:
2891: for(i=0;i<MAXRELIC;i++)
2892: rs_read_int(inf,&cur_relic[i]);
2893:
2894: rs_read_rooms(inf, rooms, MAXROOMS);
2895: rs_read_int(inf, &room);
2896:
2897: oldrp = &rooms[room];
2898:
2899: rs_read_int(inf,&weapon);
2900: cur_weapon = get_list_item(player.t_pack,weapon);
2901:
2902: rs_read_int(inf,&char_type);
2903: rs_read_int(inf,&foodlev);
2904: rs_read_int(inf,&ntraps);
2905: rs_read_int(inf,&trader);
2906: rs_read_int(inf,&curprice);
2907: rs_read_int(inf,&seed);
2908: rs_read_int(inf,&max_level);
2909: rs_read_int(inf,&cur_max);
2910: rs_read_int(inf,&prev_max);
2911: rs_read_int(inf,&move_free);
2912: rs_read_int(inf,&mpos);
2913: rs_read_int(inf,&level);
2914: rs_read_long(inf,&purse);
2915: rs_read_int(inf,&inpack);
2916: rs_read_int(inf,&total);
2917: rs_read_int(inf,&no_food);
2918: rs_read_int(inf,&foods_this_level);
2919: rs_read_int(inf,&count);
2920: rs_read_int(inf,&food_left);
2921: rs_read_int(inf,&group);
2922: rs_read_int(inf,&hungry_state);
2923: rs_read_int(inf,&infest_dam);
2924: rs_read_int(inf,&lost_str);
2925: rs_read_int(inf,&lastscore);
2926: rs_read_int(inf,&hold_count);
2927: rs_read_int(inf,&trap_tries);
2928: rs_read_int(inf,&chant_time);
2929: rs_read_int(inf,&pray_time);
2930: rs_read_int(inf,&spell_power);
2931: rs_read_long(inf,&turns);
2932: rs_read_int(inf,&quest_item);
2933: rs_read_int(inf,&cols);
2934: rs_read_int(inf,&lines);
2935: rs_read_int(inf,&nfloors);
2936: rs_read(inf,curpurch,LINELEN);
2937: rs_read_char(inf,&PLAYER);
2938: rs_read_char(inf,&take);
2939: rs_read_int(inf,&checkpoint);
2940: if (checkpoint != 1234){printf("Checkpoint failed");abort();}
2941: rs_read(inf,prbuf,LINELEN*2);
2942: rs_read_int(inf,&checkpoint);
2943: if (checkpoint != 1234){printf("Checkpoint failed");abort();}
2944: rs_read_char(inf,&runch);
2945: rs_read_int(inf,&checkpoint);
2946: if (checkpoint != 1234){printf("Checkpoint failed");abort();}
2947: rs_read_scrolls(inf);
2948: rs_read_potions(inf);
2949: rs_read_rings(inf);
2950: rs_read_sticks(inf);
2951: rs_read_misc(inf);
2952: rs_read_int(inf,&checkpoint);
2953: if (checkpoint != 1234){printf("Checkpoint failed");abort();}
2954: rs_read(inf,whoami,LINELEN);
2955: rs_read_window(inf, cw);
2956: rs_read_window(inf, hw);
2957: rs_read_window(inf, mw);
2958: rs_read_window(inf, msgw);
2959: rs_read_window(inf, stdscr);
2960: rs_read_boolean(inf,&pool_teleport);
2961: rs_read_boolean(inf,&inwhgt);
2962: rs_read_boolean(inf,&after);
2963: rs_read_boolean(inf,&waswizard);
2964: rs_read_boolean(inf, &playing); /* rogue.h/init.c */
2965: rs_read_boolean(inf, &running); /* rogue.h/init.c */
2966: rs_read_boolean(inf, &wizard); /* rogue.h/init.c */
2967: rs_read_boolean(inf, ¬ify); /* rogue.h/init.c */
2968: rs_read_boolean(inf, &fight_flush); /* rogue.h/init.c */
2969: rs_read_boolean(inf, &terse); /* rogue.h/init.c */
2970: rs_read_boolean(inf, &auto_pickup); /* rogue.h/init.c */
2971: rs_read_boolean(inf, &def_attr); /* rogue.h/init.c */
2972: rs_read_boolean(inf, &menu_overlay); /* rogue.h/init.c */
2973: rs_read_boolean(inf, &door_stop); /* rogue.h/init.c */
2974: rs_read_boolean(inf, &jump); /* rogue.h/init.c */
2975: rs_read_boolean(inf, &slow_invent); /* rogue.h/init.c */
2976: rs_read_boolean(inf, &firstmove); /* rogue.h/init.c */
2977: rs_read_boolean(inf, &askme); /* rogue.h/init.c */
2978: rs_read_boolean(inf, &in_shell); /* rogue.h/init.c */
2979: rs_read_boolean(inf, &daytime); /* rogue.h/init.c */
2980: rs_read_boolean(inf, &funfont); /* rogue.h/init.c */
2981: rs_read_levtype(inf,&levtype);
2982: rs_read_character_types(inf,char_class,NUM_CHARTYPES);
2983: rs_read_words(inf,abilities,NUMABILITIES);
2984: for(i=0;i<9;i++)
2985: rs_read_coord(inf,&grid[i]);
2986: rs_read_death_types(inf,deaths,DEATHNUM);
2987: rs_read_init_weps(inf,weaps,MAXWEAPONS);
2988: rs_read_init_armor(inf,armors,MAXARMORS);
2989: rs_read_magic_items(inf, things,NUMTHINGS); /* rogue.h/init.c */
2990: rs_read_magic_items(inf, s_magic,MAXSCROLLS); /* rogue.h/init.c */
2991: rs_read_magic_items(inf, p_magic,MAXPOTIONS); /* rogue.h/init.c */
2992: rs_read_magic_items(inf, r_magic,MAXRINGS); /* rogue.h/init.c */
2993: rs_read_magic_items(inf, ws_magic,MAXSTICKS); /* rogue.h/init.c */
2994: rs_read_magic_items(inf, m_magic,MAXMM); /* rogue.h/init.c */
2995: rs_read_magic_items(inf, rel_magic,MAXRELIC); /* rogue.h/init.c */
2996: rs_read_magic_items(inf, foods,MAXFOODS); /* rogue.h/init.c */
2997: rs_read_spells(inf,magic_spells,MAXSPELLS);
2998: rs_read_spells(inf,cleric_spells,MAXPRAYERS);
2999: rs_read_spells(inf,druid_spells,MAXCHANTS);
3000: rs_read_spells(inf,quill_scrolls,MAXQUILL);
3001:
3002: rs_read_int(inf,&mf_count); /* actions.c */
3003: rs_read_int(inf,&mf_jmpcnt); /* actions.c */
3004: rs_read_daemons(inf, d_list, MAXDAEMONS); /* daemon.c */
3005: rs_read_daemons(inf, f_list, MAXFUSES); /* daemon.c */
3006: rs_read_int(inf,&demoncnt); /* daemon.c */
3007: rs_read_int(inf,&fusecnt); /* daemon.c */
3008: rs_read_int(inf,&killed_chance); /* fight.c */
3009: rs_read_words(inf,rainbow,NCOLORS); /* init.c */
3010: rs_read_words(inf,sylls,NSYLLS); /* init.c */
3011: rs_read_words(inf,stones,NSTONES); /* init.c */
3012: rs_read_words(inf,wood,NWOOD); /* init.c */
3013: rs_read_words(inf,metal,NMETAL); /* init.c */
3014:
3015: rs_read_monsters(inf,monsters,
3016: sizeof(monsters)/sizeof(struct monster)); /* mons_def.c */
3017: rs_read_coord(inf,&move_nh); /* move.c */
3018:
3019: return(READSTAT);
3020: }
3021:
3022: void
3023: rs_write_scorefile(FILE *savef, struct sc_ent *entries, int count)
3024: {
3025: int i;
3026:
3027: rs_write_int(savef, count);
3028: for(i = 0; i < count; i++)
3029: {
3030: rs_write_ulong(savef, entries[i].sc_score);
3031: rs_write(savef, entries[i].sc_name, sizeof(entries[i].sc_name));
3032: rs_write(savef, entries[i].sc_system, sizeof(entries[i].sc_system));
3033: rs_write(savef, entries[i].sc_login, sizeof(entries[i].sc_login));
3034: rs_write_short(savef, entries[i].sc_flags);
3035: rs_write_short(savef, entries[i].sc_level);
3036: rs_write_short(savef, entries[i].sc_ctype);
3037: rs_write_short(savef, entries[i].sc_monster);
3038: rs_write_short(savef, entries[i].sc_quest);
3039: }
3040: }
3041:
3042: int
3043: rs_read_scorefile(FILE *savef, struct sc_ent *entries, int count)
3044: {
3045: int i,available = 0;
3046:
3047: rs_read_int(savef, &available);
3048:
3049: if (end_of_file)
3050: return(-1);
3051:
3052: if (available != count)
3053: return(-2);
3054:
3055: for(i = 0; i < count; i++)
3056: {
3057: rs_read_ulong(savef, &entries[i].sc_score);
3058: rs_read(savef, entries[i].sc_name, sizeof(entries[i].sc_name));
3059: rs_read(savef, entries[i].sc_system, sizeof(entries[i].sc_system));
3060: rs_read(savef, entries[i].sc_login, sizeof(entries[i].sc_login));
3061: rs_read_short(savef, &entries[i].sc_flags);
3062: rs_read_short(savef, &entries[i].sc_level);
3063: rs_read_short(savef, &entries[i].sc_ctype);
3064: rs_read_short(savef, &entries[i].sc_monster);
3065: rs_read_short(savef, &entries[i].sc_quest);
3066: }
3067:
3068: return(0);
3069: }
3070:
3071:
3072:
3073: void
3074: rs_print_thing(FILE *outf, struct thing *thing, char *prefix, int list, int index)
3075: {
3076: int i;
3077:
3078: fprintf(outf,"%sList Ident : %d\n", prefix, list);
3079: fprintf(outf,"%sList Index : %d\n", prefix, index);
3080: fprintf(outf,"%st_wasshot : %d\n", prefix, thing->t_wasshot);
3081: fprintf(outf,"%st_type : %c\n", prefix, thing->t_type);
3082: fprintf(outf,"%st_disguise : %c\n", prefix, thing->t_disguise);
3083: fprintf(outf,"%st_oldch : %c\n", prefix, thing->t_oldch);
3084: fprintf(outf,"%st_ctype : %d\n", prefix, thing->t_ctype);
3085: fprintf(outf,"%st_index : %d\n", prefix, thing->t_index);
3086: fprintf(outf,"%st_no_move : %d\n", prefix, thing->t_no_move);
3087: fprintf(outf,"%st_quiet : %d\n", prefix, thing->t_quiet);
3088: fprintf(outf,"%st_movement : %d\n", prefix, thing->t_movement);
3089: fprintf(outf,"%st_action : %d\n", prefix, thing->t_action);
3090: fprintf(outf,"%st_artificat: %d\n", prefix, thing->t_artifact);
3091: fprintf(outf,"%st_wand : %d\n", prefix, thing->t_wand);
3092: fprintf(outf,"%st_summon : %d\n", prefix, thing->t_summon);
3093: fprintf(outf,"%st_cast : %d\n", prefix, thing->t_cast);
3094: fprintf(outf,"%st_breathe : %d\n", prefix, thing->t_breathe);
3095: fprintf(outf,"%st_name : %s\n", prefix, (thing->t_name == NULL) ? "none" :
3096: thing->t_name);
3097: fprintf(outf,"%st_doorgoal : %d %d\n", prefix, thing->t_doorgoal.x, thing->t_doorgoal.y);
3098: fprintf(outf,"%st_dest : %p\n", prefix, thing->t_dest);
3099: fprintf(outf,"%st_pos : %d %d (%p)\n", prefix, thing->t_pos.x, thing->t_pos.y,&thing->t_pos);
3100: fprintf(outf,"%st_oldpos : %d %d\n", prefix, thing->t_oldpos.x, thing->t_oldpos.y);
3101: fprintf(outf,"%st_newpos : %d %d\n", prefix, thing->t_newpos.x, thing->t_newpos.y);
3102: fprintf(outf,"%st_flags : ", prefix);
3103:
3104: for(i = 0; i<16; i++)
3105: fprintf(outf,"%X ",thing->t_flags[i]);
3106: fprintf(outf,"\n");
3107:
3108: fprintf(outf,"%st_pack : %p\n",prefix,thing->t_pack);
3109: fprintf(outf,"%st_using : %p\n",prefix,thing->t_using);
3110: fprintf(outf,"%st_stats : Not Implemented\n",prefix);
3111: fprintf(outf,"%st_maxstats : Not Implemented\n",prefix);
3112: fprintf(outf,"%st_reserved : %d\n",prefix,thing->t_reserved);
3113: }
3114:
3115: void
3116: rs_print_game_state(FILE *outf)
3117: {
3118: fprintf(outf, "Player\n");
3119:
3120: rs_print_thing(outf, &player, " ", 0, 0);
3121: }
3122:
3123: /****
3124: Machine Dependent Functions
3125:
3126: md_getuid()
3127: md_memused()
3128: md_getusername()
3129: md_gethostname()
3130: md_gethomedir()
3131: md_getroguedir()
3132: md_getshell()
3133: md_shellescape()
3134: md_getpass()
3135: md_crypt()
3136: md_htons()
3137: md_nstoh()
3138: md_unlink()
3139: md_isdir()
3140: md_ntohl()
3141: md_htonl()
3142:
3143: ****/
3144:
3145: int
3146: md_rand(int range)
3147: {
3148: #ifdef _WIN32
3149: return(range <= 0 ? 0 : rand() % range);
3150: #else
3151: return(range <= 0 ? 0 : random() % range);
3152: #endif
3153: }
3154:
3155: void
3156: md_srand(int seed)
3157: {
3158: #ifdef _WIN32
3159: srand(seed);
3160: #else
3161: srandom(seed);
3162: #endif
3163: }
3164:
3165: void
3166: md_flushinp(void)
3167: {
3168: /* ioctl(0,TIOCFLUSH) */
3169: /* ioctl(_tty_ch,TCFLSH,0) */
3170: flushinp();
3171: }
3172:
3173: int
3174: md_getuid(void)
3175: {
3176: #ifdef _WIN32
3177: return(42);
3178: #else
3179: return(getuid());
3180: #endif
3181: }
3182:
3183: long
3184: md_memused(void)
3185: {
3186: #ifdef _WIN32
3187: MEMORYSTATUS stat;
3188:
3189: GlobalMemoryStatus(&stat);
3190:
3191: return((long)stat.dwTotalPageFile);
3192: #else
3193: return( (long)sbrk(0) );
3194: #endif
3195: }
3196:
3197: char *
3198: md_getusername(void)
3199: {
3200: static char login[80];
3201: char *l = NULL;
3202: #ifdef _WIN32
3203: LPSTR mybuffer;
3204: DWORD size = UNLEN + 1;
3205: TCHAR buffer[UNLEN + 1];
3206:
3207: mybuffer = buffer;
3208: GetUserName(mybuffer,&size);
3209: l = mybuffer;
3210: #endif
3211: #if !defined(_WIN32) && !defined(DJGPP)
3212: struct passwd *pw;
3213:
3214: pw = getpwuid(getuid());
3215:
3216: if (pw != NULL)
3217: l = pw->pw_name;
3218: #endif
3219:
3220: if ((l == NULL) || (*l == '\0'))
3221: if ( (l = getenv("USERNAME")) == NULL )
3222: if ( (l = getenv("LOGNAME")) == NULL )
3223: if ( (l = getenv("USER")) == NULL )
3224: l = "nobody";
3225:
3226: strncpy(login,l,80);
3227: login[79] = 0;
3228:
3229: return(login);
3230: }
3231:
3232: char *
3233: md_gethomedir(void)
3234: {
3235: static char homedir[PATH_MAX];
3236: char *h = NULL;
3237: size_t len;
3238: #if defined(_WIN32)
3239: TCHAR szPath[MAX_PATH];
3240: #endif
3241: #if defined(_WIN32) || defined(DJGPP)
3242: char slash = '\\';
3243: #else
3244: char slash = '/';
3245: struct passwd *pw;
3246: pw = getpwuid(getuid());
3247:
3248: if (pw != NULL)
3249: {
3250: h = pw->pw_dir;
3251: if (strcmp(h,"/") == 0)
3252: h = NULL;
3253: }
3254: #endif
3255: homedir[0] = 0;
3256:
3257: #ifdef _WIN32
3258: if(SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, szPath)))
3259: h = szPath;
3260: #endif
3261:
3262: if ( (h == NULL) || (*h == '\0') )
3263: if ( (h = getenv("HOME")) == NULL )
3264: if ( (h = getenv("HOMEDRIVE")) == NULL)
3265: h = "";
3266: else
3267: {
3268: strncpy(homedir,h,PATH_MAX-1);
3269: homedir[PATH_MAX-1] = 0;
3270:
3271: if ( (h = getenv("HOMEPATH")) == NULL)
3272: h = "";
3273: }
3274:
3275:
3276: len = strlen(homedir);
3277: strncat(homedir,h,PATH_MAX-len-1);
3278: len = strlen(homedir);
3279:
3280: if ((len > 0) && (homedir[len-1] != slash)) {
3281: homedir[len] = slash;
3282: homedir[len+1] = 0;
3283: }
3284:
3285: return(homedir);
3286: }
3287:
3288: int
3289: directory_exists(char *dirname)
3290: {
3291: struct stat sb;
3292:
3293: if (stat(dirname, &sb) == 0) /* path exists */
3294: return (sb.st_mode & S_IFDIR);
3295:
3296: return(0);
3297: }
3298:
3299: char *
3300: md_getroguedir(void)
3301: {
3302: static char path[1024];
3303: char *end,*home;
3304:
3305: if ( (home = getenv("ROGUEHOME")) != NULL)
3306: {
3307: if (*home)
3308: {
3309: strncpy(path, home, PATH_MAX - 20);
3310:
3311: end = &path[strlen(path)-1];
3312:
3313:
3314: while( (end >= path) && ((*end == '/') || (*end == '\\')))
3315: *end-- = '\0';
3316:
3317: if (directory_exists(path))
3318: return(path);
3319: }
3320: }
3321:
3322: if (directory_exists("/var/games/roguelike"))
3323: return("/var/games/roguelike");
3324: if (directory_exists("/var/lib/roguelike"))
3325: return("/var/lib/roguelike");
3326: if (directory_exists("/var/roguelike"))
3327: return("/var/roguelike");
3328: if (directory_exists("/usr/games/lib"))
3329: return("/usr/games/lib");
3330: if (directory_exists("/games/roguelik"))
3331: return("/games/roguelik");
3332:
3333: return("");
3334: }
3335:
3336: char *
3337: md_getshell(void)
3338: {
3339: static char shell[PATH_MAX];
3340: char *s = NULL;
3341: #ifdef _WIN32
3342: char *def = "C:\\WINDOWS\\SYSTEM32\\CMD.EXE";
3343: #elif defined(__DJGPP__)
3344: char *def = "C:\\COMMAND.COM";
3345: #else
3346: char *def = "/bin/sh";
3347: struct passwd *pw;
3348: pw = getpwuid(getuid());
3349: if (pw != NULL)
3350: s = pw->pw_shell;
3351: #endif
3352: if ((s == NULL) || (*s == '\0'))
3353: if ( (s = getenv("COMSPEC")) == NULL)
3354: if ( (s = getenv("SHELL")) == NULL)
3355: if ( (s = getenv("SystemRoot")) == NULL)
3356: s = def;
3357:
3358: strncpy(shell,s,PATH_MAX);
3359: shell[PATH_MAX-1] = 0;
3360:
3361: return(shell);
3362: }
3363:
3364: char *
3365: md_gethostname(void)
3366: {
3367: static char nodename[80];
3368: char *n = NULL;
3369: #if !defined(_WIN32) && !defined(__DJGPP__)
3370: struct utsname ourname;
3371:
3372: if (uname(&ourname) == 0)
3373: n = ourname.nodename;
3374: #endif
3375: if ((n == NULL) || (*n == '\0'))
3376: if ( (n = getenv("COMPUTERNAME")) == NULL)
3377: if ( (n = getenv("HOSTNAME")) == NULL)
3378: n = "localhost";
3379:
3380: strncpy(nodename, n, 80);
3381: nodename[79] = 0;
3382:
3383: return(nodename);
3384: }
3385:
3386: int
3387: md_shellescape(void)
3388: {
3389: #if (!defined(_WIN32) && !defined(__DJGPP__))
3390: int ret_status;
3391: int pid;
3392: #endif
3393: char *sh;
3394:
3395: sh = md_getshell();
3396:
3397: #if defined(_WIN32)
3398: return(_spawnl(_P_WAIT,sh,"shell",NULL,0));
3399: #elif defined(__DJGPP__)
3400: return ( spawnl(P_WAIT,sh,"shell",NULL,0) );
3401: #else
3402: while((pid = fork()) < 0)
3403: sleep(1);
3404:
3405: if (pid == 0) /* Shell Process */
3406: {
3407: /*
3408: * Set back to original user, just in case
3409: */
3410: setuid(getuid());
3411: setgid(getgid());
3412: execl(sh == NULL ? "/bin/sh" : sh, "shell", "-i", 0);
3413: perror("No shelly");
3414: _exit(-1);
3415: }
3416: else /* Application */
3417: {
3418: while (wait(&ret_status) != pid)
3419: continue;
3420: }
3421:
3422: return(ret_status);
3423: #endif
3424: }
3425:
3426: int
3427: md_erasechar(void)
3428: {
3429: /*
3430: return(_tty.sg_erase);
3431: return(_tty.c_cc[VERASE]);
3432: */
3433: return(erasechar());
3434: }
3435:
3436: int
3437: md_killchar(void)
3438: {
3439: /*
3440: return(_tty.sg_kill);
3441: return(_tty.c_cc[VKILL]);
3442: */
3443: return(killchar());
3444: }
3445:
3446: int md_endian = 0x01020304;
3447:
3448: unsigned long int
3449: md_ntohl(unsigned long int x)
3450: {
3451: #ifndef HAVE_ARPA_INET_H
3452: if ( *((char *)&md_endian) == 0x01 )
3453: return(x);
3454: else
3455: return( ((x & 0x000000ffU) << 24) |
3456: ((x & 0x0000ff00U) << 8) |
3457: ((x & 0x00ff0000U) >> 8) |
3458: ((x & 0xff000000U) >> 24) );
3459: #else
3460: return( ntohl(x) );
3461: #endif
3462: }
3463:
3464: unsigned long int
3465: md_htonl(unsigned long int x)
3466: {
3467: #ifndef HAVE_ARPA_INET_H
3468: if ( *((char *)&md_endian) == 0x01 )
3469: return(x);
3470: else
3471: return( ((x & 0x000000ffU) << 24) |
3472: ((x & 0x0000ff00U) << 8) |
3473: ((x & 0x00ff0000U) >> 8) |
3474: ((x & 0xff000000U) >> 24) );
3475: #else
3476: return( htonl(x) );
3477: #endif
3478: }
3479:
3480: void
3481: md_init(void)
3482: {
3483: #ifdef __INTERIX
3484: char *term;
3485:
3486: term = getenv("TERM");
3487:
3488: if (term == NULL)
3489: setenv("TERM","interix");
3490: #endif
3491: #if defined(__DJGPP__) || defined(_WIN32)
3492: _fmode = _O_BINARY;
3493: #endif
3494: }
3495:
3496: char *
3497: md_getpass(char *prompt)
3498: {
3499: #ifdef _WIN32
3500: static char password_buffer[9];
3501: char *p = password_buffer;
3502: int c, count = 0;
3503: int max_length = 9;
3504:
3505: fflush(stdout);
3506: /* If we can't prompt, abort */
3507: if (fputs(prompt, stderr) < 0)
3508: {
3509: *p = '\0';
3510: return NULL;
3511: }
3512:
3513: for(;;)
3514: {
3515: /* Get a character with no echo */
3516: c = _getch();
3517:
3518: /* Exit on interrupt (^c or ^break) */
3519: if (c == '\003' || c == 0x100)
3520: exit(1);
3521:
3522: /* Terminate on end of line or file (^j, ^m, ^d, ^z) */
3523: if (c == '\r' || c == '\n' || c == '\004' || c == '\032')
3524: break;
3525:
3526: /* Back up on backspace */
3527: if (c == '\b')
3528: {
3529: if (count)
3530: count--;
3531: else if (p > password_buffer)
3532: p--;
3533: continue;
3534: }
3535:
3536: /* Ignore DOS extended characters */
3537: if ((c & 0xff) != c)
3538: continue;
3539:
3540: /* Add to password if it isn't full */
3541: if (p < password_buffer + max_length - 1)
3542: *p++ = c;
3543: else
3544: count++;
3545: }
3546: *p = '\0';
3547:
3548: fputc('\n', stderr);
3549:
3550: return password_buffer;
3551: #else
3552: return( (char *) getpass(prompt) );
3553: #endif
3554: }
3555:
3556: #ifdef SIGTSTP
3557:
3558: /*
3559: * handle stop and start signals
3560: */
3561:
3562: /*UNUSED*/
3563: void
3564: tstp(int a)
3565: {
3566: mvcur(0, cols - 1, lines - 1, 0);
3567: fflush(stdout);
3568: kill(0, SIGTSTP);
3569: signal(SIGTSTP, tstp);
3570: crmode();
3571: noecho();
3572: clearok(curscr, TRUE);
3573: touchwin(cw);
3574: draw(cw);
3575: flushinp();
3576: }
3577: #endif
3578:
3579: void
3580: md_setup(void)
3581: {
3582: #ifdef SIGTSTP
3583: signal(SIGTSTP, tstp);
3584: #endif
3585: #ifdef SIGHUP
3586: signal(SIGHUP, auto_save);
3587: #endif
3588: signal(SIGTERM, auto_save);
3589: signal(SIGINT, quit);
3590: #ifdef SIGQUIT
3591: signal(SIGQUIT, endit);
3592: #endif
3593: #if defined(__CYGWIN__) || defined(__MSYS__)
3594: ESCDELAY = 250;
3595: #endif
3596: nonl();
3597: crmode(); /* Cbreak mode */
3598: noecho(); /* Echo off */
3599: }
3600:
3601: void
3602: md_normaluser(void)
3603: {
3604: #ifndef _WIN32
3605: setuid(getuid());
3606: setgid(getgid());
3607: #endif
3608: }
3609:
3610: int
3611: md_fileno(FILE *fp)
3612: {
3613: #ifdef _WIN32
3614: return( _fileno(fp) );
3615: #else
3616: return( fileno(fp) );
3617: #endif
3618: }
3619:
3620: int
3621: md_unlink(char *file)
3622: {
3623: #ifdef _WIN32
3624: chmod(file, 0600);
3625: return( _unlink(file) );
3626: #else
3627: return(unlink(file));
3628: #endif
3629: }
3630:
3631: unsigned int
3632: md_random_seed(void)
3633: {
3634: unsigned int seed;
3635: seed = (unsigned int) time((time_t *) NULL);
3636: #ifdef _WIN32
3637: seed += _getpid();
3638: #else
3639: seed += getpid();
3640: #endif
3641: return seed;
3642: }