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.

*/

/*

 *

 * Code for rendering & otherwise dealing with explosions

 *

 */

#include <algorithm>

#include <numeric>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "dxxerror.h"

#include "maths.h"

#include "vecmat.h"

#include "gr.h"

#include "3d.h"

#include "inferno.h"

#include "object.h"

#include "vclip.h"

#include "game.h"

#include "robot.h"

#include "sounds.h"

#include "player.h"

#include "gauges.h"

#include "powerup.h"

#include "bm.h"

#include "ai.h"

#include "weapon.h"

#include "fireball.h"

#include "collide.h"

#include "newmenu.h"

#include "gameseq.h"

#include "physics.h"

#include "scores.h"

#include "laser.h"

#include "wall.h"

#include "multi.h"

#include "endlevel.h"

#include "timer.h"

#include "fuelcen.h"

#include "playsave.h"

#include "cntrlcen.h"

#include "gameseg.h"

#include "automap.h"

#include "byteutil.h"

#include "compiler-range_for.h"

#include "partial_range.h"

#include "segiter.h"

using std::min;

#define EXPLOSION_SCALE (F1_0*5/2)              //explosion is the obj size times this 

//--unused-- ubyte      Frame_processed[MAX_OBJECTS];

namespace dcx {

unsigned Num_exploding_walls;

void init_exploding_walls()

{

        Num_exploding_walls = 0;

}

}

