Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Functions to dump text description of mine.

 * An editor-only function, called at mine load time.

 * To be read by a human to verify the correctness and completeness of a mine.

 *

 */

#include <bitset>

#include <stdio.h>

#include <cinttypes>

#include <string.h>

#include <stdarg.h>

#include <errno.h>

#include "pstypes.h"

#include "console.h"

#include "physfsx.h"

#include "key.h"

#include "gr.h"

#include "palette.h"

#include "fmtcheck.h"

#include "inferno.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#endif

#include "dxxerror.h"

#include "object.h"

#include "wall.h"

#include "gamemine.h"

#include "gameseg.h"

#include "robot.h"

#include "player.h"

#include "newmenu.h"

#include "textures.h"

#include "bm.h"

#include "menu.h"

#include "switch.h"

#include "fuelcen.h"

#include "powerup.h"

#include "gameseq.h"

#include "polyobj.h"

#include "gamesave.h"

#include "piggy.h"

#include "compiler-range_for.h"

#include "d_enumerate.h"

#include "d_range.h"

#include "d_zip.h"

#include "segiter.h"

#if DXX_USE_EDITOR

namespace dsx {

namespace {

#if defined(DXX_BUILD_DESCENT_I)

using perm_tmap_buffer_type = std::array<int, MAX_TEXTURES>;

using level_tmap_buffer_type = std::array<int8_t, MAX_TEXTURES>;

using wall_buffer_type = std::array<int, MAX_WALL_ANIMS>;

#elif defined(DXX_BUILD_DESCENT_II)

using perm_tmap_buffer_type = std::array<int, MAX_BITMAP_FILES>;

using level_tmap_buffer_type = std::array<int8_t, MAX_BITMAP_FILES>;

using wall_buffer_type = std::array<int, MAX_BITMAP_FILES>;

#endif

}

}

namespace dcx {

const std::array<char[10], 7> Wall_names{{

        "NORMAL   ",

        "BLASTABLE",

        "DOOR     ",

        "ILLUSION ",

        "OPEN     ",

        "CLOSED   ",

        "EXTERNAL "

}};

}

static void dump_used_textures_level(PHYSFS_File *my_file, int level_num, const char *Gamesave_current_filename);

static void say_totals(fvcobjptridx &vcobjptridx, PHYSFS_File *my_file, const char *level_name);

namespace dsx {

const std::array<char[9], MAX_OBJECT_TYPES> Object_type_names{{

        "WALL    ",

        "FIREBALL",

        "ROBOT   ",

        "HOSTAGE ",

        "PLAYER  ",

        "WEAPON  ",

        "CAMERA  ",

        "POWERUP ",

        "DEBRIS  ",

        "CNTRLCEN",

        "FLARE   ",

        "CLUTTER ",

        "GHOST   ",

        "LIGHT   ",

        "COOP    ",

#if defined(DXX_BUILD_DESCENT_II)

        "MARKER  ",

#endif

}};

// ----------------------------------------------------------------------------

static const char *object_types(const object_base &objp)

{

        const auto type = objp.type;

        assert(type == OBJ_NONE || type < MAX_OBJECT_TYPES);

        return &Object_type_names[type][0];

}

}

// ----------------------------------------------------------------------------

static const char *object_ids(const object_base &objp)

{

        switch (objp.type)

        {

                case OBJ_ROBOT:

                        return Robot_names[get_robot_id(objp)].data();

                case OBJ_POWERUP:

                        return Powerup_names[get_powerup_id(objp)].data();

                default:

                        return nullptr;

        }

}

static void err_puts(PHYSFS_File *f, const char *str, size_t len) __attribute_nonnull();

static void err_puts(PHYSFS_File *f, const char *str, size_t len)

#define err_puts(A1,S,...)      (err_puts(A1,S, _dxx_call_puts_parameter2(1, ## __VA_ARGS__, strlen(S))))

{

        con_puts(CON_CRITICAL, str, len);

        PHYSFSX_puts(f, str);

        Errors_in_mine++;

}

template <size_t len>

