csg.cpp

Go to the documentation of this file.

#include "cutscene/cutscenes.h"
#include "freespace2/freespace.h"
#include "gamesnd/eventmusic.h"
#include "hud/hudconfig.h"
#include "io/joy.h"
#include "io/mouse.h"
#include "menuui/techmenu.h"
#include "mission/missioncampaign.h"
#include "mission/missionload.h"
#include "missionui/missionscreencommon.h"
#include "missionui/missionshipchoice.h"
#include "pilotfile/pilotfile.h"
#include "playerman/player.h"
#include "ship/ship.h"
#include "sound/audiostr.h"
#include "stats/medals.h"
#include "weapon/weapon.h"

#define REDALERT_INTERNAL
#include "missionui/redalert.h"

#include <iostream>
#include <sstream>



void pilotfile::csg_read_flags()
{
        // tips?
        p->tips = (int)cfread_ubyte(cfp);

        // avoid having to read everything to get the rank
        if (csg_ver >= 5) {
                p->stats.rank = cfread_int(cfp);
        }
}

void pilotfile::csg_write_flags()
{
        startSection(Section::Flags);

        // tips
        cfwrite_ubyte((ubyte)p->tips, cfp);

        // avoid having to read everything to get the rank
        cfwrite_int(p->stats.rank, cfp);

        endSection();
}

void pilotfile::csg_read_info()
{
        char t_string[NAME_LENGTH+1] = { '\0' };
        index_list_t ilist;
        int idx, list_size = 0;
        ubyte allowed = 0;

        if ( !m_have_flags ) {
                throw "Info before Flags!";
        }

        //
        // NOTE: lists may contain missing/invalid entries for current data
        //       this is not necessarily fatal
        //

        // ship list (NOTE: may contain more than MAX_SHIP_CLASSES)
        list_size = cfread_int(cfp);

        for (idx = 0; idx < list_size; idx++) {
                cfread_string_len(t_string, NAME_LENGTH, cfp);

                ilist.name = t_string;
                ilist.index = ship_info_lookup(t_string);

                ship_list.push_back(ilist);
        }

        // weapon list (NOTE: may contain more than MAX_WEAPON_TYPES)
        list_size = cfread_int(cfp);

        for (idx = 0; idx < list_size; idx++) {
                cfread_string_len(t_string, NAME_LENGTH, cfp);

                ilist.name = t_string;
                ilist.index = weapon_info_lookup(t_string);

                weapon_list.push_back(ilist);
        }

        // intel list (NOTE: may contain more than MAX_INTEL_ENTRIES)
        list_size = cfread_int(cfp);

        for (idx = 0; idx < list_size; idx++) {
                cfread_string_len(t_string, NAME_LENGTH, cfp);

                ilist.name = t_string;
                ilist.index = intel_info_lookup(t_string);

                intel_list.push_back(ilist);
        }

        // medals list (NOTE: may contain more than Num_medals)
        list_size = cfread_int(cfp);

        for (idx = 0; idx < list_size; idx++) {
                cfread_string_len(t_string, NAME_LENGTH, cfp);

                ilist.name = t_string;
                ilist.index = medals_info_lookup(t_string);

                medals_list.push_back(ilist);
        }

        // last ship flown (index into ship_list)
        idx = cfread_int(cfp);

        // check the idx is within bounds
        Assertion ((idx < (int)ship_list.size()), "Campaign file contains an incorrect value for the last flown ship class. No data in ship_list for ship number %d.", idx); 
        if (idx >= (int)ship_list.size())
                idx = -1;
        else if (idx != -1)
                p->last_ship_flown_si_index = ship_list[idx].index;
        else
                p->last_ship_flown_si_index = -1;

        // progression state
        Campaign.prev_mission = cfread_int(cfp);
        Campaign.next_mission = cfread_int(cfp);

        // loop state
        Campaign.loop_reentry = cfread_int(cfp);
        Campaign.loop_enabled = cfread_int(cfp);

        // missions completed
        Campaign.num_missions_completed = cfread_int(cfp);

        // allowed ships
        list_size = (int)ship_list.size();
        for (idx = 0; idx < list_size; idx++) {
                allowed = cfread_ubyte(cfp);

                if (allowed) {
                        if (ship_list[idx].index >= 0) {
                                Campaign.ships_allowed[ship_list[idx].index] = 1;
                        } else {
                                m_data_invalid = true;
                        }
                }
        }

        // allowed weapons
        list_size = (int)weapon_list.size();
        for (idx = 0; idx < list_size; idx++) {
                allowed = cfread_ubyte(cfp);

                if (allowed) {
                        if (weapon_list[idx].index >= 0) {
                                Campaign.weapons_allowed[weapon_list[idx].index] = 1;
                        } else {
                                m_data_invalid = true;
                        }
                }
        }

        if (csg_ver >= 2) {
                // single/campaign squad name & image
                cfread_string_len(p->s_squad_name, NAME_LENGTH, cfp);
                cfread_string_len(p->s_squad_filename, MAX_FILENAME_LEN, cfp);
        }

        // if anything we need/use was missing then it should be considered fatal
        if (m_data_invalid) {
                throw "Invalid data for CSG!";
        }
}

void pilotfile::csg_write_info()
{
        int idx;

        startSection(Section::Info);

        // ship list
        cfwrite_int(static_cast<int>(Ship_info.size()), cfp);

        for (auto it = Ship_info.cbegin(); it != Ship_info.cend(); ++it) {
                cfwrite_string_len(it->name, cfp);
        }

        // weapon list
        cfwrite_int(Num_weapon_types, cfp);

        for (idx = 0; idx < Num_weapon_types; idx++) {
                cfwrite_string_len(Weapon_info[idx].name, cfp);
        }

        // intel list
        cfwrite_int(Intel_info_size, cfp);

        for (idx = 0; idx < Intel_info_size; idx++) {
                cfwrite_string_len(Intel_info[idx].name, cfp);
        }

        // medals list
        cfwrite_int(Num_medals, cfp);

        for (idx = 0; idx < Num_medals; idx++) {
                cfwrite_string_len(Medals[idx].name, cfp);
        }

        // last ship flown
        cfwrite_int(p->last_ship_flown_si_index, cfp);

        // progression state
        cfwrite_int(Campaign.prev_mission, cfp);
        cfwrite_int(Campaign.next_mission, cfp);

        // loop state
        cfwrite_int(Campaign.loop_reentry, cfp);
        cfwrite_int(Campaign.loop_enabled, cfp);

        // missions completed
        cfwrite_int(Campaign.num_missions_completed, cfp);

        // allowed ships
        for (idx = 0; idx < static_cast<int>(Ship_info.size()); idx++) {
                cfwrite_ubyte(Campaign.ships_allowed[idx], cfp);
        }

        // allowed weapons
        for (idx = 0; idx < Num_weapon_types; idx++) {
                cfwrite_ubyte(Campaign.weapons_allowed[idx], cfp);
        }

        // single/campaign squad name & image
        cfwrite_string_len(p->s_squad_name, cfp);
        cfwrite_string_len(p->s_squad_filename, cfp);

        endSection();
}

