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.

*/

/*

 *

 * object system definitions

 *

 */

#pragma once

#include <type_traits>

#include "dsx-ns.h"

#ifdef dsx

#include "pstypes.h"

#include "vecmat.h"

#include "aistruct.h"

#include "polyobj.h"

#include "laser.h"

#ifdef __cplusplus

#include <cassert>

#include <cstdint>

#include "dxxsconf.h"

#include "valptridx.h"

#include "objnum.h"

#include "fwd-segment.h"

#include <vector>

#include <stdexcept>

#include "fwd-object.h"

#include "weapon.h"

#include "powerup.h"

#include "compiler-poison.h"

#include "physics_info.h"

#include "player-flags.h"

#if defined(DXX_BUILD_DESCENT_II)

#include "escort.h"

#endif

#include <array>

#include <utility>

namespace dcx {

// Object types

enum object_type_t : uint8_t

{

        OBJ_NONE        = 255, // unused object

        OBJ_WALL        = 0,   // A wall... not really an object, but used for collisions

        OBJ_FIREBALL    = 1,   // a fireball, part of an explosion

        OBJ_ROBOT       = 2,   // an evil enemy

        OBJ_HOSTAGE     = 3,   // a hostage you need to rescue

        OBJ_PLAYER      = 4,   // the player on the console

        OBJ_WEAPON      = 5,   // a laser, missile, etc

        OBJ_CAMERA      = 6,   // a camera to slew around with

        OBJ_POWERUP     = 7,   // a powerup you can pick up

        OBJ_DEBRIS      = 8,   // a piece of robot

        OBJ_CNTRLCEN    = 9,   // the control center

        OBJ_CLUTTER     = 11,  // misc objects

        OBJ_GHOST       = 12,  // what the player turns into when dead

        OBJ_LIGHT       = 13,  // a light source, & not much else

        OBJ_COOP        = 14,  // a cooperative player object.

        OBJ_MARKER      = 15,  // a map marker

};

enum movement_type_t : uint8_t

{

        MT_NONE = 0,   // doesn't move

        MT_PHYSICS = 1,   // moves by physics

        MT_SPINNING = 3,   // this object doesn't move, just sits and spins

};

enum render_type_t : uint8_t

{

        RT_NONE = 0,   // does not render

        RT_POLYOBJ = 1,   // a polygon model

        RT_FIREBALL = 2,   // a fireball

        RT_LASER = 3,   // a laser

        RT_HOSTAGE = 4,   // a hostage

        RT_POWERUP = 5,   // a powerup

        RT_MORPH = 6,   // a robot being morphed

        RT_WEAPON_VCLIP = 7,   // a weapon that renders as a vclip

};

static inline bool valid_render_type(const uint8_t r)

{

        switch (r)

        {

                case RT_NONE:

                case RT_POLYOBJ:

                case RT_FIREBALL:

                case RT_LASER:

                case RT_HOSTAGE:

                case RT_POWERUP:

                case RT_MORPH:

                case RT_WEAPON_VCLIP:

                        return true;

                default:

                        return false;

        }

}

}

namespace dsx {

/*

 * STRUCTURES

 */

struct reactor_static {

        /* Location of the gun on the reactor object */

        std::array<vms_vector, MAX_CONTROLCEN_GUNS>     gun_pos,

        /* Orientation of the gun on the reactor object */

                gun_dir;

};

struct player_info

{

        fix     energy;                 // Amount of energy remaining.

        fix     homing_object_dist;     // Distance of nearest homing object.

        fix Fusion_charge;

#if defined(DXX_BUILD_DESCENT_II)

        fix Omega_charge;

        fix Omega_recharge_delay;

#endif

        player_flags powerup_flags;

        objnum_t   killer_objnum;          // Who killed me.... (-1 if no one)

        uint16_t vulcan_ammo;

#if defined(DXX_BUILD_DESCENT_I)

        using primary_weapon_flag_type = uint8_t;

#elif defined(DXX_BUILD_DESCENT_II)

        using primary_weapon_flag_type = uint16_t;

#endif

        primary_weapon_flag_type primary_weapon_flags;

        bool Player_eggs_dropped;

        bool FakingInvul;

        bool lavafall_hiss_playing;

        uint8_t missile_gun;

        player_selected_weapon<primary_weapon_index_t> Primary_weapon;

