diff --git a/src/drawing/drawing.c b/src/drawing/drawing.c
index e4ddeb5759..55eb628397 100644
--- a/src/drawing/drawing.c
+++ b/src/drawing/drawing.c
@@ -144,7 +144,7 @@ void load_palette(){
 
 	uint32 palette = 0x5FC;
 
-	if ((uintptr_t)water_type != (uint32)-1){
+	if ((sint32)water_type != -1){
 		palette = water_type->image_id;
 	}
 
diff --git a/src/drawing/drawing.h b/src/drawing/drawing.h
index d06b5df4e6..04367bc40e 100644
--- a/src/drawing/drawing.h
+++ b/src/drawing/drawing.h
@@ -24,9 +24,8 @@
 #ifndef NO_RCT2
 #pragma pack(push, 1)
 #endif
-
-// Size: 0x10 or more
-typedef struct {
+// Size: 0x10
+typedef struct rct_g1_element {
 	uint8* offset;			// 0x00
 	sint16 width;			// 0x04
 	sint16 height;			// 0x06
@@ -60,17 +59,18 @@ assert_struct_size(rct_drawpixelinfo, 0x10);
 
 // Size: 0x10
 typedef struct rct_g1_element_32bit {
-		uint32 offset;                  // 0x00 note: uint32 always!
-		sint16 width;                   // 0x04
-		sint16 height;                  // 0x06
-		sint16 x_offset;                // 0x08
-		sint16 y_offset;                // 0x0A
-		uint16 flags;                   // 0x0C
-		uint16 zoomed_offset;   // 0x0E
+	uint32 offset;                  // 0x00 note: uint32 always!
+	sint16 width;                   // 0x04
+	sint16 height;                  // 0x06
+	sint16 x_offset;                // 0x08
+	sint16 y_offset;                // 0x0A
+	uint16 flags;                   // 0x0C
+	uint16 zoomed_offset;   // 0x0E
 } rct_g1_element_32bit;
 assert_struct_size(rct_g1_element_32bit, 0x10);
 
-enum{
+
+enum {
 	G1_FLAG_BMP = (1 << 0), //No invisible sections
 	G1_FLAG_RLE_COMPRESSION = (1<<2),
 };
diff --git a/src/drawing/sprite.c b/src/drawing/sprite.c
index cf4dc11582..26458bb1ab 100644
--- a/src/drawing/sprite.c
+++ b/src/drawing/sprite.c
@@ -71,6 +71,20 @@ int gfx_load_g1()
 			 * pointers to however long our machine wants them.
 			 */
 
+			#pragma pack(push, 1)
+			// Size: 0x10
+			typedef struct {
+				uint32 offset;			// 0x00 note: uint32 always!
+				sint16 width;			// 0x04
+				sint16 height;			// 0x06
+				sint16 x_offset;		// 0x08
+				sint16 y_offset;		// 0x0A
+				uint16 flags;			// 0x0C
+				uint16 zoomed_offset;	// 0x0E
+			} rct_g1_element_32bit;
+			assert_struct_size(rct_g1_element_32bit, 0x10);
+			#pragma pack(pop)
+
 			/* number of elements is stored in g1.dat, but because the entry
 			 * headers are static, this can't be variable until made into a
 			 * dynamic array.
@@ -91,9 +105,8 @@ int gfx_load_g1()
 			SDL_RWclose(file);
 
 			// Fix entry data offsets
-			for (i = 0; i < header.num_entries; i++) {
+			for (i = 0; i < header.num_entries; i++)
 				g1Elements[i].offset += (uintptr_t)_g1Buffer;
-			}
 
 			// Successful
 			return 1;
diff --git a/src/object.c b/src/object.c
index a80313510b..ce0d7c86e3 100644
--- a/src/object.c
+++ b/src/object.c
@@ -130,13 +130,6 @@ int object_load_file(int groupIndex, const rct_object_entry *entry, int* chunkSi
 			}
 		}
 	}
-
-	if (RCT2_GLOBAL(0x9ADAFD, uint8) != 0) {
-		uint8 *oldChunk = chunk;
-		chunk = object_load(objectType, oldChunk, groupIndex, chunkSize);
-		free(oldChunk);
-	}
-
 	chunk_list[groupIndex] = chunk;
 
 	rct_object_entry_extended* extended_entry = &object_entry_groups[objectType].entries[groupIndex];
@@ -146,6 +139,9 @@ int object_load_file(int groupIndex, const rct_object_entry *entry, int* chunkSi
 
 	gLastLoadedObjectChunkData = chunk;
 
+	if (RCT2_GLOBAL(0x9ADAFD, uint8) != 0) {
+		object_load(objectType, chunk, groupIndex);
+	}
 	return 1;
 }
 
@@ -489,570 +485,28 @@ int object_chunk_load_image_directory(uint8_t** chunk)
 	return image_start_no;
 }
 
-/**
- * object_load_func will receive the struct as it is stored in a file, this
- * means 32bit pointers. On non-32bit platforms it's supposed to upconvert
- * structure to native pointer types and return pointer to newly allocated
- * space. It should not be the same pointer as input.
- *
- * object_unload_func will receive a pointer to the structure created with
- * object_load_func, i.e. with native pointer types
- *
- * object_test_func will receive a pointer to the struct as it is stored in a
- * file.
- *
- * object_paint_func and object_paint_func will receive structs with native
- * pointer types.
- */
-typedef uint8* (*object_load_func)(void *objectEntry, uint32 entryIndex, int *chunkSize);
-typedef void   (*object_unload_func)(void *objectEntry);
-typedef bool   (*object_test_func)(void *objectEntry);
-typedef void   (*object_paint_func)(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y);
+typedef bool (*object_load_func)(void *objectEntry, uint32 entryIndex);
+typedef void (*object_unload_func)(void *objectEntry);
+typedef bool (*object_test_func)(void *objectEntry);
+typedef void (*object_paint_func)(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y);
 typedef rct_string_id (*object_desc_func)(void *objectEntry);
-typedef void   (*object_reset_func)(void *objectEntry, uint32 entryIndex);
 
 /**
  * Represents addresses for virtual object functions.
  */
 typedef struct object_type_vtable {
-	object_load_func   load;
+	object_load_func load;
 	object_unload_func unload;
-	object_test_func   test;
-	object_paint_func  paint;
-	object_desc_func   desc;
-	object_reset_func  reset;
+	object_test_func test;
+	object_paint_func paint;
+	object_desc_func desc;
 } object_type_vtable;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Ride (rct2: 0x006E6E2A)
 ///////////////////////////////////////////////////////////////////////////////
 
-#pragma pack(push, 1)
-/**
- * Ride type vehicle structure.
- * size: 0x65
- */
-typedef struct rct_ride_entry_vehicle_32bit {
-	uint16 rotation_frame_mask;		// 0x00 , 0x1A
-	uint8 var_02;					// 0x02 , 0x1C
-	uint8 var_03;					// 0x03 , 0x1D
-	uint32 spacing;					// 0x04 , 0x1E
-	uint16 car_friction;			// 0x08 , 0x22
-	sint8 tab_height;				// 0x0A , 0x24
-	uint8 num_seats;				// 0x0B , 0x25
-	uint16 sprite_flags;			// 0x0C , 0x26
-	uint8 sprite_width;				// 0x0E , 0x28
-	uint8 sprite_height_negative;	// 0x0F , 0x29
-	uint8 sprite_height_positive;	// 0x10 , 0x2A
-	uint8 var_11;					// 0x11 , 0x2B
-	uint16 flags_a;					// 0x12 , 0x2C
-	uint16 flags_b;					// 0x14 , 0x2E
-	uint16 var_16;					// 0x16 , 0x30
-	uint32 base_image_id;			// 0x18 , 0x32
-	uint32 var_1C;					// 0x1C , 0x36
-	uint32 var_20;					// 0x20 , 0x3A
-	uint32 var_24;					// 0x24 , 0x3E
-	uint32 var_28;					// 0x28 , 0x42
-	uint32 var_2C;					// 0x2C , 0x46
-	uint32 var_30;					// 0x30 , 0x4A
-	uint32 var_34;					// 0x34 , 0x4E
-	uint32 var_38;					// 0x38 , 0x52
-	uint32 var_3C;					// 0x3C , 0x56
-	uint32 var_40;					// 0x40 , 0x5A
-	uint32 var_44;					// 0x44 , 0x5E
-	uint32 var_48;					// 0x48 , 0x62
-	uint32 var_4C;					// 0x4C , 0x66
-	uint32 no_vehicle_images;		// 0x50 , 0x6A
-	uint8 no_seating_rows;			// 0x54 , 0x6E
-	uint8 spinning_inertia;			// 0x55 , 0x6F
-	uint8 spinning_friction;		// 0x56 , 0x70
-	uint8 friction_sound_id;		// 0x57 , 0x71
-	uint8 var_58;					// 0x58 , 0x72
-	uint8 sound_range;				// 0x59 , 0x73
-	uint8 var_5A;					// 0x5A , 0x74
-	uint8 powered_acceleration;		// 0x5B , 0x75
-	uint8 powered_max_speed;		// 0x5C , 0x76
-	uint8 car_visual;				// 0x5D , 0x77
-	uint8 effect_visual;
-	uint8 draw_order;
-	uint8 special_frames;			// 0x60 , 0x7A
-	uint32 peep_loading_positions;	// 0x61 , 0x7B note: uint32
-} rct_ride_entry_vehicle_32bit;
-assert_struct_size(rct_ride_entry_vehicle_32bit, 0x65);
-
-/**
- * Ride type structure.
- * size: unknown
- */
-typedef struct rct_ride_entry_32bit {
-	rct_string_id name;						// 0x000
-	rct_string_id description;				// 0x002
-	uint32 images_offset;					// 0x004
-	uint32 flags;							// 0x008
-	uint8 ride_type[3];						// 0x00C
-	uint8 min_cars_in_train;				// 0x00F
-	uint8 max_cars_in_train;				// 0x010
-	uint8 cars_per_flat_ride;				// 0x011
-	// Number of cars that can't hold passengers
-	uint8 zero_cars;						// 0x012
-	// The index to the vehicle type displayed in
-	// the vehicle tab.
-	uint8 tab_vehicle;						// 0x013
-	uint8 default_vehicle;					// 0x014
-	// Convert from first - fourth vehicle to
-	// vehicle structure
-	uint8 front_vehicle;					// 0x015
-	uint8 second_vehicle;					// 0x016
-	uint8 rear_vehicle;						// 0x017
-	uint8 third_vehicle;					// 0x018
-	uint8 pad_019;
-	rct_ride_entry_vehicle_32bit vehicles[4];		// 0x1A note: 32bit!
-	uint32 vehicle_preset_list;				// 0x1AE note: uint32!
-	sint8 excitement_multipler;				// 0x1B2
-	sint8 intensity_multipler;				// 0x1B3
-	sint8 nausea_multipler;					// 0x1B4
-	uint8 max_height;						// 0x1B5
-	union {
-		uint64 enabledTrackPieces;						// 0x1B6
-		struct {
-			uint32 enabledTrackPiecesA;					// 0x1B6
-			uint32 enabledTrackPiecesB;					// 0x1BA
-		};
-	};
-	uint8 category[2];									// 0x1BE
-	uint8 shop_item;									// 0x1C0
-	uint8 shop_item_secondary;							// 0x1C1
-} rct_ride_entry_32bit;
-assert_struct_size(rct_ride_entry_32bit, 0x1c2);
-#pragma pack(pop)
-
-static uint8* object_type_ride_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
-{
-	rct_ride_entry_32bit *rideEntry = (rct_ride_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_ride_entry_32bit));
-	const size_t extendedDataSize = *chunkSize - sizeof(rct_ride_entry_32bit);
-	*chunkSize = *chunkSize + sizeof(rct_ride_entry) - sizeof(rct_ride_entry_32bit);
-	assert(*chunkSize > 0);
-	rct_ride_entry* outRideEntry = malloc(*chunkSize);
-	assert(outRideEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outRideEntry + sizeof(rct_ride_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
-
-	// After rideEntry is 3 string tables
-	rideEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_RIDE, entryIndex, 0);
-	rideEntry->description = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_RIDE, entryIndex, 1);
-
-	//TODO: Move to its own function when ride construction window is merged.
-	if (gConfigInterface.select_by_track_type) {
-		rideEntry->enabledTrackPieces = 0xFFFFFFFFFFFFFFFF;
-	}
-
-	object_get_localised_text(&extendedEntryData, OBJECT_TYPE_RIDE, entryIndex, 2);
-	outRideEntry->vehicle_preset_list = (vehicle_colour_preset_list*)extendedEntryData;
-
-	// If Unknown struct size is 0xFF then there are 32 3 byte structures
-	uint8 unknown_size = *extendedEntryData++;
-	if (unknown_size != 0xFF) {
-		extendedEntryData += unknown_size * 3;
-	} else {
-		extendedEntryData += 0x60;
-	}
-
-	sint8 *peep_loading_positions = (sint8*)extendedEntryData;
-	// Peep loading positions variable size
-	// 4 different vehicle subtypes are available
-	for (int i = 0; i < 4; i++){
-		uint16 no_peep_positions = *extendedEntryData++;
-		// If no_peep_positions is 0xFF then no_peep_positions is a word
-		if (no_peep_positions == 0xFF) {
-			no_peep_positions = *((uint16*)extendedEntryData);
-			extendedEntryData += 2;
-		}
-		extendedEntryData += no_peep_positions;
-	}
-
-	int images_offset = object_chunk_load_image_directory(&extendedEntryData);
-	outRideEntry->images_offset = images_offset;
-
-	int cur_vehicle_images_offset = images_offset + 3;
-
-	for (int i = 0; i < 4; i++) {
-		rct_ride_entry_vehicle_32bit* vehicleEntry = &rideEntry->vehicles[i];
-		rct_ride_entry_vehicle* outVehicleEntry = &outRideEntry->vehicles[i];
-
-		if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_FLAT) {
-			int al = 1;
-			if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_SWINGING) {
-				al = 13;
-				if ((vehicleEntry->flags_b & (VEHICLE_ENTRY_FLAG_B_5 | VEHICLE_ENTRY_FLAG_B_11)) != (VEHICLE_ENTRY_FLAG_B_5 | VEHICLE_ENTRY_FLAG_B_11)) {
-					al = 7;
-					if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_5)) {
-						if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_11)) {
-							al = 5;
-							if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_9) {
-								al = 3;
-							}
-						}
-					}
-				}
-			}
-			vehicleEntry->var_03 = al;
-			// 0x6DE90B
-
-			al = 0x20;
-			if (!(vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_14)) {
-				al = 1;
-				if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_7) {
-					if (vehicleEntry->var_11 != 6) {
-						al = 2;
-						if (!(vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_7)) {
-							al = 4;
-						}
-					}
-				}
-			}
-			if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_12) {
-				al = vehicleEntry->special_frames;
-			}
-			vehicleEntry->var_02 = al;
-			// 0x6DE946
-
-			vehicleEntry->var_16 = vehicleEntry->var_02 * vehicleEntry->var_03;
-			vehicleEntry->base_image_id = cur_vehicle_images_offset;
-			int image_index = vehicleEntry->base_image_id;
-
-			if (vehicleEntry->car_visual != VEHICLE_VISUAL_RIVER_RAPIDS) {
-				int b = vehicleEntry->var_16 * 32;
-
-				if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_11) b /= 2;
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_15) b /= 8;
-
-				image_index += b;
-
-				// Incline 25
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_GENTLE_SLOPES) {
-					vehicleEntry->var_20 = image_index;
-					b = vehicleEntry->var_16 * 72;
-					if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_14)
-						b = vehicleEntry->var_16 * 16;
-
-					image_index += b;
-				}
-
-				// Incline 60
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_STEEP_SLOPES) {
-					vehicleEntry->var_24 = image_index;
-					b = vehicleEntry->var_16 * 80;
-					image_index += b;
-				}
-
-				// Verticle
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_VERTICAL_SLOPES) {
-					vehicleEntry->var_28 = image_index;
-					b = vehicleEntry->var_16 * 116;
-					image_index += b;
-				}
-
-				// Unknown
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_DIAGONAL_SLOPES) {
-					vehicleEntry->var_2C = image_index;
-					b = vehicleEntry->var_16 * 24;
-					image_index += b;
-				}
-
-				// Bank
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_FLAT_BANKED) {
-					vehicleEntry->var_30 = image_index;
-					b = vehicleEntry->var_16 * 80;
-					image_index += b;
-				}
-
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_INLINE_TWISTS) {
-					vehicleEntry->var_34 = image_index;
-					b = vehicleEntry->var_16 * 40;
-					image_index += b;
-				}
-
-				// Track half? Up/Down
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS) {
-					vehicleEntry->var_38 = image_index;
-					b = vehicleEntry->var_16 * 128;
-					image_index += b;
-				}
-
-				// Unknown
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS) {
-					vehicleEntry->var_3C = image_index;
-					b = vehicleEntry->var_16 * 16;
-					image_index += b;
-				}
-
-				// Unknown
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS) {
-					vehicleEntry->var_40 = image_index;
-					b = vehicleEntry->var_16 * 16;
-					image_index += b;
-				}
-
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS) {
-					vehicleEntry->var_44 = image_index;
-					b = vehicleEntry->var_16 * 128;
-					image_index += b;
-				}
-
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS) {
-					vehicleEntry->var_48 = image_index;
-					b = vehicleEntry->var_16 * 16;
-					image_index += b;
-				}
-
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_CORKSCREWS) {
-					vehicleEntry->var_4C = image_index;
-					b = vehicleEntry->var_16 * 80;
-					image_index += b;
-				}
-
-				// Unknown
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_RESTRAINT_ANIMATION) {
-					vehicleEntry->var_1C = image_index;
-					b = vehicleEntry->var_16 * 12;
-					image_index += b;
-				}
-
-				if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_14) {
-					// Same offset as above???
-					vehicleEntry->var_4C = image_index;
-					b = vehicleEntry->var_16 * 32;
-					image_index += b;
-				}
-			} else {
-				image_index += vehicleEntry->var_16 * 36;
-			}
-			// No vehicle images
-			vehicleEntry->no_vehicle_images = image_index - cur_vehicle_images_offset;
-
-			// Move the offset over this vehicles images. Including peeps
-			cur_vehicle_images_offset = image_index + vehicleEntry->no_seating_rows * vehicleEntry->no_vehicle_images;
-			// 0x6DEB0D
-
-			// Copy the vehicle entry over to new one
-			outVehicleEntry->rotation_frame_mask = vehicleEntry->rotation_frame_mask;
-			outVehicleEntry->var_02 = vehicleEntry->var_02;
-			outVehicleEntry->var_03 = vehicleEntry->var_03;
-			outVehicleEntry->spacing = vehicleEntry->spacing;
-			outVehicleEntry->car_friction = vehicleEntry->car_friction;
-			outVehicleEntry->tab_height = vehicleEntry->tab_height;
-			outVehicleEntry->num_seats = vehicleEntry->num_seats;
-			outVehicleEntry->sprite_flags = vehicleEntry->sprite_flags;
-			outVehicleEntry->sprite_width = vehicleEntry->sprite_width;
-			outVehicleEntry->sprite_height_negative = vehicleEntry->sprite_height_negative;
-			outVehicleEntry->sprite_height_positive = vehicleEntry->sprite_height_positive;
-			outVehicleEntry->var_11 = vehicleEntry->var_11;
-			outVehicleEntry->flags_a = vehicleEntry->flags_a;
-			outVehicleEntry->flags_b = vehicleEntry->flags_b;
-			outVehicleEntry->var_16 = vehicleEntry->var_16;
-			outVehicleEntry->base_image_id = vehicleEntry->base_image_id;
-			outVehicleEntry->var_1C = vehicleEntry->var_1C;
-			outVehicleEntry->var_20 = vehicleEntry->var_20;
-			outVehicleEntry->var_24 = vehicleEntry->var_24;
-			outVehicleEntry->var_28 = vehicleEntry->var_28;
-			outVehicleEntry->var_2C = vehicleEntry->var_2C;
-			outVehicleEntry->var_30 = vehicleEntry->var_30;
-			outVehicleEntry->var_34 = vehicleEntry->var_34;
-			outVehicleEntry->var_38 = vehicleEntry->var_38;
-			outVehicleEntry->var_3C = vehicleEntry->var_3C;
-			outVehicleEntry->var_40 = vehicleEntry->var_40;
-			outVehicleEntry->var_44 = vehicleEntry->var_44;
-			outVehicleEntry->var_48 = vehicleEntry->var_48;
-			outVehicleEntry->var_4C = vehicleEntry->var_4C;
-			outVehicleEntry->no_vehicle_images = vehicleEntry->no_vehicle_images;
-			outVehicleEntry->no_seating_rows = vehicleEntry->no_seating_rows;
-			outVehicleEntry->spinning_inertia = vehicleEntry->spinning_inertia;
-			outVehicleEntry->spinning_friction = vehicleEntry->spinning_friction;
-			outVehicleEntry->friction_sound_id = vehicleEntry->friction_sound_id;
-			outVehicleEntry->var_58 = vehicleEntry->var_58;
-			outVehicleEntry->sound_range = vehicleEntry->sound_range;
-			outVehicleEntry->var_5A = vehicleEntry->var_5A;
-			outVehicleEntry->powered_acceleration = vehicleEntry->powered_acceleration;
-			outVehicleEntry->powered_max_speed = vehicleEntry->powered_max_speed;
-			outVehicleEntry->car_visual = vehicleEntry->car_visual;
-			outVehicleEntry->effect_visual = vehicleEntry->effect_visual;
-			outVehicleEntry->draw_order = vehicleEntry->draw_order;
-			outVehicleEntry->special_frames = vehicleEntry->special_frames;
-
-			if (!(vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_10)) {
-				int num_images = cur_vehicle_images_offset - vehicleEntry->base_image_id;
-				if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_13) {
-					num_images *= 2;
-				}
-
-				set_vehicle_type_image_max_sizes(outVehicleEntry, num_images);
-			}
-
-			sint8 no_positions = *peep_loading_positions++;
-			if (no_positions == -1) {
-				// The no_positions is 16 bit skip over
-				peep_loading_positions += 2;
-			}
-			// not set for original entry
-			outVehicleEntry->peep_loading_positions = peep_loading_positions;
-		}
-	}
-
-	// 0x6DEB71
-	if (RCT2_GLOBAL(0x9ADAFD, uint8) == 0) {
-		for (int i = 0; i < 3; i++) {
-			int dl = rideEntry->ride_type[i];
-			if (dl == 0xFF) {
-				continue;
-			}
-
-			uint8 *typeToRideEntryIndexMap = gTypeToRideEntryIndexMap;
-			while (dl >= 0) {
-				if (*typeToRideEntryIndexMap++ == 0xFF) {
-					dl--;
-				}
-			}
-
-			typeToRideEntryIndexMap--;
-			uint8 previous_entry = entryIndex;
-			while (typeToRideEntryIndexMap < gTypeToRideEntryIndexMap + countof(gTypeToRideEntryIndexMap)){
-				uint8 backup_entry = *typeToRideEntryIndexMap;
-				*typeToRideEntryIndexMap++ = previous_entry;
-				previous_entry = backup_entry;
-			}
-		}
-	}
-
-	// 0x6DEBAA
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-
-	int di = rideEntry->ride_type[0] | (rideEntry->ride_type[1] << 8) | (rideEntry->ride_type[2] << 16);
-
-	outRideEntry->name = rideEntry->name;
-	outRideEntry->description = rideEntry->description;
-	outRideEntry->images_offset = rideEntry->images_offset;
-	outRideEntry->flags = rideEntry->flags;
-	outRideEntry->ride_type[0] = rideEntry->ride_type[0];
-	outRideEntry->ride_type[1] = rideEntry->ride_type[1];
-	outRideEntry->ride_type[2] = rideEntry->ride_type[2];
-	outRideEntry->min_cars_in_train = rideEntry->min_cars_in_train;
-	outRideEntry->max_cars_in_train = rideEntry->max_cars_in_train;
-	outRideEntry->cars_per_flat_ride = rideEntry->cars_per_flat_ride;
-	outRideEntry->zero_cars = rideEntry->zero_cars;
-	outRideEntry->tab_vehicle = rideEntry->tab_vehicle;
-	outRideEntry->default_vehicle = rideEntry->default_vehicle;
-	outRideEntry->front_vehicle = rideEntry->front_vehicle;
-	outRideEntry->second_vehicle = rideEntry->second_vehicle;
-	outRideEntry->rear_vehicle = rideEntry->rear_vehicle;
-	outRideEntry->third_vehicle = rideEntry->third_vehicle;
-	outRideEntry->pad_019 = rideEntry->pad_019;
-	// 0x1a vehicles already set
-	// 0a1ae vehicle_preset_list already set
-	outRideEntry->excitement_multipler = rideEntry->excitement_multipler;
-	outRideEntry->intensity_multipler = rideEntry->intensity_multipler;
-	outRideEntry->nausea_multipler = rideEntry->nausea_multipler;
-	outRideEntry->max_height = rideEntry->max_height;
-	outRideEntry->enabledTrackPieces = rideEntry->enabledTrackPieces;
-	outRideEntry->category[0] = rideEntry->category[0];
-	outRideEntry->category[1] = rideEntry->category[1];
-	outRideEntry->shop_item = rideEntry->shop_item;
-	outRideEntry->shop_item_secondary = rideEntry->shop_item_secondary;
-
-	if ((rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) && !rideTypeShouldLoseSeparateFlag(outRideEntry)) {
-		di |= 0x1000000;
-	}
-
-	RCT2_GLOBAL(0xF433DD, uint32) = di;
-
-	return (uint8*)outRideEntry;
-}
-
-static void object_type_ride_unload(void *objectEntry)
-{
-	rct_ride_entry *rideEntry = (rct_ride_entry*)objectEntry;
-	rideEntry->name = 0;
-	rideEntry->description = 0;
-	rideEntry->images_offset = 0;
-
-	for (int i = 0; i < 4; i++) {
-		rct_ride_entry_vehicle* rideVehicleEntry = &rideEntry->vehicles[i];
-
-		rideVehicleEntry->base_image_id = 0;
-		rideVehicleEntry->var_1C = 0;
-		rideVehicleEntry->var_20 = 0;
-		rideVehicleEntry->var_24 = 0;
-		rideVehicleEntry->var_28 = 0;
-		rideVehicleEntry->var_2C = 0;
-		rideVehicleEntry->var_30 = 0;
-		rideVehicleEntry->var_34 = 0;
-		rideVehicleEntry->var_38 = 0;
-		rideVehicleEntry->var_3C = 0;
-		rideVehicleEntry->var_40 = 0;
-		rideVehicleEntry->var_44 = 0;
-		rideVehicleEntry->var_48 = 0;
-		rideVehicleEntry->var_4C = 0;
-		rideVehicleEntry->no_vehicle_images = 0;
-		rideVehicleEntry->var_16 = 0;
-
-		if (!(rideVehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_10)) {
-			rideVehicleEntry->sprite_width = 0;
-			rideVehicleEntry->sprite_height_negative = 0;
-			rideVehicleEntry->sprite_height_positive = 0;
-		}
-		rideVehicleEntry->var_02 = 0;
-		rideVehicleEntry->var_03 = 0;
-		rideVehicleEntry->peep_loading_positions = 0;
-	}
-
-	rideEntry->vehicle_preset_list = NULL;
-}
-
-static bool object_type_ride_test(void *objectEntry)
-{
-	rct_ride_entry_32bit* rideEntry = (rct_ride_entry_32bit*)objectEntry;
-	if (rideEntry->excitement_multipler > 75) return false;
-	if (rideEntry->intensity_multipler > 75) return false;
-	if (rideEntry->nausea_multipler > 75) return false;
-	return true;
-}
-
-static void object_type_ride_paint(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y)
-{
-	rct_ride_entry_32bit *rideEntry = (rct_ride_entry_32bit*)objectEntry;
-	int imageId = rideEntry->images_offset;
-	if (rideEntry->ride_type[0] == 0xFF) {
-		imageId++;
-		if (rideEntry->ride_type[1] == 0xFF) {
-			imageId++;
-		}
-	}
-	gfx_draw_sprite(dpi, imageId, x - 56, y - 56, 0);
-}
-
-static rct_string_id object_type_ride_desc(void *objectEntry)
-{
-	rct_ride_entry_32bit *rideEntry = (rct_ride_entry_32bit*)objectEntry;
-
-	// Get description
-	rct_string_id stringId = rideEntry->description;
-	if (!(rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) || rideTypeShouldLoseSeparateFlagByRideType(rideEntry->ride_type)) {
-		uint8 rideType = rideEntry->ride_type[0];
-		if (rideType == 0xFF) {
-			rideType = rideEntry->ride_type[1];
-			if (rideType == 0xFF) {
-				rideType = rideEntry->ride_type[2];
-			}
-		}
-		stringId = 512 + rideType;
-	}
-	return stringId;
-}
-
-static void object_type_ride_reset(void *objectEntry, uint32 entryIndex)
+static bool object_type_ride_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_ride_entry *rideEntry = (rct_ride_entry*)objectEntry;
 