void pilotfile::csg_read_missions()
{
        int i, j, idx, list_size;
        cmission *missionp;

        if ( !m_have_info ) {
                throw "Missions before Info!";
        }

        for (i = 0; i < Campaign.num_missions_completed; i++) {
                idx = cfread_int(cfp);
                missionp = &Campaign.missions[idx];

                missionp->completed = 1;

                // flags
                missionp->flags = cfread_int(cfp);

                // goals
                missionp->num_goals = cfread_int(cfp);

                if (missionp->num_goals > 0) {
                        missionp->goals = (mgoal *) vm_malloc( missionp->num_goals * sizeof(mgoal) );
                        Verify( missionp->goals != NULL );

                        memset( missionp->goals, 0, missionp->num_goals * sizeof(mgoal) );

                        for (j = 0; j < missionp->num_goals; j++) {
                                cfread_string_len(missionp->goals[j].name, NAME_LENGTH, cfp);
                                missionp->goals[j].status = cfread_char(cfp);
                        }
                }

                // events
                missionp->num_events = cfread_int(cfp);

                if (missionp->num_events > 0) {
                        missionp->events = (mevent *) vm_malloc( missionp->num_events * sizeof(mevent) );
                        Verify( missionp->events != NULL );

                        memset( missionp->events, 0, missionp->num_events * sizeof(mevent) );

                        for (j = 0; j < missionp->num_events; j++) {
                                cfread_string_len(missionp->events[j].name, NAME_LENGTH, cfp);
                                missionp->events[j].status = cfread_char(cfp);
                        }
                }

                // variables
                missionp->num_variables = cfread_int(cfp);

                if (missionp->num_variables > 0) {
                        missionp->variables = (sexp_variable *) vm_malloc( missionp->num_variables * sizeof(sexp_variable) );
                        Verify( missionp->variables != NULL );

                        memset( missionp->variables, 0, missionp->num_variables * sizeof(sexp_variable) );

                        for (j = 0; j < missionp->num_variables; j++) {
                                missionp->variables[j].type = cfread_int(cfp);
                                cfread_string_len(missionp->variables[j].text, TOKEN_LENGTH, cfp);
                                cfread_string_len(missionp->variables[j].variable_name, TOKEN_LENGTH, cfp);
                        }
                }

                // scoring stats
                missionp->stats.score = cfread_int(cfp);
                missionp->stats.rank = cfread_int(cfp);
                missionp->stats.assists = cfread_int(cfp);
                missionp->stats.kill_count = cfread_int(cfp);
                missionp->stats.kill_count_ok = cfread_int(cfp);
                missionp->stats.bonehead_kills = cfread_int(cfp);

                missionp->stats.p_shots_fired = cfread_uint(cfp);
                missionp->stats.p_shots_hit = cfread_uint(cfp);
                missionp->stats.p_bonehead_hits = cfread_uint(cfp);

                missionp->stats.s_shots_fired = cfread_uint(cfp);
                missionp->stats.s_shots_hit = cfread_uint(cfp);
                missionp->stats.s_bonehead_hits = cfread_uint(cfp);

                // ship kills (scoring)
                list_size = (int)ship_list.size();
                for (j = 0; j < list_size; j++) {
                        idx = cfread_int(cfp);

                        if (ship_list[j].index >= 0) {
                                missionp->stats.kills[ship_list[j].index] = idx;
                        }
                }

                // medals (scoring)
                list_size = (int)medals_list.size();
                for (j = 0; j < list_size; j++) {
                        idx = cfread_int(cfp);

                        if (medals_list[j].index >= 0) {
                                missionp->stats.medal_counts[medals_list[j].index] = idx;
                        }
                }
        }
}

void pilotfile::csg_write_missions()
{
        int idx, j;
        cmission *missionp;

        startSection(Section::Missions);

        for (idx = 0; idx < MAX_CAMPAIGN_MISSIONS; idx++) {
                if (Campaign.missions[idx].completed) {
                        missionp = &Campaign.missions[idx];

                        cfwrite_int(idx, cfp);

                        // flags
                        cfwrite_int(missionp->flags, cfp);

                        // goals
                        cfwrite_int(missionp->num_goals, cfp);

                        for (j = 0; j < missionp->num_goals; j++) {
                                cfwrite_string_len(missionp->goals[j].name, cfp);
                                cfwrite_char(missionp->goals[j].status, cfp);
                        }

                        // events
                        cfwrite_int(missionp->num_events, cfp);

                        for (j = 0; j < missionp->num_events; j++) {
                                cfwrite_string_len(missionp->events[j].name, cfp);
                                cfwrite_char(missionp->events[j].status, cfp);
                        }

                        // variables
                        cfwrite_int(missionp->num_variables, cfp);

                        for (j = 0; j < missionp->num_variables; j++) {
                                cfwrite_int(missionp->variables[j].type, cfp);
                                cfwrite_string_len(missionp->variables[j].text, cfp);
                                cfwrite_string_len(missionp->variables[j].variable_name, cfp);
                        }

                        // scoring stats
                        cfwrite_int(missionp->stats.score, cfp);
                        cfwrite_int(missionp->stats.rank, cfp);
                        cfwrite_int(missionp->stats.assists, cfp);
                        cfwrite_int(missionp->stats.kill_count, cfp);
                        cfwrite_int(missionp->stats.kill_count_ok, cfp);
                        cfwrite_int(missionp->stats.bonehead_kills, cfp);

                        cfwrite_uint(missionp->stats.p_shots_fired, cfp);
                        cfwrite_uint(missionp->stats.p_shots_hit, cfp);
                        cfwrite_uint(missionp->stats.p_bonehead_hits, cfp);

                        cfwrite_uint(missionp->stats.s_shots_fired, cfp);
                        cfwrite_uint(missionp->stats.s_shots_hit, cfp);
                        cfwrite_uint(missionp->stats.s_bonehead_hits, cfp);

                        // ship kills (scoring)
                        for (j = 0; j < static_cast<int>(Ship_info.size()); j++) {
                                cfwrite_int(missionp->stats.kills[j], cfp);
                        }

                        // medals earned (scoring)
                        for (j = 0; j < Num_medals; j++) {
                                cfwrite_int(missionp->stats.medal_counts[j], cfp);
                        }
                }
        }

        endSection();
}

