class writer;
class reader;

void save_tutorial( FILE* fp );
void load_tutorial( FILE* fp );

void save_tutorial(writer& outf);
void load_tutorial(reader& inf);

#include "files.h"

#include "tags.h"

void save_tutorial( FILE* fp )

void save_tutorial(writer& outf)

    writeLong( fp, TUTORIAL_VERSION);
    writeShort( fp, Options.tutorial_type);

    marshallLong( outf, TUTORIAL_VERSION);
    marshallShort( outf, Options.tutorial_type);

        writeShort( fp, Options.tutorial_events[i] );

        marshallShort( outf, Options.tutorial_events[i] );

void load_tutorial( FILE* fp )

void load_tutorial(reader& inf)

    int version = readLong(fp);

    int version = unmarshallLong(inf);

    Options.tutorial_type = readShort(fp);

    Options.tutorial_type = unmarshallShort(inf);

        Options.tutorial_events[i] = readShort(fp);

        Options.tutorial_events[i] = unmarshallShort(inf);

#   define TRAVEL_H

#define TRAVEL_H

#   include "externs.h"
#   include <stdio.h>
#   include <string>
#   include <vector>
#   include <map>

#include "externs.h"
#include <stdio.h>
#include <string>
#include <vector>
#include <map>

class reader;
class writer;

    void save(FILE *) const;
    void load(FILE *);

    void save(writer&) const;
    void load(reader&);

    void save(FILE *) const;
    void load(FILE *);

    void save(writer&) const;
    void load(reader&);

    void save(FILE *) const;
    void load(FILE *);

    void save(writer&) const;
    void load(reader&);

    void save(FILE *) const;
    void load(FILE *);

    void save(writer&) const;
    void load(reader&);

    void save(FILE *) const;
    void load(FILE *);

    void save(writer&) const;
    void load(reader&);

#include "tags.h"

void level_id::save(FILE *file) const

// NOTE: see also marshall_level_id
void level_id::save(writer& outf) const

    writeShort(file, branch);
    writeShort(file, depth);
    writeShort(file, level_type);

    marshallShort(outf, branch);
    marshallShort(outf, depth);
    marshallShort(outf, level_type);

void level_id::load(FILE *file)

void level_id::load(reader& inf)

    branch     = static_cast<branch_type>(readShort(file));
    depth      = readShort(file);
    level_type = static_cast<level_area_type>(readShort(file));

    branch     = static_cast<branch_type>(unmarshallShort(inf));
    depth      = unmarshallShort(inf);
    level_type = static_cast<level_area_type>(unmarshallShort(inf));

void level_pos::save(FILE *file) const

// NOTE: see also marshall_level_pos
void level_pos::save(writer& outf) const

    id.save(file);
    writeCoord(file, pos);

    id.save(outf);
    marshallCoord(outf, pos);

void level_pos::load(FILE *file)

void level_pos::load(reader& inf)

    id.load(file);
    readCoord(file, pos);

    id.load(inf);
    unmarshallCoord(inf, pos);

void stair_info::save(FILE *file) const

void stair_info::save(writer& outf) const

    writeCoord(file, position);
    writeShort(file, grid);
    destination.save(file);
    writeByte(file, guessed_pos? 1 : 0);
    writeByte(file, type);

    marshallCoord(outf, position);
    marshallShort(outf, grid);
    destination.save(outf);
    marshallByte(outf, guessed_pos? 1 : 0);
    marshallByte(outf, type);

void stair_info::load(FILE *file)

void stair_info::load(reader& inf)

    readCoord(file, position);
    grid = static_cast<dungeon_feature_type>(readShort(file));
    destination.load(file);
    guessed_pos = readByte(file) != 0;
    type = static_cast<stair_type>(readByte(file));

    unmarshallCoord(inf, position);
    grid = static_cast<dungeon_feature_type>(unmarshallShort(inf));
    destination.load(inf);
    guessed_pos = unmarshallByte(inf) != 0;
    type = static_cast<stair_type>(unmarshallByte(inf));

void LevelInfo::save(FILE *file) const