@@ -1296,9 +750,9 @@ static void object_type_ride_reset(void *objectEntry, uint32 entryIndex)
 		}
 	}
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	// 0x6DEBAA
+	if (RCT2_GLOBAL(0x9ADAF4, sint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
 	int di = rideEntry->ride_type[0] | (rideEntry->ride_type[1] << 8) | (rideEntry->ride_type[2] << 16);
@@ -1308,6 +762,88 @@ static void object_type_ride_reset(void *objectEntry, uint32 entryIndex)
 	}
 
 	RCT2_GLOBAL(0xF433DD, uint32) = di;
+	return true;
+}
+
+static void object_type_ride_unload(void *objectEntry)
+{
+	rct_ride_entry *rideEntry = (rct_ride_entry*)objectEntry;
+	rideEntry->name = 0;
+	rideEntry->description = 0;
+	rideEntry->images_offset = 0;
+
+	for (int i = 0; i < 4; i++) {
+		rct_ride_entry_vehicle* rideVehicleEntry = &rideEntry->vehicles[i];
+
+		rideVehicleEntry->base_image_id = 0;
+		rideVehicleEntry->var_1C = 0;
+		rideVehicleEntry->var_20 = 0;
+		rideVehicleEntry->var_24 = 0;
+		rideVehicleEntry->var_28 = 0;
+		rideVehicleEntry->var_2C = 0;
+		rideVehicleEntry->var_30 = 0;
+		rideVehicleEntry->var_34 = 0;
+		rideVehicleEntry->var_38 = 0;
+		rideVehicleEntry->var_3C = 0;
+		rideVehicleEntry->var_40 = 0;
+		rideVehicleEntry->var_44 = 0;
+		rideVehicleEntry->var_48 = 0;
+		rideVehicleEntry->var_4C = 0;
+		rideVehicleEntry->no_vehicle_images = 0;
+		rideVehicleEntry->var_16 = 0;
+
+		if (!(rideVehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_10)) {
+			rideVehicleEntry->sprite_width = 0;
+			rideVehicleEntry->sprite_height_negative = 0;
+			rideVehicleEntry->sprite_height_positive = 0;
+		}
+		rideVehicleEntry->var_02 = 0;
+		rideVehicleEntry->var_03 = 0;
+		rideVehicleEntry->peep_loading_positions = 0;
+	}
+
+	rideEntry->vehicle_preset_list = NULL;
+}
+
+static bool object_type_ride_test(void *objectEntry)
+{
+	rct_ride_entry* rideEntry = (rct_ride_entry*)objectEntry;
+	if (rideEntry->excitement_multipler > 75) return false;
+	if (rideEntry->intensity_multipler > 75) return false;
+	if (rideEntry->nausea_multipler > 75) return false;
+	return true;
+}
+
+static void object_type_ride_paint(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y)
+{
+	rct_ride_entry *rideEntry = (rct_ride_entry*)objectEntry;
+	int imageId = rideEntry->images_offset;
+	if (rideEntry->ride_type[0] == 0xFF) {
+		imageId++;
+		if (rideEntry->ride_type[1] == 0xFF) {
+			imageId++;
+		}
+	}
+	gfx_draw_sprite(dpi, imageId, x - 56, y - 56, 0);
+}
+
+static rct_string_id object_type_ride_desc(void *objectEntry)
+{
+	rct_ride_entry *rideEntry = (rct_ride_entry*)objectEntry;
+
+	// Get description
+	rct_string_id stringId = rideEntry->description;
+	if (!(rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) || rideTypeShouldLoseSeparateFlag(rideEntry)) {
+		uint8 rideType = rideEntry->ride_type[0];
+		if (rideType == 0xFF) {
+			rideType = rideEntry->ride_type[1];
+			if (rideType == 0xFF) {
+				rideType = rideEntry->ride_type[2];
+			}
+		}
+		stringId = 512 + rideType;
+	}
+	return stringId;
 }
 
 static const object_type_vtable object_type_ride_vtable[] = {
@@ -1315,67 +851,17 @@ static const object_type_vtable object_type_ride_vtable[] = {
 	object_type_ride_unload,
 	object_type_ride_test,
 	object_type_ride_paint,
-	object_type_ride_desc,
-	object_type_ride_reset,
+	object_type_ride_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Small Scenery (rct2: 0x006E3466)
 ///////////////////////////////////////////////////////////////////////////////
 
-#pragma pack(push, 1)
-typedef struct rct_large_scenery_entry_32bit {
-	uint8 tool_id;			// 0x06
-	uint8 flags;			// 0x07
-	sint16 price;			// 0x08
-	sint16 removal_price;	// 0x0A
-	uint32 tiles;			// 0x0C note: 32bit!
-	uint8 scenery_tab_id;	// 0x10
-	uint8 var_11;
-	uint32 text;
-	uint32 text_image;
-} rct_large_scenery_entry_32bit;
-assert_struct_size(rct_large_scenery_entry_32bit, 20);
-
-typedef struct rct_small_scenery_entry_32bit {
-	uint32 flags;			// 0x06
-	uint8 height;			// 0x0A
-	uint8 tool_id;			// 0x0B
-	sint16 price;			// 0x0C
-	sint16 removal_price;	// 0x0E
-	uint32 var_10;			// note: uint32!
-	uint16 var_14;
-	uint16 var_16;
-	uint16 var_18;
-	uint8 scenery_tab_id;	// 0x1A
-} rct_small_scenery_entry_32bit;
-assert_struct_size(rct_small_scenery_entry_32bit, 21);
-
-typedef struct rct_scenery_entry_32bit {
-	rct_string_id name;		// 0x00
-	uint32 image;			// 0x02
-	union {
-		rct_small_scenery_entry_32bit small_scenery;
-		rct_large_scenery_entry_32bit large_scenery;
-		rct_wall_scenery_entry wall;
-		rct_path_bit_scenery_entry path_bit;
-		rct_banner_scenery_entry banner;
-	};
-} rct_scenery_entry_32bit;
-assert_struct_size(rct_scenery_entry_32bit, 6 + 21);
-#pragma pack(pop)
-
-static uint8* object_type_small_scenery_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_small_scenery_load(void *objectEntry, uint32 entryIndex)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x1C);
-	const size_t extendedDataSize = *chunkSize - 0x1C;
-	*chunkSize = *chunkSize + sizeof(rct_scenery_entry) - 0x1C;
-	assert(*chunkSize > 0);
-	rct_scenery_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x1C);
 
 	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_SMALL_SCENERY, entryIndex, 0);
 	sceneryEntry->small_scenery.scenery_tab_id = 0xFF;
