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.

*/

/*

 *

 * Routines for EndGame, EndLevel, etc.

 *

 */

#include "dxxsconf.h"

#include <cctype>

#include <utility>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if !defined(_MSC_VER) && !defined(macintosh)

#include <unistd.h>

#endif

#include <time.h>

#if DXX_USE_OGL

#include "ogl_init.h"

#endif

#include "inferno.h"

#include "game.h"

#include "player.h"

#include "key.h"

#include "object.h"

#include "physics.h"

#include "dxxerror.h"

#include "joy.h"

#include "iff.h"

#include "pcx.h"

#include "timer.h"

#include "render.h"

#include "laser.h"

#include "event.h"

#include "screens.h"

#include "textures.h"

#include "slew.h"

#include "gauges.h"

#include "texmap.h"

#include "3d.h"

#include "effects.h"

#include "menu.h"

#include "gameseg.h"

#include "wall.h"

#include "ai.h"

#include "fuelcen.h"

#include "switch.h"

#include "digi.h"

#include "gamesave.h"

#include "scores.h"

#include "u_mem.h"

#include "palette.h"

#include "morph.h"

#include "lighting.h"

#include "newdemo.h"

#include "titles.h"

#include "collide.h"

#include "weapon.h"

#include "sounds.h"

#include "args.h"

#include "gameseq.h"

#include "gamefont.h"

#include "newmenu.h"

#include "hudmsg.h"

#include "endlevel.h"

#include "kmatrix.h"

#  include "multi.h"

#include "playsave.h"

#include "fireball.h"

#include "kconfig.h"

#include "config.h"

#include "robot.h"

#include "automap.h"

#include "cntrlcen.h"

#include "powerup.h"

#include "text.h"

#include "piggy.h"

#include "texmerge.h"

#include "paging.h"

#include "mission.h"

#include "state.h"

#include "songs.h"

#include "gamepal.h"

#include "controls.h"

#include "credits.h"

#include "gamemine.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#endif

#include "strutil.h"

#include "rle.h"

#include "segment.h"

#include "gameseg.h"

#include "fmtcheck.h"

#include "compiler-range_for.h"

#include "d_enumerate.h"

#include "partial_range.h"

#include "d_range.h"

#include "d_zip.h"

#if defined(DXX_BUILD_DESCENT_I)

#include "custom.h"

#define GLITZ_BACKGROUND        Menu_pcx_name

#elif defined(DXX_BUILD_DESCENT_II)

#include "movie.h"

#define GLITZ_BACKGROUND        STARS_BACKGROUND

namespace dsx {

static void StartNewLevelSecret(int level_num, int page_in_textures);

static void InitPlayerPosition(fvmobjptridx &vmobjptridx, fvmsegptridx &vmsegptridx, int random_flag);

static void DoEndGame();

static void filter_objects_from_level(fvmobjptr &vmobjptr);

PHYSFSX_gets_line_t<FILENAME_LEN> Current_level_palette;

int     First_secret_visit = 1;

}

#endif

namespace {

class preserve_player_object_info

{

        player_info plr_info;

        fix plr_shields;

        /* Cache the reference, not the value.  This class is designed

         * to be alive across a call to LoadLevel, which may change the

         * value of the object number.

         */

        const objnum_t &objnum;

public:

        preserve_player_object_info(fvcobjptr &vcobjptr, const objnum_t &o) :

                objnum(o)

        {

                auto &plr = *vcobjptr(objnum);

                plr_shields = plr.shields;

                plr_info = plr.ctype.player_info;

        }

        void restore(fvmobjptr &vmobjptr) const

        {

                auto &plr = *vmobjptr(objnum);

                plr.shields = plr_shields;

                plr.ctype.player_info = plr_info;

        }

};

}

namespace dsx {

static void init_player_stats_ship(object &, fix GameTime64);

static window_event_result AdvanceLevel(int secret_flag);

static void StartLevel(int random_flag);

static void copy_defaults_to_robot_all(void);

}

