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.

*/

/*

 *

 * This will contain the laser code

 *

 */

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include "inferno.h"

#include "game.h"

#include "bm.h"

#include "object.h"

#include "laser.h"

#include "args.h"

#include "segment.h"

#include "fvi.h"

#include "segpoint.h"

#include "dxxerror.h"

#include "key.h"

#include "texmap.h"

#include "gameseg.h"

#include "textures.h"

#include "render.h"

#include "vclip.h"

#include "fireball.h"

#include "polyobj.h"

#include "robot.h"

#include "weapon.h"

#include "newdemo.h"

#include "timer.h"

#include "player.h"

#include "sounds.h"

#include "ai.h"

#include "powerup.h"

#include "multi.h"

#include "physics.h"

#include "multi.h"

#include "fwd-wall.h"

#include "playsave.h"

#include "compiler-range_for.h"

#include "partial_range.h"

#ifdef NEWHOMER

#define HOMING_TRACKABLE_DOT_FRAME_TIME HOMING_TURN_TIME

static ubyte d_homer_tick_step = 0;

static fix d_homer_tick_count = 0;

#else

#define HOMING_TRACKABLE_DOT_FRAME_TIME FrameTime

#endif

static int Muzzle_queue_index;

namespace dsx {

static imobjptridx_t find_homing_object_complete(const vms_vector &curpos, const vmobjptridx_t tracker, int track_obj_type1, int track_obj_type2);

static imobjptridx_t find_homing_object(const vms_vector &curpos, vmobjptridx_t tracker);

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

// Called by render code.... determines if the laser is from a robot or the

// player and calls the appropriate routine.

void Laser_render(grs_canvas &canvas, const object_base &obj)

{

        auto &wi = Weapon_info[get_weapon_id(obj)];

        switch(wi.render_type)

        {

        case WEAPON_RENDER_LASER:

                Int3(); // Not supported anymore!

                                        //Laser_draw_one(obj-Objects, Weapon_info[obj->id].bitmap );

                break;

        case WEAPON_RENDER_BLOB:

                draw_object_blob(canvas, obj, wi.bitmap);

                break;

        case WEAPON_RENDER_POLYMODEL:

                break;

        case WEAPON_RENDER_VCLIP:

                Int3(); //      Oops, not supported, type added by mk on 09/09/94, but not for lasers...

                DXX_BOOST_FALLTHROUGH;

        default:

                Error( "Invalid weapon render type in Laser_render\n" );

        }

}

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

// Draws a texture-mapped laser bolt

//void Laser_draw_one( int objnum, grs_bitmap * bmp )

//{

//      int t1, t2, t3;

//      g3s_point p1, p2;

//      object *obj;

//      vms_vector start_pos,end_pos;

//

//      obj = &Objects[objnum];

//

//      start_pos = obj->pos;

//      vm_vec_scale_add(&end_pos,&start_pos,&obj->orient.fvec,-Laser_length);

//

//      g3_rotate_point(&p1,&start_pos);

//      g3_rotate_point(&p2,&end_pos);

//

//      t1 = Lighting_on;

//      t2 = Interpolation_method;

//      t3 = Transparency_on;

//

//      Lighting_on  = 0;

//      //Interpolation_method = 3;     // Full perspective

//      Interpolation_method = 1;       // Linear

//      Transparency_on = 1;

//

//      //gr_setcolor( gr_getcolor(31,15,0));

//      //g3_draw_line_ptrs(p1,p2);

//      //g3_draw_rod(p1,0x2000,p2,0x2000);

//      //g3_draw_rod(p1,Laser_width,p2,Laser_width);

//      g3_draw_rod_tmap(bmp,&p2,Laser_width,&p1,Laser_width,0);

//      Lighting_on = t1;

//      Interpolation_method = t2;

//      Transparency_on = t3;

//

//}

static bool ignore_proximity_weapon(const object &o)

{

        if (!is_proximity_bomb_or_player_smart_mine(get_weapon_id(o)))

                return false;

#if defined(DXX_BUILD_DESCENT_I)

        return GameTime64 > o.ctype.laser_info.creation_time + F1_0*2;

#elif defined(DXX_BUILD_DESCENT_II)

        return GameTime64 > o.ctype.laser_info.creation_time + F1_0*4;

#endif

}

#if defined(DXX_BUILD_DESCENT_I)

static bool ignore_phoenix_weapon(const object &)

{

        return false;

}

static bool ignore_guided_missile_weapon(const object &)

{

        return false;

}

#elif defined(DXX_BUILD_DESCENT_II)

static bool ignore_phoenix_weapon(const object &o)

{

        return get_weapon_id(o) == weapon_id_type::PHOENIX_ID && GameTime64 > o.ctype.laser_info.creation_time + F1_0/4;

}

static bool ignore_guided_missile_weapon(const object &o)

{

        return get_weapon_id(o) == weapon_id_type::GUIDEDMISS_ID && GameTime64 > o.ctype.laser_info.creation_time + F1_0*2;

}

#endif

//      Changed by MK on 09/07/94

//      I want you to be able to blow up your own bombs.

//      AND...Your proximity bombs can blow you up if they're 2.0 seconds or more old.

//      Changed by MK on 06/06/95: Now must be 4.0 seconds old.  Much valid Net-complaining.

bool laser_are_related(const vcobjptridx_t o1, const vcobjptridx_t o2)

{

        // See if o2 is the parent of o1

        if (o1->type == OBJ_WEAPON)

                if (laser_parent_is_object(o1->ctype.laser_info, o2))

                {

                        //      o1 is a weapon, o2 is the parent of 1, so if o1 is PROXIMITY_BOMB and o2 is player, they are related only if o1 < 2.0 seconds old

                        if (ignore_proximity_weapon(o1) || ignore_guided_missile_weapon(o1) || ignore_phoenix_weapon(o1))

                        {

                                return 0;

                        } else

                                return 1;

                }

        // See if o1 is the parent of o2

        if (o2->type == OBJ_WEAPON)

        {

                if (laser_parent_is_object(o2->ctype.laser_info, o1))

                {

#if defined(DXX_BUILD_DESCENT_II)

                        //      o2 is a weapon, o1 is the parent of 2, so if o2 is PROXIMITY_BOMB and o1 is player, they are related only if o1 < 2.0 seconds old

                        if (ignore_proximity_weapon(o2) || ignore_guided_missile_weapon(o2) || ignore_phoenix_weapon(o2))

                        {

                                return 0;

                        } else

#endif

                                return 1;

                }

        }

        // They must both be weapons

        if (o1->type != OBJ_WEAPON || o2->type != OBJ_WEAPON)

                return 0;

        //      Here is the 09/07/94 change -- Siblings must be identical, others can hurt each other

        // See if they're siblings...

        //      MK: 06/08/95, Don't allow prox bombs to detonate for 3/4 second.  Else too likely to get toasted by your own bomb if hit by opponent.

        const auto o1id = get_weapon_id(o1);

        const auto o2id = get_weapon_id(o2);

        auto &o1li = o1->ctype.laser_info;

        auto &o2li = o2->ctype.laser_info;

        if (o1li.parent_num == o2li.parent_num && o1li.parent_signature == o2li.parent_signature)

        {

                if (is_proximity_bomb_or_player_smart_mine(o1id) || is_proximity_bomb_or_player_smart_mine(o2id))

                {

                        //      If neither is older than 1/2 second, then can't blow up!

#if defined(DXX_BUILD_DESCENT_II)

                        if (!(GameTime64 > o1li.creation_time + F1_0/2 || GameTime64 > o2li.creation_time + F1_0/2))

                                return 1;

                        else

#endif

                                return 0;

                } else

                        return 1;

        }

#if defined(DXX_BUILD_DESCENT_II)

        //      Anything can cause a collision with a robot super prox mine.

        if (!(

                o1id == weapon_id_type::ROBOT_SUPERPROX_ID || o2id == weapon_id_type::ROBOT_SUPERPROX_ID ||

                o1id == weapon_id_type::PROXIMITY_ID || o2id == weapon_id_type::PROXIMITY_ID ||

                o1id == weapon_id_type::SUPERPROX_ID || o2id == weapon_id_type::SUPERPROX_ID ||

                o1id == weapon_id_type::PMINE_ID || o2id == weapon_id_type::PMINE_ID

        ))

                return 1;

#endif

        return 0;

}

}