@@ -1388,38 +874,22 @@ static uint8* object_type_small_scenery_load(void *objectEntry, uint32 entryInde
 
 	extendedEntryData += sizeof(rct_object_entry);
 	if (sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG16){
-		outSceneryEntry->small_scenery.var_10 = (uintptr_t)extendedEntryData;
+		sceneryEntry->small_scenery.var_10 = (uint32)extendedEntryData;
 		while (*++extendedEntryData != 0xFF);
 		extendedEntryData++;
-	} else {
-		outSceneryEntry->small_scenery.var_10 = sceneryEntry->small_scenery.var_10;
 	}
 
 	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
-	outSceneryEntry->name = sceneryEntry->name;
-	outSceneryEntry->image = sceneryEntry->image;
-	outSceneryEntry->small_scenery.flags = sceneryEntry->small_scenery.flags;
-	outSceneryEntry->small_scenery.height = sceneryEntry->small_scenery.height;
-	outSceneryEntry->small_scenery.tool_id = sceneryEntry->small_scenery.tool_id;
-	outSceneryEntry->small_scenery.price = sceneryEntry->small_scenery.price;
-	outSceneryEntry->small_scenery.removal_price = sceneryEntry->small_scenery.removal_price;
-	// var10 already set
-	outSceneryEntry->small_scenery.var_14 = sceneryEntry->small_scenery.var_14;
-	outSceneryEntry->small_scenery.var_16 = sceneryEntry->small_scenery.var_16;
-	outSceneryEntry->small_scenery.var_18 = sceneryEntry->small_scenery.var_18;
-	outSceneryEntry->small_scenery.scenery_tab_id = sceneryEntry->small_scenery.scenery_tab_id;
-
-	return (uint8*)outSceneryEntry;
+	return true;
 }
 
 static void object_type_small_scenery_unload(void *objectEntry)
 {
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
 	sceneryEntry->name = 0;
 	sceneryEntry->image = 0;
 	sceneryEntry->small_scenery.var_10 = 0;
@@ -1428,7 +898,7 @@ static void object_type_small_scenery_unload(void *objectEntry)
 
 static bool object_type_small_scenery_test(void *objectEntry)
 {
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
 
 	if (sceneryEntry->small_scenery.price <= 0) return false;
 	if (sceneryEntry->small_scenery.removal_price > 0) return true;
@@ -1441,7 +911,7 @@ static bool object_type_small_scenery_test(void *objectEntry)
 
 static void object_type_small_scenery_paint(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
 	rct_drawpixelinfo clipDPI;
 	if (!clip_drawpixelinfo(&clipDPI, dpi, x - 56, y - 56, 112, 112)) {
 		return;
@@ -1488,59 +958,22 @@ static rct_string_id object_type_small_scenery_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_small_scenery_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_entry));
-
-	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_SMALL_SCENERY, entryIndex, 0);
-	sceneryEntry->small_scenery.scenery_tab_id = 0xFF;
-	if (*extendedEntryData != 0xFF) {
-		uint8 entry_type, entry_index;
-		if (find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index)) {
-			sceneryEntry->small_scenery.scenery_tab_id = entry_index;
-		}
-	}
-
-	extendedEntryData += sizeof(rct_object_entry);
-	if (sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG16){
-		sceneryEntry->small_scenery.var_10 = (uintptr_t)extendedEntryData;
-		while (*++extendedEntryData != 0xFF);
-		extendedEntryData++;
-	}
-
-	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_small_scenery_vtable[] = {
 	object_type_small_scenery_load,
 	object_type_small_scenery_unload,
 	object_type_small_scenery_test,
 	object_type_small_scenery_paint,
-	object_type_small_scenery_desc,
-	object_type_small_scenery_reset,
+	object_type_small_scenery_desc
 };
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // Large Scenery (rct2: 0x006B92A7)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_large_scenery_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_large_scenery_load(void *objectEntry, uint32 entryIndex)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x1A);
-	const size_t extendedDataSize = *chunkSize - 0x1A;
-	*chunkSize = *chunkSize + sizeof(rct_scenery_entry) - 0x1A;
-	assert(*chunkSize > 0);
-	rct_scenery_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x1A);
 
 	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_LARGE_SCENERY, entryIndex, 0);
 	sceneryEntry->large_scenery.scenery_tab_id = 0xFF;