namespace dsx {

#if defined(DXX_BUILD_DESCENT_II)

fix     Flash_effect=0;

constexpr int   PK1=1, PK2=8;

#endif

static bool can_collide(const object *const weapon_object, const object_base &iter_object, const object *const parent_object)

{

        /* `weapon_object` may not be a weapon in some cases, though the

         * caller originally expected it would be.  For this function, the

         * distinction is currently irrelevant.

         */

#if defined(DXX_BUILD_DESCENT_I)

        (void)weapon_object;

#elif defined(DXX_BUILD_DESCENT_II)

        if (weapon_object == &iter_object)

                return false;

        if (iter_object.type == OBJ_NONE)

                return false;

        if (iter_object.flags & OF_SHOULD_BE_DEAD)

                return false;

#endif

        switch (iter_object.type)

        {

#if defined(DXX_BUILD_DESCENT_II)

                case OBJ_WEAPON:

                        return is_proximity_bomb_or_player_smart_mine_or_placed_mine(get_weapon_id(iter_object));

#endif

                case OBJ_CNTRLCEN:

                case OBJ_PLAYER:

                        return true;

                case OBJ_ROBOT:

                        if (parent_object == nullptr)

                                return false;

                        if (parent_object->type != OBJ_ROBOT)

                                return true;

                        return get_robot_id(*parent_object) != iter_object.id;

                default:

                        return false;

        }

}

static imobjptridx_t object_create_explosion_sub(const d_vclip_array &Vclip, fvmobjptridx &vmobjptridx, const imobjptridx_t obj_explosion_origin, const vmsegptridx_t segnum, const vms_vector &position, const fix size, const int vclip_type, const fix maxdamage, const fix maxdistance, const fix maxforce, const icobjptridx_t parent)

{

        /* `obj_explosion_origin` may not be a weapon in some cases, though

         * this function originally expected it would be.

         */

#if defined(DXX_BUILD_DESCENT_II)

        auto &Objects = LevelUniqueObjectState.Objects;

#endif

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        const auto &&obj_fireball = obj_create(OBJ_FIREBALL, vclip_type, segnum, position, &vmd_identity_matrix, size,

                                        CT_EXPLOSION,MT_NONE,RT_FIREBALL);

        if (obj_fireball == object_none)

        {

                return object_none;

        }

        //now set explosion-specific data

        obj_fireball->lifeleft = Vclip[vclip_type ].play_time;

        obj_fireball->ctype.expl_info.spawn_time = -1;

        obj_fireball->ctype.expl_info.delete_objnum = object_none;

        obj_fireball->ctype.expl_info.delete_time = -1;

        if (maxdamage > 0) {

                fix force;

                vms_vector pos_hit, vforce;

                fix damage;

                // -- now legal for badass explosions on a wall. Assert(obj_explosion_origin != NULL);

                range_for (const auto &&obj_iter, vmobjptridx)

                {

                        //      Weapons used to be affected by badass explosions, but this introduces serious problems.

                        //      When a smart bomb blows up, if one of its children goes right towards a nearby wall, it will

                        //      blow up, blowing up all the children.  So I remove it.  MK, 09/11/94

                        if (can_collide(obj_explosion_origin, obj_iter, parent))

                        {

                                const auto dist = vm_vec_dist_quick(obj_iter->pos, obj_fireball->pos);

                                // Make damage be from 'maxdamage' to 0.0, where 0.0 is 'maxdistance' away;

                                if ( dist < maxdistance ) {

                                        if (object_to_object_visibility(obj_fireball, obj_iter, FQ_TRANSWALL))

                                        {

                                                damage = maxdamage - fixmuldiv( dist, maxdamage, maxdistance );

                                                force = maxforce - fixmuldiv( dist, maxforce, maxdistance );

                                                // Find the force vector on the object

                                                vm_vec_normalized_dir_quick(vforce, obj_iter->pos, obj_fireball->pos);

                                                vm_vec_scale(vforce, force );

                                                // Find where the point of impact is... ( pos_hit )

                                                vm_vec_scale(vm_vec_sub(pos_hit, obj_fireball->pos, obj_iter->pos), fixdiv(obj_iter->size, obj_iter->size + dist));

                                                switch (obj_iter->type)

                                                {

#if defined(DXX_BUILD_DESCENT_II)

                                                        case OBJ_WEAPON:

                                                                phys_apply_force(obj_iter, vforce);

                                                                if (is_proximity_bomb_or_player_smart_mine(get_weapon_id(obj_iter)))

                                                                {               //prox bombs have chance of blowing up

                                                                        if (fixmul(dist,force) > i2f(8000)) {

                                                                                obj_iter->flags |= OF_SHOULD_BE_DEAD;

                                                                                explode_badass_weapon(obj_iter, obj_iter->pos);

                                                                        }

                                                                }

                                                                break;

#endif

                                                        case OBJ_ROBOT:

                                                                {

                                                                phys_apply_force(obj_iter, vforce);

#if defined(DXX_BUILD_DESCENT_II)

                                                                //      If not a boss, stun for 2 seconds at 32 force, 1 second at 16 force

                                                                fix flash;

                                                                if (obj_explosion_origin != object_none && obj_explosion_origin->type == OBJ_WEAPON && !Robot_info[get_robot_id(obj_iter)].boss_flag && (flash = Weapon_info[get_weapon_id(obj_explosion_origin)].flash))

                                                                {

                                                                        ai_static *const aip = &obj_iter->ctype.ai_info;

                                                                        if (obj_fireball->ctype.ai_info.SKIP_AI_COUNT * FrameTime < F1_0)

                                                                        {

                                                                                const int force_val = f2i(fixdiv(vm_vec_mag_quick(vforce) * flash, FrameTime) / 128) + 2;

                                                                                aip->SKIP_AI_COUNT += force_val;

                                                                                obj_iter->mtype.phys_info.rotthrust.x = ((d_rand() - 16384) * force_val) / 16;

                                                                                obj_iter->mtype.phys_info.rotthrust.y = ((d_rand() - 16384) * force_val) / 16;

                                                                                obj_iter->mtype.phys_info.rotthrust.z = ((d_rand() - 16384) * force_val) / 16;

                                                                                obj_iter->mtype.phys_info.flags |= PF_USES_THRUST;

                                                                        } else

                                                                                aip->SKIP_AI_COUNT--;

                                                                }

#endif

                                                                const auto Difficulty_level = GameUniqueState.Difficulty_level;

                                                                //      When a robot gets whacked by a badass force, he looks towards it because robots tend to get blasted from behind.

                                                                {

                                                                        vms_vector neg_vforce;

                                                                        neg_vforce.x = vforce.x * -2 * (7 - Difficulty_level)/8;

                                                                        neg_vforce.y = vforce.y * -2 * (7 - Difficulty_level)/8;

                                                                        neg_vforce.z = vforce.z * -2 * (7 - Difficulty_level)/8;

                                                                        phys_apply_rot(obj_iter, neg_vforce);

                                                                }

                                                                if (obj_iter->shields >= 0)

                                                                {

#if defined(DXX_BUILD_DESCENT_II)

                                                                        const auto &robot_info = Robot_info[get_robot_id(obj_iter)];

                                                                        if (robot_info.boss_flag >= BOSS_D2 && Boss_invulnerable_matter[robot_info.boss_flag - BOSS_D2])

                                                                                        damage /= 4;

#endif

                                                                        if (apply_damage_to_robot(obj_iter, damage, parent))

                                                                                if (obj_explosion_origin != object_none && parent == get_local_player().objnum)

                                                                                        add_points_to_score(ConsoleObject->ctype.player_info, Robot_info[get_robot_id(obj_iter)].score_value);

                                                                }

#if defined(DXX_BUILD_DESCENT_II)

                                                                if (obj_explosion_origin != object_none && Robot_info[get_robot_id(obj_iter)].companion && !(obj_explosion_origin->type == OBJ_WEAPON && Weapon_info[get_weapon_id(obj_explosion_origin)].flash))

                                                                {

                                                                        static const char ouch_str[] = "ouch! " "ouch! " "ouch! " "ouch! ";

                                                                        int     count;

                                                                        count = f2i(damage/8);

                                                                        if (count > 4)

                                                                                count = 4;

                                                                        else if (count <= 0)

                                                                                count = 1;

                                                                        buddy_message_str(&ouch_str[(4 - count) * 6]);

                                                                }

#endif

                                                                break;

                                                                }

                                                        case OBJ_CNTRLCEN:

                                                                if (parent != object_none && obj_iter->shields >= 0)

                                                                {

                                                                        apply_damage_to_controlcen(obj_iter, damage, parent);

                                                                }

                                                                break;

                                                        case OBJ_PLAYER:        {

                                                                icobjptridx_t killer = object_none;

#if defined(DXX_BUILD_DESCENT_II)

                                                                //      Hack! Warning! Test code!

                                                                fix flash;

                                                                if (obj_explosion_origin != object_none && obj_explosion_origin->type == OBJ_WEAPON && (flash = Weapon_info[get_weapon_id(obj_explosion_origin)].flash) && get_player_id(obj_iter) == Player_num)

                                                                {

                                                                        int fe = min(F1_0 * 4, force * flash / 32);     //      For four seconds or less

                                                                        if (laser_parent_is_player(Objects.vcptr, obj_explosion_origin->ctype.laser_info, *ConsoleObject))

                                                                        {

                                                                                fe /= 2;

                                                                                force /= 2;

                                                                        }

                                                                        if (force > F1_0) {

                                                                                Flash_effect = fe;

                                                                                PALETTE_FLASH_ADD(PK1 + f2i(PK2*force), PK1 + f2i(PK2*force), PK1 + f2i(PK2*force));

                                                                        }

                                                                }

#endif

                                                                if (obj_explosion_origin != object_none && (Game_mode & GM_MULTI) && obj_explosion_origin->type == OBJ_PLAYER)

                                                                {

                                                                        killer = obj_explosion_origin;

                                                                }

                                                                auto vforce2 = vforce;

                                                                if (parent != object_none ) {

                                                                        killer = parent;

                                                                        if (killer != ConsoleObject)            // if someone else whacks you, cut force by 2x

                                                                        {

                                                                                vforce2.x /= 2; vforce2.y /= 2; vforce2.z /= 2;

                                                                        }

                                                                }

                                                                vforce2.x /= 2; vforce2.y /= 2; vforce2.z /= 2;

                                                                phys_apply_force(obj_iter, vforce);

                                                                phys_apply_rot(obj_iter, vforce2);

                                                                if (obj_iter->shields >= 0)

                                                                {

#if defined(DXX_BUILD_DESCENT_II)

                                                                        if (GameUniqueState.Difficulty_level == 0)

                                                                        damage /= 4;

#endif

                                                                        apply_damage_to_player(obj_iter, killer, damage, 1 );

                                                                }

                                                        }

                                                                break;

                                                        default:

                                                                Int3(); //      Illegal object type

                                                }       // end switch

                                        } else {

                                                ;

                                        }       // end if (object_to_object_visibility...

                                }       // end if (dist < maxdistance)

                        }

                }       // end for

        }       // end if (maxdamage...

        return obj_fireball;

}

void object_create_muzzle_flash(const vmsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type )

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        object_create_explosion_sub(Vclip, vmobjptridx, object_none, segnum, position, size, vclip_type, 0, 0, 0, object_none );

}