void pilotfile::csg_read_techroom()
{
        int idx, list_size = 0;
        ubyte visible;

        if ( !m_have_info ) {
                throw "Techroom before Info!";
        }

        // visible ships
        list_size = (int)ship_list.size();
        for (idx = 0; idx < list_size; idx++) {
                visible = cfread_ubyte(cfp);

                if (visible) {
                        if (ship_list[idx].index >= 0) {
                                Ship_info[ship_list[idx].index].flags |= SIF_IN_TECH_DATABASE;
                        } else {
                                m_data_invalid = true;
                        }
                }
        }

        // visible weapons
        list_size = (int)weapon_list.size();
        for (idx = 0; idx < list_size; idx++) {
                visible = cfread_ubyte(cfp);

                if (visible) {
                        if (weapon_list[idx].index >= 0) {
                                Weapon_info[weapon_list[idx].index].wi_flags |= WIF_IN_TECH_DATABASE;
                        } else {
                                m_data_invalid = true;
                        }
                }
        }

        // visible intel entries
        list_size = (int)intel_list.size();
        for (idx = 0; idx < list_size; idx++) {
                visible = cfread_ubyte(cfp);

                if (visible) {
                        if (intel_list[idx].index >= 0) {
                                Intel_info[intel_list[idx].index].flags |= IIF_IN_TECH_DATABASE;
                        } else {
                                m_data_invalid = true;
                        }
                }
        }

        // if anything we need/use was missing then it should be considered fatal
        if (m_data_invalid) {
                throw "Invalid data for CSG!";
        }
}

void pilotfile::csg_write_techroom()
{
        int idx;
        ubyte visible;

        startSection(Section::Techroom);

        // visible ships
        for (auto it = Ship_info.cbegin(); it != Ship_info.cend(); ++it) {
                // only visible if not in techroom by default
                if ( (it->flags & SIF_IN_TECH_DATABASE) && !(it->flags2 & SIF2_DEFAULT_IN_TECH_DATABASE) ) {
                        visible = 1;
                } else {
                        visible = 0;
                }

                cfwrite_ubyte(visible, cfp);
        }

        // visible weapons
        for (idx = 0; idx < Num_weapon_types; idx++) {
                // only visible if not in techroom by default
                if ( (Weapon_info[idx].wi_flags & WIF_IN_TECH_DATABASE) && !(Weapon_info[idx].wi_flags2 & WIF2_DEFAULT_IN_TECH_DATABASE) ) {
                        visible = 1;
                } else {
                        visible = 0;
                }

                cfwrite_ubyte(visible, cfp);
        }

        // visible intel entries
        for (idx = 0; idx < Intel_info_size; idx++) {
                // only visible if not in techroom by default
                if ( (Intel_info[idx].flags & IIF_IN_TECH_DATABASE) && !(Intel_info[idx].flags & IIF_DEFAULT_IN_TECH_DATABASE) ) {
                        visible = 1;
                } else {
                        visible = 0;
                }

                cfwrite_ubyte(visible, cfp);
        }

        endSection();
}

void pilotfile::csg_read_loadout()
{
        int j, count, ship_idx = -1, wep_idx = -1;
        uint idx, list_size = 0;

        if ( !m_have_info ) {
                throw "Loadout before Info!";
        }

        // base info
        cfread_string_len(Player_loadout.filename, MAX_FILENAME_LEN, cfp);
        cfread_string_len(Player_loadout.last_modified, DATE_TIME_LENGTH, cfp);

        // ship pool
        list_size = ship_list.size();
        for (idx = 0; idx < list_size; idx++) {
                count = cfread_int(cfp);

                if (ship_list[idx].index >= 0) {
                        Player_loadout.ship_pool[ship_list[idx].index] = count;
                }
        }

        // weapon pool
        list_size = weapon_list.size();
        for (idx = 0; idx < list_size; idx++) {
                count = cfread_int(cfp);

                if (weapon_list[idx].index >= 0) {
                        Player_loadout.weapon_pool[weapon_list[idx].index] = count;
                }
        }

        // player ship loadout
        list_size = (uint)cfread_ushort(cfp);
        for (uint i = 0; i < list_size; i++) {
                wss_unit *slot = NULL;

                if (i < MAX_WSS_SLOTS) {
                        slot = &Player_loadout.unit_data[i];
                }

                // ship
                ship_idx = cfread_int(cfp);

                if ( (ship_idx >= (int)ship_list.size()) || (ship_idx < -1) ) { // on the casts, assume that ship & weapon lists will never exceed ~2 billion
                        mprintf(("CSG => Parse Warning: Invalid value for ship index (%d), emptying slot.\n", ship_idx));
                        ship_idx = -1;
                }

                if (slot) {
                        if (ship_idx == -1) { // -1 means no ship in this slot
                                slot->ship_class = -1;
                        } else {
                                slot->ship_class = ship_list[ship_idx].index;
                        }
                }

                // primary weapons
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        wep_idx = cfread_int(cfp);

                        if ( (wep_idx >= (int)weapon_list.size()) || (wep_idx < -1) ) {
                                mprintf(("CSG => Parse Warning: Invalid value for primary weapon index (%d), emptying slot.\n", wep_idx));
                                wep_idx = -1;
                        }


                        if ( slot && (j < MAX_SHIP_PRIMARY_BANKS) ) {
                                if (wep_idx == -1) { // -1 means no weapon in this slot
                                        slot->wep[j] = -1;
                                } else {
                                        slot->wep[j] = weapon_list[wep_idx].index;
                                }
                        }

                        idx = cfread_int(cfp);

                        if ( slot && (j < MAX_SHIP_PRIMARY_BANKS) ) {
                                slot->wep_count[j] = idx;
                        }
                }

                // secondary weapons
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        wep_idx = cfread_int(cfp);

                        if ( (wep_idx >= (int)weapon_list.size()) || (wep_idx < -1) ) {
                                mprintf(("CSG => Parse Warning: Invalid value for secondary weapon index (%d), emptying slot.\n", wep_idx));
                                wep_idx = -1;
                        }

                        if ( slot && (j < MAX_SHIP_SECONDARY_BANKS) ) {
                                if (wep_idx == -1) { // -1 means no weapon in this slot
                                        slot->wep[j+MAX_SHIP_PRIMARY_BANKS] = -1;
                                } else {
                                        slot->wep[j+MAX_SHIP_PRIMARY_BANKS] = weapon_list[wep_idx].index;
                                }
                        }

                        idx = cfread_int(cfp);

                        if ( slot && (j < MAX_SHIP_SECONDARY_BANKS) ) {
                                slot->wep_count[j+MAX_SHIP_PRIMARY_BANKS] = idx;
                        }
                }
        }       
}

