Annotation of early-roguelike/rogue5/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: #include <stdlib.h>
! 33: #include <string.h>
! 34: #include <curses.h>
! 35: #include <errno.h>
! 36: #include "rogue.h"
! 37:
! 38: /************************************************************************/
! 39: /* Save State Code */
! 40: /************************************************************************/
! 41:
! 42: #define RSID_STATS 0xABCD0001
! 43: #define RSID_THING 0xABCD0002
! 44: #define RSID_THING_NULL 0xDEAD0002
! 45: #define RSID_OBJECT 0xABCD0003
! 46: #define RSID_MAGICITEMS 0xABCD0004
! 47: #define RSID_KNOWS 0xABCD0005
! 48: #define RSID_GUESSES 0xABCD0006
! 49: #define RSID_OBJECTLIST 0xABCD0007
! 50: #define RSID_BAGOBJECT 0xABCD0008
! 51: #define RSID_MONSTERLIST 0xABCD0009
! 52: #define RSID_MONSTERSTATS 0xABCD000A
! 53: #define RSID_MONSTERS 0xABCD000B
! 54: #define RSID_TRAP 0xABCD000C
! 55: #define RSID_WINDOW 0xABCD000D
! 56: #define RSID_DAEMONS 0xABCD000E
! 57: #define RSID_IWEAPS 0xABCD000F
! 58: #define RSID_IARMOR 0xABCD0010
! 59: #define RSID_SPELLS 0xABCD0011
! 60: #define RSID_ILIST 0xABCD0012
! 61: #define RSID_HLIST 0xABCD0013
! 62: #define RSID_DEATHTYPE 0xABCD0014
! 63: #define RSID_CTYPES 0XABCD0015
! 64: #define RSID_COORDLIST 0XABCD0016
! 65: #define RSID_ROOMS 0XABCD0017
! 66:
! 67: #define READSTAT (format_error || read_error )
! 68: #define WRITESTAT (write_error)
! 69:
! 70: static int read_error = FALSE;
! 71: static int write_error = FALSE;
! 72: static int format_error = FALSE;
! 73: static int endian = 0x01020304;
! 74: #define big_endian ( *((char *)&endian) == 0x01 )
! 75:
! 76: void
! 77: rs_write(FILE *savef, const void *ptr, size_t size)
! 78: {
! 79: encwrite(ptr, size, savef);
! 80: }
! 81:
! 82: void
! 83: rs_read(FILE *savef, void *ptr, size_t size)
! 84: {
! 85: encread(ptr, size, savef);
! 86: }
! 87:
! 88: void
! 89: rs_write_int(FILE *savef, int c)
! 90: {
! 91: char bytes[4];
! 92: char *buf = (char *) &c;
! 93:
! 94: if (big_endian)
! 95: {
! 96: bytes[3] = buf[0];
! 97: bytes[2] = buf[1];
! 98: bytes[1] = buf[2];
! 99: bytes[0] = buf[3];
! 100: buf = bytes;
! 101: }
! 102:
! 103: rs_write(savef, buf, 4);
! 104: }
! 105:
! 106: void
! 107: rs_read_int(FILE *savef, int *i)
! 108: {
! 109: char bytes[4];
! 110: int input = 0;
! 111: char *buf = (char *)&input;
! 112:
! 113: rs_read(savef, &input, 4);
! 114:
! 115: if (encerror())
! 116: return;
! 117:
! 118: if (big_endian)
! 119: {
! 120: bytes[3] = buf[0];
! 121: bytes[2] = buf[1];
! 122: bytes[1] = buf[2];
! 123: bytes[0] = buf[3];
! 124: buf = bytes;
! 125: }
! 126:
! 127: *i = *((int *) buf);
! 128: }
! 129:
! 130: void
! 131: rs_write_uint(FILE *savef, unsigned int c)
! 132: {
! 133: char bytes[4];
! 134: char *buf = (char *) &c;
! 135:
! 136: if (big_endian)
! 137: {
! 138: bytes[3] = buf[0];
! 139: bytes[2] = buf[1];
! 140: bytes[1] = buf[2];
! 141: bytes[0] = buf[3];
! 142: buf = bytes;
! 143: }
! 144:
! 145: rs_write(savef, buf, 4);
! 146: }
! 147:
! 148: void
! 149: rs_read_uint(FILE *savef, unsigned int *i)
! 150: {
! 151: char bytes[4];
! 152: int input = 0;
! 153: char *buf = (char *)&input;
! 154:
! 155: rs_read(savef, &input, 4);
! 156:
! 157: if (encerror())
! 158: return;
! 159:
! 160: if (big_endian)
! 161: {
! 162: bytes[3] = buf[0];
! 163: bytes[2] = buf[1];
! 164: bytes[1] = buf[2];
! 165: bytes[0] = buf[3];
! 166: buf = bytes;
! 167: }
! 168:
! 169: *i = *((unsigned int *) buf);
! 170: }
! 171:
! 172: void
! 173: rs_write_chars(FILE *savef, const char *c, int cnt)
! 174: {
! 175: rs_write_int(savef, cnt);
! 176: rs_write(savef, c, cnt);
! 177: }
! 178:
! 179: void
! 180: rs_read_chars(FILE *savef, char *i, int cnt)
! 181: {
! 182: int value = 0;
! 183:
! 184: rs_read_int(savef, &value);
! 185:
! 186: if (!encerror() && (value != cnt))
! 187: encseterr(EILSEQ);
! 188:
! 189: rs_read(savef, i, cnt);
! 190: }
! 191:
! 192: void
! 193: rs_write_ints(FILE *savef, int *c, int cnt)
! 194: {
! 195: int n = 0;
! 196:
! 197: rs_write_int(savef, cnt);
! 198:
! 199: for(n = 0; n < cnt; n++)
! 200: rs_write_int(savef,c[n]);
! 201: }
! 202:
! 203: void
! 204: rs_read_ints(FILE *savef, int *i, int cnt)
! 205: {
! 206: int n, value;
! 207:
! 208: rs_read_int(savef,&value);
! 209:
! 210: if (!encerror() && (value != cnt))
! 211: encseterr(EILSEQ);
! 212:
! 213: for(n = 0; n < cnt; n++)
! 214: rs_read_int(savef, &i[n]);
! 215: }
! 216:
! 217: void
! 218: rs_write_marker(FILE *savef, int id)
! 219: {
! 220: rs_write_int(savef, id);
! 221: }
! 222:
! 223: void
! 224: rs_read_marker(FILE *savef, int id)
! 225: {
! 226: int nid;
! 227:
! 228: rs_read_int(savef, &nid);
! 229:
! 230: if (!encerror() && (id != nid))
! 231: encseterr(EILSEQ);
! 232: }
! 233:
! 234: /******************************************************************************/
! 235:
! 236: void
! 237: rs_write_string(FILE *savef, const char *s)
! 238: {
! 239: int len = 0;
! 240:
! 241: len = (s == NULL) ? 0 : (int) strlen(s) + 1;
! 242:
! 243: rs_write_int(savef, len);
! 244: rs_write_chars(savef, s, len);
! 245: }
! 246:
! 247: void
! 248: rs_read_string(FILE *savef, char *s, int max)
! 249: {
! 250: int len = 0;
! 251:
! 252: rs_read_int(savef, &len);
! 253:
! 254: if (!encerror() && (len > max))
! 255: encseterr(EILSEQ);
! 256:
! 257: rs_read_chars(savef, s, len);
! 258: }
! 259:
! 260: void
! 261: rs_read_new_string(FILE *savef, char **s)
! 262: {
! 263: int len=0;
! 264: char *buf=0;
! 265:
! 266: rs_read_int(savef, &len);
! 267:
! 268: if (encerror())
! 269: return;
! 270:
! 271: if (len == 0)
! 272: buf = NULL;
! 273: else
! 274: {
! 275: buf = malloc(len);
! 276:
! 277: if (buf == NULL)
! 278: encseterr(ENOMEM);
! 279: }
! 280:
! 281: rs_read_chars(savef, buf, len);
! 282:
! 283: *s = buf;
! 284: }
! 285:
! 286: void
! 287: rs_write_string_index(FILE *savef, const char *master[], int max, const char *str)
! 288: {
! 289: int i;
! 290:
! 291: for(i = 0; i < max; i++)
! 292: if (str == master[i])
! 293: {
! 294: rs_write_int(savef, i);
! 295: return;
! 296: }
! 297:
! 298: rs_write_int(savef,-1);
! 299: }
! 300:
! 301: void
! 302: rs_read_string_index(FILE *savef, const char *master[], int maxindex, const char **str)
! 303: {
! 304: int i;
! 305:
! 306: rs_read_int(savef, &i);
! 307:
! 308: if (!encerror() && (i > maxindex))
! 309: encseterr(EILSEQ);
! 310: else if (i >= 0)
! 311: *str = master[i];
! 312: else
! 313: *str = NULL;
! 314: }
! 315:
! 316: void
! 317: rs_write_coord(FILE *savef, coord c)
! 318: {
! 319: rs_write_int(savef, c.x);
! 320: rs_write_int(savef, c.y);
! 321: }
! 322:
! 323: void
! 324: rs_read_coord(FILE *savef, coord *c)
! 325: {
! 326: coord in;
! 327:
! 328: rs_read_int(savef,&in.x);
! 329: rs_read_int(savef,&in.y);
! 330:
! 331: if (!encerror())
! 332: {
! 333: c->x = in.x;
! 334: c->y = in.y;
! 335: }
! 336: }
! 337:
! 338: void
! 339: rs_write_window(FILE *savef, WINDOW *win)
! 340: {
! 341: int row,col,height,width;
! 342:
! 343: width = getmaxx(win);
! 344: height = getmaxy(win);
! 345:
! 346: rs_write_marker(savef,RSID_WINDOW);
! 347: rs_write_int(savef,height);
! 348: rs_write_int(savef,width);
! 349:
! 350: for(row=0;row<height;row++)
! 351: for(col=0;col<width;col++)
! 352: rs_write_int(savef, mvwinch(win,row,col));
! 353: }
! 354:
! 355: void
! 356: rs_read_window(FILE *savef, WINDOW *win)
! 357: {
! 358: int row,col,maxlines,maxcols,value,width,height;
! 359:
! 360: width = getmaxx(win);
! 361: height = getmaxy(win);
! 362:
! 363: rs_read_marker(savef, RSID_WINDOW);
! 364:
! 365: rs_read_int(savef, &maxlines);
! 366: rs_read_int(savef, &maxcols);
! 367:
! 368: if (encerror())
! 369: return;
! 370:
! 371: for(row = 0; row < maxlines; row++)
! 372: for(col = 0; col < maxcols; col++)
! 373: {
! 374: rs_read_int(savef, &value);
! 375:
! 376: if ((row < height) && (col < width))
! 377: mvwaddch(win,row,col,value);
! 378: }
! 379: }
! 380:
! 381: /******************************************************************************/
! 382:
! 383: void *
! 384: get_list_item(THING *l, int i)
! 385: {
! 386: int cnt;
! 387:
! 388: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 389: if (cnt == i)
! 390: return(l);
! 391:
! 392: return(NULL);
! 393: }
! 394:
! 395: int
! 396: find_list_ptr(THING *l, void *ptr)
! 397: {
! 398: int cnt;
! 399:
! 400: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 401: if (l == ptr)
! 402: return(cnt);
! 403:
! 404: return(-1);
! 405: }
! 406:
! 407: int
! 408: list_size(THING *l)
! 409: {
! 410: int cnt;
! 411:
! 412: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 413: ;
! 414:
! 415: return(cnt);
! 416: }
! 417:
! 418: /******************************************************************************/
! 419:
! 420: void
! 421: rs_write_stats(FILE *savef, struct stats *s)
! 422: {
! 423: rs_write_marker(savef, RSID_STATS);
! 424: rs_write_int(savef, s->s_str);
! 425: rs_write_int(savef, s->s_exp);
! 426: rs_write_int(savef, s->s_lvl);
! 427: rs_write_int(savef, s->s_arm);
! 428: rs_write_int(savef, s->s_hpt);
! 429: rs_write_chars(savef, s->s_dmg, sizeof(s->s_dmg));
! 430: rs_write_int(savef,s->s_maxhp);
! 431: }
! 432:
! 433: void
! 434: rs_read_stats(FILE *savef, struct stats *s)
! 435: {
! 436: rs_read_marker(savef, RSID_STATS);
! 437: rs_read_int(savef,&s->s_str);
! 438: rs_read_int(savef,&s->s_exp);
! 439: rs_read_int(savef,&s->s_lvl);
! 440: rs_read_int(savef,&s->s_arm);
! 441: rs_read_int(savef,&s->s_hpt);
! 442: rs_read_chars(savef,s->s_dmg,sizeof(s->s_dmg));
! 443: rs_read_int(savef,&s->s_maxhp);
! 444: }
! 445:
! 446: void
! 447: rs_write_stone_index(FILE *savef, const STONE master[], int max, const char *str)
! 448: {
! 449: int i;
! 450:
! 451: for(i = 0; i < max; i++)
! 452: if (str == master[i].st_name)
! 453: {
! 454: rs_write_int(savef,i);
! 455: return;
! 456: }
! 457:
! 458: rs_write_int(savef,-1);
! 459: }
! 460:
! 461: void
! 462: rs_read_stone_index(FILE *savef, const STONE master[], int maxindex, const char **str)
! 463: {
! 464: int i = 0;
! 465:
! 466: rs_read_int(savef,&i);
! 467:
! 468: if (!encerror() && (i > maxindex))
! 469: encseterr(EILSEQ);
! 470: else if (i >= 0)
! 471: *str = master[i].st_name;
! 472: else
! 473: *str = NULL;
! 474: }
! 475:
! 476: void
! 477: rs_write_scrolls(FILE *savef)
! 478: {
! 479: int i;
! 480:
! 481: for(i = 0; i < MAXSCROLLS; i++)
! 482: rs_write_string(savef, s_names[i]);
! 483: }
! 484:
! 485: void
! 486: rs_read_scrolls(FILE *savef)
! 487: {
! 488: int i;
! 489:
! 490: for(i = 0; i < MAXSCROLLS; i++)
! 491: rs_read_new_string(savef, &s_names[i]);
! 492: }
! 493:
! 494: void
! 495: rs_write_potions(FILE *savef)
! 496: {
! 497: int i;
! 498:
! 499: for(i = 0; i < MAXPOTIONS; i++)
! 500: rs_write_string_index(savef, rainbow, cNCOLORS, p_colors[i]);
! 501: }
! 502:
! 503: void
! 504: rs_read_potions(FILE *savef)
! 505: {
! 506: int i;
! 507:
! 508: for(i = 0; i < MAXPOTIONS; i++)
! 509: rs_read_string_index(savef, rainbow, cNCOLORS, &p_colors[i]);
! 510: }
! 511:
! 512: void
! 513: rs_write_rings(FILE *savef)
! 514: {
! 515: int i;
! 516:
! 517: for(i = 0; i < MAXRINGS; i++)
! 518: rs_write_stone_index(savef, stones, cNSTONES, r_stones[i]);
! 519: }
! 520:
! 521: void
! 522: rs_read_rings(FILE *savef)
! 523: {
! 524: int i;
! 525:
! 526: for(i = 0; i < MAXRINGS; i++)
! 527: rs_read_stone_index(savef, stones, cNSTONES, &r_stones[i]);
! 528: }
! 529:
! 530: void
! 531: rs_write_sticks(FILE *savef)
! 532: {
! 533: int i;
! 534:
! 535: for (i = 0; i < MAXSTICKS; i++)
! 536: {
! 537: if (strcmp(ws_type[i],"staff") == 0)
! 538: {
! 539: rs_write_int(savef,0);
! 540: rs_write_string_index(savef, wood, cNWOOD, ws_made[i]);
! 541: }
! 542: else
! 543: {
! 544: rs_write_int(savef,1);
! 545: rs_write_string_index(savef, metal, cNMETAL, ws_made[i]);
! 546: }
! 547: }
! 548: }
! 549:
! 550: void
! 551: rs_read_sticks(FILE *savef)
! 552: {
! 553: int i = 0, list = 0;
! 554:
! 555: for(i = 0; i < MAXSTICKS; i++)
! 556: {
! 557: rs_read_int(savef,&list);
! 558:
! 559: if (list == 0)
! 560: {
! 561: rs_read_string_index(savef, wood, cNWOOD, &ws_made[i]);
! 562: ws_type[i] = "staff";
! 563: }
! 564: else
! 565: {
! 566: rs_read_string_index(savef, metal, cNMETAL, &ws_made[i]);
! 567: ws_type[i] = "wand";
! 568: }
! 569: }
! 570: }
! 571:
! 572: void
! 573: rs_write_daemons(FILE *savef, struct delayed_action *dlist, int cnt)
! 574: {
! 575: int i = 0;
! 576: int func = 0;
! 577:
! 578: rs_write_marker(savef, RSID_DAEMONS);
! 579: rs_write_int(savef, cnt);
! 580:
! 581: for(i = 0; i < cnt; i++)
! 582: {
! 583: if (dlist[i].d_func == rollwand)
! 584: func = 1;
! 585: else if (dlist[i].d_func == doctor)
! 586: func = 2;
! 587: else if (dlist[i].d_func == stomach)
! 588: func = 3;
! 589: else if (dlist[i].d_func == runners)
! 590: func = 4;
! 591: else if (dlist[i].d_func == swander)
! 592: func = 5;
! 593: else if (dlist[i].d_func == nohaste)
! 594: func = 6;
! 595: else if (dlist[i].d_func == unconfuse)
! 596: func = 7;
! 597: else if (dlist[i].d_func == unsee)
! 598: func = 8;
! 599: else if (dlist[i].d_func == sight)
! 600: func = 9;
! 601: else if (dlist[i].d_func == turn_see_off)
! 602: func = 10;
! 603: else if (dlist[i].d_func == land)
! 604: func = 11;
! 605: else if (dlist[i].d_func == come_down)
! 606: func = 12;
! 607: else if (dlist[i].d_func == visuals)
! 608: func = 13;
! 609: else if (dlist[i].d_func == NULL)
! 610: func = 0;
! 611: else
! 612: func = -1;
! 613:
! 614: rs_write_int(savef, dlist[i].d_type);
! 615: rs_write_int(savef, func);
! 616: rs_write_int(savef, dlist[i].d_arg);
! 617: rs_write_int(savef, dlist[i].d_time);
! 618: }
! 619: }
! 620:
! 621: void
! 622: rs_read_daemons(FILE *savef, struct delayed_action *dlist, int cnt)
! 623: {
! 624: int i = 0;
! 625: int func = 0;
! 626: int value = 0;
! 627:
! 628: rs_read_marker(savef, RSID_DAEMONS);
! 629: rs_read_int(savef, &value);
! 630:
! 631: if (!encerror() && (value > cnt))
! 632: {
! 633: encseterr(EILSEQ);
! 634: return;
! 635: }
! 636:
! 637: for(i=0; i < cnt; i++)
! 638: {
! 639: func = 0;
! 640: rs_read_int(savef, &dlist[i].d_type);
! 641: rs_read_int(savef, &func);
! 642: rs_read_int(savef, &dlist[i].d_arg);
! 643: rs_read_int(savef, &dlist[i].d_time);
! 644:
! 645: if (encerror())
! 646: return;
! 647:
! 648: switch(func)
! 649: {
! 650: case 1: dlist[i].d_func = rollwand;
! 651: break;
! 652: case 2: dlist[i].d_func = doctor;
! 653: break;
! 654: case 3: dlist[i].d_func = stomach;
! 655: break;
! 656: case 4: dlist[i].d_func = runners;
! 657: break;
! 658: case 5: dlist[i].d_func = swander;
! 659: break;
! 660: case 6: dlist[i].d_func = nohaste;
! 661: break;
! 662: case 7: dlist[i].d_func = unconfuse;
! 663: break;
! 664: case 8: dlist[i].d_func = unsee;
! 665: break;
! 666: case 9: dlist[i].d_func = sight;
! 667: break;
! 668: case 10: dlist[i].d_func = turn_see_off;
! 669: break;
! 670: case 11: dlist[i].d_func = land;
! 671: break;
! 672: case 12: dlist[i].d_func = come_down;
! 673: break;
! 674: case 13: dlist[i].d_func = visuals;
! 675: break;
! 676: default:dlist[i].d_func = NULL;
! 677: break;
! 678: }
! 679:
! 680: if (dlist[i].d_func == NULL)
! 681: {
! 682: dlist[i].d_type = 0;
! 683: dlist[i].d_arg = 0;
! 684: dlist[i].d_time = 0;
! 685: }
! 686: }
! 687:
! 688: }
! 689:
! 690: void
! 691: rs_write_obj_info(FILE *savef, struct obj_info *i, int cnt)
! 692: {
! 693: int n;
! 694:
! 695: rs_write_marker(savef, RSID_MAGICITEMS);
! 696: rs_write_int(savef, cnt);
! 697:
! 698: for(n = 0; n < cnt; n++)
! 699: {
! 700: /* oi_name is constant, defined at compile time in all cases */
! 701: rs_write_int(savef,i[n].oi_prob);
! 702: rs_write_int(savef,i[n].oi_worth);
! 703: rs_write_string(savef,i[n].oi_guess);
! 704: rs_write_int(savef,i[n].oi_know);
! 705: }
! 706: }
! 707:
! 708: void
! 709: rs_read_obj_info(FILE *savef, struct obj_info *mi, int cnt)
! 710: {
! 711: int n;
! 712: int value;
! 713:
! 714: rs_read_marker(savef, RSID_MAGICITEMS);
! 715:
! 716: rs_read_int(savef, &value);
! 717:
! 718: if (!encerror() && (value > cnt))
! 719: {
! 720: encseterr(EILSEQ);
! 721: return;
! 722: }
! 723:
! 724: for(n = 0; n < value; n++)
! 725: {
! 726: /* mi_name is const, defined at compile time in all cases */
! 727: rs_read_int(savef,&mi[n].oi_prob);
! 728: rs_read_int(savef,&mi[n].oi_worth);
! 729: rs_read_new_string(savef,&mi[n].oi_guess);
! 730: rs_read_int(savef,&mi[n].oi_know);
! 731: }
! 732: }
! 733:
! 734: void
! 735: rs_write_room(FILE *savef, struct room *r)
! 736: {
! 737: rs_write_coord(savef, r->r_pos);
! 738: rs_write_coord(savef, r->r_max);
! 739: rs_write_coord(savef, r->r_gold);
! 740: rs_write_int(savef, r->r_goldval);
! 741: rs_write_int(savef, r->r_flags);
! 742: rs_write_int(savef, r->r_nexits);
! 743: rs_write_coord(savef, r->r_exit[0]);
! 744: rs_write_coord(savef, r->r_exit[1]);
! 745: rs_write_coord(savef, r->r_exit[2]);
! 746: rs_write_coord(savef, r->r_exit[3]);
! 747: rs_write_coord(savef, r->r_exit[4]);
! 748: rs_write_coord(savef, r->r_exit[5]);
! 749: rs_write_coord(savef, r->r_exit[6]);
! 750: rs_write_coord(savef, r->r_exit[7]);
! 751: rs_write_coord(savef, r->r_exit[8]);
! 752: rs_write_coord(savef, r->r_exit[9]);
! 753: rs_write_coord(savef, r->r_exit[10]);
! 754: rs_write_coord(savef, r->r_exit[11]);
! 755: }
! 756:
! 757: void
! 758: rs_read_room(FILE *savef, struct room *r)
! 759: {
! 760: rs_read_coord(savef,&r->r_pos);
! 761: rs_read_coord(savef,&r->r_max);
! 762: rs_read_coord(savef,&r->r_gold);
! 763: rs_read_int(savef,&r->r_goldval);
! 764: rs_read_int(savef,&r->r_flags);
! 765: rs_read_int(savef,&r->r_nexits);
! 766: rs_read_coord(savef,&r->r_exit[0]);
! 767: rs_read_coord(savef,&r->r_exit[1]);
! 768: rs_read_coord(savef,&r->r_exit[2]);
! 769: rs_read_coord(savef,&r->r_exit[3]);
! 770: rs_read_coord(savef,&r->r_exit[4]);
! 771: rs_read_coord(savef,&r->r_exit[5]);
! 772: rs_read_coord(savef,&r->r_exit[6]);
! 773: rs_read_coord(savef,&r->r_exit[7]);
! 774: rs_read_coord(savef,&r->r_exit[8]);
! 775: rs_read_coord(savef,&r->r_exit[9]);
! 776: rs_read_coord(savef,&r->r_exit[10]);
! 777: rs_read_coord(savef,&r->r_exit[11]);
! 778: }
! 779:
! 780: void
! 781: rs_write_rooms(FILE *savef, struct room r[], int cnt)
! 782: {
! 783: int n = 0;
! 784:
! 785: rs_write_int(savef, cnt);
! 786:
! 787: for(n = 0; n < cnt; n++)
! 788: rs_write_room(savef, &r[n]);
! 789: }
! 790:
! 791: void
! 792: rs_read_rooms(FILE *savef, struct room *r, int cnt)
! 793: {
! 794: int value = 0, n = 0;
! 795:
! 796: rs_read_int(savef,&value);
! 797:
! 798: if (!encerror() && (value > cnt))
! 799: encseterr(EILSEQ);
! 800: else
! 801: for(n = 0; n < value; n++)
! 802: rs_read_room(savef,&r[n]);
! 803: }
! 804:
! 805: void
! 806: rs_write_room_reference(FILE *savef, struct room *rp)
! 807: {
! 808: int i, room = -1;
! 809:
! 810: for (i = 0; i < MAXROOMS; i++)
! 811: if (&rooms[i] == rp)
! 812: room = i;
! 813:
! 814: rs_write_int(savef, room);
! 815: }
! 816:
! 817: void
! 818: rs_read_room_reference(FILE *savef, struct room **rp)
! 819: {
! 820: int i;
! 821:
! 822: rs_read_int(savef, &i);
! 823:
! 824: if (!encerror()) {
! 825: if (i >= 0 && i < MAXROOMS)
! 826: *rp = &rooms[i];
! 827: else
! 828: *rp = NULL;
! 829: }
! 830: }
! 831:
! 832: void
! 833: rs_write_monsters(FILE *savef, struct monster *m, int cnt)
! 834: {
! 835: int n;
! 836:
! 837: rs_write_marker(savef, RSID_MONSTERS);
! 838: rs_write_int(savef, cnt);
! 839:
! 840: for(n=0;n<cnt;n++)
! 841: rs_write_stats(savef, &m[n].m_stats);
! 842: }
! 843:
! 844: void
! 845: rs_read_monsters(FILE *savef, struct monster *m, int cnt)
! 846: {
! 847: int value = 0, n = 0;
! 848:
! 849: rs_read_marker(savef, RSID_MONSTERS);
! 850:
! 851: rs_read_int(savef, &value);
! 852:
! 853: if (!encerror() && (value != cnt))
! 854: encseterr(EILSEQ);
! 855: else
! 856: for(n = 0; n < cnt; n++)
! 857: rs_read_stats(savef, &m[n].m_stats);
! 858: }
! 859:
! 860: void
! 861: rs_write_object(FILE *savef, THING *o)
! 862: {
! 863: rs_write_marker(savef, RSID_OBJECT);
! 864: rs_write_int(savef, o->_o._o_type);
! 865: rs_write_coord(savef, o->_o._o_pos);
! 866: rs_write_int(savef, o->_o._o_launch);
! 867: rs_write_int(savef, o->_o._o_packch);
! 868: rs_write_chars(savef, o->_o._o_damage, sizeof(o->_o._o_damage));
! 869: rs_write_chars(savef, o->_o._o_hurldmg, sizeof(o->_o._o_hurldmg));
! 870: rs_write_int(savef, o->_o._o_count);
! 871: rs_write_int(savef, o->_o._o_which);
! 872: rs_write_int(savef, o->_o._o_hplus);
! 873: rs_write_int(savef, o->_o._o_dplus);
! 874: rs_write_int(savef, o->_o._o_arm);
! 875: rs_write_int(savef, o->_o._o_flags);
! 876: rs_write_int(savef, o->_o._o_group);
! 877: rs_write_string(savef, o->_o._o_label);
! 878: }
! 879:
! 880: void
! 881: rs_read_object(FILE *savef, THING *o)
! 882: {
! 883: rs_read_marker(savef, RSID_OBJECT);
! 884: rs_read_int(savef, &o->_o._o_type);
! 885: rs_read_coord(savef, &o->_o._o_pos);
! 886: rs_read_int(savef, &o->_o._o_launch);
! 887: rs_read_int(savef, &o->_o._o_packch);
! 888: rs_read_chars(savef, o->_o._o_damage, sizeof(o->_o._o_damage));
! 889: rs_read_chars(savef, o->_o._o_hurldmg, sizeof(o->_o._o_hurldmg));
! 890: rs_read_int(savef, &o->_o._o_count);
! 891: rs_read_int(savef, &o->_o._o_which);
! 892: rs_read_int(savef, &o->_o._o_hplus);
! 893: rs_read_int(savef, &o->_o._o_dplus);
! 894: rs_read_int(savef, &o->_o._o_arm);
! 895: rs_read_int(savef, &o->_o._o_flags);
! 896: rs_read_int(savef, &o->_o._o_group);
! 897: rs_read_new_string(savef, &o->_o._o_label);
! 898: }
! 899:
! 900: void
! 901: rs_write_object_list(FILE *savef, THING *l)
! 902: {
! 903: rs_write_marker(savef, RSID_OBJECTLIST);
! 904: rs_write_int(savef, list_size(l));
! 905:
! 906: for( ;l != NULL; l = l->l_next)
! 907: rs_write_object(savef, l);
! 908: }
! 909:
! 910: void
! 911: rs_read_object_list(FILE *savef, THING **list)
! 912: {
! 913: int i, cnt;
! 914: THING *l = NULL, *previous = NULL, *head = NULL;
! 915:
! 916: rs_read_marker(savef, RSID_OBJECTLIST);
! 917: rs_read_int(savef, &cnt);
! 918:
! 919: if (encerror())
! 920: return;
! 921:
! 922: for (i = 0; i < cnt; i++)
! 923: {
! 924: l = new_item();
! 925:
! 926: l->l_prev = previous;
! 927:
! 928: if (previous != NULL)
! 929: previous->l_next = l;
! 930:
! 931: rs_read_object(savef,l);
! 932:
! 933: if (previous == NULL)
! 934: head = l;
! 935:
! 936: previous = l;
! 937: }
! 938:
! 939: if (l != NULL)
! 940: l->l_next = NULL;
! 941:
! 942: *list = head;
! 943: }
! 944:
! 945: void
! 946: rs_write_object_reference(FILE *savef, THING *list, THING *item)
! 947: {
! 948: int i;
! 949:
! 950: i = find_list_ptr(list, item);
! 951:
! 952: rs_write_int(savef, i);
! 953: }
! 954:
! 955: void
! 956: rs_read_object_reference(FILE *savef, THING *list, THING **item)
! 957: {
! 958: int i;
! 959:
! 960: rs_read_int(savef, &i);
! 961:
! 962: if (!encerror())
! 963: *item = get_list_item(list,i);
! 964: else
! 965: *item = NULL;
! 966: }
! 967:
! 968: int
! 969: find_room_coord(const struct room *rmlist,const coord *c, int n)
! 970: {
! 971: int i = 0;
! 972:
! 973: for(i = 0; i < n; i++)
! 974: if(&rmlist[i].r_gold == c)
! 975: return(i);
! 976:
! 977: return(-1);
! 978: }
! 979:
! 980: int
! 981: find_thing_coord(THING *monlist, const coord *c)
! 982: {
! 983: THING *mitem;
! 984: THING *tp;
! 985: int i = 0;
! 986:
! 987: for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
! 988: {
! 989: tp = mitem;
! 990:
! 991: if (c == &tp->t_pos)
! 992: return(i);
! 993:
! 994: i++;
! 995: }
! 996:
! 997: return(-1);
! 998: }
! 999:
! 1000: int
! 1001: find_object_coord(THING *objlist, const coord *c)
! 1002: {
! 1003: THING *oitem;
! 1004: THING *obj;
! 1005: int i = 0;
! 1006:
! 1007: for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
! 1008: {
! 1009: obj = oitem;
! 1010:
! 1011: if (c == &obj->o_pos)
! 1012: return(i);
! 1013:
! 1014: i++;
! 1015: }
! 1016:
! 1017: return(-1);
! 1018: }
! 1019:
! 1020: void
! 1021: rs_write_thing(FILE *savef, THING *t)
! 1022: {
! 1023: int i = -1;
! 1024:
! 1025: rs_write_marker(savef, RSID_THING);
! 1026:
! 1027: if (t == NULL)
! 1028: {
! 1029: rs_write_int(savef, 0);
! 1030: return;
! 1031: }
! 1032:
! 1033: rs_write_int(savef, 1);
! 1034: rs_write_coord(savef, t->_t._t_pos);
! 1035: rs_write_int(savef, t->_t._t_turn);
! 1036: rs_write_int(savef, t->_t._t_type);
! 1037: rs_write_int(savef, t->_t._t_disguise);
! 1038: rs_write_int(savef, t->_t._t_oldch);
! 1039:
! 1040: /*
! 1041: t_dest can be:
! 1042: 0,0: NULL
! 1043: 0,1: location of hero
! 1044: 1,i: location of a thing (monster)
! 1045: 2,i: location of an object
! 1046: 3,i: location of gold in a room
! 1047:
! 1048: We need to remember what we are chasing rather than
! 1049: the current location of what we are chasing.
! 1050: */
! 1051:
! 1052: if (t->t_dest == &hero)
! 1053: {
! 1054: rs_write_int(savef,0);
! 1055: rs_write_int(savef,1);
! 1056: }
! 1057: else if (t->t_dest != NULL)
! 1058: {
! 1059: i = find_thing_coord(mlist, t->t_dest);
! 1060:
! 1061: if (i >=0 )
! 1062: {
! 1063: rs_write_int(savef,1);
! 1064: rs_write_int(savef,i);
! 1065: }
! 1066: else
! 1067: {
! 1068: i = find_object_coord(lvl_obj, t->t_dest);
! 1069:
! 1070: if (i >= 0)
! 1071: {
! 1072: rs_write_int(savef,2);
! 1073: rs_write_int(savef,i);
! 1074: }
! 1075: else
! 1076: {
! 1077: i = find_room_coord(rooms, t->t_dest, MAXROOMS);
! 1078:
! 1079: if (i >= 0)
! 1080: {
! 1081: rs_write_int(savef,3);
! 1082: rs_write_int(savef,i);
! 1083: }
! 1084: else
! 1085: {
! 1086: rs_write_int(savef, 0);
! 1087: rs_write_int(savef,1); /* chase the hero anyway */
! 1088: }
! 1089: }
! 1090: }
! 1091: }
! 1092: else
! 1093: {
! 1094: rs_write_int(savef,0);
! 1095: rs_write_int(savef,0);
! 1096: }
! 1097:
! 1098: rs_write_int(savef, t->_t._t_flags);
! 1099: rs_write_stats(savef, &t->_t._t_stats);
! 1100: rs_write_room_reference(savef, t->_t._t_room);
! 1101: rs_write_object_list(savef, t->_t._t_pack);
! 1102: }
! 1103:
! 1104: void
! 1105: rs_read_thing(FILE *savef, THING *t)
! 1106: {
! 1107: int listid = 0, index = -1;
! 1108: THING *item;
! 1109:
! 1110: rs_read_marker(savef, RSID_THING);
! 1111: rs_read_int(savef, &index);
! 1112:
! 1113: if (encerror())
! 1114: return;
! 1115:
! 1116: if (index == 0)
! 1117: return;
! 1118:
! 1119: rs_read_coord(savef,&t->_t._t_pos);
! 1120: rs_read_int(savef,&t->_t._t_turn);
! 1121: rs_read_int(savef,&t->_t._t_type);
! 1122: rs_read_int(savef,&t->_t._t_disguise);
! 1123: rs_read_int(savef,&t->_t._t_oldch);
! 1124:
! 1125: /*
! 1126: t_dest can be (listid,index):
! 1127: 0,0: NULL
! 1128: 0,1: location of hero
! 1129: 1,i: location of a thing (monster)
! 1130: 2,i: location of an object
! 1131: 3,i: location of gold in a room
! 1132:
! 1133: We need to remember what we are chasing rather than
! 1134: the current location of what we are chasing.
! 1135: */
! 1136:
! 1137: rs_read_int(savef, &listid);
! 1138: rs_read_int(savef, &index);
! 1139: t->_t._t_reserved = -1;
! 1140:
! 1141: if (encerror())
! 1142: return;
! 1143:
! 1144: if (listid == 0) /* hero or NULL */
! 1145: {
! 1146: if (index == 1)
! 1147: t->_t._t_dest = &hero;
! 1148: else
! 1149: t->_t._t_dest = NULL;
! 1150: }
! 1151: else if (listid == 1) /* monster/thing */
! 1152: {
! 1153: t->_t._t_dest = NULL;
! 1154: t->_t._t_reserved = index;
! 1155: }
! 1156: else if (listid == 2) /* object */
! 1157: {
! 1158: THING *obj;
! 1159:
! 1160: item = get_list_item(lvl_obj, index);
! 1161:
! 1162: if (item != NULL)
! 1163: {
! 1164: obj = item;
! 1165: t->_t._t_dest = &obj->o_pos;
! 1166: }
! 1167: }
! 1168: else if (listid == 3) /* gold */
! 1169: {
! 1170: t->_t._t_dest = &rooms[index].r_gold;
! 1171: }
! 1172: else
! 1173: t->_t._t_dest = NULL;
! 1174:
! 1175: rs_read_int(savef,&t->_t._t_flags);
! 1176: rs_read_stats(savef,&t->_t._t_stats);
! 1177: rs_read_room_reference(savef, &t->_t._t_room);
! 1178: rs_read_object_list(savef,&t->_t._t_pack);
! 1179: }
! 1180:
! 1181: void
! 1182: rs_fix_thing(THING *t)
! 1183: {
! 1184: THING *item;
! 1185: THING *tp;
! 1186:
! 1187: if (t->t_reserved < 0)
! 1188: return;
! 1189:
! 1190: item = get_list_item(mlist,t->t_reserved);
! 1191:
! 1192: if (item != NULL)
! 1193: {
! 1194: tp = item;
! 1195: t->t_dest = &tp->t_pos;
! 1196: }
! 1197: }
! 1198:
! 1199: void
! 1200: rs_write_thing_list(FILE *savef, THING *l)
! 1201: {
! 1202: int cnt = 0;
! 1203:
! 1204: rs_write_marker(savef, RSID_MONSTERLIST);
! 1205:
! 1206: cnt = list_size(l);
! 1207:
! 1208: rs_write_int(savef, cnt);
! 1209:
! 1210: if (cnt < 1)
! 1211: return;
! 1212:
! 1213: while (l != NULL) {
! 1214: rs_write_thing(savef, l);
! 1215: l = l->l_next;
! 1216: }
! 1217: }
! 1218:
! 1219: void
! 1220: rs_read_thing_list(FILE *savef, THING **list)
! 1221: {
! 1222: int i, cnt;
! 1223: THING *l = NULL, *previous = NULL, *head = NULL;
! 1224:
! 1225: rs_read_marker(savef, RSID_MONSTERLIST);
! 1226: rs_read_int(savef, &cnt);
! 1227:
! 1228: if (encerror())
! 1229: return;
! 1230:
! 1231: for (i = 0; i < cnt; i++)
! 1232: {
! 1233: l = new_item();
! 1234:
! 1235: l->l_prev = previous;
! 1236:
! 1237: if (previous != NULL)
! 1238: previous->l_next = l;
! 1239:
! 1240: rs_read_thing(savef,l);
! 1241:
! 1242: if (previous == NULL)
! 1243: head = l;
! 1244:
! 1245: previous = l;
! 1246: }
! 1247:
! 1248: if (l != NULL)
! 1249: l->l_next = NULL;
! 1250:
! 1251: *list = head;
! 1252: }
! 1253:
! 1254: void
! 1255: rs_fix_thing_list(THING *list)
! 1256: {
! 1257: THING *item;
! 1258:
! 1259: for(item = list; item != NULL; item = item->l_next)
! 1260: rs_fix_thing(item);
! 1261: }
! 1262:
! 1263: void
! 1264: rs_write_thing_reference(FILE *savef, THING *list, THING *item)
! 1265: {
! 1266: int i;
! 1267:
! 1268: if (item == NULL)
! 1269: rs_write_int(savef,-1);
! 1270: else
! 1271: {
! 1272: i = find_list_ptr(list, item);
! 1273:
! 1274: rs_write_int(savef, i);
! 1275: }
! 1276: }
! 1277:
! 1278: void
! 1279: rs_read_thing_reference(FILE *savef, THING *list, THING **item)
! 1280: {
! 1281: int i;
! 1282:
! 1283: rs_read_int(savef, &i);
! 1284:
! 1285: if (encerror())
! 1286: return;
! 1287:
! 1288: if (i == -1)
! 1289: *item = NULL;
! 1290: else
! 1291: *item = get_list_item(list,i);
! 1292:
! 1293: }
! 1294:
! 1295: void
! 1296: rs_write_thing_references(FILE *savef, THING *list, THING *items[], int cnt)
! 1297: {
! 1298: int i;
! 1299:
! 1300: for(i = 0; i < cnt; i++)
! 1301: rs_write_thing_reference(savef,list,items[i]);
! 1302: }
! 1303:
! 1304: void
! 1305: rs_read_thing_references(FILE *savef, THING *list, THING *items[], int cnt)
! 1306: {
! 1307: int i;
! 1308:
! 1309: for(i = 0; i < cnt; i++)
! 1310: rs_read_thing_reference(savef,list,&items[i]);
! 1311: }
! 1312:
! 1313: void
! 1314: rs_write_places(FILE *savef, PLACE *p, int cnt)
! 1315: {
! 1316: int i = 0;
! 1317:
! 1318: for(i = 0; i < cnt; i++)
! 1319: {
! 1320: rs_write_int(savef, p[i].p_ch);
! 1321: rs_write_int(savef, p[i].p_flags);
! 1322: rs_write_thing_reference(savef, mlist, p[i].p_monst);
! 1323: }
! 1324: }
! 1325:
! 1326: void
! 1327: rs_read_places(FILE *savef, PLACE *p, int cnt)
! 1328: {
! 1329: int i = 0;
! 1330:
! 1331: for(i = 0; i < cnt; i++)
! 1332: {
! 1333: rs_read_int(savef,&p[i].p_ch);
! 1334: rs_read_int(savef,&p[i].p_flags);
! 1335: rs_read_thing_reference(savef, mlist, &p[i].p_monst);
! 1336: }
! 1337: }
! 1338:
! 1339: int
! 1340: rs_save_file(FILE *savef)
! 1341: {
! 1342: encclearerr();
! 1343:
! 1344: rs_write_int(savef, noscore);
! 1345: rs_write_int(savef, seenstairs);
! 1346: rs_write_int(savef, amulet);
! 1347: rs_write_int(savef, fight_flush);
! 1348: rs_write_int(savef, jump);
! 1349: rs_write_int(savef, passgo);
! 1350: rs_write_int(savef, see_floor);
! 1351: rs_write_int(savef, terse);
! 1352: rs_write_int(savef, tombstone);
! 1353: rs_write_ints(savef, pack_used, 26);
! 1354: rs_write_chars(savef, file_name, MAXSTR);
! 1355: rs_write_chars(savef, huh, MAXSTR);
! 1356: rs_write_potions(savef);
! 1357: rs_write_rings(savef);
! 1358: rs_write_scrolls(savef);
! 1359: rs_write_chars(savef, whoami, MAXSTR);
! 1360: rs_write_sticks(savef);
! 1361: rs_write_chars(savef, fruit, MAXSTR);
! 1362: rs_write_int(savef,n_objs);
! 1363: rs_write_int(savef, ntraps);
! 1364: rs_write_int(savef, hungry_state);
! 1365: rs_write_int(savef, inpack);
! 1366: rs_write_int(savef, inv_type);
! 1367: rs_write_int(savef, level);
! 1368: rs_write_int(savef, max_level);
! 1369: rs_write_int(savef, no_food);
! 1370: rs_write_int(savef, food_left);
! 1371: rs_write_int(savef, lastscore);
! 1372: rs_write_int(savef, no_move);
! 1373: rs_write_int(savef, purse);
! 1374: rs_write_int(savef, quiet);
! 1375: rs_write_int(savef, vf_hit);
! 1376: rs_write_uint(savef, seed);
! 1377: rs_write_coord(savef, stairs);
! 1378: rs_write_thing(savef, &player);
! 1379: rs_write_object_reference(savef, player.t_pack, cur_armor);
! 1380: rs_write_object_reference(savef, player.t_pack, cur_ring[0]);
! 1381: rs_write_object_reference(savef, player.t_pack, cur_ring[1]);
! 1382: rs_write_object_reference(savef, player.t_pack, cur_weapon);
! 1383: rs_write_object_list(savef, lvl_obj);
! 1384: rs_write_thing_list(savef, mlist);
! 1385: rs_write_places(savef,places,MAXLINES*MAXCOLS);
! 1386: rs_write_stats(savef,&max_stats);
! 1387: rs_write_rooms(savef, rooms, MAXROOMS);
! 1388: rs_write_rooms(savef, passages, MAXPASS);
! 1389: rs_write_monsters(savef,monsters,26);
! 1390: rs_write_obj_info(savef, things, NUMTHINGS);
! 1391: rs_write_obj_info(savef, arm_info, MAXARMORS);
! 1392: rs_write_obj_info(savef, pot_info, MAXPOTIONS);
! 1393: rs_write_obj_info(savef, ring_info, MAXRINGS);
! 1394: rs_write_obj_info(savef, scr_info, MAXSCROLLS);
! 1395: rs_write_obj_info(savef, weap_info, MAXWEAPONS+1);
! 1396: rs_write_obj_info(savef, ws_info, MAXSTICKS);
! 1397: rs_write_daemons(savef, &d_list[0], 20);
! 1398: rs_write_int(savef,between);
! 1399: rs_write_int(savef, group);
! 1400: rs_write_window(savef,stdscr);
! 1401:
! 1402: return( encclearerr() );
! 1403: }
! 1404:
! 1405: int
! 1406: rs_restore_file(FILE *savef)
! 1407: {
! 1408: char fake_file_name[MAXSTR];
! 1409: THING *mitem;
! 1410: encclearerr();
! 1411:
! 1412: rs_read_int(savef, &noscore);
! 1413: rs_read_int(savef, &seenstairs);
! 1414: rs_read_int(savef, &amulet);
! 1415: rs_read_int(savef, &fight_flush);
! 1416: rs_read_int(savef, &jump);
! 1417: rs_read_int(savef, &passgo);
! 1418: rs_read_int(savef, &see_floor);
! 1419: rs_read_int(savef, &terse);
! 1420: rs_read_int(savef, &tombstone);
! 1421: rs_read_ints(savef, pack_used, 26);
! 1422: rs_read_chars(savef, fake_file_name, MAXSTR);
! 1423: rs_read_chars(savef, huh, MAXSTR);
! 1424: rs_read_potions(savef);
! 1425: rs_read_rings(savef);
! 1426: rs_read_scrolls(savef);
! 1427: rs_read_chars(savef, whoami, MAXSTR);
! 1428: rs_read_sticks(savef);
! 1429: rs_read_chars(savef, fruit, MAXSTR);
! 1430: rs_read_int(savef, &n_objs);
! 1431: rs_read_int(savef, &ntraps);
! 1432: rs_read_int(savef, &hungry_state);
! 1433: rs_read_int(savef, &inpack);
! 1434: rs_read_int(savef, &inv_type);
! 1435: rs_read_int(savef, &level);
! 1436: rs_read_int(savef, &max_level);
! 1437: rs_read_int(savef, &no_food);
! 1438: rs_read_int(savef, &food_left);
! 1439: rs_read_int(savef, &lastscore);
! 1440: rs_read_int(savef, &no_move);
! 1441: rs_read_int(savef, &purse);
! 1442: rs_read_int(savef, &quiet);
! 1443: rs_read_int(savef, &vf_hit);
! 1444: rs_read_uint(savef, &seed);
! 1445: rs_read_coord(savef, &stairs);
! 1446: rs_read_thing(savef, &player);
! 1447: rs_read_object_reference(savef, player.t_pack, &cur_armor);
! 1448: rs_read_object_reference(savef, player.t_pack, &cur_ring[0]);
! 1449: rs_read_object_reference(savef, player.t_pack, &cur_ring[1]);
! 1450: rs_read_object_reference(savef, player.t_pack, &cur_weapon);
! 1451: rs_read_object_list(savef, &lvl_obj);
! 1452: rs_read_thing_list(savef, &mlist);
! 1453: rs_fix_thing(&player);
! 1454: rs_fix_thing_list(mlist);
! 1455: rs_read_places(savef,places,MAXLINES*MAXCOLS);
! 1456: rs_read_stats(savef, &max_stats);
! 1457: rs_read_rooms(savef, rooms, MAXROOMS);
! 1458: rs_read_rooms(savef, passages, MAXPASS);
! 1459: rs_read_monsters(savef,monsters,26);
! 1460: rs_read_obj_info(savef, things, NUMTHINGS);
! 1461: rs_read_obj_info(savef, arm_info, MAXARMORS);
! 1462: rs_read_obj_info(savef, pot_info, MAXPOTIONS);
! 1463: rs_read_obj_info(savef, ring_info, MAXRINGS);
! 1464: rs_read_obj_info(savef, scr_info, MAXSCROLLS);
! 1465: rs_read_obj_info(savef, weap_info, MAXWEAPONS+1);
! 1466: rs_read_obj_info(savef, ws_info, MAXSTICKS);
! 1467: rs_read_daemons(savef, d_list, 20);
! 1468: rs_read_int(savef,&between);
! 1469: rs_read_int(savef,&group);
! 1470: rs_read_window(savef,stdscr);
! 1471:
! 1472: if (player.t_room == NULL)
! 1473: player.t_room = roomin(&hero);
! 1474: for (mitem = mlist; mitem != NULL; mitem = mitem->l_next) {
! 1475: if (mitem->t_room == NULL)
! 1476: mitem->t_room = roomin(&(mitem->t_pos));
! 1477: }
! 1478:
! 1479: return( encclearerr() );
! 1480: }
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 / rogue5