imobjptridx_t object_create_explosion(const vmsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type )

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        return object_create_explosion_sub(Vclip, vmobjptridx, object_none, segnum, position, size, vclip_type, 0, 0, 0, object_none );

}

imobjptridx_t object_create_badass_explosion(const imobjptridx_t objp, const vmsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, const icobjptridx_t parent )

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        const imobjptridx_t rval = object_create_explosion_sub(Vclip, vmobjptridx, objp, segnum, position, size, vclip_type, maxdamage, maxdistance, maxforce, parent);

        if ((objp != object_none) && (objp->type == OBJ_WEAPON))

                create_weapon_smart_children(objp);

        return rval;

}

//blows up a badass weapon, creating the badass explosion

//return the explosion object

void explode_badass_weapon(const vmobjptridx_t obj,const vms_vector &pos)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &imobjptridx = Objects.imptridx;

        const auto weapon_id = get_weapon_id(obj);

        const weapon_info *wi = &Weapon_info[weapon_id];

        Assert(wi->damage_radius);

#if defined(DXX_BUILD_DESCENT_II)

        if (weapon_id == weapon_id_type::EARTHSHAKER_ID || weapon_id == weapon_id_type::ROBOT_EARTHSHAKER_ID)

                smega_rock_stuff();

#endif

        digi_link_sound_to_object(SOUND_BADASS_EXPLOSION, obj, 0, F1_0, sound_stack::allow_stacking);

        const auto Difficulty_level = GameUniqueState.Difficulty_level;

        object_create_badass_explosion(obj, vmsegptridx(obj->segnum), pos,

                                              wi->impact_size,

                                              wi->robot_hit_vclip,

                                              wi->strength[Difficulty_level],

                                              wi->damage_radius,wi->strength[Difficulty_level],

                                              imobjptridx(obj->ctype.laser_info.parent_num));

}