void pilotfile::csg_write_loadout()
{
        int idx, j;

        startSection(Section::Loadout);

        // base info
        cfwrite_string_len(Player_loadout.filename, cfp);
        cfwrite_string_len(Player_loadout.last_modified, cfp);

        // ship pool
        for (idx = 0; idx < static_cast<int>(Ship_info.size()); idx++) {
                cfwrite_int(Player_loadout.ship_pool[idx], cfp);
        }

        // weapon pool
        for (idx = 0; idx < Num_weapon_types; idx++) {
                cfwrite_int(Player_loadout.weapon_pool[idx], cfp);
        }

        // play ship loadout
        cfwrite_ushort(MAX_WSS_SLOTS, cfp);

        for (idx = 0; idx < MAX_WSS_SLOTS; idx++) {
                wss_unit *slot = &Player_loadout.unit_data[idx];

                // ship
                cfwrite_int(slot->ship_class, cfp);

                // primary weapons
                cfwrite_int(MAX_SHIP_PRIMARY_BANKS, cfp);

                for (j = 0; j < MAX_SHIP_PRIMARY_BANKS; j++) {
                        cfwrite_int(slot->wep[j], cfp);
                        cfwrite_int(slot->wep_count[j], cfp);
                }

                // secondary weapons
                cfwrite_int(MAX_SHIP_SECONDARY_BANKS, cfp);

                for (j = 0; j < MAX_SHIP_SECONDARY_BANKS; j++) {
                        cfwrite_int(slot->wep[j+MAX_SHIP_PRIMARY_BANKS], cfp);
                        cfwrite_int(slot->wep_count[j+MAX_SHIP_PRIMARY_BANKS], cfp);
                }
        }

        endSection();
}

void pilotfile::csg_read_stats()
{
        int idx, list_size = 0;
        int count;

        if ( !m_have_info ) {
                throw "Stats before Info!";
        }

        // scoring stats
        p->stats.score = cfread_int(cfp);
        p->stats.rank = cfread_int(cfp);
        p->stats.assists = cfread_int(cfp);
        p->stats.kill_count = cfread_int(cfp);
        p->stats.kill_count_ok = cfread_int(cfp);
        p->stats.bonehead_kills = cfread_int(cfp);

        p->stats.p_shots_fired = cfread_uint(cfp);
        p->stats.p_shots_hit = cfread_uint(cfp);
        p->stats.p_bonehead_hits = cfread_uint(cfp);

        p->stats.s_shots_fired = cfread_uint(cfp);
        p->stats.s_shots_hit = cfread_uint(cfp);
        p->stats.s_bonehead_hits = cfread_uint(cfp);

        p->stats.flight_time = cfread_uint(cfp);
        p->stats.missions_flown = cfread_uint(cfp);
        p->stats.last_flown = (_fs_time_t)cfread_int(cfp);
        p->stats.last_backup = (_fs_time_t)cfread_int(cfp);

        // ship kills (scoring)
        list_size = (int)ship_list.size();
        for (idx = 0; idx < list_size; idx++) {
                count = cfread_int(cfp);

                if (ship_list[idx].index >= 0) {
                        p->stats.kills[ship_list[idx].index] = count;
                }
        }

        // medals earned (scoring)
        list_size = (int)medals_list.size();
        for (idx = 0; idx < list_size; idx++) {
                count = cfread_int(cfp);

                if (medals_list[idx].index >= 0) {
                        p->stats.medal_counts[medals_list[idx].index] = count;
                }
        }
}

void pilotfile::csg_write_stats()
{
        int idx;

        startSection(Section::Scoring);

        // scoring stats
        cfwrite_int(p->stats.score, cfp);
        cfwrite_int(p->stats.rank, cfp);
        cfwrite_int(p->stats.assists, cfp);
        cfwrite_int(p->stats.kill_count, cfp);
        cfwrite_int(p->stats.kill_count_ok, cfp);
        cfwrite_int(p->stats.bonehead_kills, cfp);

        cfwrite_uint(p->stats.p_shots_fired, cfp);
        cfwrite_uint(p->stats.p_shots_hit, cfp);
        cfwrite_uint(p->stats.p_bonehead_hits, cfp);

        cfwrite_uint(p->stats.s_shots_fired, cfp);
        cfwrite_uint(p->stats.s_shots_hit, cfp);
        cfwrite_uint(p->stats.s_bonehead_hits, cfp);

        cfwrite_uint(p->stats.flight_time, cfp);
        cfwrite_uint(p->stats.missions_flown, cfp);
        cfwrite_int((int)p->stats.last_flown, cfp);
        cfwrite_int((int)p->stats.last_backup, cfp);

        // ship kills (scoring)
        for (idx = 0; idx < static_cast<int>(Ship_info.size()); idx++) {
                cfwrite_int(p->stats.kills[idx], cfp);
        }

        // medals earned (scoring)
        for (idx = 0; idx < Num_medals; idx++) {
                cfwrite_int(p->stats.medal_counts[idx], cfp);
        }

        endSection();
}

void pilotfile::csg_read_redalert()
{
        int idx, i, j, list_size = 0;
        int count;
        char t_string[MAX_FILENAME_LEN+NAME_LENGTH+1] = { '\0' };
        float hit;
        wep_t weapons;

        if ( !m_have_info ) {
                throw "RedAlert before Info!";
        }

        list_size = cfread_int(cfp);

        if (list_size <= 0) {
                return;
        }

        cfread_string_len(t_string, MAX_FILENAME_LEN, cfp);

        Red_alert_precursor_mission = t_string;

        for (idx = 0; idx < list_size; idx++) {
                red_alert_ship_status ras;

                cfread_string_len(t_string, NAME_LENGTH, cfp);
                ras.name = t_string;

                ras.hull = cfread_float(cfp);

                // ship class, index into ship_list[]
                i = cfread_int(cfp);
                if ( (i >= (int)ship_list.size()) || (i < RED_ALERT_LOWEST_VALID_SHIP_CLASS) ) {
                        mprintf(("CSG => Parse Warning: Invalid value for red alert ship index (%d), emptying slot.\n", i));
                        ras.ship_class = RED_ALERT_DESTROYED_SHIP_CLASS;
                } else if ( (i < 0 ) && (i >= RED_ALERT_LOWEST_VALID_SHIP_CLASS) ) {  // ship destroyed/exited
                        ras.ship_class = i;
                } else {
                        ras.ship_class = ship_list[i].index;
                }

                // subsystem hits
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        hit = cfread_float(cfp);
                        ras.subsys_current_hits.push_back( hit );
                }

                // subsystem aggregate hits
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        hit = cfread_float(cfp);
                        ras.subsys_aggregate_current_hits.push_back( hit );
                }

                // primary weapon loadout and status
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        i = cfread_int(cfp);
                        weapons.index = weapon_list[i].index;
                        weapons.count = cfread_int(cfp);

                        // triggering this means something is really fubar
                        if (weapons.index < 0) {
                                continue;
                        }

                        ras.primary_weapons.push_back( weapons );
                }

                // secondary weapon loadout and status
                count = cfread_int(cfp);

                for (j = 0; j < count; j++) {
                        i = cfread_int(cfp);
                        weapons.index = weapon_list[i].index;
                        weapons.count = cfread_int(cfp);

                        // triggering this means something is really fubar
                        if (weapons.index < 0) {
                                continue;
                        }

                        ras.secondary_weapons.push_back( weapons );
                }

                // this is quite likely a *bad* thing if it doesn't happen
                if (ras.ship_class >= RED_ALERT_LOWEST_VALID_SHIP_CLASS) {
                        Red_alert_wingman_status.push_back( ras );
                }
        }
}