namespace dcx {

constexpr vm_distance MAX_SMART_DISTANCE(F1_0*150);

constexpr vm_distance_squared MAX_SMART_DISTANCE_SQUARED = MAX_SMART_DISTANCE * MAX_SMART_DISTANCE;

static void do_muzzle_stuff(segnum_t segnum, const vms_vector &pos)

{

        auto &m = Muzzle_data[Muzzle_queue_index];

        Muzzle_queue_index++;

        if (Muzzle_queue_index >= MUZZLE_QUEUE_MAX)

                Muzzle_queue_index = 0;

        m.segnum = segnum;

        m.pos = pos;

        m.create_time = timer_query();

}

__attribute_noreturn

static void report_invalid_weapon_render_type(const int weapon_type, const unsigned render_type)

{

        char buf[96];

        snprintf(buf, sizeof(buf), "invalid weapon render type %u on weapon %i", render_type, weapon_type);

        throw std::runtime_error(buf);

}

}

namespace dsx {

//creates a weapon object

static imobjptridx_t create_weapon_object(int weapon_type,const vmsegptridx_t segnum, const vms_vector &position)

{

        render_type_t rtype;

        fix laser_radius = -1;

        switch( Weapon_info[weapon_type].render_type )  {

                case WEAPON_RENDER_BLOB:

                        rtype = RT_LASER;                       // Render as a laser even if blob (see render code above for explanation)

                        laser_radius = Weapon_info[weapon_type].blob_size;

                        break;

                case WEAPON_RENDER_POLYMODEL:

                        laser_radius = 0;       //      Filled in below.

                        rtype = RT_POLYOBJ;

                        break;

                case WEAPON_RENDER_LASER:

                        Int3();         // Not supported anymore

                        return object_none;

                case WEAPON_RENDER_NONE:

                        rtype = RT_NONE;

                        laser_radius = F1_0;

                        break;

                case WEAPON_RENDER_VCLIP:

                        rtype = RT_WEAPON_VCLIP;

                        laser_radius = Weapon_info[weapon_type].blob_size;

                        break;

                default:

                        report_invalid_weapon_render_type(weapon_type, Weapon_info[weapon_type].render_type);

        }

        Assert(laser_radius != -1);

        auto &&obj = obj_create( OBJ_WEAPON, weapon_type, segnum, position, NULL, laser_radius, CT_WEAPON, MT_PHYSICS, rtype);

        if (obj == object_none)

                return object_none;

        if (Weapon_info[weapon_type].render_type == WEAPON_RENDER_POLYMODEL) {

                auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

                obj->rtype.pobj_info.model_num = Weapon_info[get_weapon_id(obj)].model_num;

                obj->size = fixdiv(Polygon_models[obj->rtype.pobj_info.model_num].rad,Weapon_info[get_weapon_id(obj)].po_len_to_width_ratio);

        }

        obj->mtype.phys_info.mass = Weapon_info[weapon_type].mass;

        obj->mtype.phys_info.drag = Weapon_info[weapon_type].drag;

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

        if (Weapon_info[weapon_type].bounce==1)

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

#if defined(DXX_BUILD_DESCENT_II)

        if (Weapon_info[weapon_type].bounce==2 || cheats.bouncyfire)

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

#endif

        return obj;

}

#if defined(DXX_BUILD_DESCENT_II)

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

//      ***** HEY ARTISTS!! *****

//      Here are the constants you're looking for! --MK

//      Change the following constants to affect the look of the omega cannon.

//      Changing these constants will not affect the damage done.

//      WARNING: If you change DESIRED_OMEGA_DIST and MAX_OMEGA_BLOBS, you don't merely change the look of the cannon,

//      you change its range.  If you decrease DESIRED_OMEGA_DIST, you decrease how far the gun can fire.

constexpr std::integral_constant<fix, F1_0/20> OMEGA_BASE_TIME{}; // How many blobs per second!! No FPS-based blob creation anymore, no FPS-based damage anymore!

constexpr std::integral_constant<unsigned, 3> MIN_OMEGA_BLOBS{};                                //      No matter how close the obstruction, at this many blobs created.

constexpr std::integral_constant<fix, F1_0*3> MIN_OMEGA_DIST{};         //      At least this distance between blobs, unless doing so would violate MIN_OMEGA_BLOBS

constexpr std::integral_constant<fix, F1_0*5> DESIRED_OMEGA_DIST{};             //      This is the desired distance between blobs.  For distances > MIN_OMEGA_BLOBS*DESIRED_OMEGA_DIST, but not very large, this will apply.

constexpr std::integral_constant<unsigned, 16> MAX_OMEGA_BLOBS{};                               //      No matter how far away the obstruction, this is the maximum number of blobs.

constexpr vm_distance MAX_OMEGA_DIST{MAX_OMEGA_BLOBS * DESIRED_OMEGA_DIST};             //      Maximum extent of lightning blobs.

constexpr vm_distance_squared MAX_OMEGA_DIST_SQUARED{MAX_OMEGA_DIST * MAX_OMEGA_DIST};

//      Additionally, several constants which apply to homing objects in general control the behavior of the Omega Cannon.

//      They are defined in laser.h.  They are copied here for reference.  These values are valid on 1/10/96:

//      If you want the Omega Cannon view cone to be different than the Homing Missile viewcone, contact MK to make the change.

//      (Unless you are a programmer, in which case, do it yourself!)

#define OMEGA_MIN_TRACKABLE_DOT                 (15*F1_0/16)            //      Larger values mean narrower cone.  F1_0 means damn near impossible.  0 means 180 degree field of view.

constexpr vm_distance OMEGA_MAX_TRACKABLE_DIST = MAX_OMEGA_DIST; //     An object must be at least this close to be tracked.

//      Note, you don't need to change these constants.  You can control damage and energy consumption by changing the

//      usual bitmaps.tbl parameters.

#define OMEGA_DAMAGE_SCALE                      32                              //      Controls how much damage is done.  This gets multiplied by the damage specified in bitmaps.tbl in the $WEAPON line.

#define OMEGA_ENERGY_CONSUMPTION        16                              //      Controls how much energy is consumed.  This gets multiplied by the energy parameter from bitmaps.tbl.

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

// Delete omega blobs further away than MAX_OMEGA_DIST

// Since last omega blob has VERY high velocity it's impossible to ensure a constant travel distance on varying FPS. So delete if they exceed their maximum distance.

static int omega_cleanup(fvcobjptr &vcobjptr, const vmobjptridx_t weapon)

{

        if (weapon->type != OBJ_WEAPON || get_weapon_id(weapon) != weapon_id_type::OMEGA_ID)

                return 0;

        auto &weapon_laser_info = weapon->ctype.laser_info;

        auto &obj = *vcobjptr(weapon_laser_info.parent_num);

        if (laser_parent_is_matching_signature(weapon_laser_info, obj))

                if (vm_vec_dist2(weapon->pos, obj.pos) > MAX_OMEGA_DIST_SQUARED)

                {

                        obj_delete(LevelUniqueObjectState, Segments, weapon);

                        return 1;

                }

        return 0;

}

// Return true if ok to do Omega damage. For Multiplayer games. See comment for omega_cleanup()

int ok_to_do_omega_damage(const object &weapon)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptr = Objects.vcptr;