static void err_puts_literal(PHYSFS_File *f, const char (&str)[len]) __attribute_nonnull();

template <size_t len>

static void err_puts_literal(PHYSFS_File *f, const char (&str)[len])

{

        err_puts(f, str, len);

}

static void err_printf(PHYSFS_File *my_file, const char * format, ... ) __attribute_format_printf(2, 3);

static void err_printf(PHYSFS_File *my_file, const char * format, ... )

#define err_printf(A1,F,...)    dxx_call_printf_checked(err_printf,err_puts_literal,(A1),(F),##__VA_ARGS__)

{

        va_list args;

        char            message[256];

        va_start(args, format );

        size_t len = vsnprintf(message,sizeof(message),format,args);

        va_end(args);

        err_puts(my_file, message, len);

}

static void warning_puts(PHYSFS_File *f, const char *str, size_t len) __attribute_nonnull();

static void warning_puts(PHYSFS_File *f, const char *str, size_t len)

#define warning_puts(A1,S,...)  (warning_puts(A1,S, _dxx_call_puts_parameter2(1, ## __VA_ARGS__, strlen(S))))

{

        con_puts(CON_URGENT, str, len);

        PHYSFSX_puts(f, str);

}

template <size_t len>

static void warning_puts_literal(PHYSFS_File *f, const char (&str)[len]) __attribute_nonnull();

template <size_t len>

static void warning_puts_literal(PHYSFS_File *f, const char (&str)[len])

{

        warning_puts(f, str, len);

}

static void warning_printf(PHYSFS_File *my_file, const char * format, ... ) __attribute_format_printf(2, 3);

static void warning_printf(PHYSFS_File *my_file, const char * format, ... )

#define warning_printf(A1,F,...)        dxx_call_printf_checked(warning_printf,warning_puts_literal,(A1),(F),##__VA_ARGS__)

{

        va_list args;

        char            message[256];

        va_start(args, format );

        vsnprintf(message,sizeof(message),format,args);

        va_end(args);

        warning_puts(my_file, message);

}

// ----------------------------------------------------------------------------

namespace dsx {

static void write_exit_text(fvcsegptridx &vcsegptridx, fvcwallptridx &vcwallptridx, PHYSFS_File *my_file)

{

        int     count;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Exit stuff\n");

        //      ---------- Find exit triggers ----------

        count=0;

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        auto &vctrgptridx = Triggers.vcptridx;

        range_for (const auto &&t, vctrgptridx)

        {

                if (trigger_is_exit(t))

                {

                        int     count2;

                        const auto i = t.get_unchecked_index();

                        PHYSFSX_printf(my_file, "Trigger %2i, is an exit trigger with %i links.\n", i, t->num_links);

                        count++;

                        if (t->num_links != 0)

                                err_printf(my_file, "Error: Exit triggers must have 0 links, this one has %i links.", t->num_links);

                        //      Find wall pointing to this trigger.

                        count2 = 0;

                        range_for (const auto &&w, vcwallptridx)

                        {

                                if (w->trigger == i)

                                {

                                        count2++;

                                        PHYSFSX_printf(my_file, "Exit trigger %i is in segment %i, on side %i, bound to wall %i\n", i, w->segnum, w->sidenum, static_cast<wallnum_t>(w));

                                }

                        }

                        if (count2 == 0)

                                err_printf(my_file, "Error: Trigger %i is not bound to any wall.", i);

                        else if (count2 > 1)

                                err_printf(my_file, "Error: Trigger %i is bound to %i walls.", i, count2);

                }

        }

        if (count == 0)

                err_printf(my_file, "Error: No exit trigger in this mine.");

        else if (count != 1)

                err_printf(my_file, "Error: More than one exit trigger in this mine.");

        else

                PHYSFSX_printf(my_file, "\n");

        //      ---------- Find exit doors ----------

        count = 0;

        range_for (const auto &&segp, vcsegptridx)

        {

                range_for (const auto &&es, enumerate(segp->children))

                {

                        if (es.value == segment_exit)

                        {

                                PHYSFSX_printf(my_file, "Segment %3hu, side %" PRIuFAST32 " is an exit door.\n", segp.get_unchecked_index(), es.idx);

                                count++;

                        }

                }

        }

        if (count == 0)

                err_printf(my_file, "Error: No external wall in this mine.");

        else if (count != 1) {

#if defined(DXX_BUILD_DESCENT_I)

                warning_printf(my_file, "Warning: %i external walls in this mine.", count);

                warning_printf(my_file, "(If %i are secret exits, then no problem.)", count-1);

#endif

        } else

                PHYSFSX_printf(my_file, "\n");

}

}