void LevelInfo::save(writer& outf) const

    writeShort(file, stair_count);

    marshallShort(outf, stair_count);

        stairs[i].save(file);

        stairs[i].save(outf);

                writeShort(file, -1);

                marshallShort(outf, -1);

                writeShort(file, stair_distances[i]);

                marshallShort(outf, stair_distances[i]);

    writeShort(file, excludes.size());

    marshallShort(outf, excludes.size());

            writeCoord(file, excludes[i].pos);
            writeShort(file, excludes[i].radius);

            marshallCoord(outf, excludes[i].pos);
            marshallShort(outf, excludes[i].radius);

void LevelInfo::load(FILE *file)

void LevelInfo::load(reader& inf)

    int stair_count = readShort(file);

    int stair_count = unmarshallShort(inf);

        si.load(file);

        si.load(inf);

            stair_distances.push_back( readShort(file) );

            stair_distances.push_back( unmarshallShort(inf) );

    int nexcludes = readShort(file);

    int nexcludes = unmarshallShort(inf);

            readCoord(file, c);
            const int radius = readShort(file);

            unmarshallCoord(inf, c);
            const int radius = unmarshallShort(inf);

void TravelCache::save(FILE *file) const

void TravelCache::save(writer& outf) const

    writeByte(file, TC_MAJOR_VERSION);
    writeByte(file, TC_MINOR_VERSION);

    marshallByte(outf, TC_MAJOR_VERSION);
    marshallByte(outf, TC_MINOR_VERSION);

    writeShort(file, level_count);

    marshallShort(outf, level_count);

        i->first.save(file);
        i->second.save(file);

        i->first.save(outf);
        i->second.save(outf);

        waypoints[wp].save(file);

        waypoints[wp].save(outf);

void TravelCache::load(FILE *file)

void TravelCache::load(reader& inf)

    unsigned char major = readByte(file),
                  minor = readByte(file);

    unsigned char major = unmarshallByte(inf),
                  minor = unmarshallByte(inf);

    int level_count = readShort(file);

    int level_count = unmarshallShort(inf);

        id.load(file);

        id.load(inf);

        linfo.load(file);

        linfo.load(inf);

        waypoints[wp].load(file);

        waypoints[wp].load(inf);

    long tell();

void marshallString4 (writer &, const std::string &);

void        unmarshallString4 (reader &, std::string&);

}
long writer::tell()
{
    ASSERT(_file);
    return ftell(_file);

// XXX: redundant with level_id.save()/load()

// XXX: redundant with level_pos.save()/load()

// string -- marshall length & string data

// string -- 2 byte length, string data

// string -- 4 byte length, non-terminated string data
void marshallString4(writer &th, const std::string &data)
{
    marshallLong(th, data.length());
    th.write(data.c_str(), data.length());
}
void unmarshallString4(reader &th, std::string& s)
{
    const int len = unmarshallLong(th);
    s.resize(len);
    if (len) th.read(&s.at(0), len);
}

class reader;
class writer;

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    // Note that we aren't bothering to use virtual functions here.
    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    void  save(FILE *) const;
    void  load(FILE *);

    void  save(writer&) const;
    void  load(reader&);

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

}
static void save_item(FILE *file, const item_def &item)
{
    writer outf(file);
    marshallItem(outf, item);

static void load_item(FILE *file, item_def &item)
{
    reader inf(file);
    unmarshallItem(inf, item);
}

// ----------------------------------------------------------------------
// Stash
// ----------------------------------------------------------------------

void Stash::save(FILE *file) const

void Stash::save(writer& outf) const

    writeShort(file, (short) items.size());

    marshallShort(outf, (short) items.size());

    writeByte(file, x);
    writeByte(file, y);

    marshallByte(outf, x);
    marshallByte(outf, y);

    writeByte(file, feat);
    writeByte(file, trap);

    marshallByte(outf, feat);
    marshallByte(outf, trap);

    writeByte(file, 

    marshallByte(outf, 

        save_item(file, items[i]);

        marshallItem(outf, items[i]);

void Stash::load(FILE *file)

void Stash::load(reader& inf)

    int count = readShort(file);

    int count = unmarshallShort(inf);

    x = readByte(file);
    y = readByte(file);

    x = unmarshallByte(inf);
    y = unmarshallByte(inf);

            static_cast<unsigned char>( readByte(file) ));

            static_cast<unsigned char>( unmarshallByte(inf) ));

            static_cast<unsigned char>( readByte(file) ));

            static_cast<unsigned char>( unmarshallByte(inf) ));

    unsigned char flags = readByte(file);

    unsigned char flags = unmarshallByte(inf);

        load_item(file, item);

        unmarshallItem(inf, item);