@@ -1553,105 +986,7 @@ static uint8* object_type_large_scenery_load(void *objectEntry, uint32 entryInde
 
 	extendedEntryData += sizeof(rct_object_entry);
 	if (sceneryEntry->large_scenery.flags & (1 << 2)) {
-		outSceneryEntry->large_scenery.text = (rct_large_scenery_text*)extendedEntryData;
-		extendedEntryData += 1038;
-	}
-
-	outSceneryEntry->large_scenery.tiles = (rct_large_scenery_tile*)extendedEntryData;
-
-	// skip over large scenery tiles
-	while (*((uint16*)extendedEntryData) != 0xFFFF){
-		extendedEntryData += sizeof(rct_large_scenery_tile);
-	}
-
-	extendedEntryData += 2;
-
-	int imageId = object_chunk_load_image_directory(&extendedEntryData);
-	if (sceneryEntry->large_scenery.flags & (1 << 2)){
-		sceneryEntry->large_scenery.text_image = imageId;
-
-		uint8* edx = (uint8*)outSceneryEntry->large_scenery.text;
-		if (!(edx[0xC] & 1)) {
-			imageId += edx[0xD] * 4;
-		} else{
-			imageId += edx[0xD] * 2;
-		}
-	}
-	sceneryEntry->image = imageId;
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-
-	outSceneryEntry->name = sceneryEntry->name;
-	outSceneryEntry->image = sceneryEntry->image;
-	outSceneryEntry->large_scenery.tool_id = sceneryEntry->large_scenery.tool_id;
-	outSceneryEntry->large_scenery.flags = sceneryEntry->large_scenery.flags;
-	outSceneryEntry->large_scenery.price = sceneryEntry->large_scenery.price;
-	outSceneryEntry->large_scenery.removal_price = sceneryEntry->large_scenery.removal_price;
-	// 0x0a tiles is a pointer, already set
-	outSceneryEntry->large_scenery.scenery_tab_id = sceneryEntry->large_scenery.scenery_tab_id;
-	outSceneryEntry->large_scenery.var_11 = sceneryEntry->large_scenery.var_11;
-	// var_12 is a pointer, already set
-	outSceneryEntry->large_scenery.text_image = sceneryEntry->large_scenery.text_image;
-
-	return (uint8*)outSceneryEntry;
-}
-
-static void object_type_large_scenery_unload(void *objectEntry)
-{
-	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
-	sceneryEntry->name = 0;
-	sceneryEntry->image = 0;
-	sceneryEntry->large_scenery.tiles = 0;
-	sceneryEntry->large_scenery.scenery_tab_id = 0;
-	sceneryEntry->large_scenery.text = 0;
-	sceneryEntry->large_scenery.text_image = 0;
-}
-
-static bool object_type_large_scenery_test(void *objectEntry)
-{
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-
-	if (sceneryEntry->large_scenery.price <= 0) return false;
-	if (sceneryEntry->large_scenery.removal_price > 0) return true;
-
-	// Make sure you don't make a profit when placing then removing.
-	if (-sceneryEntry->large_scenery.removal_price > sceneryEntry->large_scenery.price) return false;
-
-	return true;
-}
-
-static void object_type_large_scenery_paint(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-
-	int imageId = sceneryEntry->image | 0xB2D00000;
-	gfx_draw_sprite(dpi, imageId, x, y - 39, 0);
-}
-
-static rct_string_id object_type_large_scenery_desc(void *objectEntry)
-{
-	return STR_NONE;
-}
-
-static void object_type_large_scenery_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_entry));
-
-	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_LARGE_SCENERY, entryIndex, 0);
-	sceneryEntry->large_scenery.scenery_tab_id = 0xFF;
-	if (*extendedEntryData != 0xFF) {
-		uint8 entry_type, entry_index;
-		if (find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index)) {
-			sceneryEntry->large_scenery.scenery_tab_id = entry_index;
-		}
-	}
-
-	extendedEntryData += sizeof(rct_object_entry);
-	if (sceneryEntry->large_scenery.flags & (1 << 2)) {
-		sceneryEntry->large_scenery.text = (rct_large_scenery_text *)extendedEntryData;
+		sceneryEntry->large_scenery.text = (rct_large_scenery_text*)extendedEntryData;
 		extendedEntryData += 1038;
 	}
 