namespace {

class key_stat

{

        const char *const label;

        unsigned wall_count = 0, powerup_count = 0;

        segnum_t seg = segment_none;

        uint8_t side = 0;

public:

        key_stat(const char *const p) :

                label(p)

        {

        }

        void check_wall(const segment_array &segments, PHYSFS_File *const fp, const vcwallptridx_t wpi, const wall_key_t key)

        {

                auto &w = *wpi;

                if (!(w.keys & key))

                        return;

                PHYSFSX_printf(fp, "Wall %i (seg=%i, side=%i) is keyed to the %s key.\n", static_cast<wallnum_t>(wpi), w.segnum, w.sidenum, label);

                if (seg == segment_none)

                {

                        seg = w.segnum;

                        side = w.sidenum;

                }

                else

                {

                        const auto &&connect_side = find_connect_side(segments.vcptridx(w.segnum), segments.vcptr(seg));

                        if (connect_side == side)

                                return;

                        warning_printf(fp, "Warning: This door at seg %i, is different than the one at seg %i, side %i", w.segnum, seg, side);

                }

                ++wall_count;

        }

        void report_walls(PHYSFS_File *const fp) const

        {

                if (wall_count > 1)

                        warning_printf(fp, "Warning: %i doors are keyed to the %s key.", wall_count, label);

        }

        void found_powerup(const unsigned amount = 1)

        {

                powerup_count += amount;

        }

        void report_keys(PHYSFS_File *const fp) const

        {

                if (!powerup_count)

                {

                        if (wall_count)

                                err_printf(fp, "Error: There is a door keyed to the %s key, but no %s key!", label, label);

                }

                else if (powerup_count > 1)

                        err_printf(fp, "Error: There are %i %s keys!", powerup_count, label);

        }

};

}

// ----------------------------------------------------------------------------

static void write_key_text(fvcobjptridx &vcobjptridx, segment_array &segments, fvcwallptridx &vcwallptridx, PHYSFS_File *my_file)

{

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Key stuff:\n");

        key_stat blue("blue"), gold("gold"), red("red");

        range_for (const auto &&w, vcwallptridx)

        {

                blue.check_wall(segments, my_file, w, KEY_BLUE);

                gold.check_wall(segments, my_file, w, KEY_GOLD);

                red.check_wall(segments, my_file, w, KEY_RED);

        }

        blue.report_walls(my_file);

        gold.report_walls(my_file);

        red.report_walls(my_file);

        range_for (const auto &&objp, vcobjptridx)

        {

                if (objp->type == OBJ_POWERUP)

                {

                        const char *color;

                        const auto id = get_powerup_id(objp);

                        if (

                                (id == POW_KEY_BLUE && (blue.found_powerup(), color = "BLUE", true)) ||

                                (id == POW_KEY_RED && (red.found_powerup(), color = "RED", true)) ||

                                (id == POW_KEY_GOLD && (gold.found_powerup(), color = "GOLD", true))

                        )

                        {

                                PHYSFSX_printf(my_file, "The %s key is object %hu in segment %i\n", color, static_cast<objnum_t>(objp), objp->segnum);

                        }

                }

                if (const auto contains_count = objp->contains_count)

                {

                        if (objp->contains_type == OBJ_POWERUP)

                        {

                                const char *color;

                                const auto id = objp->contains_id;

                                if (

                                        (id == POW_KEY_BLUE && (blue.found_powerup(contains_count), color = "BLUE", true)) ||

                                        (id == POW_KEY_RED && (red.found_powerup(contains_count), color = "RED", true)) ||

                                        (id == POW_KEY_GOLD && (gold.found_powerup(contains_count), color = "GOLD", true))

                                )

                                        PHYSFSX_printf(my_file, "The %s key is contained in object %hu (a %s %s) in segment %hu\n", color, static_cast<objnum_t>(objp), object_types(objp), Robot_names[get_robot_id(objp)].data(), objp->segnum);

                        }

                }

        }

        blue.report_keys(my_file);

        gold.report_keys(my_file);

        red.report_keys(my_file);

}