static void explode_badass_object(fvmsegptridx &vmsegptridx, const vmobjptridx_t objp, fix damage, fix distance, fix force)

{

        const auto &&rval = object_create_badass_explosion(objp, vmsegptridx(objp->segnum), objp->pos, objp->size,

                                        get_explosion_vclip(objp, explosion_vclip_stage::s0),

                                        damage, distance, force,

                                        objp);

        if (rval != object_none)

                digi_link_sound_to_object(SOUND_BADASS_EXPLOSION, rval, 0, F1_0, sound_stack::allow_stacking);

}

//blows up the player with a badass explosion

//return the explosion object

void explode_badass_player(const vmobjptridx_t objp)

{

        explode_badass_object(vmsegptridx, objp, F1_0*50, F1_0*40, F1_0*150);

}

#define DEBRIS_LIFE (f1_0 * (PERSISTENT_DEBRIS?60:2))           //lifespan in seconds

static void object_create_debris(fvmsegptridx &vmsegptridx, const object_base &parent, int subobj_num)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        Assert(parent.type == OBJ_ROBOT || parent.type == OBJ_PLAYER);

        auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

        const auto &&obj = obj_create(OBJ_DEBRIS, 0, vmsegptridx(parent.segnum), parent.pos, &parent.orient, Polygon_models[parent.rtype.pobj_info.model_num].submodel_rads[subobj_num],

                                CT_DEBRIS,MT_PHYSICS,RT_POLYOBJ);

        if ((obj == object_none ) && (Highest_object_index >= MAX_OBJECTS-1)) {

//              Int3(); // this happens often and is normal :-)

                return;

        }

        if ( obj == object_none )

                return;                         // Not enough debris slots!

        Assert(subobj_num < 32);

        //Set polygon-object-specific data

        obj->rtype.pobj_info.model_num = parent.rtype.pobj_info.model_num;

        obj->rtype.pobj_info.subobj_flags = 1<<subobj_num;

        obj->rtype.pobj_info.tmap_override = parent.rtype.pobj_info.tmap_override;

        //Set physics data for this object

        obj->mtype.phys_info.velocity.x = D_RAND_MAX/2 - d_rand();

        obj->mtype.phys_info.velocity.y = D_RAND_MAX/2 - d_rand();

        obj->mtype.phys_info.velocity.z = D_RAND_MAX/2 - d_rand();

        vm_vec_normalize_quick(obj->mtype.phys_info.velocity);

        vm_vec_scale(obj->mtype.phys_info.velocity,i2f(10 + (30 * d_rand() / D_RAND_MAX)));

        vm_vec_add2(obj->mtype.phys_info.velocity, parent.mtype.phys_info.velocity);

        // -- used to be: Notice, not random! vm_vec_make(&obj->mtype.phys_info.rotvel,10*0x2000/3,10*0x4000/3,10*0x7000/3);

        obj->mtype.phys_info.rotvel = {d_rand() + 0x1000, d_rand()*2 + 0x4000, d_rand()*3 + 0x2000};

        vm_vec_zero(obj->mtype.phys_info.rotthrust);

        obj->lifeleft = 3*DEBRIS_LIFE/4 + fixmul(d_rand(), DEBRIS_LIFE);        //      Some randomness, so they don't all go away at the same time.

        obj->mtype.phys_info.mass = fixmuldiv(parent.mtype.phys_info.mass, obj->size, parent.size);

        obj->mtype.phys_info.drag = 0; //fl2f(0.2);             //parent->mtype.phys_info.drag;

        if (PERSISTENT_DEBRIS)

        {

                obj->mtype.phys_info.flags |= PF_BOUNCE;

                obj->mtype.phys_info.drag = 128;

        }

}