void ShopInfo::save(FILE *file) const

void ShopInfo::save(writer& outf) const

    writeShort(file, shoptype);

    marshallShort(outf, shoptype);

    writeShort(file, mangledx);
    writeShort(file, (short) y);

    marshallShort(outf, mangledx);
    marshallShort(outf, (short) y);

    writeShort(file, (short) items.size());

    marshallShort(outf, (short) items.size());

    writeString(file, name);

    marshallString4(outf, name);

        save_item(file, items[i].item);
        writeShort(file, (short) items[i].price );

        marshallItem(outf, items[i].item);
        marshallShort(outf, (short) items[i].price );

void ShopInfo::load(FILE *file)

void ShopInfo::load(reader& inf)

    shoptype = readShort(file);

    shoptype = unmarshallShort(inf);

    x = readShort(file);

    x = unmarshallShort(inf);

    y = readShort(file);

    y = unmarshallShort(inf);

    int itemcount = readShort(file);

    int itemcount = unmarshallShort(inf);

    name = readString(file);

    unmarshallString4(inf, name);

        load_item(file, item.item);
        item.price = (unsigned) readShort(file);

        unmarshallItem(inf, item.item);
        item.price = (unsigned) unmarshallShort(inf);

void LevelStashes::save(FILE *file) const

void LevelStashes::save(writer& outf) const

    writeShort(file, (short) m_stashes.size());

    marshallShort(outf, (short) m_stashes.size());

    m_place.save(file);

    m_place.save(outf);

            iter != m_stashes.end(); iter++)
        iter->second.save(file);

         iter != m_stashes.end(); iter++)
    {
        iter->second.save(outf);
    }

    writeShort(file, (short) m_shops.size());

    marshallShort(outf, (short) m_shops.size());

        m_shops[i].save(file);

        m_shops[i].save(outf);

void LevelStashes::load(FILE *file)

void LevelStashes::load(reader& inf)

    int size = readShort(file);

    int size = unmarshallShort(inf);

    m_place.load(file);

    m_place.load(inf);

        s.load(file);

        s.load(inf);

    int shopc = readShort(file);

    int shopc = unmarshallShort(inf);

        si.load(file);

        si.load(inf);

void StashTracker::save(FILE *file) const

void StashTracker::save(writer& outf) const

    writeByte(file, ST_MAJOR_VER);
    writeByte(file, ST_MINOR_VER);

    marshallByte(outf, ST_MAJOR_VER);
    marshallByte(outf, ST_MINOR_VER);

    writeShort(file, (short) levels.size());

    marshallShort(outf, (short) levels.size());

        iter->second.save(file);

        iter->second.save(outf);

void StashTracker::load(FILE *file)

void StashTracker::load(reader& inf)

    unsigned char major = readByte(file),
                  minor = readByte(file);

    unsigned char major = unmarshallByte(inf),
                  minor = unmarshallByte(inf);

    int count = readShort(file);

    int count = unmarshallShort(inf);

        st.load(file);

        st.load(inf);

class reader;
class writer;

    void save(writer& outf) const;
    void load(reader& inf);
    std::string describe( bool when = true, bool where = true,
                          bool what = true ) const;
    void check_milestone() const;

    void load( FILE* fp );
    void save( FILE* fp ) const;
    std::string describe( bool when = true, bool where = true,
                          bool what = true ) const;
    void check_milestone() const;

void save_notes( FILE* fp );
void load_notes( FILE* fp );

void save_notes(writer&);
void load_notes(reader&);

#include "tags.h"