@@ -1676,10 +1011,48 @@ static void object_type_large_scenery_reset(void *objectEntry, uint32 entryIndex
 		}
 	}
 	sceneryEntry->image = imageId;
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
+
+	return true;
+}
+
+static void object_type_large_scenery_unload(void *objectEntry)
+{
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
+	sceneryEntry->name = 0;
+	sceneryEntry->image = 0;
+	sceneryEntry->large_scenery.tiles = 0;
+	sceneryEntry->large_scenery.scenery_tab_id = 0;
+	sceneryEntry->large_scenery.text = 0;
+	sceneryEntry->large_scenery.text_image = 0;
+}
+
+static bool object_type_large_scenery_test(void *objectEntry)
+{
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
+
+	if (sceneryEntry->large_scenery.price <= 0) return false;
+	if (sceneryEntry->large_scenery.removal_price > 0) return true;
+
+	// Make sure you don't make a profit when placing then removing.
+	if (-sceneryEntry->large_scenery.removal_price > sceneryEntry->large_scenery.price) return false;
+
+	return true;
+}
+
+static void object_type_large_scenery_paint(void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y)
+{
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+
+	int imageId = sceneryEntry->image | 0xB2D00000;
+	gfx_draw_sprite(dpi, imageId, x, y - 39, 0);
+}
+
+static rct_string_id object_type_large_scenery_desc(void *objectEntry)
+{
+	return STR_NONE;
 }
 
 static const object_type_vtable object_type_large_scenery_vtable[] = {
@@ -1687,25 +1060,17 @@ static const object_type_vtable object_type_large_scenery_vtable[] = {
 	object_type_large_scenery_unload,
 	object_type_large_scenery_test,
 	object_type_large_scenery_paint,
-	object_type_large_scenery_desc,
-	object_type_large_scenery_reset,
+	object_type_large_scenery_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Wall (rct2: 0x006E5A25)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_wall_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_wall_load(void *objectEntry, uint32 entryIndex)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x0E);
-	const size_t extendedDataSize = *chunkSize - 0x0E;
-	*chunkSize = *chunkSize + sizeof(rct_scenery_entry) - 0x0E;
-	assert(*chunkSize > 0);
-	rct_scenery_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x0E);
 
 	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_WALLS, entryIndex, 0);
 	sceneryEntry->wall.scenery_tab_id = 0xFF;
@@ -1719,22 +1084,11 @@ static uint8* object_type_wall_load(void *objectEntry, uint32 entryIndex, int *c
 	extendedEntryData += sizeof(rct_object_entry);
 	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
-	outSceneryEntry->name = sceneryEntry->name;
-	outSceneryEntry->image = sceneryEntry->image;
-	outSceneryEntry->wall.tool_id = sceneryEntry->wall.tool_id;
-	outSceneryEntry->wall.flags = sceneryEntry->wall.flags;
-	outSceneryEntry->wall.height = sceneryEntry->wall.height;
-	outSceneryEntry->wall.flags2 = sceneryEntry->wall.flags2;
-	outSceneryEntry->wall.price = sceneryEntry->wall.price;
-	outSceneryEntry->wall.scenery_tab_id = sceneryEntry->wall.scenery_tab_id;
-	outSceneryEntry->wall.var_0D = sceneryEntry->wall.var_0D;
-
-	return (uint8*)outSceneryEntry;
+	return true;
 
 }
 
@@ -1748,7 +1102,7 @@ static void object_type_wall_unload(void *objectEntry)
 
 static bool object_type_wall_test(void *objectEntry)
 {
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
 	if (sceneryEntry->wall.price <= 0) return false;
 	return true;
 }
@@ -1785,53 +1139,22 @@ static rct_string_id object_type_wall_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_wall_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_entry));
-
-	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_WALLS, entryIndex, 0);
-	sceneryEntry->wall.scenery_tab_id = 0xFF;
-	if (*extendedEntryData != 0xFF){
-		uint8 entry_type, entry_index;
-		if (find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index)) {
-			sceneryEntry->wall.scenery_tab_id = entry_index;
-		}
-	}
-
-	extendedEntryData += sizeof(rct_object_entry);
-	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_wall_vtable[] = {
 	object_type_wall_load,
 	object_type_wall_unload,
 	object_type_wall_test,
 	object_type_wall_paint,
-	object_type_wall_desc,
-	object_type_wall_reset,
+	object_type_wall_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Banner (rct2: 0x006BA84E)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_banner_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_banner_load(void *objectEntry, uint32 entryIndex)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x0C);
-	const size_t extendedDataSize = *chunkSize - 0x0C;
-	*chunkSize = *chunkSize + sizeof(rct_scenery_entry) - 0x0C;
-	assert(*chunkSize > 0);
-	rct_scenery_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x0C);
 
 	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_BANNERS, entryIndex, 0);
 	sceneryEntry->banner.scenery_tab_id = 0xFF;
@@ -1845,18 +1168,11 @@ static uint8* object_type_banner_load(void *objectEntry, uint32 entryIndex, int
 	extendedEntryData += sizeof(rct_object_entry);
 	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
-	outSceneryEntry->name = sceneryEntry->name;
-	outSceneryEntry->image = sceneryEntry->image;
-	outSceneryEntry->banner.scrolling_mode = sceneryEntry->banner.scrolling_mode;
-	outSceneryEntry->banner.flags = sceneryEntry->banner.flags;
-	outSceneryEntry->banner.price = sceneryEntry->banner.price;
-	outSceneryEntry->banner.scenery_tab_id = sceneryEntry->banner.scenery_tab_id;
 
-	return (uint8*)outSceneryEntry;
+	return true;
 }
 
 static void object_type_banner_unload(void *objectEntry)