void draw_fireball(const d_vclip_array &Vclip, grs_canvas &canvas, const vcobjptridx_t obj)

{

        const auto lifeleft = obj->lifeleft;

        if (lifeleft > 0)

                draw_vclip_object(canvas, obj, lifeleft, Vclip[get_fireball_id(obj)]);

}

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

//      Return true if there is a door here and it is openable

//      It is assumed that the player has all keys.

static int door_is_openable_by_player(fvcwallptr &vcwallptr, const shared_segment &segp, const unsigned sidenum)

{

        const auto wall_num = segp.sides[sidenum].wall_num;

        if (wall_num == wall_none)

                return 0;                                               //      no wall here.

        auto &w = *vcwallptr(wall_num);

        const auto wall_type = w.type;

        //      Can't open locked doors.

        if ((wall_type == WALL_DOOR && (w.flags & WALL_DOOR_LOCKED)) || wall_type == WALL_CLOSED)

                return 0;

        return 1;

}

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

//      Return a segment %i segments away from initial segment.

//      Returns -1 if can't find a segment that distance away.

imsegidx_t pick_connected_segment(const vcsegidx_t start_seg, int max_depth)

{

        using std::swap;

        int             i;

        int             cur_depth;

        int             head, tail;

        constexpr unsigned QUEUE_SIZE = 64;

        std::array<segnum_t, QUEUE_SIZE * 2> seg_queue{};

        std::array<uint8_t, MAX_SEGMENTS> depth{};

        std::array<uint8_t, MAX_SIDES_PER_SEGMENT> side_rand;

        visited_segment_bitarray_t visited;

        head = 0;

        tail = 0;

        seg_queue[head++] = start_seg;

        cur_depth = 0;

        std::iota(side_rand.begin(), side_rand.end(), 0);

        //      Now, randomize a bit to start, so we don't always get started in the same direction.

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

                int     ind1;

                ind1 = (d_rand() * MAX_SIDES_PER_SEGMENT) >> 15;

                swap(side_rand[ind1], side_rand[i]);

        }

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vcwallptr = Walls.vcptr;

        while (tail != head) {

                int             sidenum, count;

                int             ind1, ind2;

                if (cur_depth >= max_depth) {

                        return seg_queue[tail];

                }

                const auto &&segp = vcsegptr(seg_queue[tail++]);

                tail &= QUEUE_SIZE-1;

                //      to make random, switch a pair of entries in side_rand.

                ind1 = (d_rand() * MAX_SIDES_PER_SEGMENT) >> 15;

                ind2 = (d_rand() * MAX_SIDES_PER_SEGMENT) >> 15;

                swap(side_rand[ind1], side_rand[ind2]);

                count = 0;

                for (sidenum=ind1; count<MAX_SIDES_PER_SEGMENT; count++) {

                        int     snrand;

                        if (sidenum == MAX_SIDES_PER_SEGMENT)

                                sidenum = 0;

                        snrand = side_rand[sidenum];

                        auto wall_num = segp->shared_segment::sides[snrand].wall_num;

                        sidenum++;

                        if ((wall_num == wall_none || door_is_openable_by_player(vcwallptr, segp, snrand)) && IS_CHILD(segp->children[snrand]))

                        {

                                if (!visited[segp->children[snrand]]) {

                                        seg_queue[head++] = segp->children[snrand];

                                        visited[segp->children[snrand]] = true;

                                        depth[segp->children[snrand]] = cur_depth+1;

                                        head &= QUEUE_SIZE-1;

                                        if (head > tail) {

                                                if (head == tail + QUEUE_SIZE-1)

                                                        Int3(); //      queue overflow.  Make it bigger!

                                        } else

                                                if (head+QUEUE_SIZE == tail + QUEUE_SIZE-1)

                                                        Int3(); //      queue overflow.  Make it bigger!

                                }

                        }

                }

                if (seg_queue[tail] > Highest_segment_index)

                {

                        // -- Int3();   //      Something bad has happened.  Queue is trashed.  --MK, 12/13/94

                        return segment_none;

                }

                cur_depth = depth[seg_queue[tail]];

        }

        return segment_none;

}