void Note::save( FILE* fp ) const {
    writeLong( fp, type );
    writeLong( fp, turn );
    writeShort( fp, packed_place );
    writeLong( fp, first );
    writeLong( fp, second );
    writeString( fp, name );
    writeString( fp, desc );

void Note::save(writer& outf) const
{
    marshallLong( outf, type );
    marshallLong( outf, turn );
    marshallShort( outf, packed_place );
    marshallLong( outf, first );
    marshallLong( outf, second );
    marshallString4( outf, name );
    marshallString4( outf, desc );

void Note::load( FILE* fp )

void Note::load(reader& inf)

    type = static_cast<NOTE_TYPES>(readLong( fp ));
    turn = readLong( fp );
    packed_place = readShort( fp );
    first = readLong( fp );
    second = readLong( fp );
    name = readString( fp );
    desc = readString( fp );

    type = static_cast<NOTE_TYPES>(unmarshallLong( inf ));
    turn = unmarshallLong( inf );
    packed_place = unmarshallShort( inf );
    first = unmarshallLong( inf );
    second = unmarshallLong( inf );
    unmarshallString4( inf, name );
    unmarshallString4( inf, desc );

void save_notes( FILE* fp ) 

void save_notes(writer& outf) 

    writeLong( fp, NOTES_VERSION_NUMBER );
    writeLong( fp, note_list.size() );

    marshallLong( outf, NOTES_VERSION_NUMBER );
    marshallLong( outf, note_list.size() );

        note_list[i].save(fp);

        note_list[i].save(outf);

void load_notes( FILE* fp ) 

void load_notes(reader& inf) 

    if ( readLong(fp) != NOTES_VERSION_NUMBER )

    if ( unmarshallLong(inf) != NOTES_VERSION_NUMBER )

    const long num_notes = readLong(fp);

    const long num_notes = unmarshallLong(inf);

        new_note.load(fp);

        new_note.load(inf);

#include "tags.h"

    FILE *inf = fopen(file.c_str(), "rb");
    if (!inf)

    FILE *fp = fopen(file.c_str(), "rb");
    if (!fp)

    const long ver = readLong(inf);
    fclose(inf);

    reader inf(fp);
    const long ver = unmarshallLong(inf);
    fclose(fp);

    FILE *inf = fopen((base + ".lux").c_str(), "rb");
    if (inf)

        lc_global_prelude.read(inf);
        fclose(inf);

        FILE *fp = fopen((base + ".lux").c_str(), "rb");
        if (fp)
        {
            reader inf(fp);
            lc_global_prelude.read(inf);
            fclose(fp);

        global_preludes.push_back( lc_global_prelude );

            global_preludes.push_back( lc_global_prelude );
        }

    inf = fopen((base + ".idx").c_str(), "rb");
    if (!inf)

    FILE* fp = fopen((base + ".idx").c_str(), "rb");
    if (!fp)

    reader inf(fp);

    readLong(inf);
    const int nmaps = readShort(inf);

    (void) unmarshallLong(inf);
    const int nmaps = unmarshallShort(inf);

    fclose(inf);

    fclose(fp);

    FILE *outf = fopen(luafile.c_str(), "wb");

    FILE *fp = fopen(luafile.c_str(), "wb");
    writer outf(fp);

    fclose(outf);

    fclose(fp);

    FILE *outf = fopen(cfile.c_str(), "wb");
    if (!outf)

    FILE *fp = fopen(cfile.c_str(), "wb");
    if (!fp)

    writeLong(outf, MAP_CACHE_VERSION);

    writer outf(fp);
    marshallLong(outf, MAP_CACHE_VERSION);

    fclose(outf);

    fclose(fp);

    FILE *outf = fopen(cfile.c_str(), "wb");
    if (!outf)

    FILE *fp = fopen(cfile.c_str(), "wb");
    if (!fp)

    writeLong(outf, MAP_CACHE_VERSION);
    writeShort(outf, ve > vs? ve - vs : 0);

    writer outf(fp);
    marshallLong(outf, MAP_CACHE_VERSION);
    marshallShort(outf, ve > vs? ve - vs : 0);

    fclose(outf);

    fclose(fp);

    void write(FILE *) const;
    void read(FILE *);

    void write(writer&) const;
    void read(reader&);

    void write_index(FILE *) const;
    void write_full(FILE *);

    void write_index(writer&) const;
    void write_full(writer&);

    void read_index(FILE *);
    void read_full(FILE *);

    void read_index(reader&);
    void read_full(reader&);

    void write_depth_ranges(FILE *) const;
    void read_depth_ranges(FILE *);

    void write_depth_ranges(writer&) const;
    void read_depth_ranges(reader&);

#include "dungeon.h"

#include "dungeon.h"

#include "tags.h"

void level_range::write(FILE *outf) const

void level_range::write(writer& outf) const

    writeShort(outf, branch);
    writeShort(outf, shallowest);
    writeShort(outf, deepest);
    writeByte(outf, deny);

    marshallShort(outf, branch);
    marshallShort(outf, shallowest);
    marshallShort(outf, deepest);
    marshallByte(outf, deny);

void level_range::read(FILE *inf)

void level_range::read(reader& inf)

    branch     = static_cast<branch_type>( readShort(inf) );
    shallowest = readShort(inf);
    deepest    = readShort(inf);
    deny       = readByte(inf);

    branch     = static_cast<branch_type>( unmarshallShort(inf) );
    shallowest = unmarshallShort(inf);
    deepest    = unmarshallShort(inf);
    deny       = unmarshallByte(inf);

void map_def::write_full(FILE *outf)

void map_def::write_full(writer& outf)

    cache_offset = ftell(outf);
    writeShort(outf, MAP_CACHE_VERSION);   // Level indicator.
    writeString(outf, name);

    cache_offset = outf.tell();
    marshallShort(outf, MAP_CACHE_VERSION);   // Level indicator.
    marshallString4(outf, name);

void map_def::read_full(FILE *inf)

void map_def::read_full(reader& inf)

    if (readShort(inf) != MAP_CACHE_VERSION || readString(inf) != name)

    const short fp_version = unmarshallShort(inf);
    std::string fp_name;
    unmarshallString4(inf, fp_name);
    if (fp_version != MAP_CACHE_VERSION || fp_name != name)
    {        

    }

    FILE *inf = fopen(loadfile.c_str(), "rb");
    fseek(inf, cache_offset, SEEK_SET);

    FILE *fp = fopen(loadfile.c_str(), "rb");
    fseek(fp, cache_offset, SEEK_SET);
    reader inf(fp);

    fclose(inf);

    fclose(fp);

void map_def::write_index(FILE *outf) const

void map_def::write_index(writer& outf) const

    writeString(outf, name);
    writeString(outf, place_loaded_from.filename);
    writeLong(outf, place_loaded_from.lineno);
    writeShort(outf, orient);
    writeLong(outf, chance);
    writeLong(outf, cache_offset);
    writeString(outf, tags);

    marshallString4(outf, name);
    marshallString4(outf, place_loaded_from.filename);
    marshallLong(outf, place_loaded_from.lineno);
    marshallShort(outf, orient);
    marshallLong(outf, chance);
    marshallLong(outf, cache_offset);
    marshallString4(outf, tags);

void map_def::read_index(FILE *inf)

void map_def::read_index(reader& inf)

    name         = readString(inf);
    place_loaded_from.filename = readString(inf);
    place_loaded_from.lineno   = readLong(inf);
    orient       = static_cast<map_section_type>( readShort(inf) );
    chance       = readLong(inf);
    cache_offset = readLong(inf);
    tags         = readString(inf);

    unmarshallString4(inf, name);
    unmarshallString4(inf, place_loaded_from.filename);
    place_loaded_from.lineno   = unmarshallLong(inf);
    orient       = static_cast<map_section_type>( unmarshallShort(inf) );
    chance       = unmarshallLong(inf);
    cache_offset = unmarshallLong(inf);
    unmarshallString4(inf, tags);

void map_def::write_depth_ranges(FILE *outf) const

void map_def::write_depth_ranges(writer& outf) const

    writeShort(outf, depths.size());

    marshallShort(outf, depths.size());

void map_def::read_depth_ranges(FILE *inf)

void map_def::read_depth_ranges(reader& inf)

    const int nranges = readShort(inf);

    const int nranges = unmarshallShort(inf);

class reader;
class writer;

    void write(FILE *) const;
    void read(FILE *);

    void write(writer&) const;
    void read(reader&);

void dlua_chunk::write(FILE *outf) const

void dlua_chunk::write(writer& outf) const

        writeByte(outf, CT_EMPTY);

        marshallByte(outf, CT_EMPTY);

        writeByte(outf, CT_COMPILED);
        writeString(outf, compiled, LUA_CHUNK_MAX_SIZE);

        marshallByte(outf, CT_COMPILED);
        marshallString4(outf, compiled);

        writeByte(outf, CT_SOURCE);
        writeString(outf, chunk, LUA_CHUNK_MAX_SIZE);

        marshallByte(outf, CT_SOURCE);
        marshallString4(outf, chunk);

    writeString(outf, file);
    writeLong(outf, first);

    marshallString4(outf, file);
    marshallLong(outf, first);

void dlua_chunk::read(FILE *inf)

void dlua_chunk::read(reader& inf)

    chunk_t type = static_cast<chunk_t>(readByte(inf));

    chunk_t type = static_cast<chunk_t>(unmarshallByte(inf));

        chunk = readString(inf, LUA_CHUNK_MAX_SIZE);

        unmarshallString4(inf, chunk);

        compiled = readString(inf, LUA_CHUNK_MAX_SIZE);

        unmarshallString4(inf, compiled);

    file  = readString(inf);
    first = readLong(inf);

    unmarshallString4(inf, file);
    first = unmarshallLong(inf);

// Default cap on strings marshalled.
#define STR_CAP 1000
void writeShort(FILE *file, short s);
short readShort(FILE *file);
void writeByte(FILE *file, unsigned char byte);
unsigned char readByte(FILE *file);
void writeString(FILE* file, const std::string &s, int cap = STR_CAP);
std::string readString(FILE *file, int cap = STR_CAP);
void writeLong(FILE* file, long num);
long readLong(FILE *file);
void writeCoord(FILE *file, const coord_def &pos);
void readCoord(FILE *file, coord_def &pos);

        StashTrack.save(stashf);

        writer outf(stashf);
        StashTrack.save(outf);

        you.kills->save(killf);

        writer outf(killf);
        you.kills->save(outf);

        travel_cache.save(travelf);

        writer outf(travelf);
        travel_cache.save(outf);

        save_notes(notesf);

        writer outf(notesf);
        save_notes(outf);

        save_tutorial(tutorf);

        writer outf(tutorf);
        save_tutorial(outf);

        StashTrack.load(stashf);

        reader inf(stashf);
        StashTrack.load(inf);

        you.kills->load(killf);

        reader inf(killf);
        you.kills->load(inf);

        travel_cache.load(travelf);

        reader inf(travelf);
        travel_cache.load(inf);

        load_notes(notesf);

        reader inf(notesf);
        load_notes(inf);

        load_tutorial(tutorf);

        reader inf(tutorf);
        load_tutorial(inf);

    reader inf(ghostFile);

    if (readShort(ghostFile) != GHOST_SIGNATURE)

    if (unmarshallShort(inf) != GHOST_SIGNATURE)

        for (int i = 0; i < 3; ++i)
            readLong(ghostFile);
        

        inf.read(NULL, 3*4);

void writeShort(FILE *file, short s)
{
    char data[2];
    // High byte first - network order
    data[0] = static_cast<char>((s >> 8) & 0xFF);
    data[1] = static_cast<char>(s & 0xFF);
    write2(file, data, sizeof(data));
}
short readShort(FILE *file)
{
    unsigned char data[2];
    read2(file, (char *) data, 2);
    // High byte first
    return (((short) data[0]) << 8) | (short) data[1];
}
void writeByte(FILE *file, unsigned char byte)
{
    write2(file, (char *) &byte, sizeof byte);
}
unsigned char readByte(FILE *file)
{
    unsigned char byte;
    read2(file, (char *) &byte, sizeof byte);
    return byte;
}
void writeString(FILE* file, const std::string &s, int cap)
{
    int length = s.length();
    if (length > cap)
        length = cap;
    writeLong(file, length);
    if (length)
        write2(file, s.c_str(), length);
}
std::string readString(FILE *file, int cap)
{
    const int length = readLong(file);
    if (length > 0)
    {
        if (length <= cap)
        {
            char *buf = new char[length];
            read2(file, buf, length);
            const std::string s(buf, length);
            delete [] buf;
            return (s);
        }
        end(1, false, "String too long: %d bytes\n", length);
    }

    return ("");
}
void writeLong(FILE* file, long num)
{
    // High word first, network order
    writeShort(file, (short) ((num >> 16) & 0xFFFFL));
    writeShort(file, (short) (num & 0xFFFFL));
}
long readLong(FILE *file)
{
    // We need the unsigned short cast even for the high word because we
    // might be on a system where long is more than 4 bytes, and we don't want
    // to sign extend the high short.
    return ((long) (unsigned short) readShort(file)) << 16 | 
        (long) (unsigned short) readShort(file);
}
void writeCoord(FILE *file, const coord_def &pos)
{
    writeShort(file, pos.x);
    writeShort(file, pos.y);
}
void readCoord(FILE *file, coord_def &pos)
{
    pos.x = readShort(file);
    pos.y = readShort(file);
}

class reader;
class writer;

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

    void save(FILE*) const;
    void load(FILE*);

    void save(writer&) const;
    void load(reader&);

void KillMaster::save(FILE *file) const

void KillMaster::save(writer& outf) const

    writeByte(file, KILLS_MAJOR_VERSION);
    writeByte(file, KILLS_MINOR_VERSION);

    marshallByte(outf, KILLS_MAJOR_VERSION);
    marshallByte(outf, KILLS_MINOR_VERSION);

        categorized_kills[i].save(file);

        categorized_kills[i].save(outf);

void KillMaster::load(FILE *file)

void KillMaster::load(reader& inf)

    unsigned char major = readByte(file),
                  minor = readByte(file);

    unsigned char major = unmarshallByte(inf),
                  minor = unmarshallByte(inf);

            (minor != KILLS_MINOR_VERSION && minor > 0))
        return ;

        (minor != KILLS_MINOR_VERSION && minor > 0))
    {
        return;
    }

        categorized_kills[i].load(file);

        categorized_kills[i].load(inf);