@@ -1869,7 +1185,7 @@ static void object_type_banner_unload(void *objectEntry)
 
 static bool object_type_banner_test(void *objectEntry)
 {
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
 	if (sceneryEntry->banner.price <= 0) return false;
 	return true;
 }
@@ -1888,53 +1204,22 @@ static rct_string_id object_type_banner_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_banner_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_entry));
-
-	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_BANNERS, entryIndex, 0);
-	sceneryEntry->banner.scenery_tab_id = 0xFF;
-	if (*extendedEntryData != 0xFF){
-		uint8 entry_type, entry_index;
-		if (find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index)){
-			sceneryEntry->banner.scenery_tab_id = entry_index;
-		}
-	}
-
-	extendedEntryData += sizeof(rct_object_entry);
-	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_banner_vtable[] = {
 	object_type_banner_load,
 	object_type_banner_unload,
 	object_type_banner_test,
 	object_type_banner_paint,
-	object_type_banner_desc,
-	object_type_banner_reset,
+	object_type_banner_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Path (rct2: 0x006A8621)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_path_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_path_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_footpath_entry *pathEntry = (rct_footpath_entry*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x0E);
-	const size_t extendedDataSize = *chunkSize - 0x0E;
-	*chunkSize = *chunkSize + 0x0E - 0x0E;
-	assert(*chunkSize > 0);
-	rct_footpath_entry* outPathEntry = malloc(*chunkSize);
-	assert(outPathEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outPathEntry + 0x0E);
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x0E);
 
 	pathEntry->string_idx = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PATHS, entryIndex, 0);
 
@@ -1942,15 +1227,11 @@ static uint8* object_type_path_load(void *objectEntry, uint32 entryIndex, int *c
 	pathEntry->image = imageId;
 	pathEntry->bridge_image = imageId + 109;
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
-	// rct_path_Type has no pointer, its size does not change, safe to memcpy
-	memcpy(outPathEntry, pathEntry, sizeof(rct_footpath_entry));
-
-	return (uint8*)outPathEntry;
+	return true;
 }
 
 static void object_type_path_unload(void *objectEntry)
@@ -1980,61 +1261,22 @@ static rct_string_id object_type_path_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_path_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_footpath_entry *pathEntry = (rct_footpath_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_footpath_entry));
-
-	pathEntry->string_idx = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PATHS, entryIndex, 0);
-
-	int imageId = object_chunk_load_image_directory(&extendedEntryData);
-	pathEntry->image = imageId;
-	pathEntry->bridge_image = imageId + 109;
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-
-	gFootpathSelectedId = 0;
-	// Set the default path for when opening footpath window
-	for (int i = 0; i < object_entry_group_counts[OBJECT_TYPE_PATHS]; i++) {
-		rct_footpath_entry *pathEntry2 = (rct_footpath_entry*)object_entry_groups[OBJECT_TYPE_PATHS].chunks[i];
-		if (pathEntry2 == (rct_footpath_entry*)-1) {
-			continue;
-		}
-		if (!(pathEntry2->flags & 4)) {
-			gFootpathSelectedId = i;
-			break;
-		}
-		gFootpathSelectedId = i;
-	}
-}
-
 static const object_type_vtable object_type_path_vtable[] = {
 	object_type_path_load,
 	object_type_path_unload,
 	object_type_path_test,
 	object_type_path_paint,
-	object_type_path_desc,
-	object_type_path_reset,
+	object_type_path_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Path Item (rct2: 0x006A86E2)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_path_bit_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_path_bit_load(void *objectEntry, uint32 entryIndex)
 {
-	rct_scenery_entry_32bit* sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x0E);
-	const size_t extendedDataSize = *chunkSize - 0x0E;
-	*chunkSize = *chunkSize + sizeof(rct_scenery_entry) - 0x0E;
-	assert(*chunkSize > 0);
-	rct_scenery_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + (size_t)0x0E);
 
 	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PATH_BITS, entryIndex, 0);
 	sceneryEntry->path_bit.scenery_tab_id = 0xFF;
@@ -2048,20 +1290,11 @@ static uint8* object_type_path_bit_load(void *objectEntry, uint32 entryIndex, in
 	extendedEntryData += sizeof(rct_object_entry);
 	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
-	outSceneryEntry->name = sceneryEntry->name;
-	outSceneryEntry->image = sceneryEntry->image;
-	outSceneryEntry->path_bit.flags = sceneryEntry->path_bit.flags;
-	outSceneryEntry->path_bit.draw_type = sceneryEntry->path_bit.draw_type;
-	outSceneryEntry->path_bit.tool_id = sceneryEntry->path_bit.tool_id;
-	outSceneryEntry->path_bit.price = sceneryEntry->path_bit.price;
-	outSceneryEntry->path_bit.scenery_tab_id = sceneryEntry->path_bit.scenery_tab_id;
-
-	return (uint8*)outSceneryEntry;
+	return true;
 }
 
 static void object_type_path_bit_unload(void *objectEntry)
@@ -2074,7 +1307,7 @@ static void object_type_path_bit_unload(void *objectEntry)
 
 static bool object_type_path_bit_test(void *objectEntry)
 {
-	rct_scenery_entry_32bit *sceneryEntry = (rct_scenery_entry_32bit*)objectEntry;
+	rct_scenery_entry *sceneryEntry = (rct_scenery_entry*)objectEntry;
 	if (sceneryEntry->path_bit.price <= 0) return false;
 	return true;
 }
@@ -2090,62 +1323,32 @@ static rct_string_id object_type_path_bit_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_path_bit_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_entry* sceneryEntry = (rct_scenery_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_entry));
-
-	sceneryEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PATH_BITS, entryIndex, 0);
-	sceneryEntry->path_bit.scenery_tab_id = 0xFF;
-	if (*extendedEntryData != 0xFF) {
-		uint8 entry_type, entry_index;
-		if (find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index)){
-			sceneryEntry->path_bit.scenery_tab_id = entry_index;
-		}
-	}
-
-	extendedEntryData += sizeof(rct_object_entry);
-	sceneryEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_path_bit_vtable[] = {
 	object_type_path_bit_load,
 	object_type_path_bit_unload,
 	object_type_path_bit_test,
 	object_type_path_bit_paint,
-	object_type_path_bit_desc,
-	object_type_path_bit_reset,
+	object_type_path_bit_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Scenery Set (rct2: 0x006B93AA)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_scenery_set_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_scenery_set_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_scenery_set_entry *scenerySetEntry = (rct_scenery_set_entry*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_set_entry));
-	const size_t extendedDataSize = *chunkSize - sizeof(rct_scenery_set_entry);
-	*chunkSize = *chunkSize + sizeof(rct_scenery_set_entry) - sizeof(rct_scenery_set_entry);
-	assert(*chunkSize > 0);
-	rct_scenery_set_entry* outSceneryEntry = malloc(*chunkSize);
-	assert(outSceneryEntry != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outSceneryEntry + sizeof(rct_scenery_set_entry));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_set_entry));
 
 	scenerySetEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_SCENERY_SETS, entryIndex, 0);
 	
 	rct_object_entry *entryObjects = NULL;
-	uintptr_t eax = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (eax != (uintptr_t)0xFFFFFFFF){
+	uint8 *eax = RCT2_GLOBAL(0x9ADAF4, uint8*);
+	if ((uint32)eax != 0xFFFFFFFF){
 		*((uint16*)eax) = 0;
 		entryObjects = (rct_object_entry*)(eax + 2);
 	}
+
 	scenerySetEntry->entry_count = 0;
 	scenerySetEntry->var_107 = 0;
 
@@ -2155,7 +1358,7 @@ static uint8* object_type_scenery_set_load(void *objectEntry, uint32 entryIndex,
 		if (entryObjects != NULL){
 			memcpy(entryObjects, extendedEntryData, sizeof(rct_object_entry));
 			entryObjects++;
-			(*((uint8*)(eax + 1)))++;
+			(*(eax + 1))++;
 		}
 		uint8 entry_type;
 		uint8 entry_index = 0;
@@ -2187,9 +1390,7 @@ static uint8* object_type_scenery_set_load(void *objectEntry, uint32 entryIndex,
 	extendedEntryData++;
 	scenerySetEntry->image = object_chunk_load_image_directory(&extendedEntryData);
 
-	memcpy(outSceneryEntry, scenerySetEntry, sizeof(rct_scenery_set_entry));
-
-	return (uint8*)outSceneryEntry;
+	return true;
 }
 
 static void object_type_scenery_set_unload(void *objectEntry)
@@ -2219,98 +1420,31 @@ static rct_string_id object_type_scenery_set_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_scenery_set_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_scenery_set_entry *scenerySetEntry = (rct_scenery_set_entry*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_scenery_set_entry));
-
-	scenerySetEntry->name = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_SCENERY_SETS, entryIndex, 0);
-
-	rct_object_entry *entryObjects = NULL;
-	uintptr_t eax = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (eax != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)eax) = 0;
-		entryObjects = (rct_object_entry*)(eax + 2);
-	}
-
-	scenerySetEntry->entry_count = 0;
-	scenerySetEntry->var_107 = 0;
-
-	for (; *extendedEntryData != 0xFF; extendedEntryData += sizeof(rct_object_entry)) {
-		scenerySetEntry->var_107++;
-
-		if (entryObjects != NULL){
-			memcpy(entryObjects, extendedEntryData, sizeof(rct_object_entry));
-			entryObjects++;
-			(*((uint16*)(eax + 1)))++;
-		}
-		uint8 entry_type;
-		uint8 entry_index = 0;
-		if (!find_object_in_entry_group((rct_object_entry*)extendedEntryData, &entry_type, &entry_index))
-			continue;
-
-		uint16 scenery_entry = entry_index;
-
-		switch (entry_type){
-		case OBJECT_TYPE_SMALL_SCENERY:
-			break;
-		case OBJECT_TYPE_LARGE_SCENERY:
-			scenery_entry |= 0x300;
-			break;
-		case OBJECT_TYPE_WALLS:
-			scenery_entry |= 0x200;
-			break;
-		case OBJECT_TYPE_PATH_BITS:
-			scenery_entry |= 0x100;
-			break;
-		default:
-			scenery_entry |= 0x400;
-			break;
-		}
-
-		scenerySetEntry->scenery_entries[scenerySetEntry->entry_count++] = scenery_entry;
-	}
-
-	extendedEntryData++;
-	scenerySetEntry->image = object_chunk_load_image_directory(&extendedEntryData);
-}
-
 static const object_type_vtable object_type_scenery_set_vtable[] = {
 	object_type_scenery_set_load,
 	object_type_scenery_set_unload,
 	object_type_scenery_set_test,
 	object_type_scenery_set_paint,
-	object_type_scenery_set_desc,
-	object_type_scenery_set_reset,
+	object_type_scenery_set_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Park Entrance (rct2: 0x00666E42)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_park_entrance_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+bool object_type_park_entrance_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_entrance_type *entranceType = (rct_entrance_type*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_entrance_type));
-	const size_t extendedDataSize = *chunkSize - sizeof(rct_entrance_type);
-	*chunkSize = *chunkSize + sizeof(rct_entrance_type) - sizeof(rct_entrance_type);
-	assert(*chunkSize > 0);
-	rct_entrance_type* outEntranceType = malloc(*chunkSize);
-	assert(outEntranceType != NULL);
-	uint8 *extendedEntryData = (uint8*)((size_t)outEntranceType + sizeof(rct_entrance_type));
-	memcpy(extendedEntryData, origExtendedEntryData, extendedDataSize);
+	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_entrance_type));
 
 	entranceType->string_idx = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PARK_ENTRANCE, entryIndex, 0);
 	entranceType->image_id = object_chunk_load_image_directory(&extendedEntryData);
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x9ADAF4, uint16*) = 0;
 	}
 