        if (weapon.type != OBJ_WEAPON || get_weapon_id(weapon) != weapon_id_type::OMEGA_ID)

                return 1;

        if (!(Game_mode & GM_MULTI))

                return 1;

        auto &weapon_laser_info = weapon.ctype.laser_info;

        auto &obj = *vcobjptr(weapon_laser_info.parent_num);

        if (laser_parent_is_matching_signature(weapon_laser_info, obj))

                if (vm_vec_dist2(obj.pos, weapon.pos) > MAX_OMEGA_DIST_SQUARED)

                        return 0;

        return 1;

}

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

static void create_omega_blobs(const imsegptridx_t firing_segnum, const vms_vector &firing_pos, const vms_vector &goal_pos, const vmobjptridx_t parent_objp)

{

        imobjptridx_t  last_created_objnum = object_none;

        fix             dist_to_goal = 0, omega_blob_dist = 0;

        std::array<fix, MAX_OMEGA_BLOBS> perturb_array{};

        auto vec_to_goal = vm_vec_sub(goal_pos, firing_pos);

        dist_to_goal = vm_vec_normalize_quick(vec_to_goal);

        unsigned num_omega_blobs = 0;

        if (dist_to_goal < MIN_OMEGA_BLOBS * MIN_OMEGA_DIST) {

                omega_blob_dist = MIN_OMEGA_DIST;

                num_omega_blobs = dist_to_goal/omega_blob_dist;

                if (num_omega_blobs == 0)

                        num_omega_blobs = 1;

        } else {

                omega_blob_dist = DESIRED_OMEGA_DIST;

                num_omega_blobs = dist_to_goal / omega_blob_dist;

                if (num_omega_blobs > MAX_OMEGA_BLOBS) {

                        num_omega_blobs = MAX_OMEGA_BLOBS;

                        omega_blob_dist = dist_to_goal / num_omega_blobs;

                } else if (num_omega_blobs < MIN_OMEGA_BLOBS) {

                        num_omega_blobs = MIN_OMEGA_BLOBS;

                        omega_blob_dist = dist_to_goal / num_omega_blobs;

                }

        }

        vms_vector omega_delta_vector, blob_pos;

        omega_delta_vector = vec_to_goal;

        vm_vec_scale(omega_delta_vector, omega_blob_dist);

        //      Now, create all the blobs

        blob_pos = firing_pos;

        auto last_segnum = firing_segnum;

        //      If nearby, don't perturb vector.  If not nearby, start halfway out.

        if (dist_to_goal < MIN_OMEGA_DIST*4) {

        } else {

                vm_vec_scale_add2(blob_pos, omega_delta_vector, F1_0/2);        //      Put first blob half way out.

                for (int i=0; i<num_omega_blobs/2; i++) {

                        perturb_array[i] = F1_0*i + F1_0/4;

                        perturb_array[num_omega_blobs-1-i] = F1_0*i;

                }

        }

        //      Create random perturbation vector, but favor _not_ going up in player's reference.

        auto perturb_vec = make_random_vector();

        vm_vec_scale_add2(perturb_vec, parent_objp->orient.uvec, -F1_0/2);

        Doing_lighting_hack_flag = 1;   //      Ugly, but prevents blobs which are probably outside the mine from killing framerate.

        const auto &Difficulty_level = GameUniqueState.Difficulty_level;

        for (int i=0; i<num_omega_blobs; i++) {

                //      This will put the last blob right at the destination object, causing damage.

                if (i == num_omega_blobs-1)

                        vm_vec_scale_add2(blob_pos, omega_delta_vector, 15*F1_0/32);    //      Move last blob another (almost) half section

                //      Every so often, re-perturb blobs

                if ((i % 4) == 3) {

                        vm_vec_scale_add2(perturb_vec, make_random_vector(), F1_0/4);

                }

                const auto temp_pos = vm_vec_scale_add(blob_pos, perturb_vec, perturb_array[i]);

                const auto &&segnum = find_point_seg(LevelSharedSegmentState, LevelUniqueSegmentState, temp_pos, last_segnum);

                if (segnum != segment_none) {

                        last_segnum = segnum;

                        auto objp = obj_create(OBJ_WEAPON, weapon_id_type::OMEGA_ID, segnum, temp_pos, NULL, 0, CT_WEAPON, MT_PHYSICS, RT_WEAPON_VCLIP );

                        if (objp == object_none)

                                break;

                        last_created_objnum = objp;

                        objp->lifeleft = OMEGA_BASE_TIME+(d_rand()/8); // add little randomness so the lighting effect becomes a little more interesting

                        objp->mtype.phys_info.velocity = vec_to_goal;

                        //      Only make the last one move fast, else multiple blobs might collide with target.

                        vm_vec_scale(objp->mtype.phys_info.velocity, F1_0*4);

                        const auto &weapon_info = Weapon_info[get_weapon_id(objp)];

                        objp->size = weapon_info.blob_size;

                        objp->shields = fixmul(OMEGA_DAMAGE_SCALE*OMEGA_BASE_TIME, weapon_info.strength[Difficulty_level]);

                        objp->ctype.laser_info.parent_type                      = parent_objp->type;

                        objp->ctype.laser_info.parent_signature = parent_objp->signature;

                        objp->ctype.laser_info.parent_num                       = parent_objp;

                        objp->movement_type = MT_NONE;  //      Only last one moves, that will get bashed below.

                }

                vm_vec_add2(blob_pos, omega_delta_vector);

        }

        //      Make last one move faster, but it's already moving at speed = F1_0*4.

        if (last_created_objnum != object_none) {

                vm_vec_scale(last_created_objnum->mtype.phys_info.velocity, Weapon_info[weapon_id_type::OMEGA_ID].speed[Difficulty_level]/4);

                last_created_objnum->movement_type = MT_PHYSICS;

        }

        Doing_lighting_hack_flag = 0;

}