        player_selected_weapon<secondary_weapon_index_t> Secondary_weapon;

        stored_laser_level laser_level;

        std::array<uint8_t, MAX_SECONDARY_WEAPONS>  secondary_ammo; // How much ammo of each type.

        uint8_t Spreadfire_toggle;

#if defined(DXX_BUILD_DESCENT_II)

        uint8_t Primary_last_was_super;

        uint8_t Secondary_last_was_super;

        uint8_t Helix_orientation;

#endif

        int16_t net_killed_total;               // Number of times killed total

        int16_t net_kills_total;                // Number of net kills total

        int16_t KillGoalCount;                  // Num of players killed this level

        union {

                struct {

                        int score;                              // Current score.

                        int last_score;                 // Score at beginning of current level.

                        uint16_t hostages_rescued_total; // Total number of hostages rescued.

                        uint8_t hostages_on_board;

                } mission;

                struct {

                        uint8_t orbs;

                } hoard;

        };

        enum

        {

                max_hoard_orbs = 12,

        };

        fix64   cloak_time;             // Time cloaked

        fix64   invulnerable_time;      // Time invulnerable

        fix64 Next_flare_fire_time;

        fix64 Next_laser_fire_time;

        fix64 Next_missile_fire_time;

        fix64 Last_bumped_local_player;

        fix64 Auto_fire_fusion_cannon_time;

};

}

namespace dcx {

// A compressed form for sending crucial data

struct shortpos : prohibit_void_ptr<shortpos>

{

        std::array<int8_t, 9> bytemat;

        int16_t xo, yo, zo;

        segnum_t segment;

        int16_t velx, vely, velz;

};

// Another compressed form for object position, velocity, orientation and rotvel using quaternion

struct quaternionpos : prohibit_void_ptr<quaternionpos>

{

        using packed_size = std::integral_constant<std::size_t, sizeof(vms_quaternion) + sizeof(segnum_t) + (sizeof(vms_vector) * 3)>;

        vms_quaternion orient;

        vms_vector pos;

        segnum_t segment;

        vms_vector vel;

        vms_vector rotvel;

};

// stuctures for different kinds of simulation

struct laser_parent

{

        int16_t parent_type = {};        // The type of the parent of this object

        objnum_t parent_num = {};         // The object's parent's number

        object_signature_t parent_signature = object_signature_t{0};   // The object's parent's signature...

};

struct laser_info : prohibit_void_ptr<laser_info>, laser_parent

{

        fix64 creation_time = 0;      // Absolute time of creation.

        /* hitobj_pos specifies the next position to which a value should be

         * written.  That position may have a defined value if the array has

         * wrapped, but should be treated as write-only in the general case.

         *

         * hitobj_count tells how many elements in hitobj_values[] are

         * valid.  Its valid values are [0, hitobj_values.size()].  When

         * hitobj_count == hitobj_values.size(), hitobj_pos wraps around and

         * begins erasing the oldest elements first.

         */

        uint8_t hitobj_pos = 0, hitobj_count = 0;

        std::array<objnum_t, 83> hitobj_values = {};

        objnum_t track_goal = 0;         // Object this object is tracking.

        fix multiplier = 0;         // Power if this is a fusion bolt (or other super weapon to be added).

        uint_fast8_t test_set_hitobj(const vcobjidx_t o);

        uint_fast8_t test_hitobj(const vcobjidx_t o) const;

        icobjidx_t get_last_hitobj() const;

        void clear_hitobj()

        {

                hitobj_pos = hitobj_count = 0;

        }

        void reset_hitobj(const icobjidx_t o)

        {

                if (o == object_none)

                {

                        /* Adding object_none to the array is harmless, since

                         * get_last_hitobj can return object_none for empty arrays.

                         * However, by filtering it here (which is called only when

                         * loading data into new objects), test_hitobj (which is

                         * called every time the object strikes a potential target)

                         * will not need to read a slot that is guaranteed not to

                         * match.

                         */

                        clear_hitobj();

                        return;

                }

                /* Assume caller already poisoned the unused array elements */

                hitobj_pos = hitobj_count = 1;

                hitobj_values[0] = o;

        }

};

// Same as above but structure Savegames/Multiplayer objects expect

struct laser_info_rw

{

        short   parent_type;        // The type of the parent of this object

        short   parent_num;         // The object's parent's number

        int     parent_signature;   // The object's parent's signature...