// ----------------------------------------------------------------------------

static void write_control_center_text(fvcsegptridx &vcsegptridx, PHYSFS_File *my_file)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

        int     count, count2;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Control Center stuff:\n");

        count = 0;

        range_for (const auto &&segp, vcsegptridx)

        {

                if (segp->special == SEGMENT_IS_CONTROLCEN)

                {

                        count++;

                        PHYSFSX_printf(my_file, "Segment %3hu is a control center.\n", static_cast<uint16_t>(segp));

                        count2 = 0;

                        range_for (const object &objp, objects_in(segp, vcobjptridx, vcsegptr))

                        {

                                if (objp.type == OBJ_CNTRLCEN)

                                        count2++;

                        }

                        if (count2 == 0)

                                PHYSFSX_printf(my_file, "No control center object in control center segment.\n");

                        else if (count2 != 1)

                                PHYSFSX_printf(my_file, "%i control center objects in control center segment.\n", count2);

                }

        }

        if (count == 0)

                err_printf(my_file, "Error: No control center in this mine.");

        else if (count != 1)

                err_printf(my_file, "Error: More than one control center in this mine.");

}

// ----------------------------------------------------------------------------

static void write_fuelcen_text(PHYSFS_File *my_file)

{

        auto &Station = LevelUniqueFuelcenterState.Station;

        int     i;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Fuel Center stuff: (Note: This means fuel, repair, materialize, control centers!)\n");

        const auto Num_fuelcenters = LevelUniqueFuelcenterState.Num_fuelcenters;

        for (i=0; i<Num_fuelcenters; i++) {

                PHYSFSX_printf(my_file, "Fuelcenter %i: Type=%i (%s), segment = %3i\n", i, Station[i].Type, Special_names[Station[i].Type], Station[i].segnum);

                if (Segments[Station[i].segnum].special != Station[i].Type)

                        err_printf(my_file, "Error: Conflicting data: Segment %i has special type %i (%s), expected to be %i", Station[i].segnum, Segments[Station[i].segnum].special, Special_names[Segments[Station[i].segnum].special], Station[i].Type);

        }

}

// ----------------------------------------------------------------------------

static void write_segment_text(fvcsegptridx &vcsegptridx, PHYSFS_File *my_file)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Segment stuff:\n");

        range_for (const auto &&segp, vcsegptridx)

        {

                PHYSFSX_printf(my_file, "Segment %4hu:", static_cast<uint16_t>(segp));

                if (segp->special != 0)

                        PHYSFSX_printf(my_file, " special = %3i (%s), station_idx=%3i", segp->special, Special_names[segp->special], segp->station_idx);

                if (segp->matcen_num != -1)

                        PHYSFSX_printf(my_file, " matcen = %3i", segp->matcen_num);

                PHYSFSX_printf(my_file, "\n");

        }

        range_for (const auto &&segp, vcsegptridx)

        {

                int     depth;

                PHYSFSX_printf(my_file, "Segment %4hu: ", static_cast<uint16_t>(segp));

                depth=0;

                        PHYSFSX_printf(my_file, "Objects: ");

                range_for (const auto objp, objects_in(segp, vcobjptridx, vcsegptr))

                        {

                                short objnum = objp;

                                PHYSFSX_printf(my_file, "[%8s %8s %3i] ", object_types(objp), object_ids(objp), objnum);

                                if (depth++ > 30) {

                                        PHYSFSX_printf(my_file, "\nAborted after %i links\n", depth);

                                        break;

                                }

                        }

                PHYSFSX_printf(my_file, "\n");

        }

}