#define MIN_OMEGA_CHARGE        (MAX_OMEGA_CHARGE/8)

#define OMEGA_CHARGE_SCALE      4                       //      FrameTime / OMEGA_CHARGE_SCALE added to Omega_charge every frame.

#define OMEGA_CHARGE_SCALE      4

fix get_omega_energy_consumption(const fix delta_charge)

{

        const fix energy_used = fixmul(F1_0 * 190 / 17, delta_charge);

        const auto Difficulty_level = GameUniqueState.Difficulty_level;

        return Difficulty_level < 2

                ? fixmul(energy_used, i2f(Difficulty_level + 2) / 4)

                : energy_used;

}

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

//      Call this every frame to recharge the Omega Cannon.

void omega_charge_frame(player_info &player_info)

{

        if (!(player_info.primary_weapon_flags & HAS_PRIMARY_FLAG(primary_weapon_index_t::OMEGA_INDEX)))

                return;

        auto &Omega_charge = player_info.Omega_charge;

        if (Omega_charge >= MAX_OMEGA_CHARGE)

                return;

        if (Player_dead_state != player_dead_state::no)

                return;

        //      Don't charge while firing. Wait 1/3 second after firing before recharging

        auto &Omega_recharge_delay = player_info.Omega_recharge_delay;

        if (Omega_recharge_delay)

        {

                if (Omega_recharge_delay > FrameTime)

                {

                        Omega_recharge_delay -= FrameTime;

                        return;

                }

                Omega_recharge_delay = 0;

        }

        if (auto &energy = player_info.energy)

        {

                const auto old_omega_charge = Omega_charge;

                Omega_charge += FrameTime/OMEGA_CHARGE_SCALE;

                if (Omega_charge > MAX_OMEGA_CHARGE)

                        Omega_charge = MAX_OMEGA_CHARGE;

                const auto energy_used = get_omega_energy_consumption(Omega_charge - old_omega_charge);

                energy -= energy_used;

                if (energy < 0)

                        energy = 0;

        }

}