        fix     creation_time;      // Absolute time of creation.

        short   last_hitobj;        // For persistent weapons (survive object collision), object it most recently hit.

        short   track_goal;         // Object this object is tracking.

        fix     multiplier;         // Power if this is a fusion bolt (or other super weapon to be added).

} __pack__;

struct explosion_info : prohibit_void_ptr<explosion_info>

{

    fix     spawn_time;         // when lifeleft is < this, spawn another

    fix     delete_time;        // when to delete object

    objnum_t   delete_objnum;      // and what object to delete

    objnum_t   attach_parent;      // explosion is attached to this object

    objnum_t   prev_attach;        // previous explosion in attach list

    objnum_t   next_attach;        // next explosion in attach list

};

struct explosion_info_rw

{

    fix     spawn_time;         // when lifeleft is < this, spawn another

    fix     delete_time;        // when to delete object

    short   delete_objnum;      // and what object to delete

    short   attach_parent;      // explosion is attached to this object

    short   prev_attach;        // previous explosion in attach list

    short   next_attach;        // next explosion in attach list

} __pack__;

struct light_info : prohibit_void_ptr<light_info>

{

    fix     intensity;          // how bright the light is

};

struct light_info_rw

{

    fix     intensity;          // how bright the light is

} __pack__;

struct powerup_info : prohibit_void_ptr<powerup_info>

{

        int     count;          // how many/much we pick up (vulcan cannon only?)

        int     flags;          // spat by player?

        fix64   creation_time;  // Absolute time of creation.

};

}

namespace dsx {

struct powerup_info_rw

{

        int     count;          // how many/much we pick up (vulcan cannon only?)

#if defined(DXX_BUILD_DESCENT_II)

// Same as above but structure Savegames/Multiplayer objects expect

        fix     creation_time;  // Absolute time of creation.

        int     flags;          // spat by player?

#endif

} __pack__;

}

namespace dcx {

struct vclip_info : prohibit_void_ptr<vclip_info>

{

        int     vclip_num;

        fix     frametime;

        uint8_t framenum;

};

struct vclip_info_rw

{

        int     vclip_num;

        fix     frametime;

        sbyte   framenum;

} __pack__;

// structures for different kinds of rendering

struct polyobj_info : prohibit_void_ptr<polyobj_info>

{

        int     model_num = 0;          // which polygon model

        std::array<vms_angvec, MAX_SUBMODELS> anim_angles{}; // angles for each subobject

        int     subobj_flags = 0;       // specify which subobjs to draw

        int     tmap_override = 0;      // if this is not -1, map all face to this

        int     alt_textures = 0;       // if not -1, use these textures instead

};

struct polyobj_info_rw

{

        int     model_num;          // which polygon model

        vms_angvec anim_angles[MAX_SUBMODELS]; // angles for each subobject

        int     subobj_flags;       // specify which subobjs to draw

        int     tmap_override;      // if this is not -1, map all face to this

        int     alt_textures;       // if not -1, use these textures instead

} __pack__;

struct object_base

{

        object_signature_t signature;

        object_type_t   type;           // what type of object this is... robot, weapon, hostage, powerup, fireball

        ubyte   id;             // which form of object...which powerup, robot, etc.

        objnum_t   next,prev;      // id of next and previous connected object in Objects, -1 = no connection

        ubyte   control_type;   // how this object is controlled

        movement_type_t   movement_type;  // how this object moves

        render_type_t render_type;    // how this object renders

        ubyte   flags;          // misc flags

        segnum_t   segnum;         // segment number containing object

        objnum_t   attached_obj;   // number of attached fireball object

        vms_vector pos;         // absolute x,y,z coordinate of center of object

        vms_matrix orient;      // orientation of object in world

        fix     size;           // 3d size of object - for collision detection

        fix     shields;        // Starts at maximum, when <0, object dies..

        sbyte   contains_type;  // Type of object this object contains (eg, spider contains powerup)

        sbyte   contains_id;    // ID of object this object contains (eg, id = blue type = key)

        sbyte   contains_count; // number of objects of type:id this object contains

        sbyte   matcen_creator; // Materialization center that created this object, high bit set if matcen-created

        fix     lifeleft;       // how long until goes away, or 7fff if immortal

        // -- Removed, MK, 10/16/95, using lifeleft instead: int     lightlevel;