-	memcpy(outEntranceType, entranceType, sizeof(rct_entrance_type));
-
-	return (uint8*)outEntranceType;
+	return true;
 }
 
 static void object_type_park_entrance_unload(void *objectEntry)
@@ -2345,45 +1479,23 @@ static rct_string_id object_type_park_entrance_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_park_entrance_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_entrance_type *entranceType = (rct_entrance_type*)objectEntry;
-	uint8 *extendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_entrance_type));
-
-	entranceType->string_idx = object_get_localised_text(&extendedEntryData, OBJECT_TYPE_PARK_ENTRANCE, entryIndex, 0);
-	entranceType->image_id = object_chunk_load_image_directory(&extendedEntryData);
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_park_entrance_vtable[] = {
 	object_type_park_entrance_load,
 	object_type_park_entrance_unload,
 	object_type_park_entrance_test,
 	object_type_park_entrance_paint,
-	object_type_park_entrance_desc,
-	object_type_park_entrance_reset,
+	object_type_park_entrance_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Water (rct2: 0x006E6E2A)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_water_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_water_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_water_type *waterEntry = (rct_water_type*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + sizeof(rct_water_type));
-	const size_t extendedDataSize = *chunkSize - sizeof(rct_water_type);
-	*chunkSize = *chunkSize + sizeof(rct_water_type) - sizeof(rct_water_type);
-	assert(*chunkSize > 0);
-	rct_water_type* outWaterEntry = malloc(*chunkSize);
-	assert(outWaterEntry != NULL);
-	uint8 *pStringTable = (uint8*)((size_t)outWaterEntry + sizeof(rct_water_type));
-	memcpy(pStringTable, origExtendedEntryData, extendedDataSize);
 
+	uint8 *pStringTable = (uint8*)((size_t)objectEntry + sizeof(rct_water_type));
 	waterEntry->string_idx = object_get_localised_text(&pStringTable, OBJECT_TYPE_WATER, entryIndex, 0);
 
 	int imageId = object_chunk_load_image_directory(&pStringTable);
@@ -2391,9 +1503,8 @@ static uint8* object_type_water_load(void *objectEntry, uint32 entryIndex, int *
 	waterEntry->var_06 = imageId + 1;
 	waterEntry->var_0A = imageId + 4;
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x009ADAF4, uint32) != 0xFFFFFFFF) {
+		*RCT2_GLOBAL(0x009ADAF4, uint16*) = 0;
 	}
 
 	if (RCT2_GLOBAL(0x009ADAFD, uint8) == 0) {
@@ -2401,9 +1512,7 @@ static uint8* object_type_water_load(void *objectEntry, uint32 entryIndex, int *
 		gfx_invalidate_screen();
 	}
 
-	memcpy(outWaterEntry, waterEntry, sizeof(rct_water_type));
-
-	return (uint8*)outWaterEntry;
+	return true;
 }
 
 static void object_type_water_unload(void *objectEntry)
@@ -2431,66 +1540,32 @@ static rct_string_id object_type_water_desc(void *objectEntry)
 	return STR_NONE;
 }
 
-static void object_type_water_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_water_type *waterEntry = (rct_water_type*)objectEntry;
-
-	uint8 *pStringTable = (uint8*)((size_t)objectEntry + sizeof(rct_water_type));
-	waterEntry->string_idx = object_get_localised_text(&pStringTable, OBJECT_TYPE_WATER, entryIndex, 0);
-
-	int imageId = object_chunk_load_image_directory(&pStringTable);
-	waterEntry->image_id = imageId;
-	waterEntry->var_06 = imageId + 1;
-	waterEntry->var_0A = imageId + 4;
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-
-	if (RCT2_GLOBAL(0x009ADAFD, uint8) == 0) {
-		load_palette();
-		gfx_invalidate_screen();
-	}
-}
-
 static const object_type_vtable object_type_water_vtable[] = {
 	object_type_water_load,
 	object_type_water_unload,
 	object_type_water_test,
 	object_type_water_paint,
-	object_type_water_desc,
-	object_type_water_reset,
+	object_type_water_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Stex (rct2: 0x0066B355)
 ///////////////////////////////////////////////////////////////////////////////
 
-static uint8* object_type_stex_load(void *objectEntry, uint32 entryIndex, int *chunkSize)
+static bool object_type_stex_load(void *objectEntry, uint32 entryIndex)
 {
 	rct_stex_entry *stexEntry = (rct_stex_entry*)objectEntry;
-	const uint8 *origExtendedEntryData = (uint8*)((size_t)objectEntry + 0x08);
-	const size_t extendedDataSize = *chunkSize - 0x08;
-	*chunkSize = *chunkSize + 0x08 - 0x08;
-	assert(*chunkSize > 0);
-	rct_stex_entry* outStexEntry = malloc(*chunkSize);
-	assert(outStexEntry != NULL);
-	uint8 *stringTable = (uint8*)((size_t)outStexEntry + 0x08);
-	memcpy(stringTable, origExtendedEntryData, extendedDataSize);
+	uint8 *stringTable = (uint8*)((size_t)objectEntry + (size_t)0x08);
 	
 	stexEntry->scenario_name = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 0);
 	stexEntry->park_name = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 1);
 	stexEntry->details = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 2);
 
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
+	if (RCT2_GLOBAL(0x9ADAF4, int) != -1) {
+		RCT2_GLOBAL(0x9ADAF4, uint16*)[0] = 0;
 	}
 
-	memcpy(outStexEntry, stexEntry, sizeof(rct_stex_entry));
-
-	return (uint8*)outStexEntry;
+	return true;
 }
 
 static void object_type_stex_unload(void *objectEntry)
@@ -2518,28 +1593,12 @@ static rct_string_id object_type_stex_desc(void *objectEntry)
 	return stexEntry->details;
 }
 
-static void object_type_stex_reset(void *objectEntry, uint32 entryIndex)
-{
-	rct_stex_entry *stexEntry = (rct_stex_entry*)objectEntry;
-	uint8 *stringTable = (uint8*)((size_t)objectEntry + (size_t)0x08);
-
-	stexEntry->scenario_name = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 0);
-	stexEntry->park_name = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 1);
-	stexEntry->details = object_get_localised_text(&stringTable, OBJECT_TYPE_SCENARIO_TEXT, entryIndex, 2);
-
-	uintptr_t some_pointer = RCT2_GLOBAL(0x9ADAF4, uint32);
-	if (some_pointer != (uintptr_t)0xFFFFFFFF){
-		*((uint16*)some_pointer) = 0;
-	}
-}
-
 static const object_type_vtable object_type_stex_vtable[] = {
 	object_type_stex_load,
 	object_type_stex_unload,
 	object_type_stex_test,
 	object_type_stex_paint,
-	object_type_stex_desc,
-	object_type_stex_reset,
+	object_type_stex_desc
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2558,11 +1617,11 @@ static const object_type_vtable * const object_type_vtables[] = {
 	object_type_stex_vtable
 };
 
-uint8* object_load(int type, void *objectEntry, uint32 entryIndex, int *chunkSize)
+bool object_load(int type, void *objectEntry, uint32 entryIndex)
 {
 	assert(type >= OBJECT_TYPE_RIDE && type <= OBJECT_TYPE_SCENARIO_TEXT);
 	const object_type_vtable *vtable = object_type_vtables[type];
-	return vtable->load(objectEntry, entryIndex, chunkSize);
+	return vtable->load(objectEntry, entryIndex) ? 0 : 1;
 }
 
 void object_unload(int type, void *objectEntry)
@@ -2593,13 +1652,6 @@ rct_string_id object_desc(int type, void *objectEntry)
 	return vtable->desc(objectEntry);
 }
 
