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.

 * See COPYING.txt for license details.

 */

#pragma once

#include <type_traits>

#include "dxxsconf.h"

#include "dsx-ns.h"

#include "objnum.h"

#include "fwd-vecmat.h"

#include "fwd-segment.h"

#include "fwd-window.h"

#include "fwd-valptridx.h"

#include <array>

struct bitmap_index;

namespace dcx {

// Movement types

enum movement_type_t : uint8_t;

constexpr std::integral_constant<std::size_t, 350> MAX_OBJECTS{};

constexpr std::integral_constant<std::size_t, MAX_OBJECTS - 20> MAX_USED_OBJECTS{};

struct d_level_unique_control_center_state;

// Render types

enum render_type_t : uint8_t;

}

#ifdef dsx

namespace dsx {

struct object;

struct d_level_unique_object_state;

}

DXX_VALPTRIDX_DECLARE_SUBTYPE(dsx::, object, objnum_t, MAX_OBJECTS);

namespace dsx {

DXX_VALPTRIDX_DEFINE_SUBTYPE_TYPEDEFS(object, obj);

static constexpr valptridx<object>::magic_constant<0xffff> object_none{};

static constexpr valptridx<object>::magic_constant<0> object_first{};

#if defined(DXX_BUILD_DESCENT_I)

constexpr std::integral_constant<unsigned, 15> MAX_OBJECT_TYPES{};

#elif defined(DXX_BUILD_DESCENT_II)

constexpr std::integral_constant<unsigned, 16> MAX_OBJECT_TYPES{};

struct d_level_unique_control_center_state;

#endif

}

#endif

// Result types

typedef unsigned result_type_t;

constexpr std::integral_constant<result_type_t, 0> RESULT_NOTHING{};   // Ignore this collision

constexpr std::integral_constant<result_type_t, 1> RESULT_CHECK{};   // Check for this collision

// Control types - what tells this object what do do

typedef unsigned control_type_t;

constexpr std::integral_constant<control_type_t, 0> CT_NONE{};          // doesn't move (or change movement)

constexpr std::integral_constant<control_type_t, 1> CT_AI{};                    // driven by AI

constexpr std::integral_constant<control_type_t, 2> CT_EXPLOSION{};     // explosion sequencer

constexpr std::integral_constant<control_type_t, 4> CT_FLYING{};                // the player is flying

constexpr std::integral_constant<control_type_t, 5> CT_SLEW{};          // slewing

constexpr std::integral_constant<control_type_t, 6> CT_FLYTHROUGH{};    // the flythrough system

constexpr std::integral_constant<control_type_t, 9> CT_WEAPON{};                // laser, etc.

constexpr std::integral_constant<control_type_t, 10> CT_REPAIRCEN{};    // under the control of the repair center

constexpr std::integral_constant<control_type_t, 11> CT_MORPH{};                // this object is being morphed

constexpr std::integral_constant<control_type_t, 12> CT_DEBRIS{};       // this is a piece of debris

constexpr std::integral_constant<control_type_t, 13> CT_POWERUP{};      // animating powerup blob

constexpr std::integral_constant<control_type_t, 14> CT_LIGHT{};                // doesn't actually do anything

constexpr std::integral_constant<control_type_t, 15> CT_REMOTE{};       // controlled by another net player

constexpr std::integral_constant<control_type_t, 16> CT_CNTRLCEN{};     // the control center/main reactor

// misc object flags

typedef unsigned object_flag_t;

constexpr std::integral_constant<object_flag_t, 1> OF_EXPLODING{};   // this object is exploding

constexpr std::integral_constant<object_flag_t, 2> OF_SHOULD_BE_DEAD{};   // this object should be dead, so next time we can, we should delete this object.

constexpr std::integral_constant<object_flag_t, 4> OF_DESTROYED{};   // this has been killed, and is showing the dead version

constexpr std::integral_constant<object_flag_t, 8> OF_SILENT{};   // this makes no sound when it hits a wall.  Added by MK for weapons, if you extend it to other types, do it completely!

constexpr std::integral_constant<object_flag_t, 16> OF_ATTACHED{};  // this object is a fireball attached to another object

#if defined(DXX_BUILD_DESCENT_II)

constexpr std::integral_constant<object_flag_t, 64> OF_PLAYER_DROPPED{};  // this object was dropped by the player...

#endif

// physics flags

typedef unsigned physics_flag_t;

constexpr std::integral_constant<physics_flag_t, 0x01> PF_TURNROLL{};    // roll when turning

constexpr std::integral_constant<physics_flag_t, 0x02> PF_LEVELLING{};    // level object with closest side

constexpr std::integral_constant<physics_flag_t, 0x04> PF_BOUNCE{};    // bounce (not slide) when hit will

