root/trunk/src/save.c

/*
 * File: save.c
 * Purpose: Old-style savefile saving
 *
 * Copyright (c) 1997 Ben Harrison
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
#include "angband.h"
#include "option.h"




/*
 * Some "local" parameters, used to help write savefiles
 */

static ang_file *fff;           /* Current save "file" */

static byte     xor_byte;       /* Simple encryption */

static u32b     v_stamp = 0L;   /* A simple "checksum" on the actual values */
static u32b     x_stamp = 0L;   /* A simple "checksum" on the encoded bytes */



/*
 * These functions place information into a savefile a byte at a time
 */

static void sf_put(byte v)
{
        /* Encode the value, write a character */
        xor_byte ^= v;
        file_writec(fff, xor_byte);

        /* Maintain the checksum info */
        v_stamp += v;
        x_stamp += xor_byte;
}

static void wr_byte(byte v)
{
        sf_put(v);
}

static void wr_u16b(u16b v)
{
        sf_put((byte)(v & 0xFF));
        sf_put((byte)((v >> 8) & 0xFF));
}

static void wr_s16b(s16b v)
{
        wr_u16b((u16b)v);
}

static void wr_u32b(u32b v)
{
        sf_put((byte)(v & 0xFF));
        sf_put((byte)((v >> 8) & 0xFF));
        sf_put((byte)((v >> 16) & 0xFF));
        sf_put((byte)((v >> 24) & 0xFF));
}

static void wr_s32b(s32b v)
{
        wr_u32b((u32b)v);
}

static void wr_string(cptr str)
{
        while (*str)
        {
                wr_byte(*str);
                str++;
        }
        wr_byte(*str);
}


/*
 * These functions write info in larger logical records
 */


/*
 * Write an "item" record
 */
static void wr_item(const object_type *o_ptr)
{
        wr_s16b(o_ptr->k_idx);

        /* Location */
        wr_byte(o_ptr->iy);
        wr_byte(o_ptr->ix);

        wr_byte(o_ptr->tval);
        wr_byte(o_ptr->sval);
        wr_s16b(o_ptr->pval);

        wr_byte(o_ptr->pseudo);

        wr_byte(o_ptr->number);
        wr_s16b(o_ptr->weight);

        wr_byte(o_ptr->name1);
        wr_byte(o_ptr->name2);

        wr_s16b(o_ptr->timeout);

        wr_s16b(o_ptr->to_h);
        wr_s16b(o_ptr->to_d);
        wr_s16b(o_ptr->to_a);
        wr_s16b(o_ptr->ac);
        wr_byte(o_ptr->dd);
        wr_byte(o_ptr->ds);

        wr_byte(o_ptr->ident);

        wr_byte(o_ptr->marked);

        wr_byte(o_ptr->origin);
        wr_byte(o_ptr->origin_depth);
        wr_u16b(o_ptr->origin_xtra);

        wr_u32b(o_ptr->flags1);
        wr_u32b(o_ptr->flags2);
        wr_u32b(o_ptr->flags3);

        /* Held by monster index */
        wr_s16b(o_ptr->held_m_idx);

        /* Save the inscription (if any) */
        if (o_ptr->note)
        {
                wr_string(quark_str(o_ptr->note));
        }
        else
        {
                wr_string("");
        }
}


/*
 * Write a "monster" record
 */
static void wr_monster(const monster_type *m_ptr)
{
        wr_s16b(m_ptr->r_idx);
        wr_byte(m_ptr->fy);
        wr_byte(m_ptr->fx);
        wr_s16b(m_ptr->hp);
        wr_s16b(m_ptr->maxhp);
        wr_s16b(m_ptr->csleep);
        wr_byte(m_ptr->mspeed);
        wr_byte(m_ptr->energy);
        wr_byte(m_ptr->stunned);
        wr_byte(m_ptr->confused);
        wr_byte(m_ptr->monfear);
        wr_byte(0);
}


/*
 * Write a "lore" record
 */