namespace dcx {

//Current_level_num starts at 1 for the first level

//-1,-2,-3 are secret levels

//0 used to mean not a real level loaded (i.e. editor generated level), but this hack has been removed

int     Current_level_num=1,Next_level_num;

PHYSFSX_gets_line_t<LEVEL_NAME_LEN> Current_level_name;

// Global variables describing the player

unsigned        N_players=1;    // Number of players ( >1 means a net game, eh?)

playernum_t Player_num; // The player number who is on the console.

fix StartingShields=INITIAL_SHIELDS;

std::array<obj_position, MAX_PLAYERS> Player_init;

// Global variables telling what sort of game we have

unsigned NumNetPlayerPositions;

int     Do_appearance_effect=0;

template <object_type_t type>

static bool is_object_of_type(const object_base &o)

{

        return o.type == type;

}

static unsigned get_starting_concussion_missile_count()

{

        return 2 + NDL - GameUniqueState.Difficulty_level;

}

}

namespace dsx {

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

static void verify_console_object()

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        Assert(Player_num < Players.size());

        const auto &&console = vmobjptr(get_local_player().objnum);

        ConsoleObject = console;

        Assert(console->type == OBJ_PLAYER);

        Assert(get_player_id(console) == Player_num);

}

template <object_type_t type>

static unsigned count_number_of_objects_of_type(fvcobjptr &vcobjptr)

{

        return std::count_if(vcobjptr.begin(), vcobjptr.end(), is_object_of_type<type>);

}

#define count_number_of_robots  count_number_of_objects_of_type<OBJ_ROBOT>

#define count_number_of_hostages        count_number_of_objects_of_type<OBJ_HOSTAGE>

static bool operator!=(const vms_vector &a, const vms_vector &b)

{

        return a.x != b.x || a.y != b.y || a.z != b.z;

}