// -- fix       Last_omega_muzzle_flash_time;

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

//      *objp is the object firing the omega cannon

//      *pos is the location from which the omega bolt starts

static void do_omega_stuff(fvmsegptridx &vmsegptridx, const vmobjptridx_t parent_objp, const vms_vector &firing_pos, const vmobjptridx_t weapon_objp)

{

        vms_vector      goal_pos;

        if (parent_objp->type == OBJ_PLAYER && get_player_id(parent_objp) == Player_num)

        {

                //      If charge >= min, or (some charge and zero energy), allow to fire.

                auto &player_info = parent_objp->ctype.player_info;

                auto &Omega_charge = player_info.Omega_charge;

                if (!((Omega_charge >= MIN_OMEGA_CHARGE) || (Omega_charge && !player_info.energy))) {

                        obj_delete(LevelUniqueObjectState, Segments, weapon_objp);

                        return;

                }

                Omega_charge -= OMEGA_BASE_TIME;

                if (Omega_charge < 0)

                        Omega_charge = 0;

                player_info.Omega_recharge_delay = F1_0 / 3;

        }

        weapon_objp->ctype.laser_info.parent_type = parent_objp->type;

        weapon_objp->ctype.laser_info.parent_num = parent_objp.get_unchecked_index();

        weapon_objp->ctype.laser_info.parent_signature = parent_objp->signature;

        const auto &&lock_objnum = find_homing_object(firing_pos, weapon_objp);

        const auto &&firing_segnum = find_point_seg(LevelSharedSegmentState, LevelUniqueSegmentState, firing_pos, Segments.vmptridx(parent_objp->segnum));

        //      Play sound.

        {

                const auto flash_sound = Weapon_info[get_weapon_id(weapon_objp)].flash_sound;

        if ( parent_objp == Viewer )

                digi_play_sample(flash_sound, F1_0);

        else

                digi_link_sound_to_pos(flash_sound, vmsegptridx(weapon_objp->segnum), 0, weapon_objp->pos, 0, F1_0);

        }

        // -- if ((Last_omega_muzzle_flash_time + F1_0/4 < GameTime) || (Last_omega_muzzle_flash_time > GameTime)) {

        // --   do_muzzle_stuff(firing_segnum, firing_pos);

        // --   Last_omega_muzzle_flash_time = GameTime;

        // -- }

        //      Delete the original object.  Its only purpose in life was to determine which object to home in on.

        obj_delete(LevelUniqueObjectState, Segments, weapon_objp);

        //      If couldn't lock on anything, fire straight ahead.

        if (lock_objnum == object_none) {

                fvi_query       fq;

                fvi_info                hit_data;

                int                     fate;

                const auto &&perturbed_fvec = vm_vec_scale_add(parent_objp->orient.fvec, make_random_vector(), F1_0/16);

                vm_vec_scale_add(goal_pos, firing_pos, perturbed_fvec, MAX_OMEGA_DIST);

                fq.startseg = firing_segnum;

                if (fq.startseg == segment_none) {

                        return;

                }

                fq.p0                                           = &firing_pos;

                fq.p1                                           = &goal_pos;

                fq.rad                                  = 0;

                fq.thisobjnum                   = parent_objp;

                fq.ignore_obj_list.first = nullptr;

                fq.flags                                        = FQ_IGNORE_POWERUPS | FQ_TRANSPOINT | FQ_CHECK_OBJS;           //what about trans walls???

                fate = find_vector_intersection(fq, hit_data);

                if (fate != HIT_NONE) {

                        Assert(hit_data.hit_seg != segment_none);               //      How can this be?  We went from inside the mine to outside without hitting anything?

                        goal_pos = hit_data.hit_pnt;

                }

        } else

                goal_pos = lock_objnum->pos;

        //      This is where we create a pile of omega blobs!

        create_omega_blobs(firing_segnum, firing_pos, goal_pos, parent_objp);

}