static void wr_lore(int r_idx)
{
        int i;

        monster_race *r_ptr = &r_info[r_idx];
        monster_lore *l_ptr = &l_list[r_idx];

        /* Count sights/deaths/kills */
        wr_s16b(l_ptr->sights);
        wr_s16b(l_ptr->deaths);
        wr_s16b(l_ptr->pkills);
        wr_s16b(l_ptr->tkills);

        /* Count wakes and ignores */
        wr_byte(l_ptr->wake);
        wr_byte(l_ptr->ignore);

        /* Count drops */
        wr_byte(l_ptr->drop_gold);
        wr_byte(l_ptr->drop_item);

        /* Count spells */
        wr_byte(l_ptr->cast_innate);
        wr_byte(l_ptr->cast_spell);

        /* Count blows of each type */
        for (i = 0; i < MONSTER_BLOW_MAX; i++)
                wr_byte(l_ptr->blows[i]);

        /* Memorize flags */
        for (i = 0; i < RACE_FLAG_STRICT_UB; i++)
                wr_u32b(l_ptr->flags[i]);
        for (i = 0; i < RACE_FLAG_SPELL_STRICT_UB; i++)
                wr_u32b(l_ptr->spell_flags[i]);


        /* Monster limit per level */
        wr_byte(r_ptr->max_num);

        /* Later (?) */
        wr_byte(0);
        wr_byte(0);
        wr_byte(0);
}


/*
 * Write an "xtra" record
 */
static void wr_xtra(int k_idx)
{
        byte tmp8u = 0;

        object_kind *k_ptr = &k_info[k_idx];

        if (k_ptr->aware) tmp8u |= 0x01;
        if (k_ptr->tried) tmp8u |= 0x02;
        if (k_ptr->squelch) tmp8u |= 0x04;
        if (k_ptr->everseen) tmp8u |= 0x08;

        wr_byte(tmp8u);
}


/*
 * Write a "store" record
 */
static void wr_store(const store_type *st_ptr)
{
        int j;

        /* XXX Old value (<= Angband 3.0.3) */
        wr_u32b(0L);

        /* XXX Old value (<= Angband 3.0.3) */
        wr_s16b(0);

        /* Save the current owner */
        wr_byte(st_ptr->owner);

        /* Save the stock size */
        wr_byte(st_ptr->stock_num);

        /* XXX Old values (<= Angband 3.0.3) */
        wr_s16b(0);
        wr_s16b(0);

        /* Save the stock */
        for (j = 0; j < st_ptr->stock_num; j++)
        {
                /* Save each item in stock */
                wr_item(&st_ptr->stock[j]);
        }
}


/*
 * Write RNG state
 */
static errr wr_randomizer(void)
{
        int i;

        /* Zero */
        wr_u16b(0);

        /* Place */
        wr_u16b(Rand_place);

        /* State */
        for (i = 0; i < RAND_DEG; i++)
        {
                wr_u32b(Rand_state[i]);
        }

        /* Success */
        return (0);
}


/*
 * Write the "options"
 */
static void wr_options(void)
{
        int i, k;

        u32b flag[8];
        u32b mask[8];
        u32b window_flag[ANGBAND_TERM_MAX];
        u32b window_mask[ANGBAND_TERM_MAX];


        /*** Oops ***/

        /* Oops */
        for (i = 0; i < 4; i++) wr_u32b(0L);


        /*** Special Options ***/

        /* Write "delay_factor" */
        wr_byte(op_ptr->delay_factor);

        /* Write "hitpoint_warn" */
        wr_byte(op_ptr->hitpoint_warn);

        /* Write movement delay */
        wr_u16b(lazymove_delay);


        /*** Normal options ***/

        /* Reset */
        for (i = 0; i < 8; i++)
        {
                flag[i] = 0L;
                mask[i] = 0L;
        }

        /* Analyze the options */
        for (i = 0; i < OPT_MAX; i++)
        {
                int os = i / 32;
                int ob = i % 32;

                /* Process real entries */
                if (option_name(i))
                {
                        /* Set flag */
                        if (op_ptr->opt[i])
                        {
                                /* Set */
                                flag[os] |= (1L << ob);
                        }

                        /* Set mask */
                        mask[os] |= (1L << ob);
                }
        }

        /* Dump the flags */
        for (i = 0; i < 8; i++) wr_u32b(flag[i]);

        /* Dump the masks */
        for (i = 0; i < 8; i++) wr_u32b(mask[i]);


        /*** Window options ***/

        /* Reset */
        for (i = 0; i < ANGBAND_TERM_MAX; i++)
        {
                /* Flags */
                window_flag[i] = op_ptr->window_flag[i];

                /* Mask */
                window_mask[i] = 0L;

                /* Build the mask */
                for (k = 0; k < 32; k++)
                {
                        /* Set mask */
                        if (window_flag_desc[k])
                        {
                                window_mask[i] |= (1L << k);
                        }
                }
        }

        /* Dump the flags */
        for (i = 0; i < ANGBAND_TERM_MAX; i++) wr_u32b(window_flag[i]);

        /* Dump the masks */
        for (i = 0; i < ANGBAND_TERM_MAX; i++) wr_u32b(window_mask[i]);
}