        // movement info, determined by MOVEMENT_TYPE

        union movement_info {

                physics_info phys_info; // a physics object

                vms_vector   spin_rate; // for spinning objects

                constexpr movement_info() :

                        phys_info{}

                {

                        static_assert(sizeof(phys_info) == sizeof(*this), "insufficient initialization");

                }

        } mtype;

        // render info, determined by RENDER_TYPE

        union render_info {

                struct polyobj_info    pobj_info;      // polygon model

                struct vclip_info      vclip_info;     // vclip

                constexpr render_info() :

                        pobj_info{}

                {

                        static_assert(sizeof(pobj_info) == sizeof(*this), "insufficient initialization");

                }

        } rtype;

};

}

namespace dsx {

#if defined(DXX_BUILD_DESCENT_II)

struct laser_info : public ::dcx::laser_info

{

        fix64 last_afterburner_time = 0;        //      Time at which this object last created afterburner blobs.

};

#endif

struct object : public ::dcx::object_base

{

        // control info, determined by CONTROL_TYPE

        union control_info {

                constexpr control_info() :

                        ai_info{}

                {

                        static_assert(sizeof(ai_info) == sizeof(*this), "insufficient initialization");

                }

                struct laser_info      laser_info;

                struct explosion_info  expl_info;      // NOTE: debris uses this also

                struct light_info      light_info;     // why put this here?  Didn't know what else to do with it.

                struct powerup_info    powerup_info;

                struct ai_static       ai_info;

                struct reactor_static  reactor_info;

                struct player_info     player_info;

        } ctype;

};

}

namespace dcx {

// Same as above but structure Savegames/Multiplayer objects expect

struct object_rw

{

        int     signature;      // Every object ever has a unique signature...

        ubyte   type;           // what type of object this is... robot, weapon, hostage, powerup, fireball

        ubyte   id;             // which form of object...which powerup, robot, etc.

        short   next,prev;      // id of next and previous connected object in Objects, -1 = no connection

        ubyte   control_type;   // how this object is controlled

        ubyte   movement_type;  // how this object moves

        ubyte   render_type;    // how this object renders

        ubyte   flags;          // misc flags

        short   segnum;         // segment number containing object

        short   attached_obj;   // number of attached fireball object

        vms_vector pos;         // absolute x,y,z coordinate of center of object

        vms_matrix orient;      // orientation of object in world

        fix     size;           // 3d size of object - for collision detection

        fix     shields;        // Starts at maximum, when <0, object dies..

        vms_vector last_pos;    // where object was last frame

        sbyte   contains_type;  // Type of object this object contains (eg, spider contains powerup)

        sbyte   contains_id;    // ID of object this object contains (eg, id = blue type = key)

        sbyte   contains_count; // number of objects of type:id this object contains

        sbyte   matcen_creator; // Materialization center that created this object, high bit set if matcen-created

        fix     lifeleft;       // how long until goes away, or 7fff if immortal

        // -- Removed, MK, 10/16/95, using lifeleft instead: int     lightlevel;

        // movement info, determined by MOVEMENT_TYPE

        union {

                physics_info_rw phys_info; // a physics object

                vms_vector   spin_rate; // for spinning objects

        } __pack__ mtype ;

        // control info, determined by CONTROL_TYPE

        union {

                laser_info_rw   laser_info;

                explosion_info_rw  expl_info;      // NOTE: debris uses this also

                ai_static_rw    ai_info;

                light_info_rw      light_info;     // why put this here?  Didn't know what else to do with it.

                powerup_info_rw powerup_info;

        } __pack__ ctype ;

        // render info, determined by RENDER_TYPE

        union {

                polyobj_info_rw    pobj_info;      // polygon model

                vclip_info_rw      vclip_info;     // vclip

        } __pack__ rtype;

} __pack__;

struct obj_position

{

        vms_vector  pos;        // absolute x,y,z coordinate of center of object

        vms_matrix  orient;     // orientation of object in world

        segnum_t       segnum;     // segment number containing object

};

#define set_object_type(O,T)    \