// ----------------------------------------------------------------------------

// This routine is bogus.  It assumes that all centers are matcens,

// which is not true.  The setting of segnum is bogus.

static void write_matcen_text(PHYSFS_File *my_file)

{

        int     i;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Materialization centers:\n");

        auto &RobotCenters = LevelSharedRobotcenterState.RobotCenters;

        auto &Station = LevelUniqueFuelcenterState.Station;

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        auto &vctrgptridx = Triggers.vcptridx;

        const auto Num_robot_centers = LevelSharedRobotcenterState.Num_robot_centers;

        for (i=0; i<Num_robot_centers; i++) {

                int     trigger_count=0, fuelcen_num;

                PHYSFSX_printf(my_file, "FuelCenter[%02i].Segment = %04i  ", i, Station[i].segnum);

                PHYSFSX_printf(my_file, "Segment[%04i].matcen_num = %02i  ", Station[i].segnum, Segments[Station[i].segnum].matcen_num);

                fuelcen_num = RobotCenters[i].fuelcen_num;

                if (Station[fuelcen_num].Type != SEGMENT_IS_ROBOTMAKER)

                        err_printf(my_file, "Error: Matcen %i corresponds to Station %i, which has type %i (%s).", i, fuelcen_num, Station[fuelcen_num].Type, Special_names[Station[fuelcen_num].Type]);

                auto segnum = Station[fuelcen_num].segnum;

                //      Find trigger for this materialization center.

                range_for (auto &&t, vctrgptridx)

                {

                        if (trigger_is_matcen(t))

                        {

                                range_for (auto &k, partial_const_range(t->seg, t->num_links))

                                        if (k == segnum)

                                        {

                                                PHYSFSX_printf(my_file, "Trigger = %2i  ", t.get_unchecked_index());

                                                trigger_count++;

                                        }

                        }

                }

                PHYSFSX_printf(my_file, "\n");

                if (trigger_count == 0)

                        err_printf(my_file, "Error: Matcen %i in segment %i has no trigger!", i, segnum);

        }

}

// ----------------------------------------------------------------------------

namespace dsx {

static void write_wall_text(fvcsegptridx &vcsegptridx, fvcwallptridx &vcwallptridx, PHYSFS_File *my_file)

{

        std::array<int8_t, MAX_WALLS> wall_flags;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Walls:\n");

#if defined(DXX_BUILD_DESCENT_II)

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

#endif

        range_for (auto &&wp, vcwallptridx)

        {

                auto &w = *wp;

                int     sidenum;

                const auto i = static_cast<wallnum_t>(wp);

                PHYSFSX_printf(my_file, "Wall %03i: seg=%3i, side=%2i, linked_wall=%3i, type=%s, flags=%4x, hps=%3i, trigger=%2i, clip_num=%2i, keys=%2i, state=%i\n", i,

                        w.segnum, w.sidenum, w.linked_wall, Wall_names[w.type], w.flags, w.hps >> 16, w.trigger, w.clip_num, w.keys, w.state);

#if defined(DXX_BUILD_DESCENT_II)

                if (w.trigger >= Triggers.get_count())

                        PHYSFSX_printf(my_file, "Wall %03d points to invalid trigger %d\n",i,w.trigger);

#endif

                auto segnum = w.segnum;

                sidenum = w.sidenum;

                if (Segments[segnum].shared_segment::sides[sidenum].wall_num != wp)

                        err_printf(my_file, "Error: Wall %u points at segment %i, side %i, but that segment doesn't point back (it's wall_num = %hi)", i, segnum, sidenum, static_cast<int16_t>(Segments[segnum].shared_segment::sides[sidenum].wall_num));

        }

        wall_flags = {};

        range_for (const auto &&segp, vcsegptridx)

        {

                range_for (const auto &&es, enumerate(segp->shared_segment::sides))

                {

                        const auto sidep = &es.value;

                        if (sidep->wall_num != wall_none)

                        {

                                if (wall_flags[sidep->wall_num])

                                        err_printf(my_file, "Error: Wall %hu appears in two or more segments, including segment %hu, side %" PRIuFAST32 ".", static_cast<int16_t>(sidep->wall_num), static_cast<segnum_t>(segp), es.idx);

                                else

                                        wall_flags[sidep->wall_num] = 1;

                        }

                }

        }

}

}