/*
 * Hack -- Write the "ghost" info
 */
static void wr_ghost(void)
{
        int i;

        /* Name */
        wr_string("Broken Ghost");

        /* Hack -- stupid data */
        for (i = 0; i < 60; i++) wr_byte(0);
}


/*
 * Write autoinscribe & squelch item-quality submenu to the savefile
 */
static void wr_squelch(void)
{
        int i;

        /* Write number of squelch bytes */
        wr_byte(SQUELCH_BYTES);
        for (i = 0; i < SQUELCH_BYTES; i++)
                wr_byte(squelch_level[i]);

        /* Write ego-item squelch bits */
        wr_u16b(z_info->e_max);
        for (i = 0; i < z_info->e_max; i++)
        {
                byte flags = 0;

                /* Figure out and write the everseen flag */
                if (e_info[i].everseen) flags |= 0x02;
                wr_byte(flags);
        }

        /* Write the current number of auto-inscriptions */
        wr_u16b(inscriptions_count);

        /* Write the autoinscriptions array */
        for (i = 0; i < inscriptions_count; i++)
        {
                wr_s16b(inscriptions[i].kind_idx);
                wr_string(quark_str(inscriptions[i].inscription_idx));
        }

        return;
}


/*
 * Write some "extra" info
 */
static void wr_extra(void)
{
        int i;

        wr_string(op_ptr->full_name);

        wr_string(p_ptr->died_from);

        wr_string(p_ptr->history);

        /* Race/Class/Gender/Spells */
        wr_byte(p_ptr->prace);
        wr_byte(p_ptr->pclass);
        wr_byte(p_ptr->psex);
        wr_byte(0);     /* oops */

        wr_byte(p_ptr->hitdie);
        wr_byte(p_ptr->expfact);

        wr_s16b(p_ptr->age);
        wr_s16b(p_ptr->ht);
        wr_s16b(p_ptr->wt);

        /* Dump the stats (maximum and current and birth) */
        for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_max[i]);
        for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_cur[i]);
        for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_birth[i]);

        wr_s16b(p_ptr->ht_birth);
        wr_s16b(p_ptr->wt_birth);
        wr_u32b(p_ptr->au_birth);

        /* Padding */
        wr_u32b(0);

        wr_u32b(p_ptr->au);


        wr_u32b(p_ptr->max_exp);
        wr_u32b(p_ptr->exp);
        wr_u16b(p_ptr->exp_frac);
        wr_s16b(p_ptr->lev);

        wr_s16b(p_ptr->mhp);
        wr_s16b(p_ptr->chp);
        wr_u16b(p_ptr->chp_frac);

        wr_s16b(p_ptr->msp);
        wr_s16b(p_ptr->csp);
        wr_u16b(p_ptr->csp_frac);

        /* Max Player and Dungeon Levels */
        wr_s16b(p_ptr->max_lev);
        wr_s16b(p_ptr->max_depth);

        /* More info */
        wr_s16b(0);     /* oops */
        wr_s16b(0);     /* oops */
        wr_s16b(0);     /* oops */
        wr_s16b(0);     /* oops */
        wr_s16b(p_ptr->sc);
        wr_s16b(0);     /* oops */

        wr_s16b(p_ptr->food);
        wr_s16b(p_ptr->energy);
        wr_s16b(p_ptr->word_recall);
        wr_s16b(p_ptr->see_infra);
        wr_byte(p_ptr->confusing);
        wr_byte(p_ptr->searching);

        /* Find the number of timed effects */
        wr_byte(TMD_MAX);

        /* Read all the effects, in a loop */
        for (i = 0; i < TMD_MAX; i++)
                wr_s16b(p_ptr->timed[i]);

        /* Future use */
        for (i = 0; i < 10; i++) wr_u32b(0L);

        wr_squelch();

        /* Random artifact version */
        wr_u32b(RANDART_VERSION);

        /* Random artifact seed */
        wr_u32b(seed_randart);


        /* Ignore some flags */
        wr_u32b(0L);    /* oops */
        wr_u32b(0L);    /* oops */
        wr_u32b(0L);    /* oops */


        /* Write the "object seeds" */
        wr_u32b(seed_flavor);
        wr_u32b(seed_town);


        /* Special stuff */
        wr_u16b(p_ptr->panic_save);
        wr_u16b(p_ptr->total_winner);
        wr_u16b(p_ptr->noscore);


        /* Write death */
        wr_byte(p_ptr->is_dead);

        /* Write feeling */
        wr_byte(feeling);

        /* Turn of last "feeling" */
        wr_s32b(old_turn);

        /* Current turn */
        wr_s32b(turn);
}