void pilotfile::csg_write_redalert()
{
        int idx, j, list_size = 0;
        int count;
        red_alert_ship_status *ras;

        startSection(Section::RedAlert);

        list_size = (int)Red_alert_wingman_status.size();

        cfwrite_int(list_size, cfp);

        if (list_size) {
                cfwrite_string_len(Red_alert_precursor_mission.c_str(), cfp);

                for (idx = 0; idx < list_size; idx++) {
                        ras = &Red_alert_wingman_status[idx];

                        cfwrite_string_len(ras->name.c_str(), cfp);

                        cfwrite_float(ras->hull, cfp);

                        // ship class, should be index into ship_list[] on load
                        cfwrite_int(ras->ship_class, cfp);

                        // subsystem hits
                        count = (int)ras->subsys_current_hits.size();
                        cfwrite_int(count, cfp);

                        for (j = 0; j < count; j++) {
                                cfwrite_float(ras->subsys_current_hits[j], cfp);
                        }

                        // subsystem aggregate hits
                        count = (int)ras->subsys_aggregate_current_hits.size();
                        cfwrite_int(count, cfp);

                        for (j = 0; j < count; j++) {
                                cfwrite_float(ras->subsys_aggregate_current_hits[j], cfp);
                        }

                        // primary weapon loadout and status
                        count = (int)ras->primary_weapons.size();
                        cfwrite_int(count, cfp);

                        for (j = 0; j < count; j++) {
                                cfwrite_int(ras->primary_weapons[j].index, cfp);
                                cfwrite_int(ras->primary_weapons[j].count, cfp);
                        }

                        // secondary weapon loadout and status
                        count = (int)ras->secondary_weapons.size();
                        cfwrite_int(count, cfp);

                        for (j = 0; j < count; j++) {
                                cfwrite_int(ras->secondary_weapons[j].index, cfp);
                                cfwrite_int(ras->secondary_weapons[j].count, cfp);
                        }
                }
        }

        endSection();
}

void pilotfile::csg_read_hud()
{
        int idx;

        // flags
        HUD_config.show_flags = cfread_int(cfp);
        HUD_config.show_flags2 = cfread_int(cfp);

        HUD_config.popup_flags = cfread_int(cfp);
        HUD_config.popup_flags2 = cfread_int(cfp);

        // settings
        HUD_config.num_msg_window_lines = cfread_ubyte(cfp);

        HUD_config.rp_flags = cfread_int(cfp);
        HUD_config.rp_dist = cfread_int(cfp);

        // basic colors
        HUD_config.main_color = cfread_int(cfp);
        HUD_color_alpha = cfread_int(cfp);

        if (HUD_color_alpha < HUD_COLOR_ALPHA_USER_MIN) {
                HUD_color_alpha = HUD_COLOR_ALPHA_DEFAULT;
        }

        hud_config_record_color(HUD_config.main_color);

        // gauge-specific colors
        int num_gauges = cfread_int(cfp);

        for (idx = 0; idx < num_gauges; idx++) {
                ubyte red = cfread_ubyte(cfp);
                ubyte green = cfread_ubyte(cfp);
                ubyte blue = cfread_ubyte(cfp);
                ubyte alpha = cfread_ubyte(cfp);

                if (idx >= NUM_HUD_GAUGES) {
                        continue;
                }

                HUD_config.clr[idx].red = red;
                HUD_config.clr[idx].green = green;
                HUD_config.clr[idx].blue = blue;
                HUD_config.clr[idx].alpha = alpha;
        }
}

void pilotfile::csg_write_hud()
{
        int idx;

        startSection(Section::HUD);

        // flags
        cfwrite_int(HUD_config.show_flags, cfp);
        cfwrite_int(HUD_config.show_flags2, cfp);

        cfwrite_int(HUD_config.popup_flags, cfp);
        cfwrite_int(HUD_config.popup_flags2, cfp);

        // settings
        cfwrite_ubyte(HUD_config.num_msg_window_lines, cfp);

        cfwrite_int(HUD_config.rp_flags, cfp);
        cfwrite_int(HUD_config.rp_dist, cfp);

        // basic colors
        cfwrite_int(HUD_config.main_color, cfp);
        cfwrite_int(HUD_color_alpha, cfp);

        // gauge-specific colors
        cfwrite_int(NUM_HUD_GAUGES, cfp);

        for (idx = 0; idx < NUM_HUD_GAUGES; idx++) {
                cfwrite_ubyte(HUD_config.clr[idx].red, cfp);
                cfwrite_ubyte(HUD_config.clr[idx].green, cfp);
                cfwrite_ubyte(HUD_config.clr[idx].blue, cfp);
                cfwrite_ubyte(HUD_config.clr[idx].alpha, cfp);
        }

        endSection();
}