static int is_laser_weapon_type(const weapon_id_type weapon_type)

{

        return weapon_type == weapon_id_type::LASER_ID_L1 ||

                weapon_type == weapon_id_type::LASER_ID_L2 ||

                weapon_type == weapon_id_type::LASER_ID_L3 ||

                weapon_type == weapon_id_type::LASER_ID_L4 ||

                weapon_type == weapon_id_type::LASER_ID_L5 ||

                weapon_type == weapon_id_type::LASER_ID_L6;

}

#endif

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

// Initializes a laser after Fire is pressed

//      Returns object number.

imobjptridx_t Laser_create_new(const vms_vector &direction, const vms_vector &position, const vmsegptridx_t segnum, const vmobjptridx_t parent, weapon_id_type weapon_type, int make_sound )

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        fix parent_speed, weapon_speed;

        fix volume;

        fix laser_length=0;

        if (weapon_type >= N_weapon_types)

        {

                con_printf(CON_URGENT, DXX_STRINGIZE_FL(__FILE__, __LINE__, "invalid weapon id %u fired by parent %hu (type %u) in segment %hu"), weapon_type, parent.get_unchecked_index(), parent->type, segnum.get_unchecked_index());

                weapon_type = weapon_id_type::LASER_ID_L1;

        }

        //      Don't let homing blobs make muzzle flash.

        if (parent->type == OBJ_ROBOT)

                do_muzzle_stuff(segnum, position);

        const imobjptridx_t obj = create_weapon_object(weapon_type,segnum,position);

        if (obj == object_none)

        {

                return object_none;

        }

        const auto &weapon_info = Weapon_info[weapon_type];