/*
 * Dump the random artifacts
 */
static void wr_randarts(void)
{
        int i;

        wr_u16b(z_info->a_max);

        for (i = 0; i < z_info->a_max; i++)
        {
                artifact_type *a_ptr = &a_info[i];

                wr_byte(a_ptr->tval);
                wr_byte(a_ptr->sval);
                wr_s16b(a_ptr->pval);

                wr_s16b(a_ptr->to_h);
                wr_s16b(a_ptr->to_d);
                wr_s16b(a_ptr->to_a);
                wr_s16b(a_ptr->ac);

                wr_byte(a_ptr->dd);
                wr_byte(a_ptr->ds);

                wr_s16b(a_ptr->weight);

                wr_s32b(a_ptr->cost);

                wr_u32b(a_ptr->flags1);
                wr_u32b(a_ptr->flags2);
                wr_u32b(a_ptr->flags3);

                wr_byte(a_ptr->level);
                wr_byte(a_ptr->rarity);

                wr_byte(a_ptr->effect);
                wr_u16b(a_ptr->time_base);
                wr_u16b(a_ptr->time_dice);
                wr_u16b(a_ptr->time_sides);
        }
}


/*
 * The cave grid flags that get saved in the savefile
 */
#define IMPORTANT_FLAGS (CAVE_MARK | CAVE_GLOW | CAVE_ICKY | CAVE_ROOM)


/*
 * Write the current dungeon
 */