void pilotfile::csg_read_variables()
{
        int idx;

        Campaign.num_variables = cfread_int(cfp);

        if (Campaign.num_variables > 0) {
                Campaign.variables = (sexp_variable *) vm_malloc( Campaign.num_variables * sizeof(sexp_variable) );
                Verify( Campaign.variables != NULL );

                memset( Campaign.variables, 0, Campaign.num_variables * sizeof(sexp_variable) );

                for (idx = 0; idx < Campaign.num_variables; idx++) {
                        Campaign.variables[idx].type = cfread_int(cfp);
                        cfread_string_len(Campaign.variables[idx].text, TOKEN_LENGTH, cfp);
                        cfread_string_len(Campaign.variables[idx].variable_name, TOKEN_LENGTH, cfp);
                }
        }

        if (csg_ver < 4) { // CSG files before version 4 don't have a Red Alert set of CPVs to load, so just copy the regular set.
                Campaign.redalert_num_variables = Campaign.num_variables;
                Campaign.redalert_variables = (sexp_variable *) vm_malloc( Campaign.redalert_num_variables * sizeof(sexp_variable) );
                Verify( Campaign.redalert_variables != NULL);

                memcpy( Campaign.redalert_variables, Campaign.variables, Campaign.num_variables * sizeof(sexp_variable));
        } else {
                Campaign.redalert_num_variables = cfread_int(cfp);

                if (Campaign.redalert_num_variables > 0) {
                        Campaign.redalert_variables = (sexp_variable *) vm_malloc( Campaign.redalert_num_variables * sizeof(sexp_variable) );
                        Verify( Campaign.redalert_variables != NULL );

                        memset( Campaign.redalert_variables, 0, Campaign.redalert_num_variables * sizeof(sexp_variable) );

                        for (idx = 0; idx < Campaign.redalert_num_variables; idx++) {
                                Campaign.redalert_variables[idx].type = cfread_int(cfp);
                                cfread_string_len(Campaign.redalert_variables[idx].text, TOKEN_LENGTH, cfp);
                                cfread_string_len(Campaign.redalert_variables[idx].variable_name, TOKEN_LENGTH, cfp);
                        }
                }
        }
}

void pilotfile::csg_write_variables()
{
        int idx;

        startSection(Section::Variables);

        cfwrite_int(Campaign.num_variables, cfp);

        for (idx = 0; idx < Campaign.num_variables; idx++) {
                cfwrite_int(Campaign.variables[idx].type, cfp);
                cfwrite_string_len(Campaign.variables[idx].text, cfp);
                cfwrite_string_len(Campaign.variables[idx].variable_name, cfp);
        }

        cfwrite_int(Campaign.redalert_num_variables, cfp);

        for (idx = 0; idx < Campaign.redalert_num_variables; idx++) {
                cfwrite_int(Campaign.redalert_variables[idx].type, cfp);
                cfwrite_string_len(Campaign.redalert_variables[idx].text, cfp);
                cfwrite_string_len(Campaign.redalert_variables[idx].variable_name, cfp);
        }

        endSection();
}

void pilotfile::csg_read_settings()
{
        // sound/voice/music
        Master_sound_volume = cfread_float(cfp);
        Master_event_music_volume = cfread_float(cfp);
        Master_voice_volume = cfread_float(cfp);

        audiostream_set_volume_all(Master_voice_volume, ASF_VOICE);
        audiostream_set_volume_all(Master_event_music_volume, ASF_EVENTMUSIC);

        if (Master_event_music_volume > 0.0f) {
                Event_music_enabled = 1;
        } else {
                Event_music_enabled = 0;
        }

        Briefing_voice_enabled = cfread_int(cfp);

        // skill level
        Game_skill_level = cfread_int(cfp);

        // input options
        Use_mouse_to_fly = cfread_int(cfp);
        Mouse_sensitivity = cfread_int(cfp);
        Joy_sensitivity = cfread_int(cfp);
        Dead_zone_size = cfread_int(cfp);

        if (csg_ver < 3) {
                // detail
                int dummy  __UNUSED = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
                dummy = cfread_int(cfp);
        }
}

void pilotfile::csg_write_settings()
{
        startSection(Section::Settings);

        // sound/voice/music
        cfwrite_float(Master_sound_volume, cfp);
        cfwrite_float(Master_event_music_volume, cfp);
        cfwrite_float(Master_voice_volume, cfp);

        cfwrite_int(Briefing_voice_enabled, cfp);

        // skill level
        cfwrite_int(Game_skill_level, cfp);

        // input options
        cfwrite_int(Use_mouse_to_fly, cfp);
        cfwrite_int(Mouse_sensitivity, cfp);
        cfwrite_int(Joy_sensitivity, cfp);
        cfwrite_int(Dead_zone_size, cfp);

        endSection();
}

void pilotfile::csg_read_controls()
{
        int idx, list_size;
        short id1, id2, id3 __UNUSED;

        list_size = (int)cfread_ushort(cfp);

        for (idx = 0; idx < list_size; idx++) {
                id1 = cfread_short(cfp);
                id2 = cfread_short(cfp);
                id3 = cfread_short(cfp);        // unused, at the moment

                if (idx < CCFG_MAX) {
                        Control_config[idx].key_id = id1;
                        Control_config[idx].joy_id = id2;
                }
        }
}

void pilotfile::csg_write_controls()
{
        int idx;

        startSection(Section::Controls);

        cfwrite_ushort(CCFG_MAX, cfp);

        for (idx = 0; idx < CCFG_MAX; idx++) {
                cfwrite_short(Control_config[idx].key_id, cfp);
                cfwrite_short(Control_config[idx].joy_id, cfp);
                // placeholder? for future mouse_id?
                cfwrite_short(-1, cfp);
        }

        endSection();
}

void pilotfile::csg_read_cutscenes() {
        size_t list_size = cfread_uint(cfp);

        for(size_t i = 0; i < list_size; i++) {
                char tempFilename[MAX_FILENAME_LEN];

                cfread_string_len(tempFilename, MAX_FILENAME_LEN, cfp);
                cutscene_mark_viewable(tempFilename);
        }
}

void pilotfile::csg_write_cutscenes() {
        SCP_vector<cutscene_info>::iterator cut;

        startSection(Section::Cutscenes);

        size_t viewableScenes = 0;
        for(cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut) {
                if(cut->viewable)
                        viewableScenes ++;
        }
        cfwrite_uint(viewableScenes, cfp);

        for(cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut) {
                if(cut->viewable)
                        cfwrite_string_len(cut->filename, cfp);
        }

        endSection();
}

/*
 * Only used for quick start missions
 */
void pilotfile::csg_read_lastmissions()
{
        int i;

        // restore list of most recently played missions
        Num_recent_missions = cfread_int( cfp );
        Assert(Num_recent_missions <= MAX_RECENT_MISSIONS);
        for ( i = 0; i < Num_recent_missions; i++ ) {
                char *cp;

                cfread_string_len( Recent_missions[i], MAX_FILENAME_LEN, cfp);
                // Remove the extension (safety check: shouldn't exist anyway)
                cp = strchr(Recent_missions[i], '.');
                        if (cp)
                                *cp = 0;
        }
}

/*
 * Only used for quick start missions
 */

