TakeV/dxx-rebirth
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Propagate use of vsegptridx_t

Browse source
This commit is contained in:
Kp 2014-11-23 04:58:45 +00:00
parent 80f3f83577
commit d63be88eb0
18 changed files with 215 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
common/include/valptridx.h
View file

@ -93,12 +93,15 @@ protected:
typedef typename tt::remove_const<P>::type Prc;
typedef valptr_t valptr_type;
using valutil::check_null_pointer;
using valutil::check_index_range;
public:
typedef typename valutil::pointer_type pointer_type;
typedef P &reference;
valptr_t() = delete;
valptr_t(I) = delete;
valptr_t(vvalptr_t<const P, I> &&) = delete;
valptr_t(vvalptr_t<Prc, I> &&) = delete;
valptr_t(std::nullptr_t) : p(nullptr) {}
template <template <I> class magic_constant>
valptr_t(valptridx_template_t<vvalptr_t, vvalidx_t, valptr_t, validx_t, const P, I, magic_constant> v) :
p(v)
@ -163,6 +166,11 @@ public:
template <typename U>
typename tt::enable_if<!tt::is_base_of<valptr_t, U>::value, bool>::type operator==(U) const = delete;
protected:
template <typename A>
valptr_t(A &a, I i) :
p(&a[check_index_range(a, i)])
{
}
pointer_type p;
};
@ -173,11 +181,13 @@ class validx_t : protected valbaseptridxutil_t<P, I>
protected:
using valutil::check_index_match;
using valutil::check_index_range;
typedef validx_t validx_type;
public:
typedef typename valutil::pointer_type pointer_type;
typedef typename valutil::index_type index_type;
typedef I integral_type;
validx_t() = delete;
validx_t(P) = delete;
template <integral_type v>
validx_t(const magic_constant<v> &) :
i(v)
@ -366,6 +376,7 @@ public:
reference operator*() const { return *this; }
operator reference() const { return *static_cast<pointer_type>(*this); }
vvalptr_t() = delete;
vvalptr_t(I) = delete;
vvalptr_t(std::nullptr_t) = delete;
vvalptr_t(base_t &&) = delete;
vvalptr_t(const valptr_t<const P, I> &t) :
@ -389,6 +400,11 @@ public:
base_t(a, check_null_pointer(p))
{
}
template <typename A>
vvalptr_t(A &a, I i) :
base_t(a, i)
{
}
vvalptr_t(pointer_type p) :
base_t(check_null_pointer(p))
{
@ -441,6 +457,7 @@ protected:
using base_t::get_array;
using base_t::check_index_match;
using base_t::check_index_range;
typedef vvalidx_t validx_type;
public:
typedef typename base_t::index_type index_type;
typedef typename base_t::integral_type integral_type;
@ -451,6 +468,7 @@ public:
{
}
vvalidx_t() = delete;
vvalidx_t(P) = delete;
vvalidx_t(base_t &&) = delete;
vvalidx_t(const base_t &t) :
base_t(check_index_range(get_array(), t))
@ -513,10 +531,22 @@ public:
DXX_INHERIT_CONSTRUCTORS(v##prefix##ptridx_t, valptridx_type); \
}; \
\
static inline v##prefix##ptr_t N##ptr(prefix##ptr_t::pointer_type o) { \
static inline v##prefix##ptr_t v##prefix##ptr(v##prefix##ptr_t::pointer_type o) { \
return {A, o}; \
} \
\
static inline v##prefix##ptr_t v##prefix##ptr(v##prefix##ptridx_t::integral_type i) { \
return {A, i}; \
} \
\
static inline prefix##ptridx_t prefix##ptridx(prefix##ptridx_t::index_type i) { \
return {A, i}; \
} \
\
static inline v##prefix##ptridx_t v##prefix##ptridx(v##prefix##ptridx_t::index_type i) { \
return {A, i}; \
} \
\
static inline v##prefix##ptridx_t N##ptridx(prefix##ptridx_t::pointer_type o) { \
return {const_cast<Pconst decltype(A) &>(A), o}; \
} \
@ -541,13 +571,5 @@ public:
static inline constexpr typename tt::add_const<decltype(A)>::type &get_global_array(P const *) { return A; } \
\
_DEFINE_VALPTRIDX_SUBTYPE_USERTYPE(N,P,I,A,N,); \
\
static inline N##ptridx_t N##ptridx(N##ptridx_t::index_type i) { \
return {A, i}; \
} \
\
static inline v##N##ptridx_t v##N##ptridx(N##ptridx_t::index_type i) { \
return {A, i}; \
} \
_DEFINE_VALPTRIDX_SUBTYPE_USERTYPE(N,P,I,A,c##N,const) \

4
common/main/collide.h
View file

@ -32,7 +32,7 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
#ifdef __cplusplus
void collide_two_objects(vobjptridx_t A, vobjptridx_t B, vms_vector &collision_point);
void collide_object_with_wall(vobjptridx_t A, fix hitspeed, segnum_t hitseg, short hitwall, const vms_vector &hitpt);
void collide_object_with_wall(vobjptridx_t A, fix hitspeed, vsegptridx_t hitseg, short hitwall, const vms_vector &hitpt);
void apply_damage_to_player(vobjptr_t player, cobjptridx_t killer, fix damage, ubyte possibly_friendly);
// Returns 1 if robot died, else 0.
@ -43,7 +43,7 @@ int apply_damage_to_robot(vobjptridx_t robot, fix damage, objnum_t killer_objnum
void collide_player_and_materialization_center(vobjptridx_t objp);
void collide_robot_and_materialization_center(vobjptridx_t objp);
void scrape_player_on_wall(vobjptridx_t obj, segnum_t hitseg, short hitwall, const vms_vector &hitpt);
void scrape_player_on_wall(vobjptridx_t obj, vsegptridx_t hitseg, short hitwall, const vms_vector &hitpt);
int maybe_detonate_weapon(vobjptridx_t obj0p, vobjptr_t obj, const vms_vector &pos);
void collide_player_and_nasty_robot(vobjptridx_t player, vobjptridx_t robot, const vms_vector &collision_point);

10
common/main/fireball.h
View file

@ -56,10 +56,10 @@ struct expl_wall
#define MAX_EXPLODING_WALLS 10
extern expl_wall expl_wall_list[MAX_EXPLODING_WALLS];
objptridx_t object_create_explosion(segnum_t segnum, const vms_vector &position, fix size, int vclip_type);
void object_create_muzzle_flash(segnum_t segnum, const vms_vector &position, fix size, int vclip_type);
objptridx_t object_create_explosion(vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type);
void object_create_muzzle_flash(vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type);
objptridx_t object_create_badass_explosion(objptridx_t objp, segnum_t segnum, const vms_vector &position, fix size, int vclip_type,
objptridx_t object_create_badass_explosion(objptridx_t objp, vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type,
fix maxdamage, fix maxdistance, fix maxforce, cobjptridx_t parent);
// blows up a badass weapon, creating the badass explosion
@ -75,7 +75,7 @@ void do_debris_frame(vobjptridx_t obj); // deal with debris for this frame
void draw_fireball(vobjptridx_t obj);
void explode_wall(segnum_t segnum, int sidenum);
void explode_wall(vsegptridx_t segnum, int sidenum);
void do_exploding_wall_frame(void);
void init_exploding_walls(void);
extern void maybe_drop_net_powerup(int powerup_type);
@ -84,7 +84,7 @@ void maybe_replace_powerup_with_energy(vobjptr_t del_obj);
int get_explosion_vclip(vcobjptr_t obj, int stage);
#if defined(DXX_BUILD_DESCENT_II)
objptridx_t drop_powerup(int type, int id, int num, const vms_vector &init_vel, const vms_vector &pos, segnum_t segnum);
objptridx_t drop_powerup(int type, int id, int num, const vms_vector &init_vel, const vms_vector &pos, vsegptridx_t segnum);
// creates afterburner blobs behind the specified object
void drop_afterburner_blobs(vobjptr_t obj, int count, fix size_scale, fix lifetime);

2
common/main/fuelcen.h
View file

@ -151,7 +151,7 @@ static inline long operator-(FuelCenter *s, array<FuelCenter, MAX_NUM_FUELCENS>
// Called when a materialization center gets triggered by the player
// flying through some trigger!
void trigger_matcen(segnum_t segnum);
void trigger_matcen(vsegptridx_t segnum);
extern void disable_matcens(void);

12
common/main/gameseg.h
View file

@ -66,7 +66,7 @@ int_fast32_t find_connect_side(vcsegptridx_t base_seg, vcsegptr_t con_seg) __att
struct side_vertnum_list_t : array<int, 4> {};
// Fill in array with four absolute point numbers for a given side
void get_side_verts(side_vertnum_list_t &vertlist,segnum_t segnum,int sidenum);
void get_side_verts(side_vertnum_list_t &vertlist,vcsegptr_t segnum,int sidenum);
struct vertex_array_list_t : array<int, 6> {};
@ -80,10 +80,10 @@ struct vertex_array_list_t : array<int, 6> {};
// Note: these are not absolute vertex numbers, but are relative to the segment
// Note: for triagulated sides, the middle vertex of each trianle is the one NOT
// adjacent on the diagonal edge
void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segnum_t segnum, int sidenum);
void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, vcsegptr_t segnum, int sidenum);
//like create_all_vertex_lists(), but generate absolute point numbers
void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segnum_t segnum, int sidenum);
void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, vcsegptr_t segnum, int sidenum);
// -----------------------------------------------------------------------------------
// Like create all vertex lists, but returns the vertnums (relative to
@ -91,14 +91,14 @@ void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segn
// If there is one face, it has 4 vertices.
// If there are two faces, they both have three vertices, so face #0 is stored in vertices 0,1,2,
// face #1 is stored in vertices 3,4,5.
void create_all_vertnum_lists(int *num_faces, vertex_array_list_t &vertnums, segnum_t segnum, int sidenum);
void create_all_vertnum_lists(int *num_faces, vertex_array_list_t &vertnums, vcsegptr_t segnum, int sidenum);
// Given a side, return the number of faces
int get_num_faces(const side *sidep);
//returns 3 different bitmasks with info telling if this sphere is in
//this segment. See segmasks structure for info on fields
segmasks get_seg_masks(const vms_vector &checkp, segnum_t segnum, fix rad, const char *calling_file, int calling_linenum);
segmasks get_seg_masks(const vms_vector &checkp, vcsegptridx_t segnum, fix rad, const char *calling_file, int calling_linenum);
//this macro returns true if the segnum for an object is correct
#define check_obj_seg(obj) (get_seg_masks((obj)->pos, (obj)->segnum, 0, __FILE__, __LINE__).centermask == 0)
@ -117,7 +117,7 @@ segptridx_t find_point_seg(const vms_vector &p,segptridx_t segnum);
// Search up to a maximum depth of max_depth.
// Return the distance.
struct WALL_IS_DOORWAY_mask_t;
fix find_connected_distance(const vms_vector &p0, segnum_t seg0, const vms_vector &p1, segnum_t seg1, int max_depth, WALL_IS_DOORWAY_mask_t wid_flag);
fix find_connected_distance(const vms_vector &p0, vcsegptridx_t seg0, const vms_vector &p1, vcsegptridx_t seg1, int max_depth, WALL_IS_DOORWAY_mask_t wid_flag);
//create a matrix that describes the orientation of the given segment
void extract_orient_from_segment(vms_matrix *m,vcsegptr_t seg);

