From d63be88eb036b815b7547cd9ca0255b5e7e6a488 Mon Sep 17 00:00:00 2001
From: Kp <kp@valhallalegends.com>
Date: Sun, 23 Nov 2014 04:58:45 +0000
Subject: [PATCH] Propagate use of vsegptridx_t

---
 common/include/valptridx.h  |  40 +++++++++++---
 common/main/collide.h       |   4 +-
 common/main/fireball.h      |  10 ++--
 common/main/fuelcen.h       |   2 +-
 common/main/gameseg.h       |  12 ++--
 common/main/segment.h       |   4 +-
 d2x-rebirth/main/escort.cpp |   4 +-
 similar/main/ai.cpp         |  35 +++++-------
 similar/main/collide.cpp    |  61 ++++++++++----------
 similar/main/fireball.cpp   |  32 +++++------
 similar/main/fuelcen.cpp    |   6 +-
 similar/main/fvi.cpp        |  10 ++--
 similar/main/gamemine.cpp   |  88 ++++++++++++++---------------
 similar/main/gamesave.cpp   |   4 +-
 similar/main/gameseg.cpp    | 107 ++++++++++++++++--------------------
 similar/main/laser.cpp      |   2 +-
 similar/main/object.cpp     |   2 +-
 similar/main/physics.cpp    |  10 ++--
 18 files changed, 215 insertions(+), 218 deletions(-)

diff --git a/common/include/valptridx.h b/common/include/valptridx.h
index e73896ee6..731ed8f2b 100644
--- a/common/include/valptridx.h
+++ b/common/include/valptridx.h
@@ -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)	\
 
diff --git a/common/main/collide.h b/common/main/collide.h
index bf590c59f..353d560bf 100644
--- a/common/main/collide.h
+++ b/common/main/collide.h
@@ -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);
diff --git a/common/main/fireball.h b/common/main/fireball.h
index cce4b65a1..60763b7c8 100644
--- a/common/main/fireball.h
+++ b/common/main/fireball.h
@@ -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);
diff --git a/common/main/fuelcen.h b/common/main/fuelcen.h
index e51fd450a..af23ac373 100644
--- a/common/main/fuelcen.h
+++ b/common/main/fuelcen.h
@@ -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);
 
diff --git a/common/main/gameseg.h b/common/main/gameseg.h
index cc13bc12e..479960854 100644
--- a/common/main/gameseg.h
+++ b/common/main/gameseg.h
@@ -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);
diff --git a/common/main/segment.h b/common/main/segment.h
index e4ab93feb..8fa3c1560 100644
--- a/common/main/segment.h
+++ b/common/main/segment.h
@@ -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
diff --git a/d2x-rebirth/main/escort.cpp b/d2x-rebirth/main/escort.cpp
index 7a859f75d..3547fa5b1 100644
--- a/d2x-rebirth/main/escort.cpp
+++ b/d2x-rebirth/main/escort.cpp
@@ -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) {
diff --git a/similar/main/ai.cpp b/similar/main/ai.cpp
index 15a76f23c..e5dc6768e 100644
--- a/similar/main/ai.cpp
+++ b/similar/main/ai.cpp
@@ -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;
diff --git a/similar/main/collide.cpp b/similar/main/collide.cpp
index 080c14a0b..c52f00500 100644
--- a/similar/main/collide.cpp
+++ b/similar/main/collide.cpp
@@ -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 )	{
diff --git a/similar/main/fireball.cpp b/similar/main/fireball.cpp
index 568e38682..974c0515a 100644
--- a/similar/main/fireball.cpp
+++ b/similar/main/fireball.cpp
@@ -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]];
diff --git a/similar/main/fuelcen.cpp b/similar/main/fuelcen.cpp
index 5f230b87d..a365837a9 100644
--- a/similar/main/fuelcen.cpp
+++ b/similar/main/fuelcen.cpp
@@ -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) {
diff --git a/similar/main/fvi.cpp b/similar/main/fvi.cpp
index 496fd587b..a69bf7988 100644
--- a/similar/main/fvi.cpp
+++ b/similar/main/fvi.cpp
@@ -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);
diff --git a/similar/main/gamemine.cpp b/similar/main/gamemine.cpp
index d2f981d33..a97ebd3d7 100644
--- a/similar/main/gamemine.cpp
+++ b/similar/main/gamemine.cpp
@@ -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;
diff --git a/similar/main/gamesave.cpp b/similar/main/gamesave.cpp
index 36dc9a868..b2f10825c 100644
--- a/similar/main/gamesave.cpp
+++ b/similar/main/gamesave.cpp
@@ -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];
diff --git a/similar/main/gameseg.cpp b/similar/main/gameseg.cpp
index 3ad343a9f..8890a193f 100644
--- a/similar/main/gameseg.cpp
+++ b/similar/main/gameseg.cpp
@@ -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;
 				}
 			}
diff --git a/similar/main/laser.cpp b/similar/main/laser.cpp
index 405ccbdda..a24fd9ef1 100644
--- a/similar/main/laser.cpp
+++ b/similar/main/laser.cpp
@@ -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;
diff --git a/similar/main/object.cpp b/similar/main/object.cpp
index 66c6a23cf..3ab48b196 100644
--- a/similar/main/object.cpp
+++ b/similar/main/object.cpp
@@ -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;
 	}
diff --git a/similar/main/physics.cpp b/similar/main/physics.cpp
index 7ce8e4b27..b28a98e68 100644
--- a/similar/main/physics.cpp
+++ b/similar/main/physics.cpp
@@ -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);