static unsigned generate_extra_starts_by_displacement_within_segment(const unsigned preplaced_starts, const unsigned total_required_num_starts)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcobjptr = Objects.vcptr;

        auto &vmobjptr = Objects.vmptr;

        std::array<uint8_t, MAX_PLAYERS> player_init_segment_capacity_flag{};

        DXX_MAKE_VAR_UNDEFINED(player_init_segment_capacity_flag);

        static_assert(WRIGHT + 1 == WBOTTOM, "side ordering error");

        static_assert(WBOTTOM + 1 == WBACK, "side ordering error");

        constexpr uint8_t capacity_x = 1 << WRIGHT;

        constexpr uint8_t capacity_y = 1 << WBOTTOM;

        constexpr uint8_t capacity_z = 1 << WBACK;

        /* When players are displaced, they are moved by their size

         * multiplied by this constant.  Larger values provide more

         * separation between the player starts, but increase the chance

         * that the player will be too close to a wall or that the segment

         * will be deemed too small to support displacement.

         */

        constexpr fix size_scalar = 0x18000;    // 1.5 in fixed point

        unsigned segments_with_spare_capacity = 0;

        auto &vcvertptr = Vertices.vcptr;

        for (unsigned i = 0; i < preplaced_starts; ++i)

        {

                /* For each existing Player_init, compute whether the segment is

                 * large enough in each dimension to support adding more ships.

                 */

                const auto &pi = Player_init[i];

                const auto segnum = pi.segnum;

                const shared_segment &seg = *vcsegptr(segnum);

                auto &plr = *Players.vcptr(i);

                auto &old_player_obj = *vcobjptr(plr.objnum);

                const vm_distance_squared size2(fixmul64(old_player_obj.size * old_player_obj.size, size_scalar));

                auto &v0 = *vcvertptr(seg.verts[0]);

                uint8_t capacity_flag = 0;

                if (vm_vec_dist2(v0, vcvertptr(seg.verts[1])) > size2)

                        capacity_flag |= capacity_x;

                if (vm_vec_dist2(v0, vcvertptr(seg.verts[3])) > size2)

                        capacity_flag |= capacity_y;

                if (vm_vec_dist2(v0, vcvertptr(seg.verts[4])) > size2)

                        capacity_flag |= capacity_z;

                player_init_segment_capacity_flag[i] = capacity_flag;

                con_printf(CON_NORMAL, "Original player %u has size %u, starts in segment #%hu, and has segment capacity flags %x.", i, old_player_obj.size, static_cast<segnum_t>(segnum), capacity_flag);

                if (capacity_flag)

                        ++segments_with_spare_capacity;

        }

        if (!segments_with_spare_capacity)

                return preplaced_starts;

        unsigned k = preplaced_starts;

        for (unsigned old_player_idx = -1, side = WRIGHT; ++ old_player_idx != preplaced_starts || (old_player_idx = 0, side ++ != WBACK);)

        {

                auto &old_player_ref = *Players.vcptr(old_player_idx);

                const auto &&old_player_ptridx = Objects.vcptridx(old_player_ref.objnum);

                auto &old_player_obj = *old_player_ptridx;

                if (player_init_segment_capacity_flag[old_player_idx] & (1 << side))

                {

                        auto &&segp = vmsegptridx(old_player_obj.segnum);

                        /* Copy the start exactly.  The next loop will fix the

                         * collisions caused by placing the clone on top of the

                         * original.

                         *

                         * Currently, there is no handling for the case that the

                         * level author already put two players too close together.

                         * If this is a problem, more logic can be added to suppress

                         * cloning in that case.

                         */

                        const auto &&extra_player_ptridx = obj_create_copy(old_player_obj, segp);

                        if (extra_player_ptridx == object_none)

                        {

                                con_printf(CON_URGENT, "%s:%u: warning: failed to copy start object %hu", __FILE__, __LINE__, old_player_ptridx.get_unchecked_index());

                                continue;

                        }

                        Players.vmptr(k)->objnum = extra_player_ptridx;

                        auto &extra_player_obj = *extra_player_ptridx;

                        set_player_id(extra_player_obj, k);

                        con_printf(CON_NORMAL, "Copied player %u (object %hu at {%i, %i, %i}) to create player %u (object %hu).", old_player_idx, old_player_ptridx.get_unchecked_index(), old_player_obj.pos.x, old_player_obj.pos.y, old_player_obj.pos.z, k, extra_player_ptridx.get_unchecked_index());

                        if (++ k >= total_required_num_starts)

                                break;

                }

        }

        for (unsigned old_player_idx = 0; old_player_idx < preplaced_starts; ++old_player_idx)

        {

                auto &old_player_init = Player_init[old_player_idx];

                const auto old_player_pos = old_player_init.pos;

                auto &old_player_obj = *vmobjptr(Players.vcptr(old_player_idx)->objnum);

                std::array<vms_vector, 3> vec_displacement{};

                DXX_MAKE_VAR_UNDEFINED(vec_displacement);

                const shared_segment &seg = *vcsegptr(old_player_init.segnum);

                /* For each of [right, bottom, back], compute the vector between

                 * the center of that side and the reference player's start

                 * point.  This will be used in the next loop.

                 */

                for (unsigned side = WRIGHT; side != WBACK + 1; ++side)

                {

                        const auto &&center_on_side = compute_center_point_on_side(vcvertptr, seg, side);

                        const auto &&vec_pos_to_center_on_side = vm_vec_sub(center_on_side, old_player_init.pos);

                        const unsigned idxside = side - WRIGHT;

                        assert(idxside < vec_displacement.size());

                        vec_displacement[idxside] = vec_pos_to_center_on_side;

                }

                const auto displace_player = [&](const unsigned plridx, object_base &plrobj, const unsigned displacement_direction) {

                        vms_vector disp{};

                        unsigned dimensions = 0;

                        for (unsigned i = 0, side = WRIGHT; side != WBACK + 1; ++side, ++i)

                        {

                                if (!(player_init_segment_capacity_flag[old_player_idx] & (1 << side)))

                                {

                                        con_printf(CON_NORMAL, "Cannot displace player %u at {%i, %i, %i}: not enough room in dimension %u.", plridx, plrobj.pos.x, plrobj.pos.y, plrobj.pos.z, side);

                                        continue;

                                }

                                const auto &v = vec_displacement[i];

                                const auto &va = (displacement_direction & (1 << i)) ? v : vm_vec_negated(v);

                                con_printf(CON_NORMAL, "Add displacement of {%i, %i, %i} for dimension %u for player %u.", va.x, va.y, va.z, side, plridx);

                                ++ dimensions;

                                vm_vec_add2(disp, va);

                        }

                        if (!dimensions)

                                return;

                        vm_vec_normalize(disp);

                        vm_vec_scale(disp, fixmul(old_player_obj.size, size_scalar >> 1));

                        const auto target_position = vm_vec_add(Player_init[plridx].pos, disp);

                        if (const auto sidemask = get_seg_masks(vcvertptr, target_position, vcsegptr(plrobj.segnum), 1).sidemask)

                        {

                                con_printf(CON_NORMAL, "Cannot displace player %u at {%i, %i, %i} to {%i, %i, %i}: would be outside segment for sides %x.", plridx, plrobj.pos.x, plrobj.pos.y, plrobj.pos.z, target_position.x, target_position.y, target_position.z, sidemask);

                                return;

                        }

                        con_printf(CON_NORMAL, "Displace player %u at {%i, %i, %i} by {%i, %i, %i} to {%i, %i, %i}.", plridx, plrobj.pos.x, plrobj.pos.y, plrobj.pos.z, disp.x, disp.y, disp.z, target_position.x, target_position.y, target_position.z);

                        Player_init[plridx].pos = target_position;

                        plrobj.pos = Player_init[plridx].pos;

                };

                for (unsigned extra_player_idx = preplaced_starts, displacements = 0; extra_player_idx < k; ++extra_player_idx)

                {

                        auto &extra_player_obj = *vmobjptr(Players.vcptr(extra_player_idx)->objnum);

                        if (old_player_pos != extra_player_obj.pos)

                                /* This clone is associated with some other player.

                                 * Skip it here.  It will be handled in a different pass

                                 * of the loop.

                                 */

                                continue;

                        auto &extra_player_init = Player_init[extra_player_idx];

                        extra_player_init = old_player_init;

                        if (!displacements++)

                                displace_player(old_player_idx, old_player_obj, 0);

                        displace_player(extra_player_idx, extra_player_obj, displacements);

                }

        }

        return k;

}