void pilotfile::csg_write_lastmissions()
{
        int i;

        startSection(Section::LastMissions);

        // store list of most recently played missions
        cfwrite_int(Num_recent_missions, cfp);
        for (i=0; i<Num_recent_missions; i++) {
                cfwrite_string_len(Recent_missions[i], cfp);
        }

        endSection();
}

void pilotfile::csg_reset_data()
{
        int idx;
        cmission *missionp;

        // internals
        m_have_flags = false;
        m_have_info = false;

        m_data_invalid = false;

        // init stats
        p->stats.init();

        // zero out allowed ships/weapons
        memset(Campaign.ships_allowed, 0, sizeof(Campaign.ships_allowed));
        memset(Campaign.weapons_allowed, 0, sizeof(Campaign.weapons_allowed));

        // reset campaign status
        Campaign.prev_mission = -1;
        Campaign.next_mission = -1;
        Campaign.num_missions_completed = 0;

        // techroom reset
        tech_reset_to_default();

        // clear out variables
        if (Campaign.variables) {
                Campaign.num_variables = 0;
                vm_free(Campaign.variables);
                Campaign.variables = NULL;
        }

        if (Campaign.redalert_variables) {
                Campaign.redalert_num_variables = 0;
                vm_free(Campaign.redalert_variables);
                Campaign.redalert_variables = NULL;
        }

        // clear red alert data
        Red_alert_wingman_status.clear();

        // clear out mission stuff
        for (idx = 0; idx < MAX_CAMPAIGN_MISSIONS; idx++) {
                missionp = &Campaign.missions[idx];

                if (missionp->goals) {
                        missionp->num_goals = 0;
                        vm_free(missionp->goals);
                        missionp->goals = NULL;
                }

                if (missionp->events) {
                        missionp->num_events = 0;
                        vm_free(missionp->events);
                        missionp->events = NULL;
                }

                if (missionp->variables) {
                        missionp->num_variables = 0;
                        vm_free(missionp->variables);
                        missionp->variables = NULL;
                }

                missionp->stats.init();
        }
}

void pilotfile::csg_close()
{
        if (cfp) {
                cfclose(cfp);
                cfp = NULL;
        }

        p = NULL;
        filename = "";

        ship_list.clear();
        weapon_list.clear();
        intel_list.clear();
        medals_list.clear();

        m_have_flags = false;
        m_have_info = false;
}

bool pilotfile::load_savefile(const char *campaign)
{
        char base[_MAX_FNAME] = { '\0' };
        std::ostringstream buf;

        if (Game_mode & GM_MULTIPLAYER) {
                return false;
        }

        if ( (campaign == NULL) || !strlen(campaign) ) {
                return false;
        }

        // set player ptr first thing
        Assert( (Player_num >= 0) && (Player_num < MAX_PLAYERS) );
        p = &Players[Player_num];

        // build up filename for the savefile...
        _splitpath((char*)campaign, NULL, NULL, base, NULL);

        buf << p->callsign << "." << base << ".csg";

        filename = buf.str().c_str();

        // if campaign file doesn't exist, abort so we don't load irrelevant data
        buf.str(std::string());
        buf << base << FS_CAMPAIGN_FILE_EXT;
        if ( !cf_exists_full((char*)buf.str().c_str(), CF_TYPE_MISSIONS) ) {
                mprintf(("CSG => Unable to find campaign file '%s'!\n", buf.str().c_str()));
                return false;
        }

        // we need to reset this early, in case open fails and we need to create
        m_data_invalid = false;

        // open it, hopefully...
        cfp = cfopen((char*)filename.c_str(), "rb", CFILE_NORMAL, CF_TYPE_PLAYERS);

        if ( !cfp ) {
                mprintf(("CSG => Unable to open '%s' for reading!\n", filename.c_str()));
                return false;
        }

        unsigned int csg_id = cfread_uint(cfp);

        if (csg_id != CSG_FILE_ID) {
                mprintf(("CSG => Invalid header id for '%s'!\n", filename.c_str()));
                csg_close();
                return false;
        }

        // version, now used
        csg_ver = cfread_ubyte(cfp);

        mprintf(("CSG => Loading '%s' with version %d...\n", filename.c_str(), (int)csg_ver));

        csg_reset_data();

        // the point of all this: read in the CSG contents
        while ( !cfeof(cfp) ) {
                ushort section_id = cfread_ushort(cfp);
                uint section_size = cfread_uint(cfp);

                size_t start_pos = cftell(cfp);

                // safety, to help protect against long reads
                cf_set_max_read_len(cfp, section_size);

                try {
                        switch (section_id) {
                                case Section::Flags:
                                        mprintf(("CSG => Parsing:  Flags...\n"));
                                        m_have_flags = true;
                                        csg_read_flags();
                                        break;

                                case Section::Info:
                                        mprintf(("CSG => Parsing:  Info...\n"));
                                        m_have_info = true;
                                        csg_read_info();
                                        break;

                                case Section::Variables:
                                        mprintf(("CSG => Parsing:  Variables...\n"));
                                        csg_read_variables();
                                        break;

                                case Section::HUD:
                                        mprintf(("CSG => Parsing:  HUD...\n"));
                                        csg_read_hud();
                                        break;

                                case Section::RedAlert:
                                        mprintf(("CSG => Parsing:  RedAlert...\n"));
                                        csg_read_redalert();
                                        break;

                                case Section::Scoring:
                                        mprintf(("CSG => Parsing:  Scoring...\n"));
                                        csg_read_stats();
                                        break;

                                case Section::Loadout:
                                        mprintf(("CSG => Parsing:  Loadout...\n"));
                                        csg_read_loadout();
                                        break;

                                case Section::Techroom:
                                        mprintf(("CSG => Parsing:  Techroom...\n"));
                                        csg_read_techroom();
                                        break;

                                case Section::Missions:
                                        mprintf(("CSG => Parsing:  Missions...\n"));
                                        csg_read_missions();
                                        break;

                                case Section::Settings:
                                        mprintf(("CSG => Parsing:  Settings...\n"));
                                        csg_read_settings();
                                        break;

                                case Section::Controls:
                                        mprintf(("CSG => Parsing:  Controls...\n"));
                                        csg_read_controls();
                                        break;

                                case Section::Cutscenes:
                                        mprintf(("CSG => Parsing:  Cutscenes...\n"));
                                        csg_read_cutscenes();
                                        break;

                                case Section::LastMissions:
                                        mprintf(("CSG => Parsing:  Last Missions...\n"));
                                        csg_read_lastmissions();
                                        break;

                                default:
                                        mprintf(("CSG => Skipping unknown section 0x%04x!\n", section_id));
                                        break;
                        }
                } catch (cfile::max_read_length &msg) {
                        // read to max section size, move to next section, discarding
                        // extra/unknown data
                        mprintf(("CSG => Warning: (0x%04x) %s\n", section_id, msg.what()));
                } catch (const char *err) {
                        mprintf(("CSG => ERROR: %s\n", err));
                        csg_close();
                        return false;
                }

                // reset safety catch
                cf_set_max_read_len(cfp, 0);

                // skip to next section (if not already there)
                size_t offset_pos = (start_pos + section_size) - cftell(cfp);

                if (offset_pos) {
                        mprintf(("CSG => Warning: (0x%04x) Short read, information may have been lost!\n", section_id));
                        cfseek(cfp, offset_pos, CF_SEEK_CUR);
                }
        }

        // if the campaign (for whatever reason) doesn't have a squad image, use the multi one
        if (p->s_squad_filename[0] == '\0') {
                strcpy_s(p->s_squad_filename, p->m_squad_filename);
        }
        player_set_squad_bitmap(p, p->s_squad_filename, false);

        mprintf(("CSG => Loading complete!\n"));

        // cleanup and return
        csg_close();

        return true;
}