#if defined(DXX_BUILD_DESCENT_I)

#define BASE_NET_DROP_DEPTH 10

#elif defined(DXX_BUILD_DESCENT_II)

#define BASE_NET_DROP_DEPTH 8

#endif

static imsegidx_t pick_connected_drop_segment(const segment_array &Segments, fvcvertptr &vcvertptr, const vcsegidx_t start_seg, const unsigned cur_drop_depth, const vms_vector &player_pos, const vcsegptridx_t &player_seg)

{

        const auto segnum = pick_connected_segment(start_seg, cur_drop_depth);

        if (segnum == segment_none)

                return segnum;

        const auto &&segp = Segments.vcptridx(segnum);

        if (segp->special == SEGMENT_IS_CONTROLCEN)

                return segment_none;

        //don't drop in any children of control centers

        range_for (const auto ch, segp->children)

        {

                if (!IS_CHILD(ch))

                        continue;

                const shared_segment &childsegp = *Segments.vcptr(ch);

                if (childsegp.special == SEGMENT_IS_CONTROLCEN)

                        return segment_none;

        }

        //bail if not far enough from original position

        const auto &&tempv = compute_segment_center(vcvertptr, segp);

        if (find_connected_distance(player_pos, player_seg, tempv, segp, -1, WID_FLY_FLAG) < static_cast<fix>(i2f(20) * cur_drop_depth))

                return segment_none;

        return segnum;

}

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