constexpr std::integral_constant<physics_flag_t, 0x08> PF_WIGGLE{};    // wiggle while flying

constexpr std::integral_constant<physics_flag_t, 0x10> PF_STICK{};    // object sticks (stops moving) when hits wall

constexpr std::integral_constant<physics_flag_t, 0x20> PF_PERSISTENT{};    // object keeps going even after it hits another object (eg, fusion cannon)

constexpr std::integral_constant<physics_flag_t, 0x40> PF_USES_THRUST{};    // this object uses its thrust

#if defined(DXX_BUILD_DESCENT_II)

constexpr std::integral_constant<physics_flag_t, 0x80> PF_BOUNCED_ONCE{};    // Weapon has bounced once.

constexpr std::integral_constant<physics_flag_t, 0x100> PF_FREE_SPINNING{};   // Drag does not apply to rotation of this object

constexpr std::integral_constant<physics_flag_t, 0x200> PF_BOUNCES_TWICE{};   // This weapon bounces twice, then dies

#endif

namespace dcx {

enum object_type_t : uint8_t;

struct object_base;

typedef unsigned powerup_flag_t;

constexpr std::integral_constant<powerup_flag_t, 1> PF_SPAT_BY_PLAYER{};   //this powerup was spat by the player

constexpr std::integral_constant<unsigned, 0x3fffffff> IMMORTAL_TIME{};  // Time assigned to immortal objects, about 32768 seconds, or about 9 hours.

struct shortpos;

struct quaternionpos;

// This is specific to the shortpos extraction routines in gameseg.c.

constexpr std::integral_constant<unsigned, 10> RELPOS_PRECISION{};

constexpr std::integral_constant<unsigned, 9> MATRIX_PRECISION{};

struct physics_info;

struct physics_info_rw;

struct laser_parent;

struct laser_info_rw;

struct explosion_info;

struct explosion_info_rw;

struct light_info;

struct light_info_rw;

struct powerup_info;

struct vclip_info;

struct vclip_info_rw;

struct polyobj_info;

struct polyobj_info_rw;

struct obj_position;

struct object_rw;

}

#ifdef dsx

namespace dsx {

#if defined(DXX_BUILD_DESCENT_I)

constexpr std::integral_constant<unsigned, 4> MAX_CONTROLCEN_GUNS{};

#elif defined(DXX_BUILD_DESCENT_II)

constexpr std::integral_constant<unsigned, 8> MAX_CONTROLCEN_GUNS{};

struct d_unique_buddy_state;

#endif

struct powerup_info_rw;

struct window_rendered_data;

struct reactor_static;

using collision_inner_array_t = std::array<uint8_t, MAX_OBJECT_TYPES>;

using collision_outer_array_t = std::array<collision_inner_array_t, MAX_OBJECT_TYPES>;

extern const collision_outer_array_t CollisionResult;

}

#endif

namespace dcx {

extern int Object_next_signature;   // The next signature for the next newly created object

extern int Num_robot_types;

}

#ifdef dsx

namespace dsx {

extern object *ConsoleObject;       // pointer to the object that is the player

extern const object *Viewer;              // which object we are seeing from

extern object *Dead_player_camera;

}

#endif

enum class player_dead_state : uint8_t

{

        no,

        yes,

        exploded,

};

namespace dcx {

extern player_dead_state Player_dead_state;          // !0 means player is dead!

extern objnum_t Player_fired_laser_this_frame;

// Draw a blob-type object, like a fireball

void draw_object_blob(grs_canvas &, const object_base &obj, bitmap_index bitmap);

}

#ifdef dsx