static void wr_dungeon(void)
{
        int i, y, x;

        byte tmp8u;

        byte count;
        byte prev_char;


        /*** Basic info ***/

        /* Dungeon specific info follows */
        wr_u16b(p_ptr->depth);
        wr_u16b(0);
        wr_u16b(p_ptr->py);
        wr_u16b(p_ptr->px);
        wr_u16b(DUNGEON_HGT);
        wr_u16b(DUNGEON_WID);
        wr_u16b(0);
        wr_u16b(0);


        /*** Simple "Run-Length-Encoding" of cave ***/

        /* Note that this will induce two wasted bytes */
        count = 0;
        prev_char = 0;

        /* Dump the cave */
        for (y = 0; y < DUNGEON_HGT; y++)
        {
                for (x = 0; x < DUNGEON_WID; x++)
                {
                        /* Extract the important cave_info flags */
                        tmp8u = (cave_info[y][x] & (IMPORTANT_FLAGS));

                        /* If the run is broken, or too full, flush it */
                        if ((tmp8u != prev_char) || (count == MAX_UCHAR))
                        {
                                wr_byte((byte)count);
                                wr_byte((byte)prev_char);
                                prev_char = tmp8u;
                                count = 1;
                        }

                        /* Continue the run */
                        else
                        {
                                count++;
                        }
                }
        }

        /* Flush the data (if any) */
        if (count)
        {
                wr_byte((byte)count);
                wr_byte((byte)prev_char);
        }

        /** Now dump the cave_info2[][] stuff **/

        /* Note that this will induce two wasted bytes */
        count = 0;
        prev_char = 0;

        /* Dump the cave */
        for (y = 0; y < DUNGEON_HGT; y++)
        {
                for (x = 0; x < DUNGEON_WID; x++)
                {
                        /* Keep all the information from info2 */
                        tmp8u = cave_info2[y][x];

                        /* If the run is broken, or too full, flush it */
                        if ((tmp8u != prev_char) || (count == MAX_UCHAR))
                        {
                                wr_byte((byte)count);
                                wr_byte((byte)prev_char);
                                prev_char = tmp8u;
                                count = 1;
                        }

                        /* Continue the run */
                        else
                        {
                                count++;
                        }
                }
        }

        /* Flush the data (if any) */
        if (count)
        {
                wr_byte((byte)count);
                wr_byte((byte)prev_char);
        }


        /*** Simple "Run-Length-Encoding" of cave ***/

        /* Note that this will induce two wasted bytes */
        count = 0;
        prev_char = 0;

        /* Dump the cave */
        for (y = 0; y < DUNGEON_HGT; y++)
        {
                for (x = 0; x < DUNGEON_WID; x++)
                {
                        /* Extract a byte */
                        tmp8u = cave_feat[y][x];

                        /* If the run is broken, or too full, flush it */
                        if ((tmp8u != prev_char) || (count == MAX_UCHAR))
                        {
                                wr_byte((byte)count);
                                wr_byte((byte)prev_char);
                                prev_char = tmp8u;
                                count = 1;
                        }

                        /* Continue the run */
                        else
                        {
                                count++;
                        }
                }
        }

        /* Flush the data (if any) */
        if (count)
        {
                wr_byte((byte)count);
                wr_byte((byte)prev_char);
        }


        /*** Compact ***/

        /* Compact the objects */
        compact_objects(0);

        /* Compact the monsters */
        compact_monsters(0);


        /*** Dump objects ***/

        /* Total objects */
        wr_u16b(o_max);

        /* Dump the objects */
        for (i = 1; i < o_max; i++)
        {
                object_type *o_ptr = &o_list[i];

                /* Dump it */
                wr_item(o_ptr);
        }


        /*** Dump the monsters ***/

        /* Total monsters */
        wr_u16b(mon_max);

        /* Dump the monsters */
        for (i = 1; i < mon_max; i++)
        {
                monster_type *m_ptr = &mon_list[i];

                /* Dump it */
                wr_monster(m_ptr);
        }
}



/*
 * Actually write a save-file
 */