//      Choose segment to drop a powerup in.

//      For all active net players, try to create a N segment path from the player.  If possible, return that

//      segment.  If not possible, try another player.  After a few tries, use a random segment.

//      Don't drop if control center in segment.

static vmsegptridx_t choose_drop_segment(fvcsegptridx &vcsegptridx, fvmsegptridx &vmsegptridx, const playernum_t drop_pnum)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcobjptr = Objects.vcptr;

        auto &vmobjptr = Objects.vmptr;

        playernum_t     pnum = 0;

        int     cur_drop_depth;

        int     count;

        auto &drop_player = *vcplayerptr(drop_pnum);

        auto &drop_playerobj = *vmobjptr(drop_player.objnum);

        d_srand(static_cast<fix>(timer_query()));

        cur_drop_depth = BASE_NET_DROP_DEPTH + ((d_rand() * BASE_NET_DROP_DEPTH*2) >> 15);

        auto &player_pos = drop_playerobj.pos;

        const auto &&player_seg = vcsegptridx(drop_playerobj.segnum);

        segnum_t        segnum = segment_none;

        auto &vcvertptr = Vertices.vcptr;

        for (; (segnum == segment_none) && (cur_drop_depth > BASE_NET_DROP_DEPTH/2); --cur_drop_depth)

        {

                pnum = (d_rand() * N_players) >> 15;

                count = 0;

#if defined(DXX_BUILD_DESCENT_I)

                while (count < N_players && (vcplayerptr(pnum)->connected == CONNECT_DISCONNECTED || pnum == drop_pnum))

#elif defined(DXX_BUILD_DESCENT_II)

                while (count < N_players && (vcplayerptr(pnum)->connected == CONNECT_DISCONNECTED || pnum == drop_pnum || ((Game_mode & (GM_TEAM|GM_CAPTURE)) && (get_team(pnum)==get_team(drop_pnum)))))

#endif

                {

                        pnum = (pnum+1)%N_players;

                        count++;

                }

                if (count == N_players) {

                        //if can't valid non-player person, use the player

                        pnum = drop_pnum;

                }

                segnum = pick_connected_drop_segment(Segments, vcvertptr, vcobjptr(vcplayerptr(pnum)->objnum)->segnum, cur_drop_depth, player_pos, player_seg);

        }

        if (segnum == segment_none) {

                cur_drop_depth = BASE_NET_DROP_DEPTH;

                while (cur_drop_depth > 0 && segnum == segment_none) // before dropping in random segment, try to find ANY segment which is connected to the player responsible for the drop so object will not spawn in inaccessible areas

                {

                        segnum = pick_connected_segment(vcobjptr(vcplayerptr(drop_pnum)->objnum)->segnum, --cur_drop_depth);

                        if (segnum != segment_none && vcsegptr(segnum)->special == SEGMENT_IS_CONTROLCEN)

                                segnum = segment_none;

                }

                if (segnum == segment_none) // basically it should be impossible segnum == -1 now... but oh well...

                        return vmsegptridx(static_cast<segnum_t>((d_rand() * Highest_segment_index) >> 15));

        }

        return vmsegptridx(segnum);

}

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

//      (Re)spawns powerup if in a network game.

