Annotation of early-roguelike/arogue5/state.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: state.c - Portable Rogue Save State Code
! 3:
! 4: Copyright (C) 1999, 2000, 2005 Nicholas J. Kisseberth
! 5: All rights reserved.
! 6:
! 7: Redistribution and use in source and binary forms, with or without
! 8: modification, are permitted provided that the following conditions
! 9: are met:
! 10: 1. Redistributions of source code must retain the above copyright
! 11: notice, this list of conditions and the following disclaimer.
! 12: 2. Redistributions in binary form must reproduce the above copyright
! 13: notice, this list of conditions and the following disclaimer in the
! 14: documentation and/or other materials provided with the distribution.
! 15: 3. Neither the name(s) of the author(s) nor the names of other contributors
! 16: may be used to endorse or promote products derived from this software
! 17: without specific prior written permission.
! 18:
! 19: THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS ``AS IS'' AND
! 20: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 21: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 22: ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE
! 23: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 24: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 25: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 26: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 27: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 28: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 29: SUCH DAMAGE.
! 30: */
! 31:
! 32: /************************************************************************/
! 33: /* Save State Code */
! 34: /************************************************************************/
! 35:
! 36: #define RSID_STATS 0xABCD0001
! 37: #define RSID_MSTATS 0xABCD0002
! 38: #define RSID_THING 0xABCD0003
! 39: #define RSID_OBJECT 0xABCD0004
! 40: #define RSID_MAGICITEMS 0xABCD0005
! 41: #define RSID_KNOWS 0xABCD0006
! 42: #define RSID_GUESSES 0xABCD0007
! 43: #define RSID_OBJECTLIST 0xABCD0008
! 44: #define RSID_BAGOBJECT 0xABCD0009
! 45: #define RSID_MONSTERLIST 0xABCD000A
! 46: #define RSID_MONSTERSTATS 0xABCD000B
! 47: #define RSID_MONSTERS 0xABCD000C
! 48: #define RSID_TRAP 0xABCD000D
! 49: #define RSID_WINDOW 0xABCD000E
! 50: #define RSID_DAEMONS 0xABCD000F
! 51: #define RSID_STICKS 0xABCD0010
! 52: #define RSID_IARMOR 0xABCD0011
! 53: #define RSID_SPELLS 0xABCD0012
! 54: #define RSID_ILIST 0xABCD0013
! 55: #define RSID_HLIST 0xABCD0014
! 56: #define RSID_DEATHTYPE 0xABCD0015
! 57: #define RSID_CTYPES 0XABCD0016
! 58: #define RSID_COORDLIST 0XABCD0017
! 59: #define RSID_ROOMS 0XABCD0018
! 60:
! 61: #include <curses.h>
! 62: #include <stdio.h>
! 63: #include <stdlib.h>
! 64: #include <string.h>
! 65: #include "rogue.h"
! 66:
! 67: int rs_read_int(FILE *inf, int *i);
! 68: int rs_write_int(FILE *savef, int c);
! 69: int list_size(struct linked_list *l);
! 70: int rs_write_object_list(FILE *savef, struct linked_list *l);
! 71: int rs_read_object_list(FILE *inf, struct linked_list **list);
! 72:
! 73: #define READSTAT (format_error || read_error )
! 74: #define WRITESTAT (write_error)
! 75:
! 76: static int read_error = FALSE;
! 77: static int write_error = FALSE;
! 78: static int format_error = FALSE;
! 79: static int endian = 0x01020304;
! 80: #define big_endian ( *((char *)&endian) == 0x01 )
! 81:
! 82: int
! 83: rs_write(FILE *savef, void *ptr, size_t size)
! 84: {
! 85: if (write_error)
! 86: return(WRITESTAT);
! 87:
! 88: if (encwrite(ptr, size, savef) != size)
! 89: write_error = 1;
! 90:
! 91: return(WRITESTAT);
! 92: }
! 93:
! 94: int
! 95: rs_read(FILE *inf, void *ptr, size_t size)
! 96: {
! 97: if (read_error || format_error)
! 98: return(READSTAT);
! 99:
! 100: if (encread(ptr, size, inf) != size)
! 101: read_error = 1;
! 102:
! 103: return(READSTAT);
! 104: }
! 105:
! 106: int
! 107: rs_write_uchar(FILE *savef, unsigned char c)
! 108: {
! 109: if (write_error)
! 110: return(WRITESTAT);
! 111:
! 112: rs_write(savef, &c, 1);
! 113:
! 114: return(WRITESTAT);
! 115: }
! 116:
! 117: int
! 118: rs_read_uchar(FILE *inf, unsigned char *c)
! 119: {
! 120: if (read_error || format_error)
! 121: return(READSTAT);
! 122:
! 123: rs_read(inf, c, 1);
! 124:
! 125: return(READSTAT);
! 126: }
! 127:
! 128: int
! 129: rs_write_char(FILE *savef, char c)
! 130: {
! 131: if (write_error)
! 132: return(WRITESTAT);
! 133:
! 134: rs_write(savef, &c, 1);
! 135:
! 136: return(WRITESTAT);
! 137: }
! 138:
! 139: int
! 140: rs_read_char(FILE *inf, char *c)
! 141: {
! 142: if (read_error || format_error)
! 143: return(READSTAT);
! 144:
! 145: rs_read(inf, c, 1);
! 146:
! 147: return(READSTAT);
! 148: }
! 149:
! 150: int
! 151: rs_write_chars(FILE *savef, char *c, int count)
! 152: {
! 153: if (write_error)
! 154: return(WRITESTAT);
! 155:
! 156: rs_write_int(savef, count);
! 157: rs_write(savef, c, count);
! 158:
! 159: return(WRITESTAT);
! 160: }
! 161:
! 162: int
! 163: rs_read_chars(FILE *inf, char *i, int count)
! 164: {
! 165: int value = 0;
! 166:
! 167: if (read_error || format_error)
! 168: return(READSTAT);
! 169:
! 170: rs_read_int(inf, &value);
! 171:
! 172: if (value != count)
! 173: format_error = TRUE;
! 174:
! 175: rs_read(inf, i, count);
! 176:
! 177: return(READSTAT);
! 178: }
! 179:
! 180: int
! 181: rs_write_int(FILE *savef, int c)
! 182: {
! 183: unsigned char bytes[4];
! 184: unsigned char *buf = (unsigned char *) &c;
! 185:
! 186: if (write_error)
! 187: return(WRITESTAT);
! 188:
! 189: if (big_endian)
! 190: {
! 191: bytes[3] = buf[0];
! 192: bytes[2] = buf[1];
! 193: bytes[1] = buf[2];
! 194: bytes[0] = buf[3];
! 195: buf = bytes;
! 196: }
! 197:
! 198: rs_write(savef, buf, 4);
! 199:
! 200: return(WRITESTAT);
! 201: }
! 202:
! 203: int
! 204: rs_read_int(FILE *inf, int *i)
! 205: {
! 206: unsigned char bytes[4];
! 207: int input = 0;
! 208: unsigned char *buf = (unsigned char *)&input;
! 209:
! 210: if (read_error || format_error)
! 211: return(READSTAT);
! 212:
! 213: rs_read(inf, &input, 4);
! 214:
! 215: if (big_endian)
! 216: {
! 217: bytes[3] = buf[0];
! 218: bytes[2] = buf[1];
! 219: bytes[1] = buf[2];
! 220: bytes[0] = buf[3];
! 221: buf = bytes;
! 222: }
! 223:
! 224: *i = *((int *) buf);
! 225:
! 226: return(READSTAT);
! 227: }
! 228:
! 229: int
! 230: rs_write_ints(FILE *savef, int *c, int count)
! 231: {
! 232: int n = 0;
! 233:
! 234: if (write_error)
! 235: return(WRITESTAT);
! 236:
! 237: rs_write_int(savef, count);
! 238:
! 239: for(n = 0; n < count; n++)
! 240: if( rs_write_int(savef,c[n]) != 0)
! 241: break;
! 242:
! 243: return(WRITESTAT);
! 244: }
! 245:
! 246: int
! 247: rs_read_ints(FILE *inf, int *i, int count)
! 248: {
! 249: int n, value;
! 250:
! 251: if (read_error || format_error)
! 252: return(READSTAT);
! 253:
! 254: rs_read_int(inf,&value);
! 255:
! 256: if (value != count)
! 257: format_error = TRUE;
! 258:
! 259: for(n = 0; n < count; n++)
! 260: if (rs_read_int(inf, &i[n]) != 0)
! 261: break;
! 262:
! 263: return(READSTAT);
! 264: }
! 265:
! 266: int
! 267: rs_write_boolean(FILE *savef, bool c)
! 268: {
! 269: unsigned char buf = (c == 0) ? 0 : 1;
! 270:
! 271: if (write_error)
! 272: return(WRITESTAT);
! 273:
! 274: rs_write(savef, &buf, 1);
! 275:
! 276: return(WRITESTAT);
! 277: }
! 278:
! 279: int
! 280: rs_read_boolean(FILE *inf, bool *i)
! 281: {
! 282: unsigned char buf = 0;
! 283:
! 284: if (read_error || format_error)
! 285: return(READSTAT);
! 286:
! 287: rs_read(inf, &buf, 1);
! 288:
! 289: *i = (buf != 0);
! 290:
! 291: return(READSTAT);
! 292: }
! 293:
! 294: int
! 295: rs_write_booleans(FILE *savef, bool *c, int count)
! 296: {
! 297: int n = 0;
! 298:
! 299: if (write_error)
! 300: return(WRITESTAT);
! 301:
! 302: rs_write_int(savef, count);
! 303:
! 304: for(n = 0; n < count; n++)
! 305: if (rs_write_boolean(savef, c[n]) != 0)
! 306: break;
! 307:
! 308: return(WRITESTAT);
! 309: }
! 310:
! 311: int
! 312: rs_read_booleans(FILE *inf, bool *i, int count)
! 313: {
! 314: int n = 0, value = 0;
! 315:
! 316: if (read_error || format_error)
! 317: return(READSTAT);
! 318:
! 319: rs_read_int(inf,&value);
! 320:
! 321: if (value != count)
! 322: format_error = TRUE;
! 323:
! 324: for(n = 0; n < count; n++)
! 325: if (rs_read_boolean(inf, &i[n]) != 0)
! 326: break;
! 327:
! 328: return(READSTAT);
! 329: }
! 330:
! 331: int
! 332: rs_write_short(FILE *savef, short c)
! 333: {
! 334: unsigned char bytes[2];
! 335: unsigned char *buf = (unsigned char *) &c;
! 336:
! 337: if (write_error)
! 338: return(WRITESTAT);
! 339:
! 340: if (big_endian)
! 341: {
! 342: bytes[1] = buf[0];
! 343: bytes[0] = buf[1];
! 344: buf = bytes;
! 345: }
! 346:
! 347: rs_write(savef, buf, 2);
! 348:
! 349: return(WRITESTAT);
! 350: }
! 351:
! 352: int
! 353: rs_read_short(FILE *inf, short *i)
! 354: {
! 355: unsigned char bytes[2];
! 356: short input;
! 357: unsigned char *buf = (unsigned char *)&input;
! 358:
! 359: if (read_error || format_error)
! 360: return(READSTAT);
! 361:
! 362: rs_read(inf, &input, 2);
! 363:
! 364: if (big_endian)
! 365: {
! 366: bytes[1] = buf[0];
! 367: bytes[0] = buf[1];
! 368: buf = bytes;
! 369: }
! 370:
! 371: *i = *((short *) buf);
! 372:
! 373: return(READSTAT);
! 374: }
! 375:
! 376: int
! 377: rs_write_shorts(FILE *savef, short *c, int count)
! 378: {
! 379: int n = 0;
! 380:
! 381: if (write_error)
! 382: return(WRITESTAT);
! 383:
! 384: rs_write_int(savef, count);
! 385:
! 386: for(n = 0; n < count; n++)
! 387: if (rs_write_short(savef, c[n]) != 0)
! 388: break;
! 389:
! 390: return(WRITESTAT);
! 391: }
! 392:
! 393: int
! 394: rs_read_shorts(FILE *inf, short *i, int count)
! 395: {
! 396: int n = 0, value = 0;
! 397:
! 398: if (read_error || format_error)
! 399: return(READSTAT);
! 400:
! 401: rs_read_int(inf,&value);
! 402:
! 403: if (value != count)
! 404: format_error = TRUE;
! 405:
! 406: for(n = 0; n < value; n++)
! 407: if (rs_read_short(inf, &i[n]) != 0)
! 408: break;
! 409:
! 410: return(READSTAT);
! 411: }
! 412:
! 413: int
! 414: rs_write_ushort(FILE *savef, unsigned short c)
! 415: {
! 416: unsigned char bytes[2];
! 417: unsigned char *buf = (unsigned char *) &c;
! 418:
! 419: if (write_error)
! 420: return(WRITESTAT);
! 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: int
! 435: rs_read_ushort(FILE *inf, unsigned short *i)
! 436: {
! 437: unsigned char bytes[2];
! 438: unsigned short input;
! 439: unsigned char *buf = (unsigned char *)&input;
! 440:
! 441: if (read_error || format_error)
! 442: return(READSTAT);
! 443:
! 444: rs_read(inf, &input, 2);
! 445:
! 446: if (big_endian)
! 447: {
! 448: bytes[1] = buf[0];
! 449: bytes[0] = buf[1];
! 450: buf = bytes;
! 451: }
! 452:
! 453: *i = *((unsigned short *) buf);
! 454:
! 455: return(READSTAT);
! 456: }
! 457:
! 458: int
! 459: rs_write_uint(FILE *savef, unsigned int c)
! 460: {
! 461: unsigned char bytes[4];
! 462: unsigned char *buf = (unsigned char *) &c;
! 463:
! 464: if (write_error)
! 465: return(WRITESTAT);
! 466:
! 467: if (big_endian)
! 468: {
! 469: bytes[3] = buf[0];
! 470: bytes[2] = buf[1];
! 471: bytes[1] = buf[2];
! 472: bytes[0] = buf[3];
! 473: buf = bytes;
! 474: }
! 475:
! 476: rs_write(savef, buf, 4);
! 477:
! 478: return(WRITESTAT);
! 479: }
! 480:
! 481: int
! 482: rs_read_uint(FILE *inf, unsigned int *i)
! 483: {
! 484: unsigned char bytes[4];
! 485: int input;
! 486: unsigned char *buf = (unsigned char *)&input;
! 487:
! 488: if (read_error || format_error)
! 489: return(READSTAT);
! 490:
! 491: rs_read(inf, &input, 4);
! 492:
! 493: if (big_endian)
! 494: {
! 495: bytes[3] = buf[0];
! 496: bytes[2] = buf[1];
! 497: bytes[1] = buf[2];
! 498: bytes[0] = buf[3];
! 499: buf = bytes;
! 500: }
! 501:
! 502: *i = *((unsigned int *) buf);
! 503:
! 504: return(READSTAT);
! 505: }
! 506:
! 507: int
! 508: rs_write_long(FILE *savef, long c)
! 509: {
! 510: int c2;
! 511: unsigned char bytes[4];
! 512: unsigned char *buf = (unsigned char *)&c;
! 513:
! 514: if (write_error)
! 515: return(WRITESTAT);
! 516:
! 517: if (sizeof(long) == 8)
! 518: {
! 519: c2 = c;
! 520: buf = (unsigned char *) &c2;
! 521: }
! 522:
! 523: if (big_endian)
! 524: {
! 525: bytes[3] = buf[0];
! 526: bytes[2] = buf[1];
! 527: bytes[1] = buf[2];
! 528: bytes[0] = buf[3];
! 529: buf = bytes;
! 530: }
! 531:
! 532: rs_write(savef, buf, 4);
! 533:
! 534: return(WRITESTAT);
! 535: }
! 536:
! 537: int
! 538: rs_read_long(FILE *inf, long *i)
! 539: {
! 540: unsigned char bytes[4];
! 541: long input;
! 542: unsigned char *buf = (unsigned char *) &input;
! 543:
! 544: if (read_error || format_error)
! 545: return(READSTAT);
! 546:
! 547: rs_read(inf, &input, 4);
! 548:
! 549: if (big_endian)
! 550: {
! 551: bytes[3] = buf[0];
! 552: bytes[2] = buf[1];
! 553: bytes[1] = buf[2];
! 554: bytes[0] = buf[3];
! 555: buf = bytes;
! 556: }
! 557:
! 558: *i = *((long *) buf);
! 559:
! 560: return(READSTAT);
! 561: }
! 562:
! 563: int
! 564: rs_write_longs(FILE *savef, long *c, int count)
! 565: {
! 566: int n = 0;
! 567:
! 568: if (write_error)
! 569: return(WRITESTAT);
! 570:
! 571: rs_write_int(savef,count);
! 572:
! 573: for(n = 0; n < count; n++)
! 574: rs_write_long(savef, c[n]);
! 575:
! 576: return(WRITESTAT);
! 577: }
! 578:
! 579: int
! 580: rs_read_longs(FILE *inf, long *i, int count)
! 581: {
! 582: int n = 0, value = 0;
! 583:
! 584: if (read_error || format_error)
! 585: return(READSTAT);
! 586:
! 587: rs_read_int(inf,&value);
! 588:
! 589: if (value != count)
! 590: format_error = TRUE;
! 591:
! 592: for(n = 0; n < value; n++)
! 593: if (rs_read_long(inf, &i[n]) != 0)
! 594: break;
! 595:
! 596: return(READSTAT);
! 597: }
! 598:
! 599: int
! 600: rs_write_ulong(FILE *savef, unsigned long c)
! 601: {
! 602: unsigned int c2;
! 603: unsigned char bytes[4];
! 604: unsigned char *buf = (unsigned char *)&c;
! 605:
! 606: if (write_error)
! 607: return(WRITESTAT);
! 608:
! 609: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
! 610: {
! 611: c2 = c;
! 612: buf = (unsigned char *) &c2;
! 613: }
! 614:
! 615: if (big_endian)
! 616: {
! 617: bytes[3] = buf[0];
! 618: bytes[2] = buf[1];
! 619: bytes[1] = buf[2];
! 620: bytes[0] = buf[3];
! 621: buf = bytes;
! 622: }
! 623:
! 624: rs_write(savef, buf, 4);
! 625:
! 626: return(WRITESTAT);
! 627: }
! 628:
! 629: int
! 630: rs_read_ulong(FILE *inf, unsigned long *i)
! 631: {
! 632: unsigned char bytes[4];
! 633: unsigned long input;
! 634: unsigned char *buf = (unsigned char *) &input;
! 635:
! 636: if (read_error || format_error)
! 637: return(READSTAT);
! 638:
! 639: rs_read(inf, &input, 4);
! 640:
! 641: if (big_endian)
! 642: {
! 643: bytes[3] = buf[0];
! 644: bytes[2] = buf[1];
! 645: bytes[1] = buf[2];
! 646: bytes[0] = buf[3];
! 647: buf = bytes;
! 648: }
! 649:
! 650: if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
! 651: *i = *((unsigned int *) buf);
! 652: else
! 653: *i = *((unsigned long *) buf);
! 654:
! 655: return(READSTAT);
! 656: }
! 657:
! 658: int
! 659: rs_write_ulongs(FILE *savef, unsigned long *c, int count)
! 660: {
! 661: int n = 0;
! 662:
! 663: if (write_error)
! 664: return(WRITESTAT);
! 665:
! 666: rs_write_int(savef,count);
! 667:
! 668: for(n = 0; n < count; n++)
! 669: if (rs_write_ulong(savef,c[n]) != 0)
! 670: break;
! 671:
! 672: return(WRITESTAT);
! 673: }
! 674:
! 675: int
! 676: rs_read_ulongs(FILE *inf, unsigned long *i, int count)
! 677: {
! 678: int n = 0, value = 0;
! 679:
! 680: if (read_error || format_error)
! 681: return(READSTAT);
! 682:
! 683: rs_read_int(inf,&value);
! 684:
! 685: if (value != count)
! 686: format_error = TRUE;
! 687:
! 688: for(n = 0; n < count; n++)
! 689: if (rs_read_ulong(inf, &i[n]) != 0)
! 690: break;
! 691:
! 692: return(READSTAT);
! 693: }
! 694:
! 695: int
! 696: rs_write_marker(FILE *savef, int id)
! 697: {
! 698: if (write_error)
! 699: return(WRITESTAT);
! 700:
! 701: rs_write_int(savef, id);
! 702:
! 703: return(WRITESTAT);
! 704: }
! 705:
! 706: int
! 707: rs_read_marker(FILE *inf, int id)
! 708: {
! 709: int nid;
! 710:
! 711: if (read_error || format_error)
! 712: return(READSTAT);
! 713:
! 714: if (rs_read_int(inf, &nid) == 0)
! 715: if (id != nid)
! 716: format_error = 1;
! 717:
! 718: return(READSTAT);
! 719: }
! 720:
! 721:
! 722:
! 723: /******************************************************************************/
! 724:
! 725: int
! 726: rs_write_string(FILE *savef, char *s)
! 727: {
! 728: int len = 0;
! 729:
! 730: if (write_error)
! 731: return(WRITESTAT);
! 732:
! 733: len = (s == NULL) ? 0 : (int) strlen(s) + 1;
! 734:
! 735: rs_write_int(savef, len);
! 736: rs_write_chars(savef, s, len);
! 737:
! 738: return(WRITESTAT);
! 739: }
! 740:
! 741: int
! 742: rs_read_string(FILE *inf, char *s, int max)
! 743: {
! 744: int len = 0;
! 745:
! 746: if (read_error || format_error)
! 747: return(READSTAT);
! 748:
! 749: rs_read_int(inf, &len);
! 750:
! 751: if (len > max)
! 752: format_error = TRUE;
! 753:
! 754: rs_read_chars(inf, s, len);
! 755:
! 756: return(READSTAT);
! 757: }
! 758:
! 759: int
! 760: rs_read_new_string(FILE *inf, char **s)
! 761: {
! 762: int len=0;
! 763: char *buf=0;
! 764:
! 765: if (read_error || format_error)
! 766: return(READSTAT);
! 767:
! 768: rs_read_int(inf, &len);
! 769:
! 770: if (len == 0)
! 771: buf = NULL;
! 772: else
! 773: {
! 774: buf = malloc(len);
! 775:
! 776: if (buf == NULL)
! 777: read_error = TRUE;
! 778: }
! 779:
! 780: rs_read_chars(inf, buf, len);
! 781:
! 782: *s = buf;
! 783:
! 784: return(READSTAT);
! 785: }
! 786:
! 787: int
! 788: rs_write_strings(FILE *savef, char *s[], int count)
! 789: {
! 790: int n = 0;
! 791:
! 792: if (write_error)
! 793: return(WRITESTAT);
! 794:
! 795: rs_write_int(savef, count);
! 796:
! 797: for(n = 0; n < count; n++)
! 798: if (rs_write_string(savef, s[n]) != 0)
! 799: break;
! 800:
! 801: return(WRITESTAT);
! 802: }
! 803:
! 804: int
! 805: rs_read_strings(FILE *inf, char **s, int count, int max)
! 806: {
! 807: int n = 0;
! 808: int value = 0;
! 809:
! 810: if (read_error || format_error)
! 811: return(READSTAT);
! 812:
! 813: rs_read_int(inf, &value);
! 814:
! 815: if (value != count)
! 816: format_error = TRUE;
! 817:
! 818: for(n = 0; n < count; n++)
! 819: if (rs_read_string(inf, s[n], max) != 0)
! 820: break;
! 821:
! 822: return(READSTAT);
! 823: }
! 824:
! 825: int
! 826: rs_read_new_strings(FILE *inf, char **s, int count)
! 827: {
! 828: int n = 0;
! 829: int value = 0;
! 830:
! 831: if (read_error || format_error)
! 832: return(READSTAT);
! 833:
! 834: rs_read_int(inf, &value);
! 835:
! 836: if (value != count)
! 837: format_error = TRUE;
! 838:
! 839: for(n = 0; n < count; n++)
! 840: if (rs_read_new_string(inf, &s[n]) != 0)
! 841: break;
! 842:
! 843: return(READSTAT);
! 844: }
! 845:
! 846: int
! 847: rs_write_string_index(FILE *savef, char *master[], int max, const char *str)
! 848: {
! 849: int i;
! 850:
! 851: if (write_error)
! 852: return(WRITESTAT);
! 853:
! 854: for(i = 0; i < max; i++)
! 855: if (str == master[i])
! 856: return( rs_write_int(savef, i) );
! 857:
! 858: return( rs_write_int(savef,-1) );
! 859: }
! 860:
! 861: int
! 862: rs_read_string_index(FILE *inf, char *master[], int maxindex, char **str)
! 863: {
! 864: int i;
! 865:
! 866: if (read_error || format_error)
! 867: return(READSTAT);
! 868:
! 869: rs_read_int(inf, &i);
! 870:
! 871: if (i > maxindex)
! 872: format_error = TRUE;
! 873: else if (i >= 0)
! 874: *str = master[i];
! 875: else
! 876: *str = NULL;
! 877:
! 878: return(READSTAT);
! 879: }
! 880:
! 881: int
! 882: rs_write_coord(FILE *savef, coord c)
! 883: {
! 884: if (write_error)
! 885: return(WRITESTAT);
! 886:
! 887: rs_write_int(savef, c.x);
! 888: rs_write_int(savef, c.y);
! 889:
! 890: return(WRITESTAT);
! 891: }
! 892:
! 893: int
! 894: rs_read_coord(FILE *inf, coord *c)
! 895: {
! 896: coord in;
! 897:
! 898: if (read_error || format_error)
! 899: return(READSTAT);
! 900:
! 901: rs_read_int(inf,&in.x);
! 902: rs_read_int(inf,&in.y);
! 903:
! 904: if (READSTAT == 0)
! 905: {
! 906: c->x = in.x;
! 907: c->y = in.y;
! 908: }
! 909:
! 910: return(READSTAT);
! 911: }
! 912:
! 913: int
! 914: rs_write_coord_list(FILE *savef, struct linked_list *l)
! 915: {
! 916: rs_write_marker(savef, RSID_COORDLIST);
! 917: rs_write_int(savef, list_size(l));
! 918:
! 919: while (l != NULL)
! 920: {
! 921: rs_write_coord(savef, *(coord *) l->l_data);
! 922: l = l->l_next;
! 923: }
! 924:
! 925: return(WRITESTAT);
! 926: }
! 927:
! 928: int
! 929: rs_read_coord_list(FILE *inf, struct linked_list **list)
! 930: {
! 931: int i, cnt;
! 932: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
! 933:
! 934: rs_read_marker(inf, RSID_COORDLIST);
! 935:
! 936: if (rs_read_int(inf,&cnt) != 0)
! 937: return(READSTAT);
! 938:
! 939: for (i = 0; i < cnt; i++)
! 940: {
! 941: l = new_item(sizeof(coord));
! 942: l->l_prev = previous;
! 943:
! 944: if (previous != NULL)
! 945: previous->l_next = l;
! 946:
! 947: rs_read_coord(inf,(coord *) l->l_data);
! 948:
! 949: if (previous == NULL)
! 950: head = l;
! 951:
! 952: previous = l;
! 953: }
! 954:
! 955: if (l != NULL)
! 956: l->l_next = NULL;
! 957:
! 958: *list = head;
! 959:
! 960: return(READSTAT);
! 961: }
! 962:
! 963: int
! 964: rs_write_window(FILE *savef, WINDOW *win)
! 965: {
! 966: int row,col,height,width;
! 967:
! 968: if (write_error)
! 969: return(WRITESTAT);
! 970:
! 971: width = getmaxx(win);
! 972: height = getmaxy(win);
! 973:
! 974: rs_write_marker(savef,RSID_WINDOW);
! 975: rs_write_int(savef,height);
! 976: rs_write_int(savef,width);
! 977:
! 978: for(row=0;row<height;row++)
! 979: for(col=0;col<width;col++)
! 980: if (rs_write_int(savef, mvwinch(win,row,col)) != 0)
! 981: return(WRITESTAT);
! 982:
! 983: return(WRITESTAT);
! 984: }
! 985:
! 986: int
! 987: rs_read_window(FILE *inf, WINDOW *win)
! 988: {
! 989: int row,col,maxlines,maxcols,value,width,height;
! 990:
! 991: if (read_error || format_error)
! 992: return(READSTAT);
! 993:
! 994: width = getmaxx(win);
! 995: height = getmaxy(win);
! 996:
! 997: rs_read_marker(inf, RSID_WINDOW);
! 998:
! 999: rs_read_int(inf, &maxlines);
! 1000: rs_read_int(inf, &maxcols);
! 1001:
! 1002: for(row = 0; row < maxlines; row++)
! 1003: for(col = 0; col < maxcols; col++)
! 1004: {
! 1005: if (rs_read_int(inf, &value) != 0)
! 1006: return(READSTAT);
! 1007:
! 1008: if ((row < height) && (col < width))
! 1009: mvwaddch(win,row,col,value);
! 1010: }
! 1011:
! 1012: return(READSTAT);
! 1013: }
! 1014:
! 1015: /******************************************************************************/
! 1016:
! 1017: void *
! 1018: get_list_item(struct linked_list *l, int i)
! 1019: {
! 1020: int count;
! 1021:
! 1022: for(count = 0; l != NULL; count++, l = l->l_next)
! 1023: if (count == i)
! 1024: return(l->l_data);
! 1025:
! 1026: return(NULL);
! 1027: }
! 1028:
! 1029: int
! 1030: find_list_ptr(struct linked_list *l, void *ptr)
! 1031: {
! 1032: int count;
! 1033:
! 1034: for(count = 0; l != NULL; count++, l = l->l_next)
! 1035: if (l->l_data == ptr)
! 1036: return(count);
! 1037:
! 1038: return(-1);
! 1039: }
! 1040:
! 1041: int
! 1042: list_size(struct linked_list *l)
! 1043: {
! 1044: int count;
! 1045:
! 1046: for(count = 0; l != NULL; count++, l = l->l_next)
! 1047: ;
! 1048:
! 1049: return(count);
! 1050: }
! 1051:
! 1052: /******************************************************************************/
! 1053:
! 1054: int
! 1055: rs_write_levtype(FILE *savef, LEVTYPE c)
! 1056: {
! 1057: int lt;
! 1058:
! 1059: switch(c)
! 1060: {
! 1061: case NORMLEV: lt = 1; break;
! 1062: case POSTLEV: lt = 2; break;
! 1063: case MAZELEV: lt = 3; break;
! 1064: case OUTSIDE: lt = 4; break;
! 1065: default: lt = -1; break;
! 1066: }
! 1067:
! 1068: rs_write_int(savef,lt);
! 1069:
! 1070: return(WRITESTAT);
! 1071: }
! 1072:
! 1073: int
! 1074: rs_read_levtype(FILE *inf, LEVTYPE *l)
! 1075: {
! 1076: int lt;
! 1077:
! 1078: rs_read_int(inf, <);
! 1079:
! 1080: switch(lt)
! 1081: {
! 1082: case 1: *l = NORMLEV; break;
! 1083: case 2: *l = POSTLEV; break;
! 1084: case 3: *l = MAZELEV; break;
! 1085: case 4: *l = OUTSIDE; break;
! 1086: default: *l = NORMLEV; break;
! 1087: }
! 1088:
! 1089: return(READSTAT);
! 1090: }
! 1091:
! 1092: int
! 1093: rs_write_stats(FILE *savef, struct stats *s)
! 1094: {
! 1095: if (write_error)
! 1096: return(WRITESTAT);
! 1097:
! 1098: rs_write_marker(savef, RSID_STATS);
! 1099: rs_write_short(savef, s->s_str);
! 1100: rs_write_short(savef, s->s_intel);
! 1101: rs_write_short(savef, s->s_wisdom);
! 1102: rs_write_short(savef, s->s_dext);
! 1103: rs_write_short(savef, s->s_const);
! 1104: rs_write_short(savef, s->s_charisma);
! 1105: rs_write_ulong(savef, s->s_exp);
! 1106: rs_write_int(savef, s->s_lvl);
! 1107: rs_write_int(savef, s->s_arm);
! 1108: rs_write_int(savef, s->s_hpt);
! 1109: rs_write_int(savef, s->s_pack);
! 1110: rs_write_int(savef, s->s_carry);
! 1111: rs_write(savef, s->s_dmg, sizeof(s->s_dmg));
! 1112:
! 1113: return(WRITESTAT);
! 1114: }
! 1115:
! 1116: int
! 1117: rs_read_stats(FILE *inf, struct stats *s)
! 1118: {
! 1119: if (read_error || format_error)
! 1120: return(READSTAT);
! 1121:
! 1122: rs_read_marker(inf, RSID_STATS);
! 1123: rs_read_short(inf,&s->s_str);
! 1124: rs_read_short(inf,&s->s_intel);
! 1125: rs_read_short(inf,&s->s_wisdom);
! 1126: rs_read_short(inf,&s->s_dext);
! 1127: rs_read_short(inf,&s->s_const);
! 1128: rs_read_short(inf,&s->s_charisma);
! 1129: rs_read_ulong(inf,&s->s_exp);
! 1130: rs_read_int(inf,&s->s_lvl);
! 1131: rs_read_int(inf,&s->s_arm);
! 1132: rs_read_int(inf,&s->s_hpt);
! 1133: rs_read_int(inf,&s->s_pack);
! 1134: rs_read_int(inf,&s->s_carry);
! 1135:
! 1136: rs_read(inf,s->s_dmg,sizeof(s->s_dmg));
! 1137:
! 1138: return(READSTAT);
! 1139: }
! 1140:
! 1141: int
! 1142: rs_write_magic_items(FILE *savef, struct magic_item *i, int count)
! 1143: {
! 1144: int n;
! 1145:
! 1146: rs_write_marker(savef, RSID_MAGICITEMS);
! 1147: rs_write_int(savef, count);
! 1148:
! 1149: for(n = 0; n < count; n++)
! 1150: {
! 1151: rs_write_int(savef,i[n].mi_prob);
! 1152: }
! 1153:
! 1154: return(WRITESTAT);
! 1155: }
! 1156:
! 1157: int
! 1158: rs_read_magic_items(FILE *inf, struct magic_item *mi, int count)
! 1159: {
! 1160: int n;
! 1161: int value;
! 1162:
! 1163: rs_read_marker(inf, RSID_MAGICITEMS);
! 1164:
! 1165: rs_read_int(inf, &value);
! 1166:
! 1167: if (value != count)
! 1168: format_error = 1;
! 1169: else
! 1170: {
! 1171: for(n = 0; n < value; n++)
! 1172: {
! 1173: rs_read_int(inf,&mi[n].mi_prob);
! 1174: }
! 1175: }
! 1176:
! 1177: return(READSTAT);
! 1178: }
! 1179:
! 1180: int
! 1181: rs_write_scrolls(FILE *savef)
! 1182: {
! 1183: int i;
! 1184:
! 1185: if (write_error)
! 1186: return(WRITESTAT);
! 1187:
! 1188: for(i = 0; i < MAXSCROLLS; i++)
! 1189: {
! 1190: rs_write_string(savef, s_names[i]);
! 1191: rs_write_boolean(savef,s_know[i]);
! 1192: rs_write_string(savef,s_guess[i]);
! 1193: }
! 1194:
! 1195: return(WRITESTAT);
! 1196: }
! 1197:
! 1198: int
! 1199: rs_read_scrolls(FILE *inf)
! 1200: {
! 1201: int i;
! 1202:
! 1203: if (read_error || format_error)
! 1204: return(READSTAT);
! 1205:
! 1206: for(i = 0; i < MAXSCROLLS; i++)
! 1207: {
! 1208: rs_read_new_string(inf,&s_names[i]);
! 1209: rs_read_boolean(inf,&s_know[i]);
! 1210: rs_read_new_string(inf,&s_guess[i]);
! 1211: }
! 1212:
! 1213: return(READSTAT);
! 1214: }
! 1215:
! 1216: int
! 1217: rs_write_potions(FILE *savef)
! 1218: {
! 1219: int i;
! 1220:
! 1221: if (write_error)
! 1222: return(WRITESTAT);
! 1223:
! 1224: for(i = 0; i < MAXPOTIONS; i++)
! 1225: {
! 1226: rs_write_string_index(savef,rainbow,NCOLORS,p_colors[i]);
! 1227: rs_write_boolean(savef,p_know[i]);
! 1228: rs_write_string(savef,p_guess[i]);
! 1229: }
! 1230:
! 1231: return(WRITESTAT);
! 1232: }
! 1233:
! 1234: int
! 1235: rs_read_potions(FILE *inf)
! 1236: {
! 1237: int i;
! 1238:
! 1239: if (read_error || format_error)
! 1240: return(READSTAT);
! 1241:
! 1242: for(i = 0; i < MAXPOTIONS; i++)
! 1243: {
! 1244: rs_read_string_index(inf,rainbow,NCOLORS,&p_colors[i]);
! 1245: rs_read_boolean(inf,&p_know[i]);
! 1246: rs_read_new_string(inf,&p_guess[i]);
! 1247: }
! 1248:
! 1249: return(READSTAT);
! 1250: }
! 1251:
! 1252: int
! 1253: rs_write_rings(FILE *savef)
! 1254: {
! 1255: int i;
! 1256:
! 1257: if (write_error)
! 1258: return(WRITESTAT);
! 1259:
! 1260: for(i = 0; i < MAXRINGS; i++)
! 1261: {
! 1262: rs_write_string_index(savef,stones,NSTONES,r_stones[i]);
! 1263: rs_write_boolean(savef,r_know[i]);
! 1264: rs_write_string(savef,r_guess[i]);
! 1265: }
! 1266:
! 1267: return(WRITESTAT);
! 1268: }
! 1269:
! 1270: int
! 1271: rs_read_rings(FILE *inf)
! 1272: {
! 1273: int i;
! 1274:
! 1275: if (read_error || format_error)
! 1276: return(READSTAT);
! 1277:
! 1278: for(i = 0; i < MAXRINGS; i++)
! 1279: {
! 1280: rs_read_string_index(inf,stones,NSTONES,&r_stones[i]);
! 1281: rs_read_boolean(inf,&r_know[i]);
! 1282: rs_read_new_string(inf,&r_guess[i]);
! 1283: }
! 1284:
! 1285: return(READSTAT);
! 1286: }
! 1287:
! 1288: int
! 1289: rs_write_sticks(FILE *savef)
! 1290: {
! 1291: int i;
! 1292:
! 1293: if (write_error)
! 1294: return(WRITESTAT);
! 1295:
! 1296: rs_write_marker(savef, RSID_STICKS);
! 1297:
! 1298: for (i = 0; i < MAXSTICKS; i++)
! 1299: {
! 1300: if (strcmp(ws_type[i],"staff") == 0)
! 1301: {
! 1302: rs_write_int(savef,0);
! 1303: rs_write_string_index(savef,wood,NWOOD,ws_made[i]);
! 1304: }
! 1305: else
! 1306: {
! 1307: rs_write_int(savef,1);
! 1308: rs_write_string_index(savef,metal,NMETAL,ws_made[i]);
! 1309: }
! 1310:
! 1311: rs_write_boolean(savef, ws_know[i]);
! 1312: rs_write_string(savef, ws_guess[i]);
! 1313: }
! 1314:
! 1315: return(WRITESTAT);
! 1316: }
! 1317:
! 1318: int
! 1319: rs_read_sticks(FILE *inf)
! 1320: {
! 1321: int i = 0, j = 0, list = 0;
! 1322:
! 1323: if (read_error || format_error)
! 1324: return(READSTAT);
! 1325:
! 1326: rs_read_marker(inf, RSID_STICKS);
! 1327:
! 1328: for(i = 0; i < MAXSTICKS; i++)
! 1329: {
! 1330: rs_read_int(inf,&list);
! 1331: ws_made[i] = NULL;
! 1332:
! 1333: if (list == 0)
! 1334: {
! 1335: rs_read_string_index(inf,wood,NWOOD,&ws_made[i]);
! 1336: ws_type[i] = "staff";
! 1337: }
! 1338: else
! 1339: {
! 1340: rs_read_string_index(inf,metal,NMETAL,&ws_made[i]);
! 1341: ws_type[i] = "wand";
! 1342: }
! 1343: rs_read_boolean(inf, &ws_know[i]);
! 1344: rs_read_new_string(inf, &ws_guess[i]);
! 1345: }
! 1346:
! 1347: return(READSTAT);
! 1348: }
! 1349:
! 1350: /* Assigns a number to an alchemy jug associated with a fuse, so it can be
! 1351: * found and reassociated when restoring.
! 1352: * 1 - 31: slot in pack
! 1353: * 32+ : on floor
! 1354: * Hopefully monsters do not pick them up.
! 1355: */
! 1356: int number_alchemy_jug(struct object *obj) {
! 1357: struct object *tobj = NULL;
! 1358: struct linked_list *item;
! 1359: int i = 1;
! 1360: for (item = player.t_pack; item != NULL; item = next(item), i++) {
! 1361: tobj = OBJPTR(item);
! 1362: if (tobj == obj &&
! 1363: tobj->o_type == MM &&
! 1364: tobj->o_which== MM_JUG)
! 1365: break;
! 1366: }
! 1367: if (item == NULL) {
! 1368: for (item = lvl_obj, i = 32; item != NULL; item = next(item), i++) {
! 1369: tobj = OBJPTR(item);
! 1370: if (tobj == obj &&
! 1371: tobj->o_type == MM &&
! 1372: tobj->o_which== MM_JUG)
! 1373: break;
! 1374: }
! 1375: }
! 1376: if (item == NULL)
! 1377: return 0;
! 1378: return i;
! 1379: }
! 1380:
! 1381: /* Takes an alchemy jug number and tracks down the object. */
! 1382: struct object *find_alchemy_jug(int n) {
! 1383: struct object *tobj;
! 1384: struct linked_list *item;
! 1385:
! 1386: if (n <= 0) {
! 1387: return NULL;
! 1388: }
! 1389: else if (n < 32) {
! 1390: item = player.t_pack;
! 1391: n -= 1;
! 1392: }
! 1393: else if (n < 1024) {
! 1394: item = lvl_obj;
! 1395: n -= 32;
! 1396: }
! 1397: else {
! 1398: /* This is likely a bug, not 1024 actual items on the floor. */
! 1399: return NULL;
! 1400: }
! 1401: while (item != NULL && n > 0) {
! 1402: item = next(item);
! 1403: n--;
! 1404: }
! 1405: if (item == NULL)
! 1406: return NULL;
! 1407: tobj = OBJPTR(item);
! 1408: if (tobj->o_type != MM || tobj->o_which != MM_JUG)
! 1409: return NULL;
! 1410: return tobj;
! 1411: }
! 1412:
! 1413: int
! 1414: rs_write_daemons(FILE *savef, struct delayed_action *d_list, int count)
! 1415: {
! 1416: int i = 0;
! 1417: int func = 0;
! 1418:
! 1419: if (write_error)
! 1420: return(WRITESTAT);
! 1421:
! 1422: rs_write_marker(savef, RSID_DAEMONS);
! 1423: rs_write_int(savef, count);
! 1424:
! 1425: for(i = 0; i < count; i++)
! 1426: {
! 1427: if ( d_list[i].d_func == rollwand)
! 1428: func = 1;
! 1429: else if ( d_list[i].d_func == doctor)
! 1430: func = 2;
! 1431: else if ( d_list[i].d_func == stomach)
! 1432: func = 3;
! 1433: else if ( d_list[i].d_func == runners)
! 1434: func = 4;
! 1435: else if ( d_list[i].d_func == swander)
! 1436: func = 5;
! 1437: else if ( d_list[i].d_func == trap_look)
! 1438: func = 6;
! 1439: else if ( d_list[i].d_func == ring_search)
! 1440: func = 7;
! 1441: else if ( d_list[i].d_func == ring_teleport)
! 1442: func = 8;
! 1443: else if ( d_list[i].d_func == strangle)
! 1444: func = 9;
! 1445: else if ( d_list[i].d_func == fumble)
! 1446: func = 10;
! 1447: else if ( d_list[i].d_func == wghtchk)
! 1448: func = 11;
! 1449: else if ( d_list[i].d_func == unstink)
! 1450: func = 12;
! 1451: else if ( d_list[i].d_func == res_strength)
! 1452: func = 13;
! 1453: else if ( d_list[i].d_func == un_itch)
! 1454: func = 14;
! 1455: else if ( d_list[i].d_func == cure_disease)
! 1456: func = 15;
! 1457: else if ( d_list[i].d_func == unconfuse)
! 1458: func = 16;
! 1459: else if ( d_list[i].d_func == suffocate)
! 1460: func = 17;
! 1461: else if ( d_list[i].d_func == undance)
! 1462: func = 18;
! 1463: else if ( d_list[i].d_func == alchemy)
! 1464: func = 19;
! 1465: else if ( d_list[i].d_func == dust_appear)
! 1466: func = 20;
! 1467: else if ( d_list[i].d_func == unchoke)
! 1468: func = 21;
! 1469: else if ( d_list[i].d_func == sight)
! 1470: func = 22;
! 1471: else if ( d_list[i].d_func == noslow)
! 1472: func = 23;
! 1473: else if ( d_list[i].d_func == nohaste)
! 1474: func = 24;
! 1475: else if ( d_list[i].d_func == unclrhead)
! 1476: func = 25;
! 1477: else if ( d_list[i].d_func == unsee)
! 1478: func = 26;
! 1479: else if ( d_list[i].d_func == unphase)
! 1480: func = 27;
! 1481: else if ( d_list[i].d_func == land)
! 1482: func = 28;
! 1483: else if ( d_list[i].d_func == appear)
! 1484: func = 29;
! 1485: else if (d_list[i].d_func == NULL)
! 1486: func = 0;
! 1487: else
! 1488: func = -1;
! 1489:
! 1490: rs_write_int(savef, d_list[i].d_type);
! 1491: rs_write_int(savef, func);
! 1492: /* d_arg is a pointer and can't actually be saved and restored. */
! 1493: if (func == 19)
! 1494: rs_write_int(savef, number_alchemy_jug(d_list[i].d_arg));
! 1495: else
! 1496: rs_write_int(savef, 0);
! 1497: rs_write_int(savef, d_list[i].d_time);
! 1498: }
! 1499:
! 1500: return(WRITESTAT);
! 1501: }
! 1502:
! 1503: int
! 1504: rs_read_daemons(FILE *inf, struct delayed_action *d_list, int count)
! 1505: {
! 1506: int i = 0;
! 1507: int func = 0;
! 1508: int value = 0;
! 1509: int dummy = 0;
! 1510:
! 1511: if (read_error || format_error)
! 1512: return(READSTAT);
! 1513:
! 1514: rs_read_marker(inf, RSID_DAEMONS);
! 1515: rs_read_int(inf, &value);
! 1516:
! 1517: if (value > count)
! 1518: format_error = TRUE;
! 1519:
! 1520:
! 1521: for(i=0; i < count; i++)
! 1522: {
! 1523: func = 0;
! 1524: rs_read_int(inf, &d_list[i].d_type);
! 1525: rs_read_int(inf, &func);
! 1526:
! 1527: switch(func)
! 1528: {
! 1529: case 1: d_list[i].d_func = rollwand;
! 1530: break;
! 1531: case 2: d_list[i].d_func = doctor;
! 1532: break;
! 1533: case 3: d_list[i].d_func = stomach;
! 1534: break;
! 1535: case 4: d_list[i].d_func = runners;
! 1536: break;
! 1537: case 5: d_list[i].d_func = swander;
! 1538: break;
! 1539: case 6: d_list[i].d_func = trap_look;
! 1540: break;
! 1541: case 7: d_list[i].d_func = ring_search;
! 1542: break;
! 1543: case 8: d_list[i].d_func = ring_teleport;
! 1544: break;
! 1545: case 9: d_list[i].d_func = strangle;
! 1546: break;
! 1547: case 10: d_list[i].d_func = fumble;
! 1548: break;
! 1549: case 11: d_list[i].d_func = wghtchk;
! 1550: break;
! 1551: case 12: d_list[i].d_func = unstink;
! 1552: break;
! 1553: case 13: d_list[i].d_func = res_strength;
! 1554: break;
! 1555: case 14: d_list[i].d_func = un_itch;
! 1556: break;
! 1557: case 15: d_list[i].d_func = cure_disease;
! 1558: break;
! 1559: case 16: d_list[i].d_func = unconfuse;
! 1560: break;
! 1561: case 17: d_list[i].d_func = suffocate;
! 1562: break;
! 1563: case 18: d_list[i].d_func = undance;
! 1564: break;
! 1565: case 19: d_list[i].d_func = alchemy;
! 1566: break;
! 1567: case 20: d_list[i].d_func = dust_appear;
! 1568: break;
! 1569: case 21: d_list[i].d_func = unchoke;
! 1570: break;
! 1571: case 22: d_list[i].d_func = sight;
! 1572: break;
! 1573: case 23: d_list[i].d_func = noslow;
! 1574: break;
! 1575: case 24: d_list[i].d_func = nohaste;
! 1576: break;
! 1577: case 25: d_list[i].d_func = unclrhead;
! 1578: break;
! 1579: case 26: d_list[i].d_func = unsee;
! 1580: break;
! 1581: case 27: d_list[i].d_func = unphase;
! 1582: break;
! 1583: case 28: d_list[i].d_func = land;
! 1584: break;
! 1585: case 29: d_list[i].d_func = appear;
! 1586: break;
! 1587: case 0:
! 1588: case -1:
! 1589: default: d_list[i].d_func = NULL;
! 1590: break;
! 1591: }
! 1592:
! 1593: /* Most functions don't use the argument. */
! 1594: rs_read_int(inf, &dummy);
! 1595: if (func == 2)
! 1596: d_list[i].d_arg = &player;
! 1597: else if (func == 19)
! 1598: d_list[i].d_arg = find_alchemy_jug(dummy);
! 1599: else
! 1600: d_list[i].d_arg = NULL;
! 1601:
! 1602: rs_read_int(inf, &d_list[i].d_time);
! 1603:
! 1604: if (d_list[i].d_func == NULL)
! 1605: {
! 1606: d_list[i].d_time = 0;
! 1607: d_list[i].d_type = 0;
! 1608: }
! 1609: }
! 1610:
! 1611: return(READSTAT);
! 1612: }
! 1613:
! 1614: int
! 1615: rs_write_room(FILE *savef, struct room *r)
! 1616: {
! 1617: struct linked_list *l;
! 1618: int i;
! 1619:
! 1620: if (write_error)
! 1621: return(WRITESTAT);
! 1622:
! 1623: rs_write_coord(savef, r->r_pos);
! 1624: rs_write_coord(savef, r->r_max);
! 1625: rs_write_long(savef, r->r_flags);
! 1626:
! 1627: l = r->r_fires;
! 1628: i = list_size(l);
! 1629:
! 1630: rs_write_int(savef, i);
! 1631:
! 1632: if (i >0)
! 1633: while (l != NULL)
! 1634: {
! 1635: i = find_list_ptr(mlist, l->l_data);
! 1636: rs_write_int(savef,i);
! 1637: l = l->l_next;
! 1638: }
! 1639:
! 1640: rs_write_coord_list(savef, r->r_exit);
! 1641:
! 1642: return(WRITESTAT);
! 1643: }
! 1644:
! 1645: int
! 1646: rs_read_room(FILE *inf, struct room *r)
! 1647: {
! 1648: int value = 0, n = 0, i = 0, index = 0, id = 0;
! 1649: struct linked_list *fires=NULL, *item = NULL;
! 1650:
! 1651: if (read_error || format_error)
! 1652: return(READSTAT);
! 1653:
! 1654: rs_read_coord(inf,&r->r_pos);
! 1655: rs_read_coord(inf,&r->r_max);
! 1656: rs_read_long(inf,&r->r_flags);
! 1657:
! 1658: rs_read_int(inf, &i);
! 1659: fires = NULL;
! 1660:
! 1661: while (i>0)
! 1662: {
! 1663: rs_read_int(inf,&index);
! 1664:
! 1665: if (index >= 0)
! 1666: {
! 1667: void *data;
! 1668: data = get_list_item(mlist,index);
! 1669: item = creat_item();
! 1670: item->l_data = data;
! 1671: if (fires == NULL)
! 1672: fires = item;
! 1673: else
! 1674: attach(fires,item);
! 1675: }
! 1676: i--;
! 1677: }
! 1678:
! 1679: r->r_fires=fires;
! 1680:
! 1681: rs_read_coord_list(inf, &r->r_exit);
! 1682:
! 1683: return(READSTAT);
! 1684: }
! 1685:
! 1686: int
! 1687: rs_write_rooms(FILE *savef, struct room r[], int count)
! 1688: {
! 1689: int n = 0;
! 1690:
! 1691: if (write_error)
! 1692: return(WRITESTAT);
! 1693:
! 1694: rs_write_int(savef, count);
! 1695:
! 1696: for(n = 0; n < count; n++)
! 1697: rs_write_room(savef, &r[n]);
! 1698:
! 1699: return(WRITESTAT);
! 1700: }
! 1701:
! 1702: int
! 1703: rs_read_rooms(FILE *inf, struct room *r, int count)
! 1704: {
! 1705: int value = 0, n = 0;
! 1706:
! 1707: if (read_error || format_error)
! 1708: return(READSTAT);
! 1709:
! 1710: rs_read_int(inf,&value);
! 1711:
! 1712: if (value > count)
! 1713: format_error = TRUE;
! 1714:
! 1715: for(n = 0; n < value; n++)
! 1716: rs_read_room(inf,&r[n]);
! 1717:
! 1718: return(READSTAT);
! 1719: }
! 1720:
! 1721: int
! 1722: rs_write_room_reference(FILE *savef, struct room *rp)
! 1723: {
! 1724: int i, room = -1;
! 1725:
! 1726: if (write_error)
! 1727: return(WRITESTAT);
! 1728:
! 1729: for (i = 0; i < MAXROOMS; i++)
! 1730: if (&rooms[i] == rp)
! 1731: room = i;
! 1732:
! 1733: rs_write_int(savef, room);
! 1734:
! 1735: return(WRITESTAT);
! 1736: }
! 1737:
! 1738: int
! 1739: rs_read_room_reference(FILE *inf, struct room **rp)
! 1740: {
! 1741: int i;
! 1742:
! 1743: if (read_error || format_error)
! 1744: return(READSTAT);
! 1745:
! 1746: rs_read_int(inf, &i);
! 1747:
! 1748: if (i >= 0 && i < MAXROOMS)
! 1749: *rp = &rooms[i];
! 1750: else
! 1751: *rp = NULL;
! 1752:
! 1753: return(READSTAT);
! 1754: }
! 1755:
! 1756: int
! 1757: rs_write_door_reference(FILE *savef, coord *exit)
! 1758: {
! 1759: int i, idx;
! 1760:
! 1761: for (i = 0; i < MAXROOMS; i++)
! 1762: {
! 1763: idx = find_list_ptr(rooms[i].r_exit, exit);
! 1764:
! 1765: if (idx != -1)
! 1766: break;
! 1767: }
! 1768:
! 1769: if (i >= MAXROOMS)
! 1770: {
! 1771: rs_write_int(savef,-1);
! 1772: rs_write_int(savef,-1);
! 1773: if (exit != NULL)
! 1774: abort();
! 1775: }
! 1776: else
! 1777: {
! 1778: rs_write_int(savef,i);
! 1779: rs_write_int(savef,idx);
! 1780: }
! 1781:
! 1782: return(WRITESTAT);
! 1783: }
! 1784:
! 1785: int
! 1786: rs_read_door_reference(FILE *inf, coord **exit)
! 1787: {
! 1788: int i, idx;
! 1789:
! 1790: rs_read_int(inf, &i);
! 1791: rs_read_int(inf, &idx);
! 1792:
! 1793: if ( (i == -1) || (idx == -1) )
! 1794: *exit = NULL;
! 1795: else
! 1796: *exit = get_list_item(rooms[i].r_exit, idx);
! 1797:
! 1798: return(READSTAT);
! 1799: }
! 1800:
! 1801: int
! 1802: rs_write_traps(FILE *savef, struct trap *trap,int count)
! 1803: {
! 1804: int n;
! 1805:
! 1806: rs_write_int(savef, RSID_TRAP);
! 1807: rs_write_int(savef, count);
! 1808:
! 1809: for(n=0; n<count; n++)
! 1810: {
! 1811: rs_write_char(savef, trap[n].tr_type);
! 1812: rs_write_char(savef, trap[n].tr_show);
! 1813: rs_write_coord(savef, trap[n].tr_pos);
! 1814: rs_write_long(savef, trap[n].tr_flags);
! 1815: }
! 1816:
! 1817: return (WRITESTAT);
! 1818: }
! 1819:
! 1820: int
! 1821: rs_read_traps(FILE *inf, struct trap *trap, int count)
! 1822: {
! 1823: int id = 0, value = 0, n = 0;
! 1824:
! 1825: if (rs_read_int(inf,&id) != 0)
! 1826: format_error = TRUE;
! 1827: else if (rs_read_int(inf,&value) != 0)
! 1828: {
! 1829: if (value != count)
! 1830: format_error = TRUE;
! 1831: }
! 1832: else
! 1833: {
! 1834: for(n=0;n<value;n++)
! 1835: {
! 1836: rs_read_char(inf,&trap[n].tr_type);
! 1837: rs_read_char(inf,&trap[n].tr_show);
! 1838: rs_read_coord(inf,&trap[n].tr_pos);
! 1839: rs_read_long(inf,&trap[n].tr_flags);
! 1840: }
! 1841: }
! 1842:
! 1843: return(READSTAT);
! 1844: }
! 1845:
! 1846: int
! 1847: rs_write_monsters(FILE *savef, struct monster *m, int count)
! 1848: {
! 1849: int n;
! 1850:
! 1851: if (write_error)
! 1852: return(WRITESTAT);
! 1853:
! 1854: rs_write_marker(savef, RSID_MONSTERS);
! 1855: rs_write_int(savef, count);
! 1856:
! 1857: for(n=0;n<count;n++)
! 1858: {
! 1859: rs_write_boolean(savef, m[n].m_normal);
! 1860: rs_write_boolean(savef, m[n].m_wander);
! 1861: rs_write_short(savef, m[n].m_numsum);
! 1862: }
! 1863:
! 1864: return(WRITESTAT);
! 1865: }
! 1866:
! 1867: int
! 1868: rs_read_monsters(FILE *inf, struct monster *m, int count)
! 1869: {
! 1870: int value = 0, n = 0;
! 1871:
! 1872: if (read_error || format_error)
! 1873: return(READSTAT);
! 1874:
! 1875: rs_read_marker(inf, RSID_MONSTERS);
! 1876:
! 1877: rs_read_int(inf, &value);
! 1878:
! 1879: if (value != count)
! 1880: format_error = TRUE;
! 1881:
! 1882: for(n = 0; n < count; n++)
! 1883: {
! 1884: rs_read_boolean(inf, &m[n].m_normal);
! 1885: rs_read_boolean(inf, &m[n].m_wander);
! 1886: rs_read_short(inf, &m[n].m_numsum);
! 1887: }
! 1888:
! 1889: return(READSTAT);
! 1890: }
! 1891:
! 1892: int
! 1893: rs_write_object(FILE *savef, struct object *o)
! 1894: {
! 1895: if (write_error)
! 1896: return(WRITESTAT);
! 1897:
! 1898: rs_write_marker(savef, RSID_OBJECT);
! 1899: rs_write_int(savef, o->o_type);
! 1900: rs_write_coord(savef, o->o_pos);
! 1901: rs_write_char(savef, o->o_launch);
! 1902: rs_write(savef, o->o_damage, sizeof(o->o_damage));
! 1903: rs_write(savef, o->o_hurldmg, sizeof(o->o_hurldmg));
! 1904: rs_write_object_list(savef, o->contents);
! 1905: rs_write_int(savef, o->o_count);
! 1906: rs_write_int(savef, o->o_which);
! 1907: rs_write_int(savef, o->o_hplus);
! 1908: rs_write_int(savef, o->o_dplus);
! 1909: rs_write_int(savef, o->o_ac);
! 1910: rs_write_long(savef, o->o_flags);
! 1911: rs_write_int(savef, o->o_group);
! 1912: rs_write_int(savef, o->o_weight);
! 1913: rs_write(savef, o->o_mark, MARKLEN);
! 1914:
! 1915:
! 1916: return(WRITESTAT);
! 1917: }
! 1918:
! 1919: int
! 1920: rs_read_object(FILE *inf, struct object *o)
! 1921: {
! 1922: if (read_error || format_error)
! 1923: return(READSTAT);
! 1924:
! 1925: rs_read_marker(inf, RSID_OBJECT);
! 1926: rs_read_int(inf, &o->o_type);
! 1927: rs_read_coord(inf, &o->o_pos);
! 1928: rs_read_char(inf, &o->o_launch);
! 1929: rs_read(inf, o->o_damage, sizeof(o->o_damage));
! 1930: rs_read(inf, o->o_hurldmg, sizeof(o->o_hurldmg));
! 1931: rs_read_object_list(inf,&o->contents);
! 1932: rs_read_int(inf, &o->o_count);
! 1933: rs_read_int(inf, &o->o_which);
! 1934: rs_read_int(inf, &o->o_hplus);
! 1935: rs_read_int(inf, &o->o_dplus);
! 1936: rs_read_int(inf, &o->o_ac);
! 1937: rs_read_long(inf,&o->o_flags);
! 1938: rs_read_int(inf, &o->o_group);
! 1939: rs_read_int(inf, &o->o_weight);
! 1940: rs_read(inf, o->o_mark, MARKLEN);
! 1941:
! 1942: return(READSTAT);
! 1943: }
! 1944:
! 1945: int
! 1946: rs_write_object_list(FILE *savef, struct linked_list *l)
! 1947: {
! 1948: if (write_error)
! 1949: return(WRITESTAT);
! 1950:
! 1951: rs_write_marker(savef, RSID_OBJECTLIST);
! 1952: rs_write_int(savef, list_size(l));
! 1953:
! 1954: for( ;l != NULL; l = l->l_next)
! 1955: rs_write_object(savef, OBJPTR(l));
! 1956:
! 1957: return(WRITESTAT);
! 1958: }
! 1959:
! 1960: int
! 1961: rs_read_object_list(FILE *inf, struct linked_list **list)
! 1962: {
! 1963: int i, cnt;
! 1964: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
! 1965:
! 1966: if (read_error || format_error)
! 1967: return(READSTAT);
! 1968:
! 1969: rs_read_marker(inf, RSID_OBJECTLIST);
! 1970: rs_read_int(inf, &cnt);
! 1971:
! 1972: for (i = 0; i < cnt; i++)
! 1973: {
! 1974: l = new_item(sizeof(struct object));
! 1975:
! 1976: l->l_prev = previous;
! 1977:
! 1978: if (previous != NULL)
! 1979: previous->l_next = l;
! 1980:
! 1981: rs_read_object(inf,OBJPTR(l));
! 1982:
! 1983: if (previous == NULL)
! 1984: head = l;
! 1985:
! 1986: previous = l;
! 1987: }
! 1988:
! 1989: if (l != NULL)
! 1990: l->l_next = NULL;
! 1991:
! 1992: *list = head;
! 1993:
! 1994: return(READSTAT);
! 1995: }
! 1996:
! 1997: int
! 1998: rs_write_object_reference(FILE *savef, struct linked_list *list, struct object *item)
! 1999: {
! 2000: int i;
! 2001:
! 2002: if (write_error)
! 2003: return(WRITESTAT);
! 2004:
! 2005: i = find_list_ptr(list, item);
! 2006:
! 2007: rs_write_int(savef, i);
! 2008:
! 2009: return(WRITESTAT);
! 2010: }
! 2011:
! 2012: int
! 2013: rs_read_object_reference(FILE *inf, struct linked_list *list, struct object **item)
! 2014: {
! 2015: int i;
! 2016:
! 2017: if (read_error || format_error)
! 2018: return(READSTAT);
! 2019:
! 2020: rs_read_int(inf, &i);
! 2021:
! 2022: *item = get_list_item(list,i);
! 2023:
! 2024: return(READSTAT);
! 2025: }
! 2026:
! 2027: int
! 2028: find_thing_coord(struct linked_list *monlist, coord *c)
! 2029: {
! 2030: struct linked_list *mitem;
! 2031: struct thing *tp;
! 2032: int i = 0;
! 2033:
! 2034: for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
! 2035: {
! 2036: tp = THINGPTR(mitem);
! 2037:
! 2038: if (c == &tp->t_pos)
! 2039: return(i);
! 2040:
! 2041: i++;
! 2042: }
! 2043:
! 2044: return(-1);
! 2045: }
! 2046:
! 2047: int
! 2048: find_object_coord(struct linked_list *objlist, coord *c)
! 2049: {
! 2050: struct linked_list *oitem;
! 2051: struct object *obj;
! 2052: int i = 0;
! 2053:
! 2054: for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
! 2055: {
! 2056: obj = OBJPTR(oitem);
! 2057:
! 2058: if (c == &obj->o_pos)
! 2059: return(i);
! 2060:
! 2061: i++;
! 2062: }
! 2063:
! 2064: return(-1);
! 2065: }
! 2066:
! 2067: int
! 2068: rs_write_thing(FILE *savef, struct thing *t)
! 2069: {
! 2070: int i = -1;
! 2071:
! 2072: if (write_error)
! 2073: return(WRITESTAT);
! 2074:
! 2075: rs_write_marker(savef, RSID_THING);
! 2076:
! 2077: if (t == NULL)
! 2078: {
! 2079: rs_write_int(savef, 0);
! 2080: return(WRITESTAT);
! 2081: }
! 2082:
! 2083: rs_write_int(savef, 1);
! 2084:
! 2085: rs_write_boolean(savef, t->t_turn);
! 2086: rs_write_boolean(savef, t->t_wasshot);
! 2087: rs_write_char(savef, t->t_type);
! 2088: rs_write_char(savef, t->t_disguise);
! 2089: rs_write_char(savef, t->t_oldch);
! 2090:
! 2091: rs_write_short(savef, t->t_ctype);
! 2092: rs_write_short(savef, t->t_index);
! 2093: rs_write_short(savef, t->t_no_move);
! 2094: rs_write_short(savef, t->t_quiet);
! 2095:
! 2096: rs_write_door_reference(savef, t->t_doorgoal);
! 2097:
! 2098: rs_write_coord(savef, t->t_pos);
! 2099: rs_write_coord(savef, t->t_oldpos);
! 2100:
! 2101: /*
! 2102: t_dest can be:
! 2103: 0,0: NULL
! 2104: 0,1: location of hero
! 2105: 0,3: global coord 'delta'
! 2106: 1,i: location of a thing (monster)
! 2107: 2,i: location of an object
! 2108: 3,i: location of gold in a room
! 2109:
! 2110: We need to remember what we are chasing rather than
! 2111: the current location of what we are chasing.
! 2112: */
! 2113:
! 2114: if (t->t_dest == &hero)
! 2115: {
! 2116: rs_write_int(savef,0);
! 2117: rs_write_int(savef,1);
! 2118: }
! 2119: else if (t->t_dest != NULL)
! 2120: {
! 2121: i = find_thing_coord(mlist, t->t_dest);
! 2122:
! 2123: if (i >=0 )
! 2124: {
! 2125: rs_write_int(savef,1);
! 2126: rs_write_int(savef,i);
! 2127: }
! 2128: else
! 2129: {
! 2130: i = find_object_coord(lvl_obj, t->t_dest);
! 2131:
! 2132: if (i >= 0)
! 2133: {
! 2134: rs_write_int(savef,2);
! 2135: rs_write_int(savef,i);
! 2136: }
! 2137: else
! 2138: {
! 2139: rs_write_int(savef, 0);
! 2140: rs_write_int(savef,1); /* chase the hero anyway */
! 2141: }
! 2142: }
! 2143: }
! 2144: else
! 2145: {
! 2146: rs_write_int(savef,0);
! 2147: rs_write_int(savef,0);
! 2148: }
! 2149:
! 2150: rs_write_ulongs(savef, t->t_flags, 16);
! 2151: rs_write_object_list(savef, t->t_pack);
! 2152: rs_write_stats(savef, &t->t_stats);
! 2153: rs_write_stats(savef, &t->maxstats);
! 2154:
! 2155: return(WRITESTAT);
! 2156: }
! 2157:
! 2158: int
! 2159: rs_read_thing(FILE *inf, struct thing *t)
! 2160: {
! 2161: int listid = 0, index = -1;
! 2162:
! 2163: if (read_error || format_error)
! 2164: return(READSTAT);
! 2165:
! 2166: rs_read_marker(inf, RSID_THING);
! 2167:
! 2168: rs_read_int(inf, &index);
! 2169:
! 2170: if (index == 0)
! 2171: return(READSTAT);
! 2172:
! 2173: rs_read_boolean(inf, &t->t_turn);
! 2174: rs_read_boolean(inf, &t->t_wasshot);
! 2175: rs_read_char(inf, &t->t_type);
! 2176: rs_read_char(inf, &t->t_disguise);
! 2177: rs_read_char(inf, &t->t_oldch);
! 2178: rs_read_short(inf, &t->t_ctype);
! 2179: rs_read_short(inf, &t->t_index);
! 2180: rs_read_short(inf, &t->t_no_move);
! 2181: rs_read_short(inf, &t->t_quiet);
! 2182: rs_read_door_reference(inf,&t->t_doorgoal);
! 2183: rs_read_coord(inf, &t->t_pos);
! 2184: rs_read_coord(inf, &t->t_oldpos);
! 2185:
! 2186: /*
! 2187: t_dest can be (listid,index):
! 2188: 0,0: NULL
! 2189: 0,1: location of hero
! 2190: 1,i: location of a thing (monster)
! 2191: 2,i: location of an object
! 2192: 3,i: location of gold in a room
! 2193:
! 2194: We need to remember what we are chasing rather than
! 2195: the current location of what we are chasing.
! 2196: */
! 2197:
! 2198: rs_read_int(inf, &listid);
! 2199: rs_read_int(inf, &index);
! 2200: t->t_reserved = -1;
! 2201:
! 2202: if (listid == 0) /* hero or NULL */
! 2203: {
! 2204: if (index == 1)
! 2205: t->t_dest = &hero;
! 2206: else
! 2207: t->t_dest = NULL;
! 2208: }
! 2209: else if (listid == 1) /* monster/thing */
! 2210: {
! 2211: t->t_dest = NULL;
! 2212: t->t_reserved = index;
! 2213: }
! 2214: else if (listid == 2) /* object */
! 2215: {
! 2216: struct object *obj;
! 2217:
! 2218: obj = get_list_item(lvl_obj, index);
! 2219:
! 2220: if (obj != NULL)
! 2221: {
! 2222: t->t_dest = &obj->o_pos;
! 2223: }
! 2224: }
! 2225: else
! 2226: t->t_dest = NULL;
! 2227:
! 2228: rs_read_ulongs(inf, t->t_flags, 16);
! 2229: rs_read_object_list(inf, &t->t_pack);
! 2230: rs_read_stats(inf, &t->t_stats);
! 2231: rs_read_stats(inf, &t->maxstats);
! 2232:
! 2233: return(READSTAT);
! 2234: }
! 2235:
! 2236: void
! 2237: rs_fix_thing(struct thing *t)
! 2238: {
! 2239: struct thing *tp;
! 2240:
! 2241: if (t->t_reserved < 0)
! 2242: return;
! 2243:
! 2244: tp = get_list_item(mlist,t->t_reserved);
! 2245:
! 2246: if (tp != NULL)
! 2247: {
! 2248: t->t_dest = &tp->t_pos;
! 2249: }
! 2250: }
! 2251:
! 2252: int
! 2253: rs_write_thing_list(FILE *savef, struct linked_list *l)
! 2254: {
! 2255: int cnt = 0;
! 2256:
! 2257: if (write_error)
! 2258: return(WRITESTAT);
! 2259:
! 2260: rs_write_marker(savef, RSID_MONSTERLIST);
! 2261:
! 2262: cnt = list_size(l);
! 2263:
! 2264: rs_write_int(savef, cnt);
! 2265:
! 2266: if (cnt < 1)
! 2267: return(WRITESTAT);
! 2268:
! 2269: while (l != NULL) {
! 2270: rs_write_thing(savef, (struct thing *)l->l_data);
! 2271: l = l->l_next;
! 2272: }
! 2273:
! 2274: return(WRITESTAT);
! 2275: }
! 2276:
! 2277: int
! 2278: rs_read_thing_list(FILE *inf, struct linked_list **list)
! 2279: {
! 2280: int i, cnt;
! 2281: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
! 2282:
! 2283: if (read_error || format_error)
! 2284: return(READSTAT);
! 2285:
! 2286: rs_read_marker(inf, RSID_MONSTERLIST);
! 2287:
! 2288: rs_read_int(inf, &cnt);
! 2289:
! 2290: for (i = 0; i < cnt; i++)
! 2291: {
! 2292: l = new_item(sizeof(struct thing));
! 2293:
! 2294: l->l_prev = previous;
! 2295:
! 2296: if (previous != NULL)
! 2297: previous->l_next = l;
! 2298:
! 2299: rs_read_thing(inf,THINGPTR(l));
! 2300:
! 2301: if (previous == NULL)
! 2302: head = l;
! 2303:
! 2304: previous = l;
! 2305: }
! 2306:
! 2307: if (l != NULL)
! 2308: l->l_next = NULL;
! 2309:
! 2310: *list = head;
! 2311:
! 2312: return(READSTAT);
! 2313: }
! 2314:
! 2315: void
! 2316: rs_fix_thing_list(struct linked_list *list)
! 2317: {
! 2318: struct linked_list *item;
! 2319:
! 2320: for(item = list; item != NULL; item = item->l_next)
! 2321: rs_fix_thing(THINGPTR(item));
! 2322: }
! 2323:
! 2324: int
! 2325: rs_save_file(FILE *savef)
! 2326: {
! 2327: int i;
! 2328:
! 2329: if (write_error)
! 2330: return(WRITESTAT);
! 2331:
! 2332: rs_write_object_list(savef, lvl_obj);
! 2333: rs_write_thing(savef, &player);
! 2334: rs_write_thing_list(savef, mlist);
! 2335: rs_write_thing_list(savef, tlist);
! 2336: rs_write_thing_list(savef, monst_dead);
! 2337:
! 2338: rs_write_traps(savef, traps, MAXTRAPS);
! 2339: rs_write_rooms(savef, rooms, MAXROOMS);
! 2340: rs_write_room_reference(savef, oldrp);
! 2341:
! 2342: rs_write_object_reference(savef, player.t_pack, cur_armor);
! 2343:
! 2344: for(i = 0; i < NUM_FINGERS; i++)
! 2345: rs_write_object_reference(savef, player.t_pack, cur_ring[i]);
! 2346:
! 2347: for(i = 0; i < NUM_MM; i++)
! 2348: rs_write_object_reference(savef, player.t_pack, cur_misc[i]);
! 2349:
! 2350: rs_write_ints(savef, cur_relic, MAXRELIC);
! 2351:
! 2352: rs_write_object_reference(savef, player.t_pack, cur_weapon);
! 2353:
! 2354: rs_write_int(savef, char_type);
! 2355: rs_write_int(savef, foodlev);
! 2356: rs_write_int(savef, ntraps);
! 2357: rs_write_int(savef, trader);
! 2358: rs_write_int(savef, curprice);
! 2359: rs_write_int(savef, no_move);
! 2360: rs_write_int(savef, seed);
! 2361: rs_write_int(savef, dnum);
! 2362: rs_write_int(savef, max_level);
! 2363: rs_write_int(savef, cur_max);
! 2364: rs_write_int(savef, lost_dext);
! 2365: rs_write_int(savef, no_command);
! 2366: rs_write_int(savef, level);
! 2367: rs_write_int(savef, purse);
! 2368: rs_write_int(savef, inpack);
! 2369: rs_write_int(savef, total);
! 2370: rs_write_int(savef, no_food);
! 2371: rs_write_int(savef, foods_this_level);
! 2372: rs_write_int(savef, count);
! 2373: rs_write_int(savef, food_left);
! 2374: rs_write_int(savef, group);
! 2375: rs_write_int(savef, hungry_state);
! 2376: rs_write_int(savef, infest_dam);
! 2377: rs_write_int(savef, lost_str);
! 2378: rs_write_int(savef, lastscore);
! 2379: rs_write_int(savef, hold_count);
! 2380: rs_write_int(savef, trap_tries);
! 2381: rs_write_int(savef, pray_time);
! 2382: rs_write_int(savef, spell_power);
! 2383: rs_write_int(savef, turns);
! 2384: rs_write_int(savef, quest_item);
! 2385: rs_write_char(savef, nfloors);
! 2386: rs_write(savef, curpurch, LINELEN*2);
! 2387: rs_write_char(savef, PLAYER);
! 2388: rs_write_char(savef, take);
! 2389: rs_write(savef, prbuf, LINELEN);
! 2390: rs_write_char(savef, runch);
! 2391: rs_write(savef, whoami, LINELEN);
! 2392: rs_write(savef, fruit, LINELEN);
! 2393: rs_write_scrolls(savef);
! 2394: rs_write_potions(savef);
! 2395: rs_write_rings(savef);
! 2396: rs_write_sticks(savef);
! 2397: for(i = 0; i < MAXMM; i++)
! 2398: rs_write_string(savef, m_guess[i]);
! 2399: rs_write_window(savef, cw);
! 2400: rs_write_window(savef, mw);
! 2401: rs_write_window(savef, stdscr);
! 2402: rs_write_boolean(savef, pool_teleport);
! 2403: rs_write_boolean(savef, inwhgt);
! 2404: rs_write_boolean(savef, after);
! 2405: rs_write_boolean(savef, waswizard);
! 2406: rs_write_booleans(savef, m_know, MAXMM);
! 2407: rs_write_boolean(savef, playing);
! 2408: rs_write_boolean(savef, running);
! 2409: rs_write_boolean(savef, wizard);
! 2410: rs_write_boolean(savef, notify);
! 2411: rs_write_boolean(savef, fight_flush);
! 2412: rs_write_boolean(savef, terse);
! 2413: rs_write_boolean(savef, auto_pickup);
! 2414: rs_write_boolean(savef, door_stop);
! 2415: rs_write_boolean(savef, jump);
! 2416: rs_write_boolean(savef, slow_invent);
! 2417: rs_write_boolean(savef, firstmove);
! 2418: rs_write_boolean(savef, askme);
! 2419: rs_write_boolean(savef, in_shell);
! 2420: rs_write_boolean(savef, daytime);
! 2421: rs_write_coord(savef, delta);
! 2422: rs_write_levtype(savef, levtype);
! 2423:
! 2424: rs_write_monsters(savef, monsters, NUMMONST+1);
! 2425:
! 2426: rs_write_magic_items(savef, things, NUMTHINGS);
! 2427: rs_write_magic_items(savef, s_magic, MAXSCROLLS);
! 2428: rs_write_magic_items(savef, p_magic, MAXPOTIONS);
! 2429: rs_write_magic_items(savef, r_magic, MAXRINGS);
! 2430: rs_write_magic_items(savef, ws_magic, MAXSTICKS);
! 2431: rs_write_magic_items(savef, m_magic, MAXMM);
! 2432:
! 2433:
! 2434: rs_write_coord(savef, ch_ret);
! 2435: rs_write_int(savef, demoncnt);
! 2436: rs_write_int(savef, fusecnt);
! 2437: rs_write_daemons(savef, d_list, MAXDAEMONS);
! 2438: rs_write_daemons(savef, f_list, MAXFUSES);
! 2439: rs_write_int(savef, between);
! 2440:
! 2441: fflush(savef);
! 2442:
! 2443: return(WRITESTAT);
! 2444: }
! 2445:
! 2446: int
! 2447: rs_restore_file(FILE *inf)
! 2448: {
! 2449: int i;
! 2450:
! 2451: if (read_error || format_error)
! 2452: return(READSTAT);
! 2453:
! 2454: rs_read_object_list(inf, &lvl_obj);
! 2455: rs_read_thing(inf, &player);
! 2456: rs_read_thing_list(inf, &mlist);
! 2457: rs_read_thing_list(inf, &tlist);
! 2458: rs_read_thing_list(inf, &monst_dead);
! 2459:
! 2460: rs_fix_thing(&player);
! 2461: rs_fix_thing_list(mlist);
! 2462: rs_fix_thing_list(tlist);
! 2463: rs_fix_thing_list(monst_dead);
! 2464:
! 2465: rs_read_traps(inf, traps, MAXTRAPS);
! 2466: rs_read_rooms(inf, rooms, MAXROOMS);
! 2467: rs_read_room_reference(inf, &oldrp);
! 2468:
! 2469: rs_read_object_reference(inf, player.t_pack, &cur_armor);
! 2470:
! 2471: for(i = 0; i < NUM_FINGERS; i++)
! 2472: rs_read_object_reference(inf, player.t_pack, &cur_ring[i]);
! 2473:
! 2474: for(i = 0; i < NUM_MM; i++)
! 2475: rs_read_object_reference(inf, player.t_pack, &cur_misc[i]);
! 2476:
! 2477: rs_read_ints(inf, cur_relic, MAXRELIC);
! 2478:
! 2479: rs_read_object_reference(inf, player.t_pack, &cur_weapon);
! 2480:
! 2481: rs_read_int(inf, &char_type);
! 2482: rs_read_int(inf, &foodlev);
! 2483: rs_read_int(inf, &ntraps);
! 2484: rs_read_int(inf, &trader);
! 2485: rs_read_int(inf, &curprice);
! 2486: rs_read_int(inf, &no_move);
! 2487: rs_read_int(inf, &seed);
! 2488: rs_read_int(inf, &dnum);
! 2489: rs_read_int(inf, &max_level);
! 2490: rs_read_int(inf, &cur_max);
! 2491: rs_read_int(inf, &lost_dext);
! 2492: rs_read_int(inf, &no_command);
! 2493: rs_read_int(inf, &level);
! 2494: rs_read_int(inf, &purse);
! 2495: rs_read_int(inf, &inpack);
! 2496: rs_read_int(inf, &total);
! 2497: rs_read_int(inf, &no_food);
! 2498: rs_read_int(inf, &foods_this_level);
! 2499: rs_read_int(inf, &count);
! 2500: rs_read_int(inf, &food_left);
! 2501: rs_read_int(inf, &group);
! 2502: rs_read_int(inf, &hungry_state);
! 2503: rs_read_int(inf, &infest_dam);
! 2504: rs_read_int(inf, &lost_str);
! 2505: rs_read_int(inf, &lastscore);
! 2506: rs_read_int(inf, &hold_count);
! 2507: rs_read_int(inf, &trap_tries);
! 2508: rs_read_int(inf, &pray_time);
! 2509: rs_read_int(inf, &spell_power);
! 2510: rs_read_int(inf, &turns);
! 2511: rs_read_int(inf, &quest_item);
! 2512: rs_read_char(inf, &nfloors);
! 2513: rs_read(inf, &curpurch, LINELEN*2);
! 2514: rs_read_char(inf, &PLAYER);
! 2515: rs_read_char(inf, &take);
! 2516: rs_read(inf, &prbuf, LINELEN);
! 2517: rs_read_char(inf, &runch);
! 2518: rs_read(inf, &whoami, LINELEN);
! 2519: rs_read(inf, &fruit, LINELEN);
! 2520: rs_read_scrolls(inf);
! 2521: rs_read_potions(inf);
! 2522: rs_read_rings(inf);
! 2523: rs_read_sticks(inf);
! 2524: for(i = 0; i < MAXMM; i++)
! 2525: rs_read_new_string(inf, &m_guess[i]);
! 2526: rs_read_window(inf, cw);
! 2527: rs_read_window(inf, mw);
! 2528: rs_read_window(inf, stdscr);
! 2529: rs_read_boolean(inf, &pool_teleport);
! 2530: rs_read_boolean(inf, &inwhgt);
! 2531: rs_read_boolean(inf, &after);
! 2532: rs_read_boolean(inf, &waswizard);
! 2533: rs_read_booleans(inf, m_know, MAXMM);
! 2534: rs_read_boolean(inf, &playing);
! 2535: rs_read_boolean(inf, &running);
! 2536: rs_read_boolean(inf, &wizard);
! 2537: rs_read_boolean(inf, ¬ify);
! 2538: rs_read_boolean(inf, &fight_flush);
! 2539: rs_read_boolean(inf, &terse);
! 2540: rs_read_boolean(inf, &auto_pickup);
! 2541: rs_read_boolean(inf, &door_stop);
! 2542: rs_read_boolean(inf, &jump);
! 2543: rs_read_boolean(inf, &slow_invent);
! 2544: rs_read_boolean(inf, &firstmove);
! 2545: rs_read_boolean(inf, &askme);
! 2546: rs_read_boolean(inf, &in_shell);
! 2547: rs_read_boolean(inf, &daytime);
! 2548: rs_read_coord(inf, &delta);
! 2549: rs_read_levtype(inf, &levtype);
! 2550:
! 2551: rs_read_monsters(inf, monsters, NUMMONST+1);
! 2552:
! 2553: rs_read_magic_items(inf, things, NUMTHINGS);
! 2554: rs_read_magic_items(inf, s_magic, MAXSCROLLS);
! 2555: rs_read_magic_items(inf, p_magic, MAXPOTIONS);
! 2556: rs_read_magic_items(inf, r_magic, MAXRINGS);
! 2557: rs_read_magic_items(inf, ws_magic, MAXSTICKS);
! 2558: rs_read_magic_items(inf, m_magic, MAXMM);
! 2559:
! 2560: rs_read_coord(inf, &ch_ret);
! 2561: rs_read_int(inf, &demoncnt);
! 2562: rs_read_int(inf, &fusecnt);
! 2563: rs_read_daemons(inf, d_list, MAXDAEMONS);
! 2564: rs_read_daemons(inf, f_list, MAXFUSES);
! 2565: rs_read_int(inf, &between);
! 2566:
! 2567: return(READSTAT);
! 2568: }
CVSweb
![[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 / arogue5