--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/arogue7/state.c	Fri May 08 15:24:40 2015 -0400
@@ -0,0 +1,2674 @@
+/*
+    state.c - Portable Rogue Save State Code
+
+    Copyright (C) 1999, 2000, 2005 Nicholas J. Kisseberth
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. Neither the name(s) of the author(s) nor the names of other contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS ``AS IS'' AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+*/
+
+/************************************************************************/
+/* Save State Code                                                      */
+/************************************************************************/
+
+#define RSID_STATS        0xABCD0001
+#define RSID_MSTATS       0xABCD0002
+#define RSID_THING        0xABCD0003
+#define RSID_OBJECT       0xABCD0004
+#define RSID_MAGICITEMS   0xABCD0005
+#define RSID_KNOWS        0xABCD0006
+#define RSID_GUESSES      0xABCD0007
+#define RSID_OBJECTLIST   0xABCD0008
+#define RSID_BAGOBJECT    0xABCD0009
+#define RSID_MONSTERLIST  0xABCD000A
+#define RSID_MONSTERSTATS 0xABCD000B
+#define RSID_MONSTERS     0xABCD000C
+#define RSID_TRAP         0xABCD000D
+#define RSID_WINDOW       0xABCD000E
+#define RSID_DAEMONS      0xABCD000F
+#define RSID_STICKS       0xABCD0010
+#define RSID_IARMOR       0xABCD0011
+#define RSID_SPELLS       0xABCD0012
+#define RSID_ILIST        0xABCD0013
+#define RSID_HLIST        0xABCD0014
+#define RSID_DEATHTYPE    0xABCD0015
+#define RSID_CTYPES       0XABCD0016
+#define RSID_COORDLIST    0XABCD0017
+#define RSID_ROOMS        0XABCD0018
+
+#include <curses.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "rogue.h"
+
+#define READSTAT (format_error || read_error )
+#define WRITESTAT (write_error)
+
+static int read_error   = FALSE;
+static int write_error  = FALSE;
+static int format_error = FALSE;
+static int endian = 0x01020304;
+#define  big_endian ( *((char *)&endian) == 0x01 )
+
+int
+rs_write(FILE *savef, void *ptr, size_t size)
+{
+    if (write_error)
+        return(WRITESTAT);
+
+    if (encwrite(ptr, size, fileno(savef)) != size)
+        write_error = 1;
+
+    return(WRITESTAT);
+}
+
+int
+rs_read(int inf, void *ptr, size_t size)
+{
+    if (read_error || format_error)
+        return(READSTAT);
+
+    if (encread(ptr, size, inf) != size)
+        read_error = 1;
+       
+    return(READSTAT);
+}
+
+int
+rs_write_uchar(FILE *savef, unsigned char c)
+{
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write(savef, &c, 1);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_uchar(int inf, unsigned char *c)
+{
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, c, 1);
+
+    return(READSTAT);
+}
+
+int
+rs_write_char(FILE *savef, char c)
+{
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write(savef, &c, 1);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_char(int inf, char *c)
+{
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, c, 1);
+
+    return(READSTAT);
+}
+
+int
+rs_write_chars(FILE *savef, char *c, int count)
+{
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef, count);
+    rs_write(savef, c, count);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_chars(int inf, char *i, int count)
+{
+    int value = 0;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf, &value);
+    
+    if (value != count)
+        format_error = TRUE;
+
+    rs_read(inf, i, count);
+    
+    return(READSTAT);
+}
+
+int
+rs_write_int(FILE *savef, int c)
+{
+    unsigned char bytes[4];
+    unsigned char *buf = (unsigned char *) &c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    rs_write(savef, buf, 4);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_int(int inf, int *i)
+{
+    unsigned char bytes[4];
+    int input = 0;
+    unsigned char *buf = (unsigned char *)&input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 4);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    *i = *((int *) buf);
+
+    return(READSTAT);
+}
+
+int
+rs_write_ints(FILE *savef, int *c, int count)
+{
+    int n = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef, count);
+
+    for(n = 0; n < count; n++)
+        if( rs_write_int(savef,c[n]) != 0)
+            break;
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_ints(int inf, int *i, int count)
+{
+    int n, value;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf,&value);
+
+    if (value != count)
+        format_error = TRUE;
+
+    for(n = 0; n < count; n++)
+        if (rs_read_int(inf, &i[n]) != 0)
+            break;
+    
+    return(READSTAT);
+}
+
+int
+rs_write_boolean(FILE *savef, bool c)
+{
+    unsigned char buf = (c == 0) ? 0 : 1;
+    
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write(savef, &buf, 1);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_boolean(int inf, bool *i)
+{
+    unsigned char buf = 0;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &buf, 1);
+
+    *i = (buf != 0);
+    
+    return(READSTAT);
+}
+
+int
+rs_write_booleans(FILE *savef, bool *c, int count)
+{
+    int n = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef, count);
+
+    for(n = 0; n < count; n++)
+        if (rs_write_boolean(savef, c[n]) != 0)
+            break;
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_booleans(int inf, bool *i, int count)
+{
+    int n = 0, value = 0;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf,&value);
+
+    if (value != count)
+        format_error = TRUE;
+
+    for(n = 0; n < count; n++)
+        if (rs_read_boolean(inf, &i[n]) != 0)
+            break;
+    
+    return(READSTAT);
+}
+
+int
+rs_write_short(FILE *savef, short c)
+{
+    unsigned char bytes[2];
+    unsigned char *buf = (unsigned char *) &c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if (big_endian)
+    {
+        bytes[1] = buf[0];
+        bytes[0] = buf[1];
+        buf = bytes;
+    }
+
+    rs_write(savef, buf, 2);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_short(int inf, short *i)
+{
+    unsigned char bytes[2];
+    short  input;
+    unsigned char *buf = (unsigned char *)&input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 2);
+
+    if (big_endian)
+    {
+        bytes[1] = buf[0];
+        bytes[0] = buf[1];
+        buf = bytes;
+    }
+    
+    *i = *((short *) buf);
+
+    return(READSTAT);
+} 
+
+int
+rs_write_shorts(FILE *savef, short *c, int count)
+{
+    int n = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef, count);
+
+    for(n = 0; n < count; n++)
+        if (rs_write_short(savef, c[n]) != 0)
+            break; 
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_shorts(int inf, short *i, int count)
+{
+    int n = 0, value = 0;
+
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf,&value);
+
+    if (value != count)
+        format_error = TRUE;
+
+    for(n = 0; n < value; n++)
+        if (rs_read_short(inf, &i[n]) != 0)
+            break;
+    
+    return(READSTAT);
+}
+
+int
+rs_write_ushort(FILE *savef, unsigned short c)
+{
+    unsigned char bytes[2];
+    unsigned char *buf = (unsigned char *) &c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if (big_endian)
+    {
+        bytes[1] = buf[0];
+        bytes[0] = buf[1];
+        buf = bytes;
+    }
+
+    rs_write(savef, buf, 2);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_ushort(int inf, unsigned short *i)
+{
+    unsigned char bytes[2];
+    unsigned short  input;
+    unsigned char *buf = (unsigned char *)&input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 2);
+
+    if (big_endian)
+    {
+        bytes[1] = buf[0];
+        bytes[0] = buf[1];
+        buf = bytes;
+    }
+    
+    *i = *((unsigned short *) buf);
+
+    return(READSTAT);
+} 
+
+int
+rs_write_uint(FILE *savef, unsigned int c)
+{
+    unsigned char bytes[4];
+    unsigned char *buf = (unsigned char *) &c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    rs_write(savef, buf, 4);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_uint(int inf, unsigned int *i)
+{
+    unsigned char bytes[4];
+    int  input;
+    unsigned char *buf = (unsigned char *)&input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 4);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    *i = *((unsigned int *) buf);
+
+    return(READSTAT);
+}
+
+int
+rs_write_long(FILE *savef, long c)
+{
+    int c2;
+    unsigned char bytes[4];
+    unsigned char *buf = (unsigned char *)&c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if (sizeof(long) == 8)
+    {
+        c2 = c;
+        buf = (unsigned char *) &c2;
+    }
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    rs_write(savef, buf, 4);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_long(int inf, long *i)
+{
+    unsigned char bytes[4];
+    long input;
+    unsigned char *buf = (unsigned char *) &input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 4);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    *i = *((long *) buf);
+
+    return(READSTAT);
+}
+
+int
+rs_write_longs(FILE *savef, long *c, int count)
+{
+    int n = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef,count);
+    
+    for(n = 0; n < count; n++)
+        rs_write_long(savef, c[n]);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_longs(int inf, long *i, int count)
+{
+    int n = 0, value = 0;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf,&value);
+
+    if (value != count)
+        format_error = TRUE;
+
+    for(n = 0; n < value; n++)
+        if (rs_read_long(inf, &i[n]) != 0)
+            break;
+    
+    return(READSTAT);
+}
+
+int
+rs_write_ulong(FILE *savef, unsigned long c)
+{
+    unsigned int c2;
+    unsigned char bytes[4];
+    unsigned char *buf = (unsigned char *)&c;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    if ( (sizeof(long) == 8) && (sizeof(int) == 4) )
+    {
+        c2 = c;
+        buf = (unsigned char *) &c2;
+    }
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    rs_write(savef, buf, 4);
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_ulong(int inf, unsigned long *i)
+{
+    unsigned char bytes[4];
+    unsigned long input;
+    unsigned char *buf = (unsigned char *) &input;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read(inf, &input, 4);
+
+    if (big_endian)
+    {
+        bytes[3] = buf[0];
+        bytes[2] = buf[1];
+        bytes[1] = buf[2];
+        bytes[0] = buf[3];
+        buf = bytes;
+    }
+    
+    *i = *((unsigned long *) buf);
+
+    return(READSTAT);
+}
+
+int
+rs_write_ulongs(FILE *savef, unsigned long *c, int count)
+{
+    int n = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef,count);
+
+    for(n = 0; n < count; n++)
+        if (rs_write_ulong(savef,c[n]) != 0)
+            break;
+
+    return(WRITESTAT);
+}
+
+int
+rs_read_ulongs(int inf, unsigned long *i, int count)
+{
+    int n = 0, value = 0;
+    
+    if (read_error || format_error)
+        return(READSTAT);
+
+    rs_read_int(inf,&value);
+
+    if (value != count)
+        format_error = TRUE;
+
+    for(n = 0; n < count; n++)
+        if (rs_read_ulong(inf, &i[n]) != 0)
+            break;
+    
+    return(READSTAT);
+}
+
+int
+rs_write_marker(FILE *savef, int id)
+{
+    if (write_error)
+        return(WRITESTAT);
+
+    rs_write_int(savef, id);
+
+    return(WRITESTAT);
+}
+
+int 
+rs_read_marker(int inf, int id)
+{
+    int nid;
+
+    if (read_error || format_error)
+        return(READSTAT);
+
+    if (rs_read_int(inf, &nid) == 0)
+        if (id != nid)
+            format_error = 1;
+    
+    return(READSTAT);
+}
+
+
+
+/******************************************************************************/
+
+int
+rs_write_string(FILE *savef, char *s)
+{
+    int len = 0;
+
+    if (write_error)
+        return(WRITESTAT);
+
+    len = (s == NULL) ? 0 : (int) strlen(s) + 1;
+
+    rs_write_int(savef, len);