//added 10/12/95: delete buddy bot if coop game.  Probably doesn't really belong here. -MT

static void gameseq_init_network_players(object_array &Objects)

{

        // Initialize network player start locations and object numbers

        ConsoleObject = &Objects.front();

        unsigned j = 0, k = 0;

        const auto multiplayer_coop = Game_mode & GM_MULTI_COOP;

#if defined(DXX_BUILD_DESCENT_II)

        const auto remove_thief = Netgame.ThiefModifierFlags & ThiefModifier::Absent;

        const auto multiplayer = Game_mode & GM_MULTI;

        const auto retain_guidebot = Netgame.AllowGuidebot;

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

#endif

        auto &vmobjptridx = Objects.vmptridx;

        range_for (const auto &&o, vmobjptridx)

        {

                const auto type = o->type;

                if (type == OBJ_PLAYER || type == OBJ_GHOST || type == OBJ_COOP)

                {

                        if (likely(k < Player_init.size()) &&

                                multiplayer_coop

                                ? (j == 0 || type == OBJ_COOP)

                                : (type == OBJ_PLAYER || type == OBJ_GHOST)

                        )

                        {

                                o->type=OBJ_PLAYER;

                                auto &pi = Player_init[k];

                                pi.pos = o->pos;

                                pi.orient = o->orient;

                                pi.segnum = o->segnum;

                                vmplayerptr(k)->objnum = o;

                                set_player_id(o, k);

                                k++;

                        }

                        else

                                obj_delete(LevelUniqueObjectState, Segments, o);

                        j++;

                }

#if defined(DXX_BUILD_DESCENT_II)

                else if (type == OBJ_ROBOT && multiplayer)

                {

                        auto &ri = Robot_info[get_robot_id(o)];

                        if ((!retain_guidebot && robot_is_companion(ri)) ||

                                (remove_thief && robot_is_thief(ri)))

                        {

                                object_create_robot_egg(o);

                                obj_delete(LevelUniqueObjectState, Segments, o);                //kill the buddy in netgames

                        }

                }

#endif

        }

        if (multiplayer_coop)

        {

        const unsigned total_required_num_starts = Netgame.max_numplayers;

        if (k < total_required_num_starts)

        {

                con_printf(CON_NORMAL, "Insufficient cooperative starts found in mission \"%s\" level %u (need %u, found %u).  Generating extra starts...", Current_mission->path.c_str(), Current_level_num, total_required_num_starts, k);

                /*

                 * First, try displacing the starts within the existing segment.

                 */

                const unsigned preplaced_starts = k;

                k = generate_extra_starts_by_displacement_within_segment(preplaced_starts, total_required_num_starts);

                con_printf(CON_NORMAL, "Generated %u starts by displacement within the original segment.", k - preplaced_starts);

        }

        else

                con_printf(CON_NORMAL, "Found %u cooperative starts in mission \"%s\" level %u.", k, Current_mission->path.c_str(), Current_level_num);

        }

        NumNetPlayerPositions = k;

}