        ( DXX_BEGIN_COMPOUND_STATEMENT {        \

                object_base &dxx_object_type_ref = (O); \

                const uint8_t &dxx_object_type_value = (T);     \

                assert( \

                        dxx_object_type_value == OBJ_NONE ||    \

                        dxx_object_type_value == OBJ_FIREBALL ||        \

                        dxx_object_type_value == OBJ_ROBOT ||   \

                        dxx_object_type_value == OBJ_HOSTAGE || \

                        dxx_object_type_value == OBJ_PLAYER ||  \

                        dxx_object_type_value == OBJ_WEAPON ||  \

                        dxx_object_type_value == OBJ_CAMERA ||  \

                        dxx_object_type_value == OBJ_POWERUP || \

                        dxx_object_type_value == OBJ_DEBRIS ||  \

                        dxx_object_type_value == OBJ_CNTRLCEN ||        \

                        dxx_object_type_value == OBJ_CLUTTER || \

                        dxx_object_type_value == OBJ_GHOST ||   \

                        dxx_object_type_value == OBJ_LIGHT ||   \

                        dxx_object_type_value == OBJ_COOP ||    \

                        dxx_object_type_value == OBJ_MARKER     \

                );      \

                dxx_object_type_ref.type = static_cast<object_type_t>(dxx_object_type_value);   \

        } DXX_END_COMPOUND_STATEMENT )

#define set_object_movement_type(O,T)   \

        ( DXX_BEGIN_COMPOUND_STATEMENT {        \

                object_base &dxx_object_movement_type_ref = (O);        \

                const uint8_t &dxx_object_movement_type_value = (T);    \

                assert( \

                        dxx_object_movement_type_value == MT_NONE ||    \

                        dxx_object_movement_type_value == MT_PHYSICS || \

                        dxx_object_movement_type_value == MT_SPINNING   \

                );      \

                dxx_object_movement_type_ref.movement_type = static_cast<movement_type_t>(dxx_object_movement_type_value);      \

        } DXX_END_COMPOUND_STATEMENT )

template <typename T, std::size_t... N>

constexpr std::array<T, sizeof...(N)> init_object_number_array(std::index_sequence<N...>)

{

        return {{((void)N, object_none)...}};

}

template <typename T, std::size_t N>

struct object_number_array : std::array<T, N>

{

        constexpr object_number_array() :

                std::array<T, N>(init_object_number_array<T>(std::make_index_sequence<N>()))

        {

        }

};

unsigned laser_parent_is_matching_signature(const laser_parent &l, const object_base &o);

struct d_level_unique_control_center_state

{

        uint8_t Control_center_destroyed;

        uint8_t Control_center_been_hit;

        uint8_t Control_center_present;

        player_visibility_state Control_center_player_been_seen;

        objnum_t Dead_controlcen_object_num;

        int Countdown_seconds_left;

        fix Countdown_timer;

        fix Frametime_until_next_fire;

        /* If the player is not dead, this stays 0.  If the player is dead,

         * this accumulates FrameTime, up until it saturates.  When it

         * saturates, the reactor stops firing.

         *

         * FIXME: The original game defined this in terms of "the player",

         * but reactors are present in multiplayer games.

         */

        fix Frametime_since_player_died;

        int Total_countdown_time;               //in whole seconds

};

struct d_level_unique_boss_state

{

        fix64 Last_gate_time;

        fix64 Boss_cloak_start_time;

        fix64 Last_teleport_time;

        fix64 Boss_dying_start_time;

        int8_t Boss_hit_this_frame;

        int8_t Boss_dying;

        int8_t Boss_dying_sound_playing;

};

}

#define Highest_object_index (Objects.get_count() - 1)

#include "morph.h"

namespace dcx {

struct d_level_unique_morph_object_state

{

        std::array<morph_data::ptr, 5> morph_objects;

        ~d_level_unique_morph_object_state();

};

}

namespace dsx {

#if defined(DXX_BUILD_DESCENT_II)

/* game_marker_index values are assigned as the object.id field for

 * marker objects, and are used as an index into most marker-related

 * arrays.  These values are scoped to a single level.  Each player

 * marker has a unique value for game_marker_index, computed based on

 * the player's ID and the player_marker_index active for that player

 * when the marker was created.

 */

enum class game_marker_index : uint8_t

{

        GuidebotDeathSite = 10,

        None = UINT8_MAX

};

/* player_marker_index are per-player marker indexes.  Each player has

 * their own private number space.  Valid values range from [0,

 * maxdrop), where maxdrop depends on the game type (single player,

 * competitive multiplayer, or cooperative multiplayer).

 */

enum class player_marker_index : uint8_t

{

        _0,