// ----------------------------------------------------------------------------

namespace dsx {

static void write_player_text(fvcobjptridx &vcobjptridx, PHYSFS_File *my_file)

{

        int     num_players=0;

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Players:\n");

        range_for (const auto &&objp, vcobjptridx)

        {

                if (objp->type == OBJ_PLAYER)

                {

                        num_players++;

                        PHYSFSX_printf(my_file, "Player %2i is object #%3hu in segment #%3i.\n", get_player_id(objp), static_cast<uint16_t>(objp), objp->segnum);

                }

        }

#if defined(DXX_BUILD_DESCENT_II)

        if (num_players != MAX_PLAYERS)

                err_printf(my_file, "Error: %i player objects.  %i are required.", num_players, MAX_PLAYERS);

#endif

        if (num_players > MAX_MULTI_PLAYERS)

                err_printf(my_file, "Error: %i player objects.  %i are required.", num_players, MAX_PLAYERS);

}

}

// ----------------------------------------------------------------------------

namespace dsx {

static void write_trigger_text(PHYSFS_File *my_file)

{

        PHYSFSX_printf(my_file, "-----------------------------------------------------------------------------\n");

        PHYSFSX_printf(my_file, "Triggers:\n");

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        auto &vctrgptridx = Triggers.vcptridx;

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vcwallptr = Walls.vcptr;

        range_for (auto &&t, vctrgptridx)

        {

                const auto i = static_cast<trgnum_t>(t);

#if defined(DXX_BUILD_DESCENT_I)

                PHYSFSX_printf(my_file, "Trigger %03i: flags=%04x, value=%08x, time=%8x, num_links=%i ", i, t->flags, static_cast<unsigned>(t->value), 0, t->num_links);

#elif defined(DXX_BUILD_DESCENT_II)

                PHYSFSX_printf(my_file, "Trigger %03i: type=%02x flags=%04x, value=%08x, time=%8x, num_links=%i ", i,

                        static_cast<uint8_t>(t->type), static_cast<uint8_t>(t->flags), t->value, 0, t->num_links);

#endif

                for (unsigned j = 0; j < t->num_links; ++j)

                        PHYSFSX_printf(my_file, "[%03i:%i] ", t->seg[j], t->side[j]);

                //      Find which wall this trigger is connected to.

                const auto &&we = vcwallptr.end();

                const auto &&wi = std::find_if(vcwallptr.begin(), we, [i](const wall *const p) { return p->trigger == i; });

                if (wi == we)

                        err_printf(my_file, "Error: Trigger %i is not connected to any wall, so it can never be triggered.", i);

                else

                {

                        const auto &&w = *wi;

                        PHYSFSX_printf(my_file, "Attached to seg:side = %i:%i, wall %hi\n", w->segnum, w->sidenum, static_cast<int16_t>(vcsegptr(w->segnum)->shared_segment::sides[w->sidenum].wall_num));

                }

        }

}

}

// ----------------------------------------------------------------------------