void gameseq_remove_unused_players()

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        // 'Remove' the unused players

        if (Game_mode & GM_MULTI)

        {

                for (unsigned i = 0; i < NumNetPlayerPositions; ++i)

                {

                        if ((!vcplayerptr(i)->connected) || (i >= N_players))

                        {

                                multi_make_player_ghost(i);

                        }

                }

        }

        else

        {               // Note link to above if!!!

                range_for (auto &i, partial_const_range(Players, 1u, NumNetPlayerPositions))

                {

                        obj_delete(LevelUniqueObjectState, Segments, vmobjptridx(i.objnum));

                }

#if defined(DXX_BUILD_DESCENT_II)

                auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

                if (PlayerCfg.ThiefModifierFlags & ThiefModifier::Absent)

                {

                        range_for (const auto &&o, vmobjptridx)

                        {

                                const auto type = o->type;

                                if (type == OBJ_ROBOT)

                                {

                                        auto &ri = Robot_info[get_robot_id(o)];

                                        if (robot_is_thief(ri))

                                        {

                                                object_create_robot_egg(o);

                                                obj_delete(LevelUniqueObjectState, Segments, o);

                                        }

                                }

                        }

                }

#endif

        }

}

// Setup player for new game

void init_player_stats_game(const playernum_t pnum)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        auto &plr = *vmplayerptr(pnum);

        plr.lives = INITIAL_LIVES;

        plr.level = 1;

        plr.time_level = 0;

        plr.time_total = 0;

        plr.hours_level = 0;

        plr.hours_total = 0;

        plr.num_kills_level = 0;

        plr.num_kills_total = 0;

        const auto &&plobj = vmobjptr(plr.objnum);

        auto &player_info = plobj->ctype.player_info;

        player_info.powerup_flags = {};

        player_info.net_killed_total = 0;

        player_info.net_kills_total = 0;

        player_info.KillGoalCount = 0;

        player_info.mission.score = 0;

        player_info.mission.last_score = 0;

        player_info.mission.hostages_rescued_total = 0;

        init_player_stats_new_ship(pnum);

#if defined(DXX_BUILD_DESCENT_II)

        if (pnum == Player_num)

                First_secret_visit = 1;

#endif

}

static void init_ammo_and_energy(object &plrobj)

{

        auto &player_info = plrobj.ctype.player_info;

        {

                auto &energy = player_info.energy;

#if defined(DXX_BUILD_DESCENT_II)

                if (player_info.primary_weapon_flags & HAS_PRIMARY_FLAG(OMEGA_INDEX))

                {

                        const auto old_omega_charge = player_info.Omega_charge;

                        if (old_omega_charge < MAX_OMEGA_CHARGE)

                        {

                                const auto energy_used = get_omega_energy_consumption((player_info.Omega_charge = MAX_OMEGA_CHARGE) - old_omega_charge);

                                energy -= energy_used;

                        }

                }

#endif

                if (energy < INITIAL_ENERGY)

                        energy = INITIAL_ENERGY;

        }

        {

                auto &shields = plrobj.shields;

                if (shields < StartingShields)

                        shields = StartingShields;

        }

        const unsigned minimum_missiles = get_starting_concussion_missile_count();

        auto &concussion = player_info.secondary_ammo[CONCUSSION_INDEX];

        if (concussion < minimum_missiles)

                concussion = minimum_missiles;

}

#if defined(DXX_BUILD_DESCENT_II)

extern  ubyte   Last_afterburner_state;

#endif

// Setup player for new level (After completion of previous level)

static void init_player_stats_level(player &plr, object &plrobj, const secret_restore secret_flag)