#if defined(DXX_BUILD_DESCENT_II)

        //      Do the special Omega Cannon stuff.  Then return on account of everything that follows does

        //      not apply to the Omega Cannon.

        if (weapon_type == weapon_id_type::OMEGA_ID) {

                // Create orientation matrix for tracking purposes.

                vm_vector_2_matrix( obj->orient, direction, &parent->orient.uvec ,nullptr);

                if (parent != Viewer && parent->type != OBJ_WEAPON) {

                        // Muzzle flash

                        if (weapon_info.flash_vclip > -1 )

                                object_create_muzzle_flash(vmsegptridx(obj->segnum), obj->pos, weapon_info.flash_size, weapon_info.flash_vclip);

                }

                do_omega_stuff(vmsegptridx, parent, position, obj);

                return obj;

        }

#endif

        if (parent->type == OBJ_PLAYER) {

                if (weapon_type == weapon_id_type::FUSION_ID) {

                        int     fusion_scale;

#if defined(DXX_BUILD_DESCENT_I)

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

                                fusion_scale = 2;

                        else

#endif

                                fusion_scale = 4;

                        auto &player_info = parent->ctype.player_info;

                        const auto Fusion_charge = player_info.Fusion_charge;

                        if (Fusion_charge <= 0)

                                obj->ctype.laser_info.multiplier = F1_0;

                        else if (Fusion_charge <= F1_0*fusion_scale)

                                obj->ctype.laser_info.multiplier = F1_0 + Fusion_charge/2;

                        else

                                obj->ctype.laser_info.multiplier = F1_0*fusion_scale;

#if defined(DXX_BUILD_DESCENT_I)

                        //      Fusion damage was boosted by mk on 3/27 (for reg 1.1 release), but we only want it to apply to single player games.

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

                                obj->ctype.laser_info.multiplier /= 2;

#endif

                }

#if defined(DXX_BUILD_DESCENT_II)

                else if (!EMULATING_D1 && is_laser_weapon_type(weapon_type) && (parent->ctype.player_info.powerup_flags & PLAYER_FLAGS_QUAD_LASERS))

                        obj->ctype.laser_info.multiplier = F1_0*3/4;

                else if (weapon_type == weapon_id_type::GUIDEDMISS_ID) {

                        if (parent==get_local_player().objnum) {

                                LevelUniqueObjectState.Guided_missile.set_player_active_guided_missile(obj, Player_num);

                                if (Newdemo_state==ND_STATE_RECORDING)

                                        newdemo_record_guided_start();

                        }

                }

#endif

        }

        //      Make children of smart bomb bounce so if they hit a wall right away, they

        //      won't detonate.  The frame interval code will clear this bit after 1/2 second.