        None = UINT8_MAX

};

static inline game_marker_index &operator++(game_marker_index &i)

{

        auto u = static_cast<unsigned>(i);

        ++ u;

        i = static_cast<game_marker_index>(u);

        return i;

}

static inline player_marker_index &operator++(player_marker_index &i)

{

        auto u = static_cast<unsigned>(i);

        ++ u;

        i = static_cast<player_marker_index>(u);

        return i;

}

playernum_t get_marker_owner(unsigned, game_marker_index, unsigned max_numplayers);

struct d_unique_buddy_state

{

        enum class Escort_goal_reachability : uint8_t

        {

                unreachable,

                reachable,

        };

        icobjidx_t Buddy_objnum = object_none;

        icobjidx_t Escort_goal_objidx = object_none;

        Escort_goal_reachability Escort_goal_reachable = Escort_goal_reachability::unreachable;

        uint8_t Buddy_allowed_to_talk;

        uint8_t Buddy_messages_suppressed;

        uint8_t Buddy_gave_hint_count;

        game_marker_index Looking_for_marker;

        int Last_buddy_key;

        int Last_buddy_polish_path_tick;

        escort_goal_t Escort_goal_object;

        escort_goal_t Escort_special_goal;

        fix64 Buddy_sorry_time;

        fix64 Buddy_last_seen_player;

        fix64 Buddy_last_missile_time;

        fix64 Last_time_buddy_gave_hint;

        fix64 Last_come_back_message_time;

        fix64 Escort_last_path_created;

        fix64 Buddy_last_player_path_created;

        fix64 Last_buddy_message_time;

};

struct d_level_unique_control_center_state :

        ::dcx::d_level_unique_control_center_state

{

        fix64 Last_time_cc_vis_check;

};

class d_guided_missile_indices : object_number_array<imobjidx_t, MAX_PLAYERS>

{

        template <typename R, typename F>

                R get_player_active_guided_missile_tmpl(F &fvcobj, unsigned pnum) const;

        static bool debug_check_current_object(const object_base &);

public:

        imobjidx_t get_player_active_guided_missile(unsigned pnum) const;

        imobjptr_t get_player_active_guided_missile(fvmobjptr &vmobjptr, unsigned pnum) const;

        imobjptridx_t get_player_active_guided_missile(fvmobjptridx &vmobjptridx, unsigned pnum) const;

        void set_player_active_guided_missile(vmobjidx_t, unsigned pnum);

        void clear_player_active_guided_missile(unsigned pnum);

};

struct d_level_unique_boss_state : ::dcx::d_level_unique_boss_state

{

        fix64 Boss_hit_time;

};

const player &get_player_controlling_guidebot(const d_unique_buddy_state & /* reserved for future use */, const valptridx<player>::array_managed_type &Players);

#endif

struct d_level_unique_object_state

{

        unsigned num_objects = 0;

        /* `accumulated_robots` counts robots present at level entry and

         * robots added later via materialization centers / boss gating.  It

         * never decreases, so it is not a shortcut for counting the number

         * of currently live objects with type OBJ_ROBOT.

         */

        unsigned accumulated_robots;

        unsigned total_hostages;

        unsigned Debris_object_count = 0;

#if defined(DXX_BUILD_DESCENT_II)

        d_unique_buddy_state BuddyState;

        d_thief_unique_state ThiefState;

        d_guided_missile_indices Guided_missile;

#endif

        object_number_array<imobjidx_t, MAX_OBJECTS> free_obj_list;

        object_array Objects;

        d_level_unique_boss_state BossState;

        d_level_unique_control_center_state ControlCenterState;

        vms_vector last_console_player_position;

        d_level_unique_morph_object_state MorphObjectState;

        auto &get_objects()

        {

                return Objects;

        }

        const auto &get_objects() const