void maybe_drop_net_powerup(powerup_type_t powerup_type, bool adjust_cap, bool random_player)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptr = Objects.vmptr;

        playernum_t pnum = Player_num;

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

                if ((Game_mode & GM_NETWORK) && adjust_cap)

                {

                        MultiLevelInv_Recount(); // recount current items

                        if (!MultiLevelInv_AllowSpawn(powerup_type))

                                return;

                }

                if (LevelUniqueControlCenterState.Control_center_destroyed || (Network_status == NETSTAT_ENDLEVEL))

                        return;

                if (random_player)

                {

                        uint_fast32_t failsafe_count = 0;

                        do {

                                pnum = d_rand() % MAX_PLAYERS;

                                if (failsafe_count > MAX_PLAYERS*4) // that was plenty of tries to find a good player...

                                {

                                        pnum = Player_num; // ... go with Player_num instead

                                        break;

                                }

                                failsafe_count++;

                        } while (vcplayerptr(pnum)->connected != CONNECT_PLAYING);

                }

//--old--               segnum = (d_rand() * Highest_segment_index) >> 15;

//--old--               Assert((segnum >= 0) && (segnum <= Highest_segment_index));

//--old--               if (segnum < 0)

//--old--                       segnum = -segnum;

//--old--               while (segnum > Highest_segment_index)

//--old--                       segnum /= 2;

                Net_create_loc = 0;

                const auto &&objnum = call_object_create_egg(vmobjptr(vcplayerptr(pnum)->objnum), 1, powerup_type);

                if (objnum == object_none)

                        return;

                const auto &&segnum = choose_drop_segment(LevelSharedSegmentState.get_segments().vcptridx, LevelUniqueSegmentState.get_segments().vmptridx, pnum);

                auto &vcvertptr = Vertices.vcptr;

                const auto &&new_pos = pick_random_point_in_seg(vcvertptr, segnum);

                multi_send_create_powerup(powerup_type, segnum, objnum, new_pos);

                objnum->pos = new_pos;

                vm_vec_zero(objnum->mtype.phys_info.velocity);

                obj_relink(vmobjptr, vmsegptr, objnum, segnum);

                object_create_explosion(segnum, new_pos, i2f(5), VCLIP_POWERUP_DISAPPEARANCE );

        }

}

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

//      Return true if current segment contains some object.

static const object *segment_contains_powerup(fvcobjptridx &vcobjptridx, fvcsegptr &vcsegptr, const unique_segment &segnum, const powerup_type_t obj_id)

{

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

        {

                auto &o = objp;

                if (o.type == OBJ_POWERUP && get_powerup_id(o) == obj_id)

                        return &o;

        }

        return nullptr;

}

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

static const object *powerup_nearby_aux(fvcobjptridx &vcobjptridx, fvcsegptr &vcsegptr, const vcsegidx_t segnum, const powerup_type_t object_id, uint_fast32_t depth)

{

        auto &&segp = vcsegptr(segnum);

        if (auto r = segment_contains_powerup(vcobjptridx, vcsegptr, segp, object_id))

                return r;

        if (! -- depth)

                return nullptr;

        range_for (const auto seg2, segp->children)

        {

                if (seg2 != segment_none)

                        if (auto r = powerup_nearby_aux(vcobjptridx, vcsegptr, seg2, object_id, depth))

                                return r;

        }

        return nullptr;

}

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

//      Return true if some powerup is nearby (within 3 segments).

static const object *weapon_nearby(fvcobjptridx &vcobjptridx, fvcsegptr &vcsegptr, const object_base &objp, const powerup_type_t weapon_id)

{

        return powerup_nearby_aux(vcobjptridx, vcsegptr, objp.segnum, weapon_id, 2);

}

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

void maybe_replace_powerup_with_energy(object_base &del_obj)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

        auto &vmobjptr = Objects.vmptr;

        int     weapon_index=-1;