namespace dsx {

// do whatever setup needs to be done

void init_objects();

// when an object has moved into a new segment, this function unlinks it

// from its old segment, and links it into the new segment

void obj_relink(fvmobjptr &vmobjptr, fvmsegptr &vmsegptr, vmobjptridx_t objnum, vmsegptridx_t newsegnum);

// for getting out of messed up linking situations (i.e. caused by demo playback)

void obj_relink_all();

// links an object into a segment's list of objects.

// takes object number and segment number

void obj_link(fvmobjptr &vmobjptr, vmobjptridx_t objnum, vmsegptridx_t segnum);

/* Link an object without checking whether the object is currently

 * unlinked.  This should be used only in cases where the caller is

 * intentionally overriding the normal linking rules (such as loading

 * objects from demos or from the network).

 */

void obj_link_unchecked(fvmobjptr &vmobjptr, vmobjptridx_t obj, vmsegptridx_t segnum);

// unlinks an object from a segment's list of objects

void obj_unlink(fvmobjptr &vmobjptr, fvmsegptr &vmsegptr, object_base &obj);

// initialize a new object.  adds to the list for the given segment

// returns the object number

imobjptridx_t obj_create(object_type_t type, unsigned id, vmsegptridx_t segnum, const vms_vector &pos, const vms_matrix *orient, fix size, unsigned ctype, movement_type_t mtype, render_type_t rtype);

// make a copy of an object. returs num of new object

imobjptridx_t obj_create_copy(const object &srcobj, vmsegptridx_t newsegnum);

// remove object from the world

void obj_delete(d_level_unique_object_state &LevelUniqueObjectState, segment_array &Segments, vmobjptridx_t objnum);

// called after load.  Takes number of objects, and objects should be

// compressed

void reset_objects(d_level_unique_object_state &, unsigned n_objs);

// make object array non-sparse

void compress_objects();

// move all objects for the current frame

window_event_result game_move_all_objects();     // moves all objects

window_event_result endlevel_move_all_objects();

// set viewer object to next object in array

void object_goto_next_viewer();

// make object0 the player, setting all relevant fields

void init_player_object();

// check if object is in object->segnum.  if not, check the adjacent

// segs.  if not any of these, returns false, else sets obj->segnum &

// returns true callers should really use find_vector_intersection()

// Note: this function is in gameseg.c

int update_object_seg(fvmobjptr &vmobjptr, const d_level_shared_segment_state &LevelSharedSegmentState, d_level_unique_segment_state &LevelUniqueSegmentState, vmobjptridx_t obj);

// Finds what segment *obj is in, returns segment number.  If not in

// any segment, returns -1.  Note: This function is defined in

// gameseg.h, but object.h depends on gameseg.h, and object.h is where

// object is defined...get it?

imsegptridx_t find_object_seg(const d_level_shared_segment_state &, d_level_unique_segment_state &, const object_base &obj);

// go through all objects and make sure they have the correct segment

// numbers used when debugging is on

void fix_object_segs();

// Drops objects contained in objp.

imobjptridx_t object_create_robot_egg(object &objp);

imobjptridx_t object_create_robot_egg(int type, int id, int num, const vms_vector &init_vel, const vms_vector &pos, vmsegptridx_t segnum);

// Interface to object_create_egg, puts count objects of type type, id

// = id in objp and then drops them.

imobjptridx_t call_object_create_egg(const object_base &objp, unsigned count, int id);

void dead_player_end();

// Extract information from an object (objp->orient, objp->pos,

// objp->segnum), stuff in a shortpos structure.  See typedef

// shortpos.

void create_shortpos_little(const d_level_shared_segment_state &, shortpos &spp, const object_base &objp);

void create_shortpos_native(const d_level_shared_segment_state &, shortpos &spp, const object_base &objp);

// Extract information from a shortpos, stuff in objp->orient

// (matrix), objp->pos, objp->segnum

void extract_shortpos_little(vmobjptridx_t objp, const shortpos *spp);

// create and extract quaternion structure from object data which greatly saves bytes by using quaternion instead or orientation matrix

void create_quaternionpos(quaternionpos &qpp, const object_base &objp);

void extract_quaternionpos(vmobjptridx_t objp, quaternionpos &qpp);

// delete objects, such as weapons & explosions, that shouldn't stay

// between levels if clear_all is set, clear even proximity bombs

void clear_transient_objects(int clear_all);

// returns the number of a free object, updating Highest_object_index.

// Generally, obj_create() should be called to get an object, since it

// fills in important fields and does the linking.  returns -1 if no

// free objects

imobjptridx_t obj_allocate(d_level_unique_object_state &);

// after calling init_object(), the network code has grabbed specific

// object slots without allocating them.  Go though the objects &

// build the free list, then set the apporpriate globals Don't call

// this function if you don't know what you're doing.

void special_reset_objects(d_level_unique_object_state &);

// attaches an object, such as a fireball, to another object, such as

// a robot

void obj_attach(object_array &Objects, vmobjptridx_t parent, vmobjptridx_t sub);

void create_small_fireball_on_object(vmobjptridx_t objp, fix size_scale, int sound_flag);

window_event_result dead_player_frame();

#if defined(DXX_BUILD_DESCENT_II)

extern int Drop_afterburner_blob_flag;          //ugly hack

enum class game_marker_index : uint8_t;

enum class player_marker_index : uint8_t;

// returns object number

imobjptridx_t drop_marker_object(const vms_vector &pos, vmsegptridx_t segnum, const vms_matrix &orient, game_marker_index marker_num);

void wake_up_rendered_objects(const object &gmissp, window_rendered_data &window);

void fuelcen_check_for_goal(object &plrobj, const shared_segment &segp);

#endif

imobjptridx_t obj_find_first_of_type(fvmobjptridx &, object_type_t type);

void object_rw_swap(struct object_rw *obj_rw, int swap);

void reset_player_object();

}

#endif