-void object_reset(int type, void *objectEntry, uint32 entryIndex)
-{
-	assert(type >= OBJECT_TYPE_RIDE && type <= OBJECT_TYPE_SCENARIO_TEXT);
-	const object_type_vtable *vtable = object_type_vtables[type];
-	vtable->reset(objectEntry, entryIndex);
-}
-
 /**
  *
  *  rct2: 0x006A9428
@@ -2664,7 +1716,6 @@ int object_get_scenario_text(rct_object_entry *entry)
 
 			// This is being changed to force the images to be loaded into a different
 			// image id.
-			chunk = object_load(openedEntry.flags & 0x0F, chunk, 0, &chunkSize);
 			gTotalNoImages = 0x726E;
 			gStexTempChunk = (rct_stex_entry*)chunk;
 			// Not used anywhere.
@@ -2675,6 +1726,7 @@ int object_get_scenario_text(rct_object_entry *entry)
 			memcpy(gTempObjectLoadName, openedEntry.name, 8);
 			// Not used??
 			RCT2_GLOBAL(0x009ADAFD, uint8) = 1;
+			object_load(openedEntry.flags & 0x0F, chunk, 0);
 			// Tell text to be loaded into normal address
 			RCT2_GLOBAL(0x009ADAFC, uint8) = 0;
 			// Not used??
diff --git a/src/object.h b/src/object.h
index 2cd15feb30..3c9b1a3ea2 100644
--- a/src/object.h
+++ b/src/object.h
@@ -140,11 +140,10 @@ char *object_get_name(rct_object_entry *entry);
 
 rct_object_filters *get_object_filter(int index);
 
-uint8* object_load(int type, void *objectEntry, uint32 entryIndex, int *chunkSize);
+bool object_load(int type, void *objectEntry, uint32 entryIndex);
 void object_unload(int type, void *objectEntry);
 bool object_test(int type, void *objectEntry);
 void object_paint(int type, void *objectEntry, rct_drawpixelinfo *dpi, sint32 x, sint32 y);
 rct_string_id object_desc(int type, void *objectEntry);
-void object_reset(int type, void *objectEntry, uint32 entryIndex);
 
 #endif
diff --git a/src/object_list.c b/src/object_list.c
index a9abfc667f..19cbc4f301 100644
--- a/src/object_list.c
+++ b/src/object_list.c
@@ -30,7 +30,7 @@
 #include "world/scenery.h"
 #include "world/water.h"
 
-#define PLUGIN_VERSION 5
+#define PLUGIN_VERSION 4
 #define FILTER_VERSION 1
 
 typedef struct rct_plugin_header {
@@ -236,7 +236,7 @@ void reset_loaded_objects()
 		for (int j = 0; j < object_entry_group_counts[type]; j++){
 			uint8* chunk = object_entry_groups[type].chunks[j];
 			if (chunk != (uint8*)-1)
-				object_reset(type, chunk, j);
+				object_load(type, chunk, j);
 		}
 	}
 }
diff --git a/src/openrct2.c b/src/openrct2.c
index 0e4ebf4cbd..fcfe3fee32 100644
--- a/src/openrct2.c
+++ b/src/openrct2.c
@@ -571,7 +571,7 @@ bool openrct2_setup_rct2_segment()
 	}
 #endif // defined(__unix__)
 
-#if !defined(NO_RCT2) && !defined(__WINDOWS__)
+#if !defined(NO_RCT2) || !defined(__WINDOWS__)
 	// Check that the expected data is at various addresses.
 	// Start at 0x9a6000, which is start of .data, to skip the region containing addresses to DLL
 	// calls, which can be changed by windows/wine loader.
diff --git a/src/rct1.c b/src/rct1.c
index 8864ae7591..04c2356359 100644
--- a/src/rct1.c
+++ b/src/rct1.c
@@ -78,11 +78,7 @@ bool rct1_read_sv4(const char *path, rct1_s4 *s4)
 	return success;
 }
 
-/**
- * Only to be used when loading 32 bit items from files, otherwise use
- * rideTypeShouldLoseSeparateFlag.
- */
-bool rideTypeShouldLoseSeparateFlagByRideType(uint8 ride_type[3])
+bool rideTypeShouldLoseSeparateFlag(rct_ride_entry *rideEntry)
 {
 	if (!gConfigInterface.select_by_track_type) {
 		return false;
@@ -90,21 +86,16 @@ bool rideTypeShouldLoseSeparateFlagByRideType(uint8 ride_type[3])
 
 	bool remove_flag = true;
 	for (int j = 0; j < 3; j++) {
-		if (ride_type_has_flag(ride_type[j], RIDE_TYPE_FLAG_FLAT_RIDE)) {
+		if (ride_type_has_flag(rideEntry->ride_type[j], RIDE_TYPE_FLAG_FLAT_RIDE)) {
 			remove_flag = false;
 		}
-		if (ride_type[j] == RIDE_TYPE_MAZE || ride_type[j] == RIDE_TYPE_MINI_GOLF) {
+		if (rideEntry->ride_type[j] == RIDE_TYPE_MAZE || rideEntry->ride_type[j] == RIDE_TYPE_MINI_GOLF) {
 			remove_flag = false;
 		}
 	}
 	return remove_flag;
 }
 
-bool rideTypeShouldLoseSeparateFlag(rct_ride_entry *rideEntry)
-{
-	return rideTypeShouldLoseSeparateFlagByRideType(rideEntry->ride_type);
-}
-
 const uint8 gRideCategories[] = {
 	2,		 // Spiral Roller coaster
 	2,		 // Stand Up Coaster
diff --git a/src/rct1.h b/src/rct1.h
index 4ac779c294..4ae06a295e 100644
--- a/src/rct1.h
+++ b/src/rct1.h
@@ -746,7 +746,6 @@ void rct1_import_s4(rct1_s4 *s4);
 void rct1_fix_landscape();
 int vehicle_preference_compare(uint8 rideType, const char * a, const char * b);
 bool rideTypeShouldLoseSeparateFlag(rct_ride_entry *rideEntry);
-bool rideTypeShouldLoseSeparateFlagByRideType(uint8 ride_type[3]);
 
 bool rct1_load_saved_game(const char *path);
 bool rct1_load_scenario(const char *path);
diff --git a/src/ride/ride.c b/src/ride/ride.c
index 8d9148dc61..f77c559b06 100644
--- a/src/ride/ride.c
+++ b/src/ride/ride.c
@@ -31,7 +31,6 @@
 #include "../management/news_item.h"
 #include "../network/network.h"
 #include "../object_list.h"
-#include "../openrct2.h"
 #include "../peep/peep.h"
 #include "../peep/staff.h"
 #include "../rct1.h"
@@ -6923,10 +6922,8 @@ void set_vehicle_type_image_max_sizes(rct_ride_entry_vehicle* vehicle_type, int
 		.zoom_level = 0
 	};
 
-	if (!gOpenRCT2Headless) {
-		for (int i = 0; i < num_images; ++i){
-			gfx_draw_sprite_software(&dpi, vehicle_type->base_image_id + i, 0, 0, 0);
-		}
+	for (int i = 0; i < num_images; ++i){
+		gfx_draw_sprite_software(&dpi, vehicle_type->base_image_id + i, 0, 0, 0);
 	}
 	int al = -1;
 	for (int i = 99; i != 0; --i){
diff --git a/src/ride/ride.h b/src/ride/ride.h
index 9497d34aba..a8facce1fc 100644
--- a/src/ride/ride.h
+++ b/src/ride/ride.h
@@ -122,7 +122,9 @@ typedef struct rct_ride_entry {
 	uint8 shop_item;									// 0x1C0
 	uint8 shop_item_secondary;							// 0x1C1
 } rct_ride_entry;
-// FIXME: unpack
+#ifdef PLATFORM_32BIT
+assert_struct_size(rct_ride_entry, 0x1c2);
+#endif
 
 /**
  * Ride structure.
diff --git a/src/ride/vehicle.h b/src/ride/vehicle.h
index df7eca6e86..424fd2e21f 100644
--- a/src/ride/vehicle.h
+++ b/src/ride/vehicle.h
@@ -77,7 +77,9 @@ typedef struct rct_ride_entry_vehicle {
 	uint8 special_frames;			// 0x60 , 0x7A
 	sint8* peep_loading_positions;	// 0x61 , 0x7B
 } rct_ride_entry_vehicle;
-// FIXME: unpack
+#ifdef PLATFORM_32BIT
+assert_struct_size(rct_ride_entry_vehicle, 0x65);
+#endif
 
 typedef struct rct_vehicle {
 	uint8 sprite_identifier;		// 0x00
diff --git a/src/world/scenery.h b/src/world/scenery.h
index 27b0d9c3d9..0f46018a55 100644
--- a/src/world/scenery.h
+++ b/src/world/scenery.h
@@ -21,18 +21,20 @@
 #include "../object.h"
 #include "../world/map.h"
 
+#pragma pack(push, 1)
 typedef struct rct_small_scenery_entry {
 	uint32 flags;			// 0x06
 	uint8 height;			// 0x0A
 	uint8 tool_id;			// 0x0B
 	sint16 price;			// 0x0C
 	sint16 removal_price;	// 0x0E
-	uintptr_t var_10;
+	uint32 var_10;
 	uint16 var_14;
 	uint16 var_16;
 	uint16 var_18;
 	uint8 scenery_tab_id;	// 0x1A
 } rct_small_scenery_entry;
+assert_struct_size(rct_small_scenery_entry, 21);
 
 typedef enum {
 	SMALL_SCENERY_FLAG_FULL_TILE = (1 << 0),					// 0x1
@@ -65,7 +67,6 @@ typedef enum {
 	SMALL_SCENERY_FLAG27 = (1 << 27),							// 0x8000000
 } SMALL_SCENERY_FLAGS;
 
-#pragma pack(push, 1)
 typedef struct rct_large_scenery_tile {
 	sint16 x_offset;
 	sint16 y_offset;
@@ -103,7 +104,9 @@ typedef struct rct_large_scenery_entry {
 	rct_large_scenery_text* text; // 0x12
 	uint32 text_image;	// 0x16
 } rct_large_scenery_entry;
-// FIXME: unpack
+#ifdef PLATFORM_32BIT
+assert_struct_size(rct_large_scenery_entry, 20);
+#endif
 
 typedef struct rct_wall_scenery_entry {
 	uint8 tool_id;			// 0x06
@@ -159,7 +162,9 @@ typedef struct rct_scenery_entry {
 		rct_banner_scenery_entry banner;
 	};
 } rct_scenery_entry;
-// FIXME: unpack?
+#ifdef PLATFORM_32BIT
+assert_struct_size(rct_scenery_entry, 6 + 21);
+#endif
 
 typedef struct rct_scenery_set_entry {
 	rct_string_id name;				// 0x00