#if defined(DXX_BUILD_DESCENT_I)

        if ((weapon_type == weapon_id_type::PLAYER_SMART_HOMING_ID) || (weapon_type == weapon_id_type::ROBOT_SMART_HOMING_ID))

#elif defined(DXX_BUILD_DESCENT_II)

        if ((weapon_type == weapon_id_type::PLAYER_SMART_HOMING_ID) || (weapon_type == weapon_id_type::SMART_MINE_HOMING_ID) || (weapon_type == weapon_id_type::ROBOT_SMART_HOMING_ID) || (weapon_type == weapon_id_type::ROBOT_SMART_MINE_HOMING_ID) || (weapon_type == weapon_id_type::EARTHSHAKER_MEGA_ID))

#endif

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

        if (weapon_info.render_type == WEAPON_RENDER_POLYMODEL)

        {

                auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

                laser_length = Polygon_models[obj->rtype.pobj_info.model_num].rad * 2;

        }

        if (weapon_type == weapon_id_type::FLARE_ID)

                obj->mtype.phys_info.flags |= PF_STICK;         //this obj sticks to walls

        const auto Difficulty_level = GameUniqueState.Difficulty_level;

        obj->shields = weapon_info.strength[Difficulty_level];

        // Fill in laser-specific data

        obj->lifeleft                                                   = weapon_info.lifetime;

        obj->ctype.laser_info.parent_type               = parent->type;

        obj->ctype.laser_info.parent_signature = parent->signature;

        obj->ctype.laser_info.parent_num                        = parent;

        //      Assign parent type to highest level creator.  This propagates parent type down from

        //      the original creator through weapons which create children of their own (ie, smart missile)

        if (parent->type == OBJ_WEAPON) {

                auto highest_parent = parent;

                int     count;

                count = 0;

                while ((count++ < 10) && (highest_parent->type == OBJ_WEAPON)) {

                        const auto next_parent = highest_parent->ctype.laser_info.parent_num;

                        const auto &&parent_objp = parent.absolute_sibling(next_parent);

                        if (!laser_parent_is_object(highest_parent->ctype.laser_info, parent_objp))

                                break;  //      Probably means parent was killed.  Just continue.

                        if (next_parent == highest_parent) {

                                Int3(); //      Hmm, object is parent of itself.  This would seem to be bad, no?

                                break;

                        }

                        highest_parent = parent_objp;

                        obj->ctype.laser_info.parent_num                        = highest_parent;

                        obj->ctype.laser_info.parent_type = highest_parent->type;

                        obj->ctype.laser_info.parent_signature = highest_parent->signature;