void Kills::save(FILE *file) const

void Kills::save(writer& outf) const

    writeLong(file, kills.size());

    marshallLong(outf, kills.size());

        iter->first.save(file);
        iter->second.save(file);

        iter->first.save(outf);
        iter->second.save(outf);

    writeShort(file, ghosts.size());

    marshallShort(outf, ghosts.size());

        iter->save(file);

        iter->save(outf);

void Kills::load(FILE *file)

void Kills::load(reader& inf)

    long kill_count = readLong(file);

    long kill_count = unmarshallLong(inf);

        md.load(file);
        kills[md].load(file);

        md.load(inf);
        kills[md].load(inf);

    short ghost_count = readShort(file);

    short ghost_count = unmarshallShort(inf);

        kg.load(file);

        kg.load(inf);

void kill_def::save(FILE *file) const

void kill_def::save(writer& outf) const

    writeShort(file, kills);
    writeShort(file, exp);

    marshallShort(outf, kills);
    marshallShort(outf, exp);

    writeShort(file, places.size());

    marshallShort(outf, places.size());

        writeShort(file, *iter);

        marshallShort(outf, *iter);

void kill_def::load(FILE *file)

void kill_def::load(reader& inf)

    kills = (unsigned short) readShort(file);
    exp   = readShort(file);

    kills = (unsigned short) unmarshallShort(inf);
    exp   = unmarshallShort(inf);

    short place_count = readShort(file);

    short place_count = unmarshallShort(inf);

        places.push_back((unsigned short) readShort(file));

        places.push_back((unsigned short) unmarshallShort(inf));

void kill_ghost::save(FILE *file) const

void kill_ghost::save(writer& outf) const

    writeString(file, ghost_name);
    writeShort(file, (unsigned short) exp);
    writeShort(file, place);

    marshallString4(outf, ghost_name);
    marshallShort(outf, (unsigned short) exp);
    marshallShort(outf, place);

void kill_ghost::load(FILE *file)

void kill_ghost::load(reader& inf)

    ghost_name = readString(file);
    exp = readShort(file);
    place = (unsigned short) readShort(file);

    unmarshallString4(inf, ghost_name);
    exp = unmarshallShort(inf);
    place = (unsigned short) unmarshallShort(inf);

void kill_monster_desc::save(FILE *file) const

void kill_monster_desc::save(writer& outf) const

    writeShort(file, (short) monnum);
    writeShort(file, (short) modifier);

    marshallShort(outf, (short) monnum);
    marshallShort(outf, (short) modifier);

void kill_monster_desc::load(FILE *file)

void kill_monster_desc::load(reader& inf)

    monnum = (int) readShort(file);
    modifier = (name_modifier) readShort(file);

    monnum = (int) unmarshallShort(inf);
    modifier = (name_modifier) unmarshallShort(inf);