Annotation of early-roguelike/rogue3/state.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: state.c - Portable Rogue Save State Code
! 3:
! 4: Copyright (C) 1999, 2000, 2005, 2007, 2008 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, char *master[], int max, 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, char *master[], int maxindex, 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_str_t(FILE *savef, str_t str)
! 340: {
! 341: rs_write_int(savef, str.st_str);
! 342: rs_write_int(savef, str.st_add);
! 343: }
! 344:
! 345: void
! 346: rs_read_str_t(FILE *savef, str_t *str)
! 347: {
! 348: str_t in;
! 349:
! 350: rs_read_int(savef,&in.st_str);
! 351: rs_read_int(savef,&in.st_add);
! 352:
! 353: if (!encerror())
! 354: {
! 355: str->st_str = in.st_str;
! 356: str->st_add = in.st_add;
! 357: }
! 358: }
! 359:
! 360: void
! 361: rs_write_window(FILE *savef, WINDOW *win)
! 362: {
! 363: int row,col,height,width;
! 364:
! 365: width = getmaxx(win);
! 366: height = getmaxy(win);
! 367:
! 368: rs_write_marker(savef,RSID_WINDOW);
! 369: rs_write_int(savef,height);
! 370: rs_write_int(savef,width);
! 371:
! 372: for(row=0;row<height;row++)
! 373: for(col=0;col<width;col++)
! 374: rs_write_int(savef, mvwinch(win,row,col));
! 375: }
! 376:
! 377: void
! 378: rs_read_window(FILE *savef, WINDOW *win)
! 379: {
! 380: int row,col,maxlines,maxcols,value,width,height;
! 381:
! 382: width = getmaxx(win);
! 383: height = getmaxy(win);
! 384:
! 385: rs_read_marker(savef, RSID_WINDOW);
! 386:
! 387: rs_read_int(savef, &maxlines);
! 388: rs_read_int(savef, &maxcols);
! 389:
! 390: if (encerror())
! 391: return;
! 392:
! 393: for(row = 0; row < maxlines; row++)
! 394: for(col = 0; col < maxcols; col++)
! 395: {
! 396: rs_read_int(savef, &value);
! 397:
! 398: if ((row < height) && (col < width))
! 399: mvwaddch(win,row,col,value);
! 400: }
! 401: }
! 402:
! 403: /******************************************************************************/
! 404:
! 405: void *
! 406: get_list_item(struct linked_list *l, int i)
! 407: {
! 408: int cnt;
! 409:
! 410: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 411: if (cnt == i)
! 412: return(l->l_data);
! 413:
! 414: return(NULL);
! 415: }
! 416:
! 417: int
! 418: find_list_ptr(struct linked_list *l, void *ptr)
! 419: {
! 420: int cnt;
! 421:
! 422: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 423: if (l->l_data == ptr)
! 424: return(cnt);
! 425:
! 426: return(-1);
! 427: }
! 428:
! 429: int
! 430: list_size(struct linked_list *l)
! 431: {
! 432: int cnt;
! 433:
! 434: for(cnt = 0; l != NULL; cnt++, l = l->l_next)
! 435: if (l->l_data == NULL)
! 436: return(cnt);
! 437:
! 438: return(cnt);
! 439: }
! 440:
! 441: /******************************************************************************/
! 442:
! 443: void
! 444: rs_write_stats(FILE *savef, struct stats *s)
! 445: {
! 446: rs_write_marker(savef, RSID_STATS);
! 447: rs_write_str_t(savef, s->s_str);
! 448: rs_write_int(savef, s->s_exp);
! 449: rs_write_int(savef, s->s_lvl);
! 450: rs_write_int(savef, s->s_arm);
! 451: rs_write_int(savef, s->s_hpt);
! 452: rs_write_chars(savef, s->s_dmg, sizeof(s->s_dmg));
! 453: }
! 454:
! 455:
! 456: void
! 457: rs_read_stats(FILE *savef, struct stats *s)
! 458: {
! 459: rs_read_marker(savef, RSID_STATS);
! 460: rs_read_str_t(savef,&s->s_str);
! 461: rs_read_int(savef,&s->s_exp);
! 462: rs_read_int(savef,&s->s_lvl);
! 463: rs_read_int(savef,&s->s_arm);
! 464: rs_read_int(savef,&s->s_hpt);
! 465: rs_read_chars(savef,s->s_dmg,sizeof(s->s_dmg));
! 466: }
! 467:
! 468:
! 469: void
! 470: rs_write_scrolls(FILE *savef)
! 471: {
! 472: int i;
! 473:
! 474: for(i = 0; i < MAXSCROLLS; i++)
! 475: {
! 476: rs_write_string(savef,s_names[i]);
! 477: rs_write_int(savef,s_know[i]);
! 478: rs_write_string(savef,s_guess[i]);
! 479: }
! 480: }
! 481:
! 482: void
! 483: rs_read_scrolls(FILE *savef)
! 484: {
! 485: int i;
! 486:
! 487: for(i = 0; i < MAXSCROLLS; i++)
! 488: {
! 489: rs_read_new_string(savef,&s_names[i]);
! 490: rs_read_int(savef,&s_know[i]);
! 491: rs_read_new_string(savef,&s_guess[i]);
! 492: }
! 493: }
! 494:
! 495: void
! 496: rs_write_potions(FILE *savef)
! 497: {
! 498: int i;
! 499:
! 500: for(i = 0; i < MAXPOTIONS; i++)
! 501: {
! 502: rs_write_string_index(savef, rainbow, cNCOLORS, p_colors[i]);
! 503: rs_write_int(savef,p_know[i]);
! 504: rs_write_string(savef,p_guess[i]);
! 505: }
! 506: }
! 507:
! 508: void
! 509: rs_read_potions(FILE *savef)
! 510: {
! 511: int i;
! 512:
! 513: for(i = 0; i < MAXPOTIONS; i++)
! 514: {
! 515: rs_read_string_index(savef, rainbow, cNCOLORS, &p_colors[i]);
! 516: rs_read_int(savef,&p_know[i]);
! 517: rs_read_new_string(savef,&p_guess[i]);
! 518: }
! 519: }
! 520:
! 521: void
! 522: rs_write_rings(FILE *savef)
! 523: {
! 524: int i;
! 525:
! 526: for(i = 0; i < MAXRINGS; i++)
! 527: {
! 528: rs_write_string_index(savef, stones, cNSTONES, r_stones[i]);
! 529: rs_write_int(savef,r_know[i]);
! 530: rs_write_string(savef,r_guess[i]);
! 531: }
! 532: }
! 533:
! 534: void
! 535: rs_read_rings(FILE *savef)
! 536: {
! 537: int i;
! 538:
! 539: for(i = 0; i < MAXRINGS; i++)
! 540: {
! 541: rs_read_string_index(savef, stones, cNSTONES, &r_stones[i]);
! 542: rs_read_int(savef,&r_know[i]);
! 543: rs_read_new_string(savef,&r_guess[i]);
! 544: }
! 545: }
! 546:
! 547: void
! 548: rs_write_sticks(FILE *savef)
! 549: {
! 550: int i;
! 551:
! 552: for (i = 0; i < MAXSTICKS; i++)
! 553: {
! 554: if (strcmp(ws_type[i],"staff") == 0)
! 555: {
! 556: rs_write_int(savef,0);
! 557: rs_write_string_index(savef, wood, cNWOOD, ws_made[i]);
! 558: }
! 559: else
! 560: {
! 561: rs_write_int(savef,1);
! 562: rs_write_string_index(savef, metal, cNMETAL, ws_made[i]);
! 563: }
! 564: rs_write_int(savef, ws_know[i]);
! 565: rs_write_string(savef, ws_guess[i]);
! 566: }
! 567: }
! 568:
! 569: void
! 570: rs_read_sticks(FILE *savef)
! 571: {
! 572: int i = 0, list = 0;
! 573:
! 574: for(i = 0; i < MAXSTICKS; i++)
! 575: {
! 576: rs_read_int(savef,&list);
! 577:
! 578: if (list == 0)
! 579: {
! 580: rs_read_string_index(savef, wood, cNWOOD, &ws_made[i]);
! 581: ws_type[i] = "staff";
! 582: }
! 583: else
! 584: {
! 585: rs_read_string_index(savef, metal, cNMETAL, &ws_made[i]);
! 586: ws_type[i] = "wand";
! 587: }
! 588: rs_read_int(savef, &ws_know[i]);
! 589: rs_read_new_string(savef, &ws_guess[i]);
! 590: }
! 591: }
! 592:
! 593: void
! 594: rs_write_daemons(FILE *savef, struct delayed_action *dlist, int cnt)
! 595: {
! 596: int i = 0;
! 597: int func = 0;
! 598:
! 599: rs_write_marker(savef, RSID_DAEMONS);
! 600: rs_write_int(savef, cnt);
! 601:
! 602: for(i = 0; i < cnt; i++)
! 603: {
! 604: if (dlist[i].d_func == rollwand)
! 605: func = 1;
! 606: else if (dlist[i].d_func == doctor)
! 607: func = 2;
! 608: else if (dlist[i].d_func == stomach)
! 609: func = 3;
! 610: else if (dlist[i].d_func == runners)
! 611: func = 4;
! 612: else if (dlist[i].d_func == swander)
! 613: func = 5;
! 614: else if (dlist[i].d_func == nohaste)
! 615: func = 6;
! 616: else if (dlist[i].d_func == unconfuse)
! 617: func = 7;
! 618: else if (dlist[i].d_func == unsee)
! 619: func = 8;
! 620: else if (dlist[i].d_func == sight)
! 621: func = 9;
! 622: else if (dlist[i].d_func == NULL)
! 623: func = 0;
! 624: else
! 625: func = -1;
! 626:
! 627: rs_write_int(savef, dlist[i].d_type);
! 628: rs_write_int(savef, func);
! 629: rs_write_int(savef, dlist[i].d_arg);
! 630: rs_write_int(savef, dlist[i].d_time);
! 631: }
! 632: }
! 633:
! 634: void
! 635: rs_read_daemons(FILE *savef, struct delayed_action *dlist, int cnt)
! 636: {
! 637: int i = 0;
! 638: int func = 0;
! 639: int value = 0;
! 640:
! 641: rs_read_marker(savef, RSID_DAEMONS);
! 642: rs_read_int(savef, &value);
! 643:
! 644: if (!encerror() && (value > cnt))
! 645: {
! 646: encseterr(EILSEQ);
! 647: return;
! 648: }
! 649:
! 650: for(i=0; i < cnt; i++)
! 651: {
! 652: func = 0;
! 653: rs_read_int(savef, &dlist[i].d_type);
! 654: rs_read_int(savef, &func);
! 655: rs_read_int(savef, &dlist[i].d_arg);
! 656: rs_read_int(savef, &dlist[i].d_time);
! 657:
! 658: if (encerror())
! 659: return;
! 660:
! 661: switch(func)
! 662: {
! 663: case 1: dlist[i].d_func = rollwand;
! 664: break;
! 665: case 2: dlist[i].d_func = doctor;
! 666: break;
! 667: case 3: dlist[i].d_func = stomach;
! 668: break;
! 669: case 4: dlist[i].d_func = runners;
! 670: break;
! 671: case 5: dlist[i].d_func = swander;
! 672: break;
! 673: case 6: dlist[i].d_func = nohaste;
! 674: break;
! 675: case 7: dlist[i].d_func = unconfuse;
! 676: break;
! 677: case 8: dlist[i].d_func = unsee;
! 678: break;
! 679: case 9: dlist[i].d_func = sight;
! 680: break;
! 681: default:dlist[i].d_func = NULL;
! 682: break;
! 683: }
! 684: if (dlist[i].d_func == NULL)
! 685: {
! 686: dlist[i].d_type = 0;
! 687: dlist[i].d_arg = 0;
! 688: dlist[i].d_time = 0;
! 689: }
! 690: }
! 691: }
! 692:
! 693: void
! 694: rs_write_room(FILE *savef, struct room *r)
! 695: {
! 696: rs_write_coord(savef, r->r_pos);
! 697: rs_write_coord(savef, r->r_max);
! 698: rs_write_coord(savef, r->r_gold);
! 699: rs_write_int(savef, r->r_goldval);
! 700: rs_write_int(savef, r->r_flags);
! 701: rs_write_int(savef, r->r_nexits);
! 702: rs_write_coord(savef, r->r_exit[0]);
! 703: rs_write_coord(savef, r->r_exit[1]);
! 704: rs_write_coord(savef, r->r_exit[2]);
! 705: rs_write_coord(savef, r->r_exit[3]);
! 706: }
! 707:
! 708: void
! 709: rs_read_room(FILE *savef, struct room *r)
! 710: {
! 711: rs_read_coord(savef,&r->r_pos);
! 712: rs_read_coord(savef,&r->r_max);
! 713: rs_read_coord(savef,&r->r_gold);
! 714: rs_read_int(savef,&r->r_goldval);
! 715: rs_read_int(savef,&r->r_flags);
! 716: rs_read_int(savef,&r->r_nexits);
! 717: rs_read_coord(savef,&r->r_exit[0]);
! 718: rs_read_coord(savef,&r->r_exit[1]);
! 719: rs_read_coord(savef,&r->r_exit[2]);
! 720: rs_read_coord(savef,&r->r_exit[3]);
! 721: }
! 722:
! 723: void
! 724: rs_write_rooms(FILE *savef, struct room r[], int cnt)
! 725: {
! 726: int n = 0;
! 727:
! 728: rs_write_int(savef, cnt);
! 729:
! 730: for(n = 0; n < cnt; n++)
! 731: rs_write_room(savef, &r[n]);
! 732: }
! 733:
! 734: void
! 735: rs_read_rooms(FILE *savef, struct room *r, int cnt)
! 736: {
! 737: int value = 0, n = 0;
! 738:
! 739: rs_read_int(savef,&value);
! 740:
! 741: if (!encerror() && (value > cnt))
! 742: encseterr(EILSEQ);
! 743: else
! 744: for(n = 0; n < value; n++)
! 745: rs_read_room(savef,&r[n]);
! 746: }
! 747:
! 748: void
! 749: rs_write_room_reference(FILE *savef, struct room *rp)
! 750: {
! 751: int i, room = -1;
! 752:
! 753: for (i = 0; i < MAXROOMS; i++)
! 754: if (&rooms[i] == rp)
! 755: room = i;
! 756:
! 757: rs_write_int(savef, room);
! 758: }
! 759:
! 760: void
! 761: rs_read_room_reference(FILE *savef, struct room **rp)
! 762: {
! 763: int i;
! 764:
! 765: rs_read_int(savef, &i);
! 766:
! 767: if (!encerror()) {
! 768: if (i >= 0 && i < MAXROOMS)
! 769: *rp = &rooms[i];
! 770: else
! 771: *rp = NULL;
! 772: }
! 773: }
! 774:
! 775: void
! 776: rs_write_object(FILE *savef, struct object *o)
! 777: {
! 778: rs_write_marker(savef, RSID_OBJECT);
! 779: rs_write_int(savef, o->o_type);
! 780: rs_write_coord(savef, o->o_pos);
! 781: rs_write_int(savef, o->o_launch);
! 782: rs_write_chars(savef, o->o_damage, sizeof(o->o_damage));
! 783: rs_write_chars(savef, o->o_hurldmg, sizeof(o->o_hurldmg));
! 784: rs_write_int(savef, o->o_count);
! 785: rs_write_int(savef, o->o_which);
! 786: rs_write_int(savef, o->o_hplus);
! 787: rs_write_int(savef, o->o_dplus);
! 788: rs_write_int(savef, o->o_ac);
! 789: rs_write_int(savef, o->o_flags);
! 790: rs_write_int(savef, o->o_group);
! 791: }
! 792:
! 793: void
! 794: rs_read_object(FILE *savef, struct object *o)
! 795: {
! 796: rs_read_marker(savef, RSID_OBJECT);
! 797: rs_read_int(savef, &o->o_type);
! 798: rs_read_coord(savef, &o->o_pos);
! 799: rs_read_int(savef, &o->o_launch);
! 800: rs_read_chars(savef, o->o_damage, sizeof(o->o_damage));
! 801: rs_read_chars(savef, o->o_hurldmg, sizeof(o->o_hurldmg));
! 802: rs_read_int(savef, &o->o_count);
! 803: rs_read_int(savef, &o->o_which);
! 804: rs_read_int(savef, &o->o_hplus);
! 805: rs_read_int(savef, &o->o_dplus);
! 806: rs_read_int(savef,&o->o_ac);
! 807: rs_read_int(savef,&o->o_flags);
! 808: rs_read_int(savef,&o->o_group);
! 809: }
! 810:
! 811: void
! 812: rs_write_object_list(FILE *savef, struct linked_list *l)
! 813: {
! 814: rs_write_marker(savef, RSID_OBJECTLIST);
! 815: rs_write_int(savef, list_size(l));
! 816:
! 817: for( ;l != NULL; l = l->l_next)
! 818: rs_write_object(savef, (struct object *) l->l_data);
! 819: }
! 820:
! 821: void
! 822: rs_read_object_list(FILE *savef, struct linked_list **list)
! 823: {
! 824: int i, cnt;
! 825: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
! 826:
! 827: rs_read_marker(savef, RSID_OBJECTLIST);
! 828: rs_read_int(savef, &cnt);
! 829:
! 830: if (encerror())
! 831: return;
! 832:
! 833: for (i = 0; i < cnt; i++)
! 834: {
! 835: l = new_item(sizeof(struct object));
! 836:
! 837: memset(l->l_data,0,sizeof(struct object));
! 838:
! 839: l->l_prev = previous;
! 840:
! 841: if (previous != NULL)
! 842: previous->l_next = l;
! 843:
! 844: rs_read_object(savef,(struct object *) l->l_data);
! 845:
! 846: if (previous == NULL)
! 847: head = l;
! 848:
! 849: previous = l;
! 850: }
! 851:
! 852: if (l != NULL)
! 853: l->l_next = NULL;
! 854:
! 855: *list = head;
! 856: }
! 857:
! 858: void
! 859: rs_write_object_reference(FILE *savef, struct linked_list *list, struct object *item)
! 860: {
! 861: int i;
! 862:
! 863: i = find_list_ptr(list, item);
! 864:
! 865: rs_write_int(savef, i);
! 866: }
! 867:
! 868: void
! 869: rs_read_object_reference(FILE *savef, struct linked_list *list, struct object **item)
! 870: {
! 871: int i;
! 872:
! 873: rs_read_int(savef, &i);
! 874:
! 875: if (!encerror())
! 876: *item = get_list_item(list,i);
! 877: else
! 878: *item = NULL;
! 879: }
! 880:
! 881: int
! 882: find_room_coord(const struct room *rmlist, const coord *c, int n)
! 883: {
! 884: int i = 0;
! 885:
! 886: for(i = 0; i < n; i++)
! 887: if(&rmlist[i].r_gold == c)
! 888: return(i);
! 889:
! 890: return(-1);
! 891: }
! 892:
! 893: int
! 894: find_thing_coord(struct linked_list *monlist, coord *c)
! 895: {
! 896: struct linked_list *mitem;
! 897: struct thing *tp;
! 898: int i = 0;
! 899:
! 900: for(mitem = monlist; mitem != NULL; mitem = mitem->l_next)
! 901: {
! 902: tp = THINGPTR(mitem);
! 903:
! 904: if (c == &tp->t_pos)
! 905: return(i);
! 906:
! 907: i++;
! 908: }
! 909:
! 910: return(-1);
! 911: }
! 912:
! 913: int
! 914: find_object_coord(struct linked_list *objlist, coord *c)
! 915: {
! 916: struct linked_list *oitem;
! 917: struct object *obj;
! 918: int i = 0;
! 919:
! 920: for(oitem = objlist; oitem != NULL; oitem = oitem->l_next)
! 921: {
! 922: obj = OBJPTR(oitem);
! 923:
! 924: if (c == &obj->o_pos)
! 925: return(i);
! 926:
! 927: i++;
! 928: }
! 929:
! 930: return(-1);
! 931: }
! 932:
! 933: void
! 934: rs_write_thing(FILE *savef, struct thing *t)
! 935: {
! 936: int i = -1;
! 937:
! 938: rs_write_marker(savef, RSID_THING);
! 939:
! 940: if (t == NULL)
! 941: {
! 942: rs_write_int(savef, 0);
! 943: return;
! 944: }
! 945:
! 946: rs_write_int(savef, 1);
! 947: rs_write_coord(savef, t->t_pos);
! 948: rs_write_int(savef, t->t_turn);
! 949: rs_write_int(savef, t->t_type);
! 950: rs_write_int(savef, t->t_disguise);
! 951: rs_write_int(savef, t->t_oldch);
! 952:
! 953: /*
! 954: t_dest can be:
! 955: 0,0: NULL
! 956: 0,1: location of hero
! 957: 1,i: location of a thing (monster)
! 958: 2,i: location of an object
! 959: 3,i: location of gold in a room
! 960:
! 961: We need to remember what we are chasing rather than
! 962: the current location of what we are chasing.
! 963: */
! 964:
! 965: if (t->t_dest == &hero)
! 966: {
! 967: rs_write_int(savef,0);
! 968: rs_write_int(savef,1);
! 969: }
! 970: else if (t->t_dest != NULL)
! 971: {
! 972: i = find_thing_coord(mlist, t->t_dest);
! 973:
! 974: if (i >=0 )
! 975: {
! 976: rs_write_int(savef,1);
! 977: rs_write_int(savef,i);
! 978: }
! 979: else
! 980: {
! 981: i = find_object_coord(lvl_obj, t->t_dest);
! 982:
! 983: if (i >= 0)
! 984: {
! 985: rs_write_int(savef,2);
! 986: rs_write_int(savef,i);
! 987: }
! 988: else
! 989: {
! 990: i = find_room_coord(rooms, t->t_dest, MAXROOMS);
! 991:
! 992: if (i >= 0)
! 993: {
! 994: rs_write_int(savef,3);
! 995: rs_write_int(savef,i);
! 996: }
! 997: else
! 998: {
! 999: rs_write_int(savef, 0);
! 1000: rs_write_int(savef,1); /* chase the hero anyway */
! 1001: }
! 1002: }
! 1003: }
! 1004: }
! 1005: else
! 1006: {
! 1007: rs_write_int(savef,0);
! 1008: rs_write_int(savef,0);
! 1009: }
! 1010:
! 1011: rs_write_int(savef, t->t_flags);
! 1012: rs_write_stats(savef, &t->t_stats);
! 1013: rs_write_object_list(savef, t->t_pack);
! 1014: }
! 1015:
! 1016: void
! 1017: rs_read_thing(FILE *savef, struct thing *t)
! 1018: {
! 1019: int listid = 0, index = -1;
! 1020: struct linked_list *item;
! 1021:
! 1022: rs_read_marker(savef, RSID_THING);
! 1023: rs_read_int(savef, &index);
! 1024:
! 1025: if (encerror())
! 1026: return;
! 1027:
! 1028: if (index == 0)
! 1029: return;
! 1030:
! 1031: rs_read_coord(savef,&t->t_pos);
! 1032: rs_read_int(savef,&t->t_turn);
! 1033: rs_read_int(savef,&t->t_type);
! 1034: rs_read_int(savef,&t->t_disguise);
! 1035: rs_read_int(savef,&t->t_oldch);
! 1036:
! 1037: /*
! 1038: t_dest can be (listid,index):
! 1039: 0,0: NULL
! 1040: 0,1: location of hero
! 1041: 1,i: location of a thing (monster)
! 1042: 2,i: location of an object
! 1043: 3,i: location of gold in a room
! 1044:
! 1045: We need to remember what we are chasing rather than
! 1046: the current location of what we are chasing.
! 1047: */
! 1048:
! 1049: rs_read_int(savef, &listid);
! 1050: rs_read_int(savef, &index);
! 1051: t->t_reserved = -1;
! 1052:
! 1053: if (encerror())
! 1054: return;
! 1055:
! 1056: if (listid == 0) /* hero or NULL */
! 1057: {
! 1058: if (index == 1)
! 1059: t->t_dest = &hero;
! 1060: else
! 1061: t->t_dest = NULL;
! 1062: }
! 1063: else if (listid == 1) /* monster/thing */
! 1064: {
! 1065: t->t_dest = NULL;
! 1066: t->t_reserved = index;
! 1067: }
! 1068: else if (listid == 2) /* object */
! 1069: {
! 1070: struct object *obj;
! 1071:
! 1072: item = get_list_item(lvl_obj,index);
! 1073:
! 1074: if (item != NULL)
! 1075: {
! 1076: obj = OBJPTR(item);
! 1077: t->t_dest = &obj->o_pos;
! 1078: }
! 1079: }
! 1080: else if (listid == 3) /* gold */
! 1081: {
! 1082: t->t_dest = &rooms[index].r_gold;
! 1083: }
! 1084: else
! 1085: t->t_dest = NULL;
! 1086:
! 1087: rs_read_int(savef,&t->t_flags);
! 1088: rs_read_stats(savef,&t->t_stats);
! 1089: rs_read_object_list(savef,&t->t_pack);
! 1090: }
! 1091:
! 1092: void
! 1093: rs_fix_thing(struct thing *t)
! 1094: {
! 1095: struct linked_list *item;
! 1096: struct thing *tp;
! 1097:
! 1098: if (t->t_reserved < 0)
! 1099: return;
! 1100:
! 1101: item = get_list_item(mlist,t->t_reserved);
! 1102:
! 1103: if (item != NULL)
! 1104: {
! 1105: tp = THINGPTR(item);
! 1106: t->t_dest = &tp->t_pos;
! 1107: }
! 1108: }
! 1109:
! 1110: void
! 1111: rs_write_thing_list(FILE *savef, struct linked_list *l)
! 1112: {
! 1113: int cnt = 0;
! 1114:
! 1115: rs_write_marker(savef, RSID_MONSTERLIST);
! 1116:
! 1117: cnt = list_size(l);
! 1118:
! 1119: rs_write_int(savef, cnt);
! 1120:
! 1121: if (cnt < 1)
! 1122: return;
! 1123:
! 1124: while (l != NULL) {
! 1125: rs_write_thing(savef, (struct thing *)l->l_data);
! 1126: l = l->l_next;
! 1127: }
! 1128: }
! 1129:
! 1130: void
! 1131: rs_read_thing_list(FILE *savef, struct linked_list **list)
! 1132: {
! 1133: int i, cnt;
! 1134: struct linked_list *l = NULL, *previous = NULL, *head = NULL;
! 1135:
! 1136: rs_read_marker(savef, RSID_MONSTERLIST);
! 1137: rs_read_int(savef, &cnt);
! 1138:
! 1139: if (encerror())
! 1140: return;
! 1141:
! 1142: for (i = 0; i < cnt; i++)
! 1143: {
! 1144: l = new_item(sizeof(struct thing));
! 1145:
! 1146: l->l_prev = previous;
! 1147:
! 1148: if (previous != NULL)
! 1149: previous->l_next = l;
! 1150:
! 1151: rs_read_thing(savef,(struct thing *)l->l_data);
! 1152:
! 1153: if (previous == NULL)
! 1154: head = l;
! 1155:
! 1156: previous = l;
! 1157: }
! 1158:
! 1159: if (l != NULL)
! 1160: l->l_next = NULL;
! 1161:
! 1162: *list = head;
! 1163: }
! 1164:
! 1165: void
! 1166: rs_fix_thing_list(struct linked_list *list)
! 1167: {
! 1168: struct linked_list *item;
! 1169:
! 1170: for(item = list; item != NULL; item = item->l_next)
! 1171: rs_fix_thing(THINGPTR(item));
! 1172: }
! 1173:
! 1174: void
! 1175: rs_fix_magic_items(struct magic_item *mi, int cnt)
! 1176: {
! 1177: int i;
! 1178:
! 1179: for (i = 0; i < cnt; i++)
! 1180: if (i > 0)
! 1181: mi[i].mi_prob += mi[i-1].mi_prob;
! 1182: }
! 1183:
! 1184: void
! 1185: rs_fix_monsters(struct monster mons[26])
! 1186: {
! 1187: sprintf(mons['F'-'A'].m_stats.s_dmg,"%dd1",fung_hit);
! 1188: }
! 1189:
! 1190: void
! 1191: rs_write_trap(FILE *savef, struct trap *trap)
! 1192: {
! 1193: rs_write_coord(savef, trap->tr_pos);
! 1194: rs_write_int(savef, trap->tr_type);
! 1195: rs_write_int(savef, trap->tr_flags);
! 1196: }
! 1197:
! 1198: void
! 1199: rs_read_trap(FILE *savef, struct trap *trap)
! 1200: {
! 1201: rs_read_coord(savef,&trap->tr_pos);
! 1202: rs_read_int(savef,&trap->tr_type);
! 1203: rs_read_int(savef,&trap->tr_flags);
! 1204: }
! 1205:
! 1206: void
! 1207: rs_write_traps(FILE *savef, struct trap t[], int cnt)
! 1208: {
! 1209: int n = 0;
! 1210:
! 1211: rs_write_marker(savef, RSID_MONSTERS);
! 1212: rs_write_int(savef, cnt);
! 1213:
! 1214: for(n = 0; n < cnt; n++)
! 1215: rs_write_trap(savef, &t[n]);
! 1216: }
! 1217:
! 1218: void
! 1219: rs_read_traps(FILE *savef, struct trap *t, int cnt)
! 1220: {
! 1221: int value = 0, n = 0;
! 1222:
! 1223: rs_read_marker(savef, RSID_MONSTERS);
! 1224:
! 1225: rs_read_int(savef,&value);
! 1226:
! 1227: if (!encerror() && (value > cnt))
! 1228: encseterr(EILSEQ);
! 1229:
! 1230: for(n = 0; n < value; n++)
! 1231: rs_read_trap(savef,&t[n]);
! 1232: }
! 1233:
! 1234: int
! 1235: rs_save_file(FILE *savef)
! 1236: {
! 1237: encclearerr();
! 1238:
! 1239: rs_write_thing(savef, &player);
! 1240: rs_write_object_list(savef, lvl_obj);
! 1241: rs_write_thing_list(savef, mlist);
! 1242: rs_write_traps(savef, traps, MAXTRAPS);
! 1243: rs_write_rooms(savef, rooms, MAXROOMS);
! 1244: rs_write_room_reference(savef, oldrp);
! 1245: rs_write_stats(savef,&max_stats);
! 1246: rs_write_object_reference(savef, player.t_pack, cur_weapon);
! 1247: rs_write_object_reference(savef, player.t_pack, cur_armor);
! 1248: rs_write_object_reference(savef, player.t_pack, cur_ring[0]);
! 1249: rs_write_object_reference(savef, player.t_pack, cur_ring[1]);
! 1250: rs_write_int(savef, level);
! 1251: rs_write_int(savef, purse);
! 1252: rs_write_int(savef, mpos);
! 1253: rs_write_int(savef, ntraps);
! 1254: rs_write_int(savef, no_move);
! 1255: rs_write_int(savef, no_command);
! 1256: rs_write_int(savef, inpack);
! 1257: rs_write_int(savef, max_hp);
! 1258: rs_write_int(savef, total);
! 1259: rs_write_int(savef, lastscore);
! 1260: rs_write_int(savef, no_food);
! 1261: rs_write_int(savef, seed);
! 1262: rs_write_int(savef, count);
! 1263: rs_write_int(savef, dnum);
! 1264: rs_write_int(savef, fung_hit);
! 1265: rs_write_int(savef, quiet);
! 1266: rs_write_int(savef, max_level);
! 1267: rs_write_int(savef, food_left);
! 1268: rs_write_int(savef, group);
! 1269: rs_write_int(savef, hungry_state);
! 1270: rs_write_int(savef, take);
! 1271: rs_write_int(savef, runch);
! 1272: rs_write_scrolls(savef);
! 1273: rs_write_potions(savef);
! 1274: rs_write_rings(savef);
! 1275: rs_write_sticks(savef);
! 1276: rs_write_chars(savef,whoami,80);
! 1277: rs_write_chars(savef,fruit,80);
! 1278: rs_write_window(savef, cw);
! 1279: rs_write_window(savef, mw);
! 1280: rs_write_window(savef, stdscr);
! 1281: rs_write_int(savef, running);
! 1282: rs_write_int(savef, playing);
! 1283: rs_write_int(savef, wizard);
! 1284: rs_write_int(savef, after);
! 1285: rs_write_int(savef, notify);
! 1286: rs_write_int(savef, fight_flush);
! 1287: rs_write_int(savef, terse);
! 1288: rs_write_int(savef, door_stop);
! 1289: rs_write_int(savef, jump);
! 1290: rs_write_int(savef, slow_invent);
! 1291: rs_write_int(savef, firstmove);
! 1292: rs_write_int(savef, waswizard);
! 1293: rs_write_int(savef, askme);
! 1294: rs_write_int(savef, amulet);
! 1295: rs_write_int(savef, in_shell);
! 1296: rs_write_coord(savef, oldpos);
! 1297: rs_write_coord(savef, delta);
! 1298: rs_write_coord(savef, ch_ret); /* chase.c */
! 1299: rs_write_daemons(savef, &d_list[0], 20); /* daemon.c */
! 1300: rs_write_int(savef,between); /* daemons.c */
! 1301: rs_write_int(savef,num_checks); /* main.c */
! 1302: rs_write_chars(savef,lvl_mons,sizeof(lvl_mons)); /* monsters.c */
! 1303: rs_write_chars(savef,wand_mons,sizeof(wand_mons)); /* monsters.c */
! 1304:
! 1305: return( encclearerr() );
! 1306: }
! 1307:
! 1308: int
! 1309: rs_restore_file(FILE *savef)
! 1310: {
! 1311: encclearerr();
! 1312:
! 1313: rs_read_thing(savef, &player);
! 1314: rs_read_object_list(savef, &lvl_obj);
! 1315: rs_read_thing_list(savef, &mlist);
! 1316: rs_fix_thing(&player);
! 1317: rs_fix_thing_list(mlist);
! 1318: rs_read_traps(savef, traps, MAXTRAPS);
! 1319: rs_read_rooms(savef, rooms, MAXROOMS);
! 1320: rs_read_room_reference(savef, &oldrp);
! 1321: rs_read_stats(savef,&max_stats);
! 1322: rs_read_object_reference(savef, player.t_pack, &cur_weapon);
! 1323: rs_read_object_reference(savef, player.t_pack, &cur_armor);
! 1324: rs_read_object_reference(savef, player.t_pack, &cur_ring[0]);
! 1325: rs_read_object_reference(savef, player.t_pack, &cur_ring[1]);
! 1326: rs_fix_magic_items(things,NUMTHINGS);
! 1327: rs_fix_magic_items(s_magic,MAXSCROLLS);
! 1328: rs_fix_magic_items(p_magic,MAXPOTIONS);
! 1329: rs_fix_magic_items(r_magic,MAXRINGS);
! 1330: rs_fix_magic_items(ws_magic,MAXSTICKS);
! 1331: rs_read_int(savef, &level);
! 1332: rs_read_int(savef, &purse);
! 1333: rs_read_int(savef, &mpos);
! 1334: rs_read_int(savef, &ntraps);
! 1335: rs_read_int(savef, &no_move);
! 1336: rs_read_int(savef, &no_command);
! 1337: rs_read_int(savef, &inpack);
! 1338: rs_read_int(savef, &max_hp);
! 1339: rs_read_int(savef, &total);
! 1340: rs_read_int(savef, &lastscore);
! 1341: rs_read_int(savef, &no_food);
! 1342: rs_read_int(savef, &seed);
! 1343: rs_read_int(savef, &count);
! 1344: rs_read_int(savef, &dnum);
! 1345: rs_read_int(savef, &fung_hit);
! 1346: rs_read_int(savef, &quiet);
! 1347: rs_read_int(savef, &max_level);
! 1348: rs_read_int(savef, &food_left);
! 1349: rs_read_int(savef, &group);
! 1350: rs_read_int(savef, &hungry_state);
! 1351: rs_read_int(savef, &take);
! 1352: rs_read_int(savef, &runch);
! 1353: rs_read_scrolls(savef);
! 1354: rs_read_potions(savef);
! 1355: rs_read_rings(savef);
! 1356: rs_read_sticks(savef);
! 1357: rs_read_chars(savef,whoami,80);
! 1358: rs_read_chars(savef,fruit,80);
! 1359: rs_read_window(savef, cw);
! 1360: rs_read_window(savef, mw);
! 1361: rs_read_window(savef, stdscr);
! 1362: rs_read_int(savef, &running);
! 1363: rs_read_int(savef, &playing);
! 1364: rs_read_int(savef, &wizard);
! 1365: rs_read_int(savef, &after);
! 1366: rs_read_int(savef, ¬ify);
! 1367: rs_read_int(savef, &fight_flush);
! 1368: rs_read_int(savef, &terse);
! 1369: rs_read_int(savef, &door_stop);
! 1370: rs_read_int(savef, &jump);
! 1371: rs_read_int(savef, &slow_invent);
! 1372: rs_read_int(savef, &firstmove);
! 1373: rs_read_int(savef, &waswizard);
! 1374: rs_read_int(savef, &askme);
! 1375: rs_read_int(savef, &amulet);
! 1376: rs_read_int(savef, &in_shell);
! 1377: rs_read_coord(savef,&oldpos);
! 1378: rs_read_coord(savef,&delta);
! 1379: rs_read_coord(savef, &ch_ret); /* chase.c */
! 1380: rs_read_daemons(savef, d_list, 20); /* daemon.c */
! 1381: rs_read_int(savef,&between); /* daemons.c */
! 1382: rs_read_int(savef,&num_checks); /* main.c */
! 1383: rs_read_chars(savef, lvl_mons, sizeof(lvl_mons)); /* monsters.c */
! 1384: rs_read_chars(savef, wand_mons, sizeof(wand_mons)); /* monsters.c */
! 1385: rs_fix_monsters(monsters);
! 1386:
! 1387: return( encclearerr() );
! 1388: }
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 / rogue3