bool pilotfile::save_savefile()
{
        char base[_MAX_FNAME] = { '\0' };
        std::ostringstream buf;

        if (Game_mode & GM_MULTIPLAYER) {
                return false;
        }

        // set player ptr first thing
        Assert( (Player_num >= 0) && (Player_num < MAX_PLAYERS) );
        p = &Players[Player_num];

        if ( !strlen(Campaign.filename) ) {
                return false;
        }

        // build up filename for the savefile...
        _splitpath(Campaign.filename, NULL, NULL, base, NULL);

        buf << p->callsign << "." << base << ".csg";

        filename = buf.str().c_str();

        // make sure that we can actually save this safely
        if (m_data_invalid) {
                mprintf(("CSG => Skipping save of '%s' due to invalid data check!\n", filename.c_str()));
                return false;
        }

        // validate the number of red alert entries
        // assertion before writing so that we don't corrupt the .csg by asserting halfway through writing
        // assertion should also prevent loss of major campaign progress
        // i.e. lose one mission, not several missions worth (in theory)
        Assertion(Red_alert_wingman_status.size() <= MAX_SHIPS, "Invalid number of Red_alert_wingman_status entries: " SIZE_T_ARG "\n", Red_alert_wingman_status.size());

        // open it, hopefully...
        cfp = cfopen((char*)filename.c_str(), "wb", CFILE_NORMAL, CF_TYPE_PLAYERS);

        if ( !cfp ) {
                mprintf(("CSG => Unable to open '%s' for saving!\n", filename.c_str()));
                return false;
        }

        // header and version
        cfwrite_int(CSG_FILE_ID, cfp);
        cfwrite_ubyte(CSG_VERSION, cfp);

        mprintf(("CSG => Saving '%s' with version %d...\n", filename.c_str(), (int)CSG_VERSION));

        // flags and info sections go first
        mprintf(("CSG => Saving:  Flags...\n"));
        csg_write_flags();
        mprintf(("CSG => Saving:  Info...\n"));
        csg_write_info();

        // everything else is next, not order specific
        mprintf(("CSG => Saving:  Missions...\n"));
        csg_write_missions();
        mprintf(("CSG => Saving:  Techroom...\n"));
        csg_write_techroom();
        mprintf(("CSG => Saving:  Loadout...\n"));
        csg_write_loadout();
        mprintf(("CSG => Saving:  Scoring...\n"));
        csg_write_stats();
        mprintf(("CSG => Saving:  RedAlert...\n"));
        csg_write_redalert();
        mprintf(("CSG => Saving:  HUD...\n"));
        csg_write_hud();
        mprintf(("CSG => Saving:  Variables...\n"));
        csg_write_variables();
        mprintf(("CSG => Saving:  Settings...\n"));
        csg_write_settings();
        mprintf(("CSG => Saving:  Controls...\n"));
        csg_write_controls();
        mprintf(("CSG => Saving:  Cutscenes...\n"));
        csg_write_cutscenes();
        mprintf(("CSG => Saving:  Last Missions...\n"));
        csg_write_lastmissions();

        // Done!
        mprintf(("CSG => Saving complete!\n"));

        csg_close();

        return true;
}

/*
 * get_csg_rank: this function is called from plr.cpp & is
 * tightly linked with pilotfile::verify()
 */
bool pilotfile::get_csg_rank(int *rank)
{
        player t_csg;

        // set player ptr first thing
        p = &t_csg;

        // filename has already been set
        cfp = cfopen((char*)filename.c_str(), "rb", CFILE_NORMAL, CF_TYPE_PLAYERS);

        if ( !cfp ) {
                mprintf(("CSG => Unable to open '%s'!\n", filename.c_str()));
                return false;
        }

        unsigned int csg_id = cfread_uint(cfp);

        if (csg_id != CSG_FILE_ID) {
                mprintf(("CSG => Invalid header id for '%s'!\n", filename.c_str()));
                csg_close();
                return false;
        }

        // version, now used
        csg_ver = cfread_ubyte(cfp);

        mprintf(("CSG => Get Rank from '%s' with version %d...\n", filename.c_str(), (int)csg_ver));

        // the point of all this: read in the CSG contents
        while ( !m_have_flags && !cfeof(cfp) ) {
                ushort section_id = cfread_ushort(cfp);
                uint section_size = cfread_uint(cfp);

                size_t start_pos = cftell(cfp);
                size_t offset_pos;

                // safety, to help protect against long reads
                cf_set_max_read_len(cfp, section_size);

                try {
                        switch (section_id) {
                                case Section::Flags:
                                        mprintf(("CSG => Parsing:  Flags...\n"));
                                        m_have_flags = true;
                                        csg_read_flags();
                                        break;

                                default:
                                        break;
                        }
                } catch (cfile::max_read_length &msg) {
                        // read to max section size, move to next section, discarding
                        // extra/unknown data
                        mprintf(("CSG => (0x%04x) %s\n", section_id, msg.what()));
                } catch (const char *err) {
                        mprintf(("CSG => ERROR: %s\n", err));
                        csg_close();
                        return false;
                }

                // reset safety catch
                cf_set_max_read_len(cfp, 0);

                // skip to next section (if not already there)
                offset_pos = (start_pos + section_size) - cftell(cfp);

                if (offset_pos) {
                        mprintf(("CSG => Warning: (0x%04x) Short read, information may have been lost!\n", section_id));
                        cfseek(cfp, offset_pos, CF_SEEK_CUR);
                }
        }

        // this is what we came for...
        *rank = p->stats.rank;

        mprintf(("CSG => Get Rank complete!\n"));

        // cleanup & return
        csg_close();

        return true;
}