static void wr_savefile_new(void)
{
        int i;

        u32b now;

        u16b tmp16u;
        u32b tmp32u;

        /* Guess at the current time */
        now = time((time_t *)0);


        /* Note the operating system */
        sf_xtra = 0L;

        /* Note when the file was saved */
        sf_when = now;

        /* Note the number of saves */
        sf_saves++;


        /*** Actually write the file ***/

        /* Dump the file header */
        xor_byte = 0;
        wr_byte(VERSION_MAJOR);
        xor_byte = 0;
        wr_byte(VERSION_MINOR);
        xor_byte = 0;
        wr_byte(VERSION_PATCH);
        xor_byte = 0;
        wr_byte(VERSION_EXTRA);


        /* Reset the checksum */
        v_stamp = 0L;
        x_stamp = 0L;


        /* Operating system */
        wr_u32b(sf_xtra);


        /* Time file last saved */
        wr_u32b(sf_when);

        /* Number of past lives */
        wr_u16b(sf_lives);

        /* Number of times saved */
        wr_u16b(sf_saves);


        /* Space */
        wr_u32b(0L);
        wr_u32b(0L);


        /* Write the RNG state */
        wr_randomizer();


        /* Write the boolean "options" */
        wr_options();


        /* Dump the number of "messages" */
        tmp16u = messages_num();
        if (tmp16u > 80) tmp16u = 80;
        wr_u16b(tmp16u);

        /* Dump the messages (oldest first!) */
        for (i = tmp16u - 1; i >= 0; i--)
        {
                wr_string(message_str((s16b)i));
                wr_u16b(message_type((s16b)i));
        }


        /* Dump the monster lore */
        tmp16u = z_info->r_max;
        wr_u16b(tmp16u);
        for (i = 0; i < tmp16u; i++) wr_lore(i);


        /* Dump the object memory */
        tmp16u = z_info->k_max;
        wr_u16b(tmp16u);
        for (i = 0; i < tmp16u; i++) wr_xtra(i);


        /* Hack -- Dump the quests */
        tmp16u = MAX_Q_IDX;
        wr_u16b(tmp16u);
        for (i = 0; i < tmp16u; i++)
        {
                wr_byte(q_list[i].level);
                wr_byte(0);
                wr_byte(0);
                wr_byte(0);
        }

        /* Hack -- Dump the artifacts */
        tmp16u = z_info->a_max;
        wr_u16b(tmp16u);
        for (i = 0; i < tmp16u; i++)
        {
                artifact_type *a_ptr = &a_info[i];
                wr_byte(a_ptr->cur_num);
                wr_byte(0);
                wr_byte(0);
                wr_byte(0);
        }


        /* Write the "extra" information */
        wr_extra();


        /* Dump the "player hp" entries */
        tmp16u = PY_MAX_LEVEL;
        wr_u16b(tmp16u);
        for (i = 0; i < tmp16u; i++)
        {
                wr_s16b(p_ptr->player_hp[i]);
        }


        /* Write spell data */
        wr_u16b(PY_MAX_SPELLS);

        for (i = 0; i < PY_MAX_SPELLS; i++)
        {
                wr_byte(p_ptr->spell_flags[i]);
        }

        /* Dump the ordered spells */
        for (i = 0; i < PY_MAX_SPELLS; i++)
        {
                wr_byte(p_ptr->spell_order[i]);
        }


        /* Write randart information */
        if (adult_randarts)
        {
                wr_randarts();
        }


        /* Write the inventory */
        for (i = 0; i < INVEN_TOTAL; i++)
        {
                object_type *o_ptr = &inventory[i];

                /* Skip non-objects */
                if (!o_ptr->k_idx) continue;

                /* Dump index */
                wr_u16b((u16b)i);

                /* Dump object */
                wr_item(o_ptr);
        }

        /* Add a sentinel */
        wr_u16b(0xFFFF);


        /* Note the stores */
        tmp16u = MAX_STORES;
        wr_u16b(tmp16u);

        /* Dump the stores */
        for (i = 0; i < tmp16u; i++) wr_store(&store[i]);


        /* Player is not dead, write the dungeon */
        if (!p_ptr->is_dead)
        {
                /* Dump the dungeon */
                wr_dungeon();

                /* Dump the ghost */
                wr_ghost();
        }

        /* NEW (jdw): dumping history entries */
        /* Dump the number of history entries */
        tmp32u = history_get_num();
        wr_u32b(tmp32u);

        /* Dump the history entries one-by-one */
        for (i = 0; i < tmp32u; i++)
        {
                wr_u16b(history_list[i].type);
                wr_s32b(history_list[i].turn);
                wr_s16b(history_list[i].dlev);
                wr_s16b(history_list[i].clev);
                wr_byte(history_list[i].a_idx);
                wr_string(history_list[i].event);
        }


        /* Write the "value check-sum" */
        wr_u32b(v_stamp);

        /* Write the "encoded checksum" */
        wr_u32b(x_stamp);
}


/*
 * Medium level player saver
 */
static bool save_player_aux(cptr name)
{
        bool ok = TRUE;

        /* No file yet */
        fff = NULL;

        /* Open the savefile */
        safe_setuid_grab();
        fff = file_open(name, MODE_WRITE, FTYPE_SAVE);
        safe_setuid_drop();

        /* Successful open */
        if (fff) wr_savefile_new();
        else ok = FALSE;

        /* Attempt to close it */
        if (ok && !file_close(fff)) ok = FALSE;


        if (ok)
                character_saved = TRUE;

        return ok;
}

#include <errno.h>

/*
 * Attempt to save the player in a savefile
 */
bool old_save(void)
{
        char new_savefile[1024];
        char old_savefile[1024];

        /* New savefile */
        strnfmt(new_savefile, sizeof(new_savefile), "%s.new", savefile);
        strnfmt(old_savefile, sizeof(old_savefile), "%s.old", savefile);

        /* Make sure that the savefile doesn't already exist */
        safe_setuid_grab();
        file_delete(new_savefile);
        file_delete(old_savefile);
        safe_setuid_drop();

        /* Attempt to save the player */
        if (save_player_aux(new_savefile))
        {
                safe_setuid_grab();

                file_move(savefile, old_savefile);
                file_move(new_savefile, savefile);
                file_delete(old_savefile);

                safe_setuid_drop();