void write_game_text_file(const char *filename)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

        char    my_filename[128];

        int     namelen;

        Errors_in_mine = 0;

        namelen = strlen(filename);

        Assert (namelen > 4);

        Assert (filename[namelen-4] == '.');

        strcpy(my_filename, filename);

        strcpy( &my_filename[namelen-4], ".txm");

        auto my_file = PHYSFSX_openWriteBuffered(my_filename);

        if (!my_file)   {

                gr_palette_load(gr_palette);

                nm_messagebox( NULL, 1, "Ok", "ERROR: Unable to open %s\nErrno = %i", my_filename, errno);

                return;

        }

        dump_used_textures_level(my_file, 0, filename);

        say_totals(vcobjptridx, my_file, filename);

        PHYSFSX_printf(my_file, "\nNumber of segments:   %4i\n", Highest_segment_index+1);

        PHYSFSX_printf(my_file, "Number of objects:    %4i\n", Highest_object_index+1);

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vcwallptridx = Walls.vcptridx;

        PHYSFSX_printf(my_file, "Number of walls:      %4i\n", Walls.get_count());

        auto &ActiveDoors = LevelUniqueWallSubsystemState.ActiveDoors;

        PHYSFSX_printf(my_file, "Number of open doors: %4i\n", ActiveDoors.get_count());

        {

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        PHYSFSX_printf(my_file, "Number of triggers:   %4i\n", Triggers.get_count());

        }

        PHYSFSX_printf(my_file, "Number of matcens:    %4i\n", LevelSharedRobotcenterState.Num_robot_centers);

        PHYSFSX_printf(my_file, "\n");

        write_segment_text(vcsegptridx, my_file);

        write_fuelcen_text(my_file);

        write_matcen_text(my_file);

        write_player_text(vcobjptridx, my_file);

        write_wall_text(vcsegptridx, vcwallptridx, my_file);

        write_trigger_text(my_file);

        write_exit_text(vcsegptridx, vcwallptridx, my_file);

        //      ---------- Find control center segment ----------

        write_control_center_text(vcsegptridx, my_file);

        //      ---------- Show keyed walls ----------

        write_key_text(vcobjptridx, Segments, vcwallptridx, my_file);

}

#if defined(DXX_BUILD_DESCENT_II)

//      Adam: Change NUM_ADAM_LEVELS to the number of levels.

#define NUM_ADAM_LEVELS 30

//      Adam: Stick the names here.

constexpr char Adam_level_names[NUM_ADAM_LEVELS][13] = {

        "D2LEVA-1.LVL",

        "D2LEVA-2.LVL",

        "D2LEVA-3.LVL",

        "D2LEVA-4.LVL",

        "D2LEVA-S.LVL",

        "D2LEVB-1.LVL",

        "D2LEVB-2.LVL",

        "D2LEVB-3.LVL",

        "D2LEVB-4.LVL",

        "D2LEVB-S.LVL",

        "D2LEVC-1.LVL",

        "D2LEVC-2.LVL",

        "D2LEVC-3.LVL",

        "D2LEVC-4.LVL",

        "D2LEVC-S.LVL",

        "D2LEVD-1.LVL",

        "D2LEVD-2.LVL",

        "D2LEVD-3.LVL",

        "D2LEVD-4.LVL",

        "D2LEVD-S.LVL",

        "D2LEVE-1.LVL",

        "D2LEVE-2.LVL",

        "D2LEVE-3.LVL",

        "D2LEVE-4.LVL",

        "D2LEVE-S.LVL",

        "D2LEVF-1.LVL",

        "D2LEVF-2.LVL",

        "D2LEVF-3.LVL",

        "D2LEVF-4.LVL",

        "D2LEVF-S.LVL",

};

static int Ignore_tmap_num2_error;

#endif

// ----------------------------------------------------------------------------

namespace dsx {

#if defined(DXX_BUILD_DESCENT_I)

#define determine_used_textures_level(LevelSharedDestructibleLightState,load_level_flag,shareware_flag,level_num,tmap_buf,wall_buffer_type,level_tmap_buf,max_tmap)     determine_used_textures_level(load_level_flag,shareware_flag,level_num,tmap_buf,wall_buffer_type,level_tmap_buf,max_tmap)

#endif

static void determine_used_textures_level(d_level_shared_destructible_light_state &LevelSharedDestructibleLightState, int load_level_flag, int shareware_flag, int level_num, perm_tmap_buffer_type &tmap_buf, wall_buffer_type &wall_buf, level_tmap_buffer_type &level_tmap_buf, int max_tmap)

{

#if defined(DXX_BUILD_DESCENT_II)

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptr = Objects.vcptr;

#endif

        int     j;

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &WallAnims = GameSharedState.WallAnims;

#if defined(DXX_BUILD_DESCENT_I)

        tmap_buf = {};