4
common/main/segment.h
View file

@ -356,8 +356,8 @@ extern array<dl_index, MAX_DL_INDICES> Dl_indices;
extern array<delta_light, MAX_DELTA_LIGHTS> Delta_lights;
extern unsigned Num_static_lights;
int subtract_light(segnum_t segnum, int sidenum);
int add_light(segnum_t segnum, int sidenum);
int subtract_light(vsegptridx_t segnum, int sidenum);
int add_light(vsegptridx_t segnum, int sidenum);
extern void restore_all_lights_in_mine(void);
extern void clear_light_subtracted(void);
#endif

4
d2x-rebirth/main/escort.cpp
View file

@ -538,9 +538,9 @@ static int get_boss_id(void)
// -----------------------------------------------------------------------------
// Return object index if object of objtype, objid exists in mine, else return -1
// "special" is used to find objects spewed by player which is hacked into flags field of powerup.
static objnum_t exists_in_mine_2(segnum_t segnum, int objtype, int objid, int special)
static objnum_t exists_in_mine_2(const vcsegptridx_t segp, int objtype, int objid, int special)
{
range_for (auto curobjp, objects_in(Segments[segnum]))
range_for (auto curobjp, objects_in(segp))
{
const auto &objnum = curobjp;
if (special == ESCORT_GOAL_PLAYER_SPEW) {

35
similar/main/ai.cpp
View file

@ -1891,16 +1891,12 @@ int ai_door_is_openable(_ai_door_is_openable_objptr objp, const vcsegptr_t segp,
// -----------------------------------------------------------------------------------------------------------
// Return side of openable door in segment, if any. If none, return -1.
static int openable_doors_in_segment(segnum_t segnum)
static int openable_doors_in_segment(const vcsegptr_t segp)
{
int i;
if ((segnum < 0) || (segnum > Highest_segment_index))
return -1;
for (i=0; i<MAX_SIDES_PER_SEGMENT; i++) {
if (Segments[segnum].sides[i].wall_num != wall_none) {
int wall_num = Segments[segnum].sides[i].wall_num;
if (segp->sides[i].wall_num != wall_none) {
int wall_num = segp->sides[i].wall_num;
#if defined(DXX_BUILD_DESCENT_I)
if ((Walls[wall_num].type == WALL_DOOR) && (Walls[wall_num].keys == KEY_NONE) && (Walls[wall_num].state == WALL_DOOR_CLOSED) && !(Walls[wall_num].flags & WALL_DOOR_LOCKED))
#elif defined(DXX_BUILD_DESCENT_II)
@ -1932,9 +1928,8 @@ static int check_object_object_intersection(const vms_vector &pos, fix size, con
// --------------------------------------------------------------------------------------------------------------------
// Return objnum if object created, else return -1.
// If pos == NULL, pick random spot in segment.
static objptridx_t create_gated_robot( segnum_t segnum, int object_id, const vms_vector *pos)
static objptridx_t create_gated_robot(const vsegptridx_t segp, int object_id, const vms_vector *pos)
{
segment *segp = &Segments[segnum];
const robot_info *robptr = &Robot_info[object_id];
int count=0;
fix objsize = Polygon_models[robptr->model_num].rad;
@ -1968,7 +1963,7 @@ static objptridx_t create_gated_robot( segnum_t segnum, int object_id, const vms
return object_none;
}
auto objp = obj_create(OBJ_ROBOT, object_id, segnum, object_pos, &vmd_identity_matrix, objsize, CT_AI, MT_PHYSICS, RT_POLYOBJ);
auto objp = obj_create(OBJ_ROBOT, object_id, segp, object_pos, &vmd_identity_matrix, objsize, CT_AI, MT_PHYSICS, RT_POLYOBJ);
if ( objp == object_none ) {
Last_gate_time = GameTime64 - 3*Gate_interval/4;
@ -2002,8 +1997,8 @@ static objptridx_t create_gated_robot( segnum_t segnum, int object_id, const vms
#endif
init_ai_object(objp, default_behavior, segment_none ); // Note, -1 = segment this robot goes to to hide, should probably be something useful
object_create_explosion(segnum, object_pos, i2f(10), VCLIP_MORPHING_ROBOT );
digi_link_sound_to_pos( Vclip[VCLIP_MORPHING_ROBOT].sound_num, segnum, 0, object_pos, 0 , F1_0);
object_create_explosion(segp, object_pos, i2f(10), VCLIP_MORPHING_ROBOT );
digi_link_sound_to_pos( Vclip[VCLIP_MORPHING_ROBOT].sound_num, segp, 0, object_pos, 0 , F1_0);
morph_start(objp);
Last_gate_time = GameTime64;
@ -2029,21 +2024,21 @@ objptridx_t gate_in_robot(int type, segnum_t segnum)
}
// --------------------------------------------------------------------------------------------------------------------
static int boss_fits_in_seg(const vobjptridx_t boss_objp, segnum_t segnum)
static int boss_fits_in_seg(const vobjptridx_t boss_objp, const vsegptridx_t segp)
{
int posnum;
const auto segcenter = compute_segment_center(&Segments[segnum]);
const auto segcenter = compute_segment_center(segp);
for (posnum=0; posnum<9; posnum++) {
if (posnum > 0) {
vms_vector vertex_pos;
Assert((posnum-1 >= 0) && (posnum-1 < 8));
vertex_pos = Vertices[Segments[segnum].verts[posnum-1]];
vertex_pos = Vertices[segp->verts[posnum-1]];
vm_vec_avg(boss_objp->pos, vertex_pos, segcenter);
} else
boss_objp->pos = segcenter;
obj_relink(boss_objp, segnum);
obj_relink(boss_objp, segp);
if (!object_intersects_wall(boss_objp))
return 1;
}
@ -2896,18 +2891,18 @@ static int openable_door_on_near_path(const object &obj, const ai_static &aip)
{
if (aip.path_length < 1)
return 0;
if (openable_doors_in_segment(obj.segnum) != -1)
if (openable_doors_in_segment(vsegptr(obj.segnum)) != -1)
return 1;
if (aip.path_length < 2)
return 0;
size_t idx;
idx = aip.hide_index + aip.cur_path_index + aip.PATH_DIR;
if (idx < sizeof(Point_segs) / sizeof(Point_segs[0]) && openable_doors_in_segment(Point_segs[idx].segnum) != -1)
if (idx < sizeof(Point_segs) / sizeof(Point_segs[0]) && openable_doors_in_segment(vsegptr(Point_segs[idx].segnum)) != -1)
return 1;
if (aip.path_length < 3)
return 0;
idx = aip.hide_index + aip.cur_path_index + 2*aip.PATH_DIR;
if (idx < sizeof(Point_segs) / sizeof(Point_segs[0]) && openable_doors_in_segment(Point_segs[idx].segnum) != -1)
if (idx < sizeof(Point_segs) / sizeof(Point_segs[0]) && openable_doors_in_segment(vsegptr(Point_segs[idx].segnum)) != -1)
return 1;
return 0;
}
@ -3386,7 +3381,7 @@ _exit_cheat:
} else if (ailp->mode != AIM_STILL) {
int r;
r = openable_doors_in_segment(obj->segnum);
r = openable_doors_in_segment(vsegptr(obj->segnum));
if (r != -1) {
ailp->mode = AIM_OPEN_DOOR;
aip->GOALSIDE = r;

61
similar/main/collide.cpp
View file

@ -106,7 +106,7 @@ static int check_collision_delayfunc_exec()
// -------------------------------------------------------------------------------------------------------------
// The only reason this routine is called (as of 10/12/94) is so Brain guys can open doors.
static void collide_robot_and_wall(const vobjptr_t robot, fix hitspeed, short hitseg, short hitwall, const vms_vector &)
static void collide_robot_and_wall(const vobjptr_t robot, fix hitspeed, const vsegptridx_t hitseg, short hitwall, const vms_vector &)
{
const ubyte robot_id = get_robot_id(robot);
#if defined(DXX_BUILD_DESCENT_I)
@ -116,10 +116,10 @@ static void collide_robot_and_wall(const vobjptr_t robot, fix hitspeed, short hi
if ((robot_id == ROBOT_BRAIN) || (robot->ctype.ai_info.behavior == AIB_RUN_FROM) || (robot_is_companion(robptr) == 1) || (robot->ctype.ai_info.behavior == AIB_SNIPE))
#endif
{
auto wall_num = Segments[hitseg].sides[hitwall].wall_num;
auto wall_num = hitseg->sides[hitwall].wall_num;
if (wall_num != wall_none) {
if ((Walls[wall_num].type == WALL_DOOR) && (Walls[wall_num].keys == KEY_NONE) && (Walls[wall_num].state == WALL_DOOR_CLOSED) && !(Walls[wall_num].flags & WALL_DOOR_LOCKED)) {
wall_open_door(&Segments[hitseg], hitwall);
wall_open_door(hitseg, hitwall);
// -- Changed from this, 10/19/95, MK: Don't want buddy getting stranded from player
//-- } else if ((Robot_info[robot->id].companion == 1) && (Walls[wall_num].type == WALL_DOOR) && (Walls[wall_num].keys != KEY_NONE) && (Walls[wall_num].state == WALL_DOOR_CLOSED) && !(Walls[wall_num].flags & WALL_DOOR_LOCKED)) {
}
@ -129,14 +129,14 @@ static void collide_robot_and_wall(const vobjptr_t robot, fix hitspeed, short hi
if ((ailp->mode == AIM_GOTO_PLAYER) || (Escort_special_goal == ESCORT_GOAL_SCRAM)) {
if (Walls[wall_num].keys != KEY_NONE) {
if (Walls[wall_num].keys & Players[Player_num].flags)
wall_open_door(&Segments[hitseg], hitwall);
wall_open_door(hitseg, hitwall);
} else if (!(Walls[wall_num].flags & WALL_DOOR_LOCKED))
wall_open_door(&Segments[hitseg], hitwall);
wall_open_door(hitseg, hitwall);
}
} else if (Robot_info[get_robot_id(robot)].thief) { // Thief allowed to go through doors to which player has key.
if (Walls[wall_num].keys != KEY_NONE)
if (Walls[wall_num].keys & Players[Player_num].flags)
wall_open_door(&Segments[hitseg], hitwall);
wall_open_door(hitseg, hitwall);
}
#endif
}
@ -311,14 +311,14 @@ void bump_one_object(const vobjptr_t obj0, const vms_vector &hit_dir, fix damage
phys_apply_force(obj0,hit_vec);
}
static void collide_player_and_wall(const vobjptridx_t playerobj, fix hitspeed, segnum_t hitseg, short hitwall, const vms_vector &hitpt)
static void collide_player_and_wall(const vobjptridx_t playerobj, fix hitspeed, const vsegptridx_t hitseg, short hitwall, const vms_vector &hitpt)
{
fix damage;
if (get_player_id(playerobj) != Player_num) // Execute only for local player
return;
int tmap_num = Segments[hitseg].sides[hitwall].tmap_num;
const auto tmap_num = hitseg->sides[hitwall].tmap_num;
// If this wall does damage, don't make *BONK* sound, we'll be making another sound.
if (TmapInfo[tmap_num].damage > 0)
@ -348,7 +348,7 @@ static void collide_player_and_wall(const vobjptridx_t playerobj, fix hitspeed,
else
#endif
{
wall_hit_process( &Segments[hitseg], hitwall, 20, get_player_id(playerobj), playerobj );
wall_hit_process(hitseg, hitwall, 20, get_player_id(playerobj), playerobj );
}
// ** Damage from hitting wall **
@ -359,7 +359,7 @@ static void collide_player_and_wall(const vobjptridx_t playerobj, fix hitspeed,
// Note: Does quad damage if hit a force field - JL
damage = (hitspeed / WALL_DAMAGE_SCALE) * (ForceFieldHit*8 + 1);
int tmap_num2 = Segments[hitseg].sides[hitwall].tmap_num2;
const auto tmap_num2 = hitseg->sides[hitwall].tmap_num2;
//don't do wall damage and sound if hit lava or water
if ((TmapInfo[tmap_num].flags & (TMI_WATER|TMI_VOLATILE)) || (tmap_num2 && (TmapInfo[tmap_num2&0x3fff].flags & (TMI_WATER|TMI_VOLATILE))))
@ -404,14 +404,14 @@ static fix64 Last_volatile_scrape_sound_time = 0;
#if defined(DXX_BUILD_DESCENT_I)
//this gets called when an object is scraping along the wall
void scrape_player_on_wall(const vobjptridx_t obj, segnum_t hitseg, short hitside, const vms_vector &hitpt)
void scrape_player_on_wall(const vobjptridx_t obj, const vsegptridx_t hitseg, short hitside, const vms_vector &hitpt)
{
fix d;
if (obj->type != OBJ_PLAYER || get_player_id(obj) != Player_num)
return;
if ((d=TmapInfo[Segments[hitseg].sides[hitside].tmap_num].damage) > 0) {
if ((d=TmapInfo[hitseg->sides[hitside].tmap_num].damage) > 0) {
vms_vector hit_dir;
fix damage = fixmul(d,FrameTime);
@ -425,7 +425,7 @@ void scrape_player_on_wall(const vobjptridx_t obj, segnum_t hitseg, short hitsid
if (Game_mode & GM_MULTI)
multi_send_play_sound(SOUND_VOLATILE_WALL_HISS, F1_0);
}
hit_dir = Segments[hitseg].sides[hitside].normals[0];
hit_dir = hitseg->sides[hitside].normals[0];
const auto rand_vec = make_random_vector();
vm_vec_scale_add2(hit_dir, rand_vec, F1_0/8);
vm_vec_normalize_quick(hit_dir);
@ -480,14 +480,14 @@ int check_volatile_wall(const vobjptridx_t obj,const vsegptridx_t seg,int sidenu
}
//this gets called when an object is scraping along the wall
void scrape_player_on_wall(const vobjptridx_t obj, segnum_t hitseg, short hitside, const vms_vector &hitpt)
void scrape_player_on_wall(const vobjptridx_t obj, const vsegptridx_t hitseg, short hitside, const vms_vector &hitpt)
{
int type;
if (obj->type != OBJ_PLAYER || get_player_id(obj) != Player_num)
return;
if ((type=check_volatile_wall(obj,vsegptridx(hitseg),hitside))!=0) {
if ((type=check_volatile_wall(obj,hitseg,hitside))!=0) {
vms_vector hit_dir;
if ((GameTime64 > Last_volatile_scrape_sound_time + F1_0/4) || (GameTime64 < Last_volatile_scrape_sound_time)) {
@ -500,7 +500,7 @@ void scrape_player_on_wall(const vobjptridx_t obj, segnum_t hitseg, short hitsid
multi_send_play_sound(sound, F1_0);
}
hit_dir = Segments[hitseg].sides[hitside].normals[0];
hit_dir = hitseg->sides[hitside].normals[0];
const auto rand_vec = make_random_vector();
vm_vec_scale_add2(hit_dir, rand_vec, F1_0/8);
@ -688,9 +688,8 @@ int check_effect_blowup(const vsegptridx_t seg,int side,const vms_vector &pnt, _
// int Show_seg_and_side = 0;
static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, segnum_t hitseg, short hitwall, const vms_vector &hitpt)
static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, const vsegptridx_t hitseg, short hitwall, const vms_vector &hitpt)
{
segment *seg = &Segments[hitseg];
int blew_up;
int wall_type;
int playernum;
@ -707,14 +706,14 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
if (get_weapon_id(weapon) == GUIDEDMISS_ID) {
fix dot;
dot = vm_vec_dot(weapon->orient.fvec, Segments[hitseg].sides[hitwall].normals[0]);
dot = vm_vec_dot(weapon->orient.fvec, hitseg->sides[hitwall].normals[0]);
if (dot < -F1_0/6) {
weapon->mtype.phys_info.flags &= ~PF_BOUNCE;
}
}
//if an energy weapon hits a forcefield, let it bounce
if ((TmapInfo[seg->sides[hitwall].tmap_num].flags & TMI_FORCE_FIELD) &&
if ((TmapInfo[hitseg->sides[hitwall].tmap_num].flags & TMI_FORCE_FIELD) &&
!(weapon->type == OBJ_WEAPON && Weapon_info[get_weapon_id(weapon)].energy_usage==0)) {
//make sound
@ -729,7 +728,7 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
if (keyd_pressed[KEY_LAPOSTRO])
if (weapon->ctype.laser_info.parent_num == Players[Player_num].objnum) {
// MK: Real pain when you need to know a seg:side and you've got quad lasers.
HUD_init_message(HM_DEFAULT, "Hit at segment = %i, side = %i", hitseg, hitwall);
HUD_init_message(HM_DEFAULT, "Hit at segment = %hu, side = %i", static_cast<vsegptridx_t::integral_type>(hitseg), hitwall);
if (get_weapon_id(weapon) < 4)
subtract_light(hitseg, hitwall);
else if (get_weapon_id(weapon) == FLARE_ID)
@ -748,7 +747,7 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
return;
}
blew_up = check_effect_blowup(seg,hitwall, hitpt, weapon, 0, 0);
blew_up = check_effect_blowup(hitseg,hitwall, hitpt, weapon, 0, 0);
//if ((seg->sides[hitwall].tmap_num2==0) && (TmapInfo[seg->sides[hitwall].tmap_num].flags & TMI_VOLATILE)) {
@ -783,17 +782,17 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
//because robots can shoot out wall triggers, and so the trigger better
//take effect
// NO -- Changed by MK, 10/18/95. We don't want robots blowing puzzles. Only player or buddy can open!
check_trigger(seg,hitwall,weapon->ctype.laser_info.parent_num,1);
check_trigger(hitseg,hitwall,weapon->ctype.laser_info.parent_num,1);
}
if (get_weapon_id(weapon) == EARTHSHAKER_ID)
smega_rock_stuff();
#endif
wall_type = wall_hit_process( seg, hitwall, weapon->shields, playernum, weapon );
wall_type = wall_hit_process( hitseg, hitwall, weapon->shields, playernum, weapon );
// Wall is volatile if either tmap 1 or 2 is volatile
if ((TmapInfo[seg->sides[hitwall].tmap_num].flags & TMI_VOLATILE) || (seg->sides[hitwall].tmap_num2 && (TmapInfo[seg->sides[hitwall].tmap_num2&0x3fff].flags & TMI_VOLATILE))) {
if ((TmapInfo[hitseg->sides[hitwall].tmap_num].flags & TMI_VOLATILE) || (hitseg->sides[hitwall].tmap_num2 && (TmapInfo[hitseg->sides[hitwall].tmap_num2&0x3fff].flags & TMI_VOLATILE))) {
weapon_info *wi = &Weapon_info[get_weapon_id(weapon)];
//we've hit a volatile wall
@ -826,7 +825,7 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
}
#if defined(DXX_BUILD_DESCENT_II)
else if ((TmapInfo[seg->sides[hitwall].tmap_num].flags & TMI_WATER) || (seg->sides[hitwall].tmap_num2 && (TmapInfo[seg->sides[hitwall].tmap_num2&0x3fff].flags & TMI_WATER))) {
else if ((TmapInfo[hitseg->sides[hitwall].tmap_num].flags & TMI_WATER) || (hitseg->sides[hitwall].tmap_num2 && (TmapInfo[hitseg->sides[hitwall].tmap_num2&0x3fff].flags & TMI_WATER))) {
weapon_info *wi = &Weapon_info[get_weapon_id(weapon)];
//we've hit water
@ -875,7 +874,7 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
//if it's not the player's weapon, or it is the player's and there
//is no wall, and no blowing up monitor, then play sound
if ((weapon->ctype.laser_info.parent_type != OBJ_PLAYER) || ((seg->sides[hitwall].wall_num == wall_none || wall_type==WHP_NOT_SPECIAL) && !blew_up))
if ((weapon->ctype.laser_info.parent_type != OBJ_PLAYER) || ((hitseg->sides[hitwall].wall_num == wall_none || wall_type==WHP_NOT_SPECIAL) && !blew_up))
if ((Weapon_info[get_weapon_id(weapon)].wall_hit_sound > -1 ) && (!(weapon->flags & OF_SILENT)))
digi_link_sound_to_pos( Weapon_info[get_weapon_id(weapon)].wall_hit_sound,weapon->segnum, 0, weapon->pos, 0, F1_0 );
@ -909,7 +908,7 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
weapon->flags |= OF_SHOULD_BE_DEAD;
//don't let flares stick in force fields
if ((get_weapon_id(weapon) == FLARE_ID) && (TmapInfo[seg->sides[hitwall].tmap_num].flags & TMI_FORCE_FIELD))
if ((get_weapon_id(weapon) == FLARE_ID) && (TmapInfo[hitseg->sides[hitwall].tmap_num].flags & TMI_FORCE_FIELD))
weapon->flags |= OF_SHOULD_BE_DEAD;
#endif
@ -958,9 +957,9 @@ static void collide_weapon_and_wall(const vobjptridx_t weapon, fix hitspeed, seg
return;
}
static void collide_debris_and_wall(const vobjptridx_t debris, fix hitspeed, segnum_t hitseg, short hitwall, const vms_vector &)
static void collide_debris_and_wall(const vobjptridx_t debris, fix hitspeed, const vsegptr_t hitseg, short hitwall, const vms_vector &)
{
if (!PERSISTENT_DEBRIS || TmapInfo[Segments[hitseg].sides[hitwall].tmap_num].damage)
if (!PERSISTENT_DEBRIS || TmapInfo[hitseg->sides[hitwall].tmap_num].damage)
explode_object(debris,0);
return;
}
@ -2587,7 +2586,7 @@ const collision_outer_array_t CollisionResult = collide_init(make_tree_index_seq
ENABLE_COLLISION( OBJ_DEBRIS, OBJ_WALL );
void collide_object_with_wall(const vobjptridx_t A, fix hitspeed, segnum_t hitseg, short hitwall, const vms_vector &hitpt)
void collide_object_with_wall(const vobjptridx_t A, fix hitspeed, const vsegptridx_t hitseg, short hitwall, const vms_vector &hitpt)
{
switch( A->type ) {

32
similar/main/fireball.cpp
View file

@ -78,7 +78,7 @@ fix Flash_effect=0;
static const int PK1=1, PK2=8;
#endif
static objptridx_t object_create_explosion_sub(const objptridx_t objp, segnum_t segnum, const vms_vector &position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, const cobjptridx_t parent )
static objptridx_t object_create_explosion_sub(const objptridx_t objp, const vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, const cobjptridx_t parent )
{
auto obj = obj_create( OBJ_FIREBALL,vclip_type,segnum,position,&vmd_identity_matrix,size,
CT_EXPLOSION,MT_NONE,RT_FIREBALL);
@ -273,17 +273,17 @@ static objptridx_t object_create_explosion_sub(const objptridx_t objp, segnum_t
}
void object_create_muzzle_flash(segnum_t segnum, const vms_vector &position, fix size, int vclip_type )
void object_create_muzzle_flash(const vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type )
{
object_create_explosion_sub(object_none, segnum, position, size, vclip_type, 0, 0, 0, object_none );
}
objptridx_t object_create_explosion(segnum_t segnum, const vms_vector &position, fix size, int vclip_type )
objptridx_t object_create_explosion(const vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type )
{
return object_create_explosion_sub(object_none, segnum, position, size, vclip_type, 0, 0, 0, object_none );
}
objptridx_t object_create_badass_explosion(const objptridx_t objp, segnum_t segnum, const vms_vector &position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, const cobjptridx_t parent )
objptridx_t object_create_badass_explosion(const objptridx_t objp, const vsegptridx_t segnum, const vms_vector &position, fix size, int vclip_type, fix maxdamage, fix maxdistance, fix maxforce, const cobjptridx_t parent )
{
const objptridx_t rval = object_create_explosion_sub(objp, segnum, position, size, vclip_type, maxdamage, maxdistance, maxforce, parent );
@ -637,12 +637,9 @@ void maybe_drop_net_powerup(int powerup_type)
// ------------------------------------------------------------------------------------------------------
// Return true if current segment contains some object.
static int segment_contains_object(int obj_type, int obj_id, segnum_t segnum)
static int segment_contains_object(int obj_type, int obj_id, const vcsegptridx_t segnum)
{
if (segnum == segment_none)
return 0;
range_for (auto objp, objects_in(Segments[segnum]))
range_for (auto objp, objects_in(segnum))
if ((objp->type == obj_type) && (objp->id == obj_id))
return 1;
@ -650,7 +647,7 @@ static int segment_contains_object(int obj_type, int obj_id, segnum_t segnum)
}
// ------------------------------------------------------------------------------------------------------
static int object_nearby_aux(segnum_t segnum, int object_type, int object_id, int depth)
static int object_nearby_aux(const vcsegptridx_t segnum, int object_type, int object_id, int depth)
{
int i;
@ -661,8 +658,7 @@ static int object_nearby_aux(segnum_t segnum, int object_type, int object_id, in
return 1;
for (i=0; i<MAX_SIDES_PER_SEGMENT; i++) {
auto seg2 = Segments[segnum].children[i];
auto seg2 = segnum->children[i];
if (seg2 != segment_none)
if (object_nearby_aux(seg2, object_type, object_id, depth-1))
return 1;
@ -765,7 +761,7 @@ void maybe_replace_powerup_with_energy(const vobjptr_t del_obj)
#if defined(DXX_BUILD_DESCENT_I)
static
#endif
objptridx_t drop_powerup(int type, int id, int num, const vms_vector &init_vel, const vms_vector &pos, segnum_t segnum)
objptridx_t drop_powerup(int type, int id, int num, const vms_vector &init_vel, const vms_vector &pos, const vsegptridx_t segnum)
{
objptridx_t objnum = object_none;
vms_vector new_velocity, new_pos;
@ -1250,7 +1246,7 @@ void init_exploding_walls()
}
//explode the given wall
void explode_wall(segnum_t segnum,int sidenum)
void explode_wall(const vsegptridx_t segnum,int sidenum)
{
int i;
//find a free slot
@ -1267,7 +1263,7 @@ void explode_wall(segnum_t segnum,int sidenum)
expl_wall_list[i].time = 0;
//play one long sound for whole door wall explosion
const auto pos = compute_center_point_on_side(&Segments[segnum],sidenum);
const auto pos = compute_center_point_on_side(segnum,sidenum);
digi_link_sound_to_pos( SOUND_EXPLODING_WALL,segnum, sidenum, pos, 0, F1_0 );
}
@ -1292,11 +1288,9 @@ void do_exploding_wall_frame()
if (expl_wall_list[i].time > EXPL_WALL_TIME)
expl_wall_list[i].time = EXPL_WALL_TIME;
const auto seg = vsegptridx(segnum);
if (expl_wall_list[i].time>(EXPL_WALL_TIME*3)/4) {
int a,n;
auto seg = &Segments[segnum];
a = Walls[seg->sides[sidenum].wall_num].clip_num;
n = WallAnims[a].num_frames;
@ -1325,7 +1319,7 @@ void do_exploding_wall_frame()
//calc expl position
side_vertnum_list_t vertnum_list;
get_side_verts(vertnum_list,segnum,sidenum);
get_side_verts(vertnum_list,seg,sidenum);
const auto &v0 = Vertices[vertnum_list[0]];
const auto &v1 = Vertices[vertnum_list[1]];

6
similar/main/fuelcen.cpp
View file

@ -203,9 +203,9 @@ void fuelcen_activate(const vsegptridx_t segp, int station_type )
//------------------------------------------------------------
// Trigger (enable) the materialization center in segment segnum
void trigger_matcen(segnum_t segnum)
void trigger_matcen(const vsegptridx_t segnum)
{
segment *segp = &Segments[segnum];
const auto &segp = segnum;
FuelCenter *robotcen;
Assert(segp->special == SEGMENT_IS_ROBOTMAKER);
@ -233,7 +233,7 @@ void trigger_matcen(segnum_t segnum)
// Create a bright object in the segment.
auto pos = compute_segment_center(segp);
const auto delta = vm_vec_sub(Vertices[Segments[segnum].verts[0]], pos);
const auto delta = vm_vec_sub(Vertices[segnum->verts[0]], pos);
vm_vec_scale_add2(pos, delta, F1_0/2);
auto objnum = obj_create( OBJ_LIGHT, 0, segnum, pos, NULL, 0, CT_LIGHT, MT_NONE, RT_NONE );
if (objnum != object_none) {

10
similar/main/fvi.cpp
View file

@ -1109,8 +1109,8 @@ void find_hitpoint_uv(fix *u,fix *v,const vms_vector &pnt,const vcsegptridx_t se
return;
}
create_abs_vertex_lists(&num_faces, vertex_list, segnum, sidenum);
create_all_vertnum_lists(&num_faces,vertnum_list,segnum,sidenum);
create_abs_vertex_lists(&num_faces, vertex_list, seg, sidenum);
create_all_vertnum_lists(&num_faces,vertnum_list,seg,sidenum);
//now the hard work.
@ -1203,7 +1203,7 @@ int check_trans_wall(const vms_vector &pnt,const vcsegptridx_t seg,int sidenum,i
//new function for Mike
//note: n_segs_visited must be set to zero before this is called
static int sphere_intersects_wall(const vms_vector &pnt,segnum_t segnum,fix rad,segnum_t *hseg,int *hside,int *hface, fvi_segments_visited_t &visited)
static int sphere_intersects_wall(const vms_vector &pnt,const vcsegptridx_t segnum,fix rad,segnum_t *hseg,int *hside,int *hface, fvi_segments_visited_t &visited)
{
int facemask;
visited[segnum] = true;
@ -1211,7 +1211,7 @@ static int sphere_intersects_wall(const vms_vector &pnt,segnum_t segnum,fix rad,
facemask = get_seg_masks(pnt, segnum, rad, __FILE__, __LINE__).facemask;
auto seg = &Segments[segnum];
const auto &seg = segnum;
if (facemask != 0) { //on the back of at least one face
@ -1230,7 +1230,7 @@ static int sphere_intersects_wall(const vms_vector &pnt,segnum_t segnum,fix rad,
//did we go through this wall/door?
create_abs_vertex_lists(&num_faces, vertex_list, seg - Segments, side);
create_abs_vertex_lists(&num_faces, vertex_list, seg, side);
face_hit_type = check_sphere_to_face( pnt,&seg->sides[side],
face,((num_faces==1)?4:3),rad,vertex_list);

88
similar/main/gamemine.cpp
View file

@ -810,36 +810,36 @@ int load_mine_data(PHYSFS_file *LoadFile)
#define COMPILED_MINE_VERSION 0
static void read_children(segnum_t segnum,ubyte bit_mask,PHYSFS_file *LoadFile)
static void read_children(const vsegptr_t segp,ubyte bit_mask,PHYSFS_file *LoadFile)
{
for (int bit=0; bit<MAX_SIDES_PER_SEGMENT; bit++) {
if (bit_mask & (1 << bit)) {
Segments[segnum].children[bit] = PHYSFSX_readShort(LoadFile);
segp->children[bit] = PHYSFSX_readShort(LoadFile);
} else
Segments[segnum].children[bit] = segment_none;
segp->children[bit] = segment_none;
}
}
static void read_verts(segnum_t segnum,PHYSFS_file *LoadFile)
static void read_verts(const vsegptr_t segp,PHYSFS_file *LoadFile)
{
// Read short Segments[segnum].verts[MAX_VERTICES_PER_SEGMENT]
range_for (auto &i, Segments[segnum].verts)
range_for (auto &i, segp->verts)
i = PHYSFSX_readShort(LoadFile);
}
static void read_special(segnum_t segnum,ubyte bit_mask,PHYSFS_file *LoadFile)
static void read_special(const vsegptr_t segp,ubyte bit_mask,PHYSFS_file *LoadFile)
{
if (bit_mask & (1 << MAX_SIDES_PER_SEGMENT)) {
// Read ubyte Segments[segnum].special
Segments[segnum].special = PHYSFSX_readByte(LoadFile);
segp->special = PHYSFSX_readByte(LoadFile);
// Read byte Segments[segnum].matcen_num
Segments[segnum].matcen_num = PHYSFSX_readByte(LoadFile);
segp->matcen_num = PHYSFSX_readByte(LoadFile);
// Read short Segments[segnum].value
Segments[segnum].value = PHYSFSX_readShort(LoadFile);
segp->value = PHYSFSX_readShort(LoadFile);
} else {
Segments[segnum].special = 0;
Segments[segnum].matcen_num = -1;
Segments[segnum].value = 0;
segp->special = 0;
segp->matcen_num = -1;
segp->value = 0;
}
}
@ -907,10 +907,11 @@ int load_mine_data_compiled(PHYSFS_file *LoadFile)
PHYSFSX_readVector(LoadFile, i);
for (segnum_t segnum=0; segnum < Num_segments; segnum++ ) {
const auto segp = vsegptr(segnum);
#ifdef EDITOR
Segments[segnum].segnum = segnum;
Segments[segnum].group = 0;
segp->segnum = segnum;
segp->group = 0;
#endif
if (New_file_format_load)
@ -919,23 +920,23 @@ int load_mine_data_compiled(PHYSFS_file *LoadFile)
bit_mask = 0x7f; // read all six children and special stuff...
if (Gamesave_current_version == 5) { // d2 SHAREWARE level
read_special(segnum,bit_mask,LoadFile);
read_verts(segnum,LoadFile);
read_children(segnum,bit_mask,LoadFile);
read_special(segp,bit_mask,LoadFile);
read_verts(segp,LoadFile);
read_children(segp,bit_mask,LoadFile);
} else {
read_children(segnum,bit_mask,LoadFile);
read_verts(segnum,LoadFile);
read_children(segp,bit_mask,LoadFile);
read_verts(segp,LoadFile);
if (Gamesave_current_version <= 1) { // descent 1 level
read_special(segnum,bit_mask,LoadFile);
read_special(segp,bit_mask,LoadFile);
}
}
Segments[segnum].objects = object_none;
segp->objects = object_none;
if (Gamesave_current_version <= 5) { // descent 1 thru d2 SHAREWARE level
// Read fix Segments[segnum].static_light (shift down 5 bits, write as short)
temp_ushort = PHYSFSX_readShort(LoadFile);
Segments[segnum].static_light = ((fix)temp_ushort) << 4;
segp->static_light = ((fix)temp_ushort) << 4;
//PHYSFS_read( LoadFile, &Segments[segnum].static_light, sizeof(fix), 1 );
}
@ -950,51 +951,50 @@ int load_mine_data_compiled(PHYSFS_file *LoadFile)
if (bit_mask & (1 << sidenum)) {
byte_wallnum = PHYSFSX_readByte(LoadFile);
if ( byte_wallnum == 255 )
Segments[segnum].sides[sidenum].wall_num = wall_none;
segp->sides[sidenum].wall_num = wall_none;
else
Segments[segnum].sides[sidenum].wall_num = byte_wallnum;
segp->sides[sidenum].wall_num = byte_wallnum;
} else
Segments[segnum].sides[sidenum].wall_num = wall_none;
segp->sides[sidenum].wall_num = wall_none;
}
for (int sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ ) {
if ( (Segments[segnum].children[sidenum]==segment_none) || (Segments[segnum].sides[sidenum].wall_num!=wall_none) ) {
if (segp->children[sidenum] == segment_none || segp->sides[sidenum].wall_num != wall_none) {
// Read short Segments[segnum].sides[sidenum].tmap_num;
temp_ushort = PHYSFSX_readShort(LoadFile);
#if defined(DXX_BUILD_DESCENT_I)
Segments[segnum].sides[sidenum].tmap_num = convert_tmap(temp_ushort & 0x7fff);
segp->sides[sidenum].tmap_num = convert_tmap(temp_ushort & 0x7fff);
if (New_file_format_load && !(temp_ushort & 0x8000))
Segments[segnum].sides[sidenum].tmap_num2 = 0;
segp->sides[sidenum].tmap_num2 = 0;
else {
// Read short Segments[segnum].sides[sidenum].tmap_num2;
Segments[segnum].sides[sidenum].tmap_num2 = PHYSFSX_readShort(LoadFile);
Segments[segnum].sides[sidenum].tmap_num2 =
(convert_tmap(Segments[segnum].sides[sidenum].tmap_num2 & 0x3fff)) |
(Segments[segnum].sides[sidenum].tmap_num2 & 0xc000);
segp->sides[sidenum].tmap_num2 = PHYSFSX_readShort(LoadFile);
segp->sides[sidenum].tmap_num2 =
(convert_tmap(segp->sides[sidenum].tmap_num2 & 0x3fff)) |
(segp->sides[sidenum].tmap_num2 & 0xc000);
}
#elif defined(DXX_BUILD_DESCENT_II)
if (New_file_format_load) {
Segments[segnum].sides[sidenum].tmap_num = temp_ushort & 0x7fff;
segp->sides[sidenum].tmap_num = temp_ushort & 0x7fff;
} else
Segments[segnum].sides[sidenum].tmap_num = temp_ushort;
segp->sides[sidenum].tmap_num = temp_ushort;
if (Gamesave_current_version <= 1)
Segments[segnum].sides[sidenum].tmap_num = convert_d1_tmap_num(Segments[segnum].sides[sidenum].tmap_num);
segp->sides[sidenum].tmap_num = convert_d1_tmap_num(segp->sides[sidenum].tmap_num);
if (New_file_format_load && !(temp_ushort & 0x8000))
Segments[segnum].sides[sidenum].tmap_num2 = 0;
segp->sides[sidenum].tmap_num2 = 0;
else {
// Read short Segments[segnum].sides[sidenum].tmap_num2;
Segments[segnum].sides[sidenum].tmap_num2 = PHYSFSX_readShort(LoadFile);
if (Gamesave_current_version <= 1 && Segments[segnum].sides[sidenum].tmap_num2 != 0)
Segments[segnum].sides[sidenum].tmap_num2 = convert_d1_tmap_num(Segments[segnum].sides[sidenum].tmap_num2);
segp->sides[sidenum].tmap_num2 = PHYSFSX_readShort(LoadFile);
if (Gamesave_current_version <= 1 && segp->sides[sidenum].tmap_num2 != 0)
segp->sides[sidenum].tmap_num2 = convert_d1_tmap_num(segp->sides[sidenum].tmap_num2);
}
#endif
// Read uvl Segments[segnum].sides[sidenum].uvls[4] (u,v>>5, write as short, l>>1 write as short)
range_for (auto &i, Segments[segnum].sides[sidenum].uvls) {
range_for (auto &i, segp->sides[sidenum].uvls) {
temp_short = PHYSFSX_readShort(LoadFile);
i.u = ((fix)temp_short) << 5;
temp_short = PHYSFSX_readShort(LoadFile);
@ -1004,9 +1004,9 @@ int load_mine_data_compiled(PHYSFS_file *LoadFile)
//PHYSFS_read( LoadFile, &i.l, sizeof(fix), 1 );
}
} else {
Segments[segnum].sides[sidenum].tmap_num = 0;
Segments[segnum].sides[sidenum].tmap_num2 = 0;
range_for (auto &i, Segments[segnum].sides[sidenum].uvls) {
segp->sides[sidenum].tmap_num = 0;
segp->sides[sidenum].tmap_num2 = 0;
range_for (auto &i, segp->sides[sidenum].uvls) {
i.u = 0;
i.v = 0;
i.l = 0;

4
similar/main/gamesave.cpp
View file

@ -1043,9 +1043,9 @@ static int load_game_data(PHYSFS_file *LoadFile)
clear_transient_objects(1); //1 means clear proximity bombs
// Make sure non-transparent doors are set correctly.
for (segnum_t i=0; i < Num_segments; i++)
range_for (auto &i, partial_range(Segments, Num_segments))
for (int j=0;j<MAX_SIDES_PER_SEGMENT;j++) {
side *sidep = &Segments[i].sides[j];
side *sidep = &i.sides[j];
if ((sidep->wall_num != wall_none) && (Walls[sidep->wall_num].clip_num != -1)) {
if (WallAnims[Walls[sidep->wall_num].clip_num].flags & WCF_TMAP1) {
sidep->tmap_num = WallAnims[Walls[sidep->wall_num].clip_num].frames[0];

107
similar/main/gameseg.cpp
View file

@ -119,10 +119,10 @@ int get_num_faces(const side *sidep)
}
// Fill in array with four absolute point numbers for a given side
void get_side_verts(side_vertnum_list_t &vertlist,segnum_t segnum,int sidenum)
void get_side_verts(side_vertnum_list_t &vertlist,const vcsegptr_t segp,int sidenum)
{
const sbyte *sv = Side_to_verts[sidenum];
auto &vp = Segments[segnum].verts;
auto &vp = segp->verts;
for (int i=4; i--;)
vertlist[i] = vp[sv[i]];
@ -141,12 +141,11 @@ void get_side_verts(side_vertnum_list_t &vertlist,segnum_t segnum,int sidenum)
// Note: these are not absolute vertex numbers, but are relative to the segment
// Note: for triagulated sides, the middle vertex of each trianle is the one NOT
// adjacent on the diagonal edge
void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segnum_t segnum, int sidenum)
void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, const vcsegptr_t segp, int sidenum)
{
side *sidep = &Segments[segnum].sides[sidenum];
auto sidep = &segp->sides[sidenum];
const int *sv = Side_to_verts_int[sidenum];
Assert((segnum <= Highest_segment_index) && (segnum >= 0));
Assert((sidenum >= 0) && (sidenum < 6));
switch (sidep->get_type()) {
@ -188,7 +187,7 @@ void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segn
//CREATE_ABS_VERTEX_LISTS(), CREATE_ALL_VERTEX_LISTS(), CREATE_ALL_VERTNUM_LISTS()
break;
default:
throw side::illegal_type(&Segments[segnum], sidep);
throw side::illegal_type(segp, sidep);
}
}
@ -200,12 +199,9 @@ void create_all_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segn
// If there is one face, it has 4 vertices.
// If there are two faces, they both have three vertices, so face #0 is stored in vertices 0,1,2,
// face #1 is stored in vertices 3,4,5.
void create_all_vertnum_lists(int *num_faces, vertex_array_list_t &vertnums, segnum_t segnum, int sidenum)
void create_all_vertnum_lists(int *num_faces, vertex_array_list_t &vertnums, const vcsegptr_t segp, int sidenum)
{
side *sidep = &Segments[segnum].sides[sidenum];
Assert((segnum <= Highest_segment_index) && (segnum >= 0));
auto sidep = &segp->sides[sidenum];
switch (sidep->get_type()) {
case SIDE_IS_QUAD:
@ -245,21 +241,18 @@ void create_all_vertnum_lists(int *num_faces, vertex_array_list_t &vertnums, seg
//CREATE_ABS_VERTEX_LISTS(), CREATE_ALL_VERTEX_LISTS(), CREATE_ALL_VERTNUM_LISTS()
break;
default:
throw side::illegal_type(&Segments[segnum], sidep);
throw side::illegal_type(segp, sidep);
}
}
// -----
// like create_all_vertex_lists(), but generate absolute point numbers
void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segnum_t segnum, int sidenum)
void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, const vcsegptr_t segp, int sidenum)
{
auto &vp = Segments[segnum].verts;
side *sidep = &Segments[segnum].sides[sidenum];
auto &vp = segp->verts;
auto sidep = &segp->sides[sidenum];
const int *sv = Side_to_verts_int[sidenum];
Assert((segnum <= Highest_segment_index) && (segnum >= 0));
switch (sidep->get_type()) {
case SIDE_IS_QUAD:
@ -299,7 +292,7 @@ void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segn
//CREATE_ABS_VERTEX_LISTS(), CREATE_ALL_VERTEX_LISTS(), CREATE_ALL_VERTNUM_LISTS()
break;
default:
throw side::illegal_type(&Segments[segnum], sidep);
throw side::illegal_type(segp, sidep);
}
}
@ -307,7 +300,7 @@ void create_abs_vertex_lists(int *num_faces, vertex_array_list_t &vertices, segn
//returns 3 different bitmasks with info telling if this sphere is in
//this segment. See segmasks structure for info on fields
segmasks get_seg_masks(const vms_vector &checkp, segnum_t segnum, fix rad, const char *calling_file, int calling_linenum)
segmasks get_seg_masks(const vms_vector &checkp, const vcsegptridx_t segnum, fix rad, const char *calling_file, int calling_linenum)
{
int sn,facebit,sidebit;
segmasks masks;
@ -315,18 +308,18 @@ segmasks get_seg_masks(const vms_vector &checkp, segnum_t segnum, fix rad, const
vertex_array_list_t vertex_list;
if (segnum < 0 || segnum > Highest_segment_index)
Error("segnum == %i (%i) in get_seg_masks() \ncheckp: %i,%i,%i, rad: %i \nfrom file: %s, line: %i \nMission: %s (%i) \nPlease report this bug.\n",segnum,Highest_segment_index,checkp.x,checkp.y,checkp.z,rad,calling_file,calling_linenum, Current_mission_filename, Current_level_num);
Error("segnum == %hu (%i) in get_seg_masks() \ncheckp: %i, %i, %i, rad: %i \nfrom file: %s, line: %i \nMission: %s (%i) \nPlease report this bug.\n", static_cast<vcsegptridx_t::integral_type>(segnum), Highest_segment_index, checkp.x, checkp.y, checkp.z, rad, calling_file, calling_linenum, Current_mission_filename, Current_level_num);
Assert((segnum <= Highest_segment_index) && (segnum >= 0));
auto seg = &Segments[segnum];
const auto &seg = segnum;
//check point against each side of segment. return bitmask
masks.sidemask = masks.facemask = masks.centermask = 0;
for (sn=0,facebit=sidebit=1;sn<6;sn++,sidebit<<=1) {
side *s = &seg->sides[sn];
auto s = &seg->sides[sn];
int side_pokes_out;
int vertnum;
@ -520,10 +513,10 @@ static ubyte get_side_dists(const vms_vector &checkp,const vsegptridx_t segnum,f
#ifndef NDEBUG
//returns true if errors detected
static int check_norms(segnum_t segnum,int sidenum,int facenum,segnum_t csegnum,int csidenum,int cfacenum)
static int check_norms(const vcsegptr_t segp,int sidenum,int facenum,const vcsegptr_t csegp,int csidenum,int cfacenum)
{
const auto &n0 = Segments[segnum].sides[sidenum].normals[facenum];
const auto &n1 = Segments[csegnum].sides[csidenum].normals[cfacenum];
const auto &n0 = segp->sides[sidenum].normals[facenum];
const auto &n1 = csegp->sides[csidenum].normals[cfacenum];
if (n0.x != -n1.x || n0.y != -n1.y || n0.z != -n1.z)
return 1;
else
@ -537,18 +530,14 @@ int check_segment_connections(void)
range_for (auto segnum, highest_valid(Segments))
{
auto seg = &Segments[segnum];
auto seg = vcsegptridx(segnum);
for (int sidenum=0;sidenum<6;sidenum++) {
int num_faces,con_num_faces;
vertex_array_list_t vertex_list, con_vertex_list;
create_abs_vertex_lists(&num_faces, vertex_list, segnum, sidenum);
create_abs_vertex_lists(&num_faces, vertex_list, seg, sidenum);
auto csegnum = seg->children[sidenum];
if (csegnum >= 0) {
auto cseg = &Segments[csegnum];
if (IS_CHILD(segnum)) {
auto cseg = vcsegptr(csegnum);
auto csidenum = find_connect_side(seg,cseg);
if (csidenum == -1) {
@ -556,7 +545,7 @@ int check_segment_connections(void)
continue;
}
create_abs_vertex_lists(&con_num_faces, con_vertex_list, csegnum, csidenum);
create_abs_vertex_lists(&con_num_faces, con_vertex_list, cseg, csidenum);
if (con_num_faces != num_faces) {
errors = 1;
@ -575,7 +564,7 @@ int check_segment_connections(void)
errors = 1;
}
else
errors |= check_norms(segnum,sidenum,0,csegnum,csidenum,0);
errors |= check_norms(seg,sidenum,0,cseg,csidenum,0);
}
else {
@ -589,8 +578,8 @@ int check_segment_connections(void)
vertex_list[5] != con_vertex_list[3]) {
Segments[csegnum].sides[csidenum].set_type(5-Segments[csegnum].sides[csidenum].get_type());
} else {
errors |= check_norms(segnum,sidenum,0,csegnum,csidenum,0);
errors |= check_norms(segnum,sidenum,1,csegnum,csidenum,1);
errors |= check_norms(seg,sidenum,0,cseg,csidenum,0);
errors |= check_norms(seg,sidenum,1,cseg,csidenum,1);
}
} else {
@ -603,8 +592,8 @@ int check_segment_connections(void)
vertex_list[3] != con_vertex_list[2]) {
Segments[csegnum].sides[csidenum].set_type(5-Segments[csegnum].sides[csidenum].get_type());
} else {
errors |= check_norms(segnum,sidenum,0,csegnum,csidenum,1);
errors |= check_norms(segnum,sidenum,1,csegnum,csidenum,0);
errors |= check_norms(seg,sidenum,0,cseg,csidenum,1);
errors |= check_norms(seg,sidenum,1,cseg,csidenum,0);
}
}
}
@ -835,7 +824,7 @@ static void add_to_fcd_cache(int seg0, int seg1, int depth, fix dist)
// Determine whether seg0 and seg1 are reachable in a way that allows sound to pass.
// Search up to a maximum depth of max_depth.
// Return the distance.
fix find_connected_distance(const vms_vector &p0, segnum_t seg0, const vms_vector &p1, segnum_t seg1, int max_depth, WALL_IS_DOORWAY_mask_t wid_flag)
fix find_connected_distance(const vms_vector &p0, const vcsegptridx_t seg0, const vms_vector &p1, const vcsegptridx_t seg1, int max_depth, WALL_IS_DOORWAY_mask_t wid_flag)
{
segnum_t cur_seg;
int qtail = 0, qhead = 0;
@ -859,10 +848,10 @@ fix find_connected_distance(const vms_vector &p0, segnum_t seg0, const vms_vecto
Connected_segment_distance = 0;
return vm_vec_dist_quick(p0, p1);
} else {
auto conn_side = find_connect_side(&Segments[seg0], &Segments[seg1]);
auto conn_side = find_connect_side(seg0, seg1);
if (conn_side != -1) {
#if defined(DXX_BUILD_DESCENT_II)
if (WALL_IS_DOORWAY(&Segments[seg1], conn_side) & wid_flag)
if (WALL_IS_DOORWAY(seg1, conn_side) & wid_flag)
#endif
{
Connected_segment_distance = 1;
@ -962,7 +951,7 @@ fcd_done1: ;
}
point_segs[num_points].segnum = seg0;
compute_segment_center(point_segs[num_points].point,&Segments[seg0]);
compute_segment_center(point_segs[num_points].point,seg0);
num_points++;
if (num_points == 1) {
@ -1656,10 +1645,8 @@ static void apply_light_to_segment(visited_segment_bitarray_t &visited, const vs
//update the static_light field in a segment, which is used for object lighting
//this code is copied from the editor routine calim_process_all_lights()
static void change_segment_light(segnum_t segnum,int sidenum,int dir)
static void change_segment_light(const vsegptridx_t segp,int sidenum,int dir)
{
segment *segp = &Segments[segnum];
if (WALL_IS_DOORWAY(segp, sidenum) & WID_RENDER_FLAG) {
side *sidep = &segp->sides[sidenum];
fix light_intensity;
@ -1686,7 +1673,7 @@ static void change_segment_light(segnum_t segnum,int sidenum,int dir)
// dir = -1 -> subtract light
// dir = 17 -> add 17x light
// dir = 0 -> you are dumb
static void change_light(segnum_t segnum, int sidenum, int dir)
static void change_light(const vsegptridx_t segnum, int sidenum, int dir)
{
range_for (auto &i, partial_range(Dl_indices, Num_static_lights))
if (i.segnum == segnum && i.sidenum == sidenum)
@ -1712,13 +1699,13 @@ static void change_light(segnum_t segnum, int sidenum, int dir)
// Subtract light cast by a light source from all surfaces to which it applies light.
// This is precomputed data, stored at static light application time in the editor (the slow lighting function).
// returns 1 if lights actually subtracted, else 0
int subtract_light(segnum_t segnum, int sidenum)
int subtract_light(const vsegptridx_t segnum, int sidenum)
{
if (Segments[segnum].light_subtracted & (1 << sidenum)) {
if (segnum->light_subtracted & (1 << sidenum)) {
return 0;
}
Segments[segnum].light_subtracted |= (1 << sidenum);
segnum->light_subtracted |= (1 << sidenum);
change_light(segnum, sidenum, -1);
return 1;
}
@ -1727,13 +1714,13 @@ int subtract_light(segnum_t segnum, int sidenum)
// This is precomputed data, stored at static light application time in the editor (the slow lighting function).
// You probably only want to call this after light has been subtracted.
// returns 1 if lights actually added, else 0
int add_light(segnum_t segnum, int sidenum)
int add_light(const vsegptridx_t segnum, int sidenum)
{
if (!(Segments[segnum].light_subtracted & (1 << sidenum))) {
if (!(segnum->light_subtracted & (1 << sidenum))) {
return 0;
}
Segments[segnum].light_subtracted &= ~(1 << sidenum);
segnum->light_subtracted &= ~(1 << sidenum);
change_light(segnum, sidenum, 1);
return 1;
}
@ -1793,26 +1780,26 @@ void clear_light_subtracted(void)
// -----------------------------------------------------------------------------
// Do a bfs from segnum, marking slots in marked_segs if the segment is reachable.
static void ambient_mark_bfs(const vsegptr_t segp, segnum_t segnum, visited_segment_multibit_array_t<2> &marked_segs, unsigned depth, uint_fast8_t s2f_bit)
static void ambient_mark_bfs(const vsegptridx_t segp, visited_segment_multibit_array_t<2> &marked_segs, unsigned depth, uint_fast8_t s2f_bit)
{
/*
* High first, then low: write here.
* Low first, then high: safe to write here, but overwritten later by marked_segs value.
*/
segp->s2_flags |= s2f_bit;
marked_segs[segnum] = s2f_bit | marked_segs[segnum];
marked_segs[segp] = s2f_bit | marked_segs[segp];
if (!depth)
return;
for (int i=0; i<MAX_SIDES_PER_SEGMENT; i++) {
auto child = Segments[segnum].children[i];
auto child = segp->children[i];
/*
* No explicit check for IS_CHILD. If !IS_CHILD, then
* WALL_IS_DOORWAY never sets WID_RENDPAST_FLAG.
*/
if ((WALL_IS_DOORWAY(&Segments[segnum],i) & WID_RENDPAST_FLAG) && !(marked_segs[child] & s2f_bit))
ambient_mark_bfs(&Segments[child], child, marked_segs, depth-1, s2f_bit);
if ((WALL_IS_DOORWAY(segp, i) & WID_RENDPAST_FLAG) && !(marked_segs[child] & s2f_bit))
ambient_mark_bfs(vsegptridx(child), marked_segs, depth-1, s2f_bit);
}
}
@ -1846,7 +1833,7 @@ void set_ambient_sound_flags()
if (!(texture_flags & s.texture_flag))
continue;
if (!IS_CHILD(segp->children[j]) || (sidep->wall_num != wall_none)) {
ambient_mark_bfs(segp, i, marked_segs, AMBIENT_SEGMENT_DEPTH, s.sound_flag);
ambient_mark_bfs(vsegptridx(i), marked_segs, AMBIENT_SEGMENT_DEPTH, s.sound_flag);
break;
}
}

2
similar/main/laser.cpp
View file

@ -236,7 +236,7 @@ static void do_muzzle_stuff(segnum_t segnum, const vms_vector &pos)
}
//creates a weapon object
static objptridx_t create_weapon_object(int weapon_type,segnum_t segnum, const vms_vector &position)
static objptridx_t create_weapon_object(int weapon_type,const vsegptridx_t segnum, const vms_vector &position)
{
int rtype=-1;
fix laser_radius = -1;

2
similar/main/object.cpp
View file

@ -181,7 +181,7 @@ objptridx_t obj_find_first_of_type(int type)
{
range_for (auto o, highest_valid(Objects))
{
const objptridx_t i = objptridx(o);
const auto i = vobjptridx(o);
if (i->type==type)
return i;
}

10
similar/main/physics.cpp
View file

@ -723,21 +723,21 @@ void do_physics_sim(const vobjptridx_t obj)
//hack to keep player from going through closed doors
if (obj->type==OBJ_PLAYER && obj->segnum!=orig_segnum && (!cheats.ghostphysics) ) {
auto sidenum = find_connect_side(&Segments[obj->segnum],&Segments[orig_segnum]);
const auto orig_segp = vcsegptr(orig_segnum);
auto sidenum = find_connect_side(&Segments[obj->segnum],orig_segp);
if (sidenum != -1) {
if (! (WALL_IS_DOORWAY(&Segments[orig_segnum],sidenum) & WID_FLY_FLAG)) {
side *s;
if (! (WALL_IS_DOORWAY(orig_segp,sidenum) & WID_FLY_FLAG)) {
int num_faces;
fix dist;
vertex_array_list_t vertex_list;
//bump object back
s = &Segments[orig_segnum].sides[sidenum];
auto s = &orig_segp->sides[sidenum];
create_abs_vertex_lists(&num_faces, vertex_list, orig_segnum, sidenum);
create_abs_vertex_lists(&num_faces, vertex_list, orig_segp, sidenum);
//let's pretend this wall is not triangulated
auto b = begin(vertex_list);