        {

                return Objects;

        }

};

extern d_level_unique_object_state LevelUniqueObjectState;

unsigned laser_parent_is_player(fvcobjptr &, const laser_parent &, const object_base &);

unsigned laser_parent_is_object(fvcobjptr &, const laser_parent &, const object_base &);

unsigned laser_parent_is_object(const laser_parent &, vcobjptridx_t);

unsigned laser_parent_object_exists(fvcobjptr &, const laser_parent &);

static inline powerup_type_t get_powerup_id(const object_base &o)

{

        return static_cast<powerup_type_t>(o.id);

}

static inline weapon_id_type get_weapon_id(const object_base &o)

{

        return static_cast<weapon_id_type>(o.id);

}

#if defined(DXX_BUILD_DESCENT_II)

static inline game_marker_index get_marker_id(const object_base &o)

{

        return game_marker_index{o.id};

}

#endif

void set_powerup_id(const d_powerup_info_array &Powerup_info, const d_vclip_array &Vclip, object_base &o, powerup_type_t id);

static inline void set_weapon_id(object_base &o, weapon_id_type id)

{

        o.id = static_cast<uint8_t>(id);

}

}

namespace dcx {

static inline uint8_t get_player_id(const object_base &o)

{

        return o.id;

}

static inline uint8_t get_reactor_id(const object_base &o)

{

        return o.id;

}

static inline uint8_t get_fireball_id(const object_base &o)

{

        return o.id;

}

static inline uint8_t get_robot_id(const object_base &o)

{

        return o.id;

}

static inline void set_player_id(object_base &o, const uint8_t id)

{

        o.id = id;

}

static inline void set_reactor_id(object_base &o, const uint8_t id)

{

        o.id = id;

}

static inline void set_robot_id(object_base &o, const uint8_t id)

{

        o.id = id;

}

void check_warn_object_type(const object_base &, object_type_t, const char *file, unsigned line);

#define get_player_id(O)        (check_warn_object_type(O, OBJ_PLAYER, __FILE__, __LINE__), get_player_id(O))

#define get_powerup_id(O)       (check_warn_object_type(O, OBJ_POWERUP, __FILE__, __LINE__), get_powerup_id(O))

#define get_reactor_id(O)       (check_warn_object_type(O, OBJ_CNTRLCEN, __FILE__, __LINE__), get_reactor_id(O))

#define get_ghost_id(O) (check_warn_object_type(O, OBJ_GHOST, __FILE__, __LINE__), (get_player_id)(O))

#define get_fireball_id(O)      (check_warn_object_type(O, OBJ_FIREBALL, __FILE__, __LINE__), get_fireball_id(O))

#define get_robot_id(O) (check_warn_object_type(O, OBJ_ROBOT, __FILE__, __LINE__), get_robot_id(O))

#define get_weapon_id(O)        (check_warn_object_type(O, OBJ_WEAPON, __FILE__, __LINE__), get_weapon_id(O))

#if defined(DXX_BUILD_DESCENT_II)

#define get_marker_id(O)        (check_warn_object_type(O, OBJ_MARKER, __FILE__, __LINE__), get_marker_id(O))

#endif

#define set_player_id(O,I)      (check_warn_object_type(O, OBJ_PLAYER, __FILE__, __LINE__), set_player_id(O, I))

#define set_reactor_id(O,I)     (check_warn_object_type(O, OBJ_CNTRLCEN, __FILE__, __LINE__), set_reactor_id(O, I))

#define set_robot_id(O,I)       (check_warn_object_type(O, OBJ_ROBOT, __FILE__, __LINE__), set_robot_id(O, I))

#define set_weapon_id(O,I)      (check_warn_object_type(O, OBJ_WEAPON, __FILE__, __LINE__), set_weapon_id(O, I))

#ifdef DXX_CONSTANT_TRUE

#define check_warn_object_type(O,T,F,L) \

        ( DXX_BEGIN_COMPOUND_STATEMENT {        \

                const object_base &dxx_check_warn_o = (O);      \

                const auto dxx_check_warn_actual_type = dxx_check_warn_o.type;  \

                const auto dxx_check_warn_expected_type = (T);  \

                /* If the type is always right, omit the runtime check. */      \

                DXX_CONSTANT_TRUE(dxx_check_warn_actual_type == dxx_check_warn_expected_type) || (      \

                        /* If the type is always wrong, force a compile-time error. */  \

                        DXX_CONSTANT_TRUE(dxx_check_warn_actual_type != dxx_check_warn_expected_type)   \

                        ? DXX_ALWAYS_ERROR_FUNCTION(dxx_error_object_type_mismatch, "object type mismatch")     \

                        : (     \

                                check_warn_object_type(dxx_check_warn_o, dxx_check_warn_expected_type, F, L)    \

                        )       \

                , 0);   \

        } DXX_END_COMPOUND_STATEMENT )

#endif

}

#endif

#endif