{

#if defined(DXX_BUILD_DESCENT_II)

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

#endif

        plr.level = Current_level_num;

        if (!Network_rejoined) {

                plr.time_level = 0;

                plr.hours_level = 0;

        }

        auto &player_info = plrobj.ctype.player_info;

        player_info.mission.last_score = player_info.mission.score;

        plr.num_kills_level = 0;

        if (secret_flag == secret_restore::none) {

                init_ammo_and_energy(plrobj);

                auto &powerup_flags = player_info.powerup_flags;

                powerup_flags &= ~(PLAYER_FLAGS_INVULNERABLE | PLAYER_FLAGS_CLOAKED);

#if defined(DXX_BUILD_DESCENT_II)

                powerup_flags &= ~(PLAYER_FLAGS_MAP_ALL);

#endif

                DXX_MAKE_VAR_UNDEFINED(player_info.cloak_time);

                DXX_MAKE_VAR_UNDEFINED(player_info.invulnerable_time);

                const auto all_keys = PLAYER_FLAGS_BLUE_KEY | PLAYER_FLAGS_GOLD_KEY | PLAYER_FLAGS_RED_KEY;

                if ((Game_mode & GM_MULTI) && !(Game_mode & GM_MULTI_COOP))

                        powerup_flags |= all_keys;

                else

                        powerup_flags &= ~all_keys;

        }

        Player_dead_state = player_dead_state::no; // Added by RH

        Dead_player_camera = NULL;

#if defined(DXX_BUILD_DESCENT_II)

        Controls.state.afterburner = 0;

        Last_afterburner_state = 0;

        digi_kill_sound_linked_to_object(vcobjptridx(plr.objnum));

#endif

        init_gauges();

#if defined(DXX_BUILD_DESCENT_II)

        Missile_viewer = NULL;

#endif

        init_player_stats_ship(plrobj, GameTime64);

}

// Setup player for a brand-new ship

void init_player_stats_new_ship(const playernum_t pnum)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        auto &plr = *vcplayerptr(pnum);

        const auto &&plrobj = vmobjptridx(plr.objnum);

        plrobj->shields = StartingShields;

        auto &player_info = plrobj->ctype.player_info;

        player_info.energy = INITIAL_ENERGY;

        player_info.secondary_ammo = {{

                static_cast<uint8_t>(get_starting_concussion_missile_count())

        }};

        const auto GrantedItems = (Game_mode & GM_MULTI) ? Netgame.SpawnGrantedItems : 0;

        player_info.vulcan_ammo = map_granted_flags_to_vulcan_ammo(GrantedItems);

        const auto granted_laser_level = map_granted_flags_to_laser_level(GrantedItems);

        player_info.laser_level = granted_laser_level;

        const auto granted_primary_weapon_flags = HAS_LASER_FLAG | map_granted_flags_to_primary_weapon_flags(GrantedItems);

        player_info.primary_weapon_flags = granted_primary_weapon_flags;

        player_info.powerup_flags &= ~(PLAYER_FLAGS_QUAD_LASERS | PLAYER_FLAGS_CLOAKED | PLAYER_FLAGS_INVULNERABLE);

#if defined(DXX_BUILD_DESCENT_II)

        player_info.powerup_flags &= ~(PLAYER_FLAGS_AFTERBURNER | PLAYER_FLAGS_MAP_ALL | PLAYER_FLAGS_CONVERTER | PLAYER_FLAGS_AMMO_RACK | PLAYER_FLAGS_HEADLIGHT | PLAYER_FLAGS_HEADLIGHT_ON | PLAYER_FLAGS_FLAG);

        player_info.Omega_charge = (granted_primary_weapon_flags & HAS_OMEGA_FLAG)

                ? MAX_OMEGA_CHARGE

                : 0;

        player_info.Omega_recharge_delay = 0;

#endif

        player_info.powerup_flags |= map_granted_flags_to_player_flags(GrantedItems);

        DXX_MAKE_VAR_UNDEFINED(player_info.cloak_time);

        DXX_MAKE_VAR_UNDEFINED(player_info.invulnerable_time);

        if (pnum == Player_num)

        {

                if (Game_mode & GM_MULTI && Netgame.InvulAppear)

                {

                        player_info.powerup_flags |= PLAYER_FLAGS_INVULNERABLE;

                        player_info.invulnerable_time = GameTime64 - (i2f(58 - Netgame.InvulAppear) >> 1);

                        player_info.FakingInvul = 1;

                }

                set_primary_weapon(player_info, [=]{

                        range_for (auto i, PlayerCfg.PrimaryOrder)

                        {

                                if (i >= MAX_PRIMARY_WEAPONS)

                                        break;

                                if (i == primary_weapon_index_t::LASER_INDEX)

                                        break;

#if defined(DXX_BUILD_DESCENT_II)

                                if (i == primary_weapon_index_t::SUPER_LASER_INDEX)

                                {

                                        if (granted_laser_level <= LASER_LEVEL_4)

                                                /* Granted lasers are not super lasers */

                                                continue;

                                        /* Super lasers still set LASER_INDEX, not

                                         * SUPER_LASER_INDEX

                                         */

                                        break;

                                }

#endif

                                if (HAS_PRIMARY_FLAG(i) & static_cast<unsigned>(granted_primary_weapon_flags))

                                        return static_cast<primary_weapon_index_t>(i);

                        }

                        return primary_weapon_index_t::LASER_INDEX;

                }());

#if defined(DXX_BUILD_DESCENT_II)

                auto primary_last_was_super = player_info.Primary_last_was_super;

                for (uint_fast32_t i = primary_weapon_index_t::VULCAN_INDEX, mask = 1 << i; i != primary_weapon_index_t::SUPER_LASER_INDEX; ++i, mask <<= 1)

                {

                        /* If no super granted, force to non-super. */

                        if (!(HAS_PRIMARY_FLAG(i + 5) & granted_primary_weapon_flags))

                                primary_last_was_super &= ~mask;

                        /* If only super granted, force to super. */

                        else if (!(HAS_PRIMARY_FLAG(i) & granted_primary_weapon_flags))

                                primary_last_was_super |= mask;

                        /* else both granted, so leave as-is. */

                        else

                                continue;

                }

                player_info.Primary_last_was_super = primary_last_was_super;

#endif

                if (Newdemo_state == ND_STATE_RECORDING)

                {

                        newdemo_record_laser_level(player_info.laser_level, 0);

                }

                set_secondary_weapon_to_concussion(player_info);

                dead_player_end(); //player no longer dead

                Player_dead_state = player_dead_state::no;

                player_info.Player_eggs_dropped = false;

                Dead_player_camera = 0;

#if defined(DXX_BUILD_DESCENT_II)

                auto &Secondary_last_was_super = player_info.Secondary_last_was_super;

                Secondary_last_was_super = {};

                Afterburner_charge = GrantedItems.has_afterburner() ? F1_0 : 0;

                Controls.state.afterburner = 0;

                Last_afterburner_state = 0;

                Missile_viewer = nullptr; //reset missile camera if out there

#endif

                init_ai_for_ship();

        }

        digi_kill_sound_linked_to_object(plrobj);

        init_player_stats_ship(plrobj, GameTime64);

}

void init_player_stats_ship(object &plrobj, const fix GameTime64)

{

        auto &player_info = plrobj.ctype.player_info;

        player_info.lavafall_hiss_playing = false;

        player_info.missile_gun = 0;

        player_info.Spreadfire_toggle = 0;

        player_info.killer_objnum = object_none;

#if defined(DXX_BUILD_DESCENT_II)

        player_info.Omega_recharge_delay = 0;

        player_info.Helix_orientation = 0;

#endif

        player_info.mission.hostages_on_board = 0;

        player_info.homing_object_dist = -F1_0; // Added by RH

        player_info.Next_flare_fire_time = player_info.Next_laser_fire_time = player_info.Next_missile_fire_time = GameTime64;

}

}

//do whatever needs to be done when a player dies in multiplayer

static void DoGameOver()

{

        if (PLAYING_BUILTIN_MISSION)

                scores_maybe_add_player();

}

//update various information about the player

void update_player_stats()

{

        auto &plr = get_local_player();

        plr.time_level += FrameTime;    //the never-ending march of time...

        if (plr.time_level > i2f(3600))

        {

                plr.time_level -= i2f(3600);

                ++ plr.hours_level;

        }

        plr.time_total += FrameTime;    //the never-ending march of time...

        if (plr.time_total > i2f(3600))

        {

                plr.time_total -= i2f(3600);

                ++ plr.hours_total;

        }

}

//go through this level and start any eclip sounds

namespace dsx {

static void set_sound_sources(fvcsegptridx &vcsegptridx, fvcvertptr &vcvertptr)

{

        auto &Effects = LevelUniqueEffectsClipState.Effects;

        auto &TmapInfo = LevelUniqueTmapInfoState.TmapInfo;

        digi_init_sounds();             //clear old sounds

#if defined(DXX_BUILD_DESCENT_II)

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vcwallptr = Walls.vcptr;

#endif

        Dont_start_sound_objects = 1;

        const auto get_eclip_for_tmap = [](const d_level_unique_tmap_info_state::TmapInfo_array &TmapInfo, const unique_side &side) {

                if (const auto tm2 = side.tmap_num2)