openttd-ottdgrfs: comparison src/vehicle.cpp

equal deleted inserted replaced

-:1ac8aac92385
+:e79cd19772dd
 #include "newgrf_sound.h"
 #include "helpers.hpp"
 #include "group.h"
 #include "economy.h"
-#define INVALID_COORD (-0x8000)
+#define INVALID_COORD (0x7fffffff)
 #define GEN_HASH(x, y) ((GB((y), 6, 6) << 6) + GB((x), 7, 6))
 /* Tables used in vehicle.h to find the right command for a certain vehicle type */
 const uint32 _veh_build_proc_table[] = {
 	}
 	return true;
 }
+/* Size of the hash, 6 = 64 x 64, 7 = 128 x 128. Larger sizes will (in theory) reduce hash
+* lookup times at the expense of memory usage. */
+const int HASH_BITS = 7;
+const int HASH_SIZE = 1 << HASH_BITS;
+const int HASH_MASK = HASH_SIZE - 1;
+const int TOTAL_HASH_SIZE = 1 << (HASH_BITS * 2);
+const int TOTAL_HASH_MASK = TOTAL_HASH_SIZE - 1;
+/* Resolution of the hash, 0 = 1*1 tile, 1 = 2*2 tiles, 2 = 4*4 tiles, etc.
+* Profiling results show that 0 is fastest. */
+const int HASH_RES = 0;
+static Vehicle *_new_vehicle_position_hash[TOTAL_HASH_SIZE];
+static void *VehicleFromHash(int xl, int yl, int xu, int yu, void *data, VehicleFromPosProc *proc)
+{
+	for (int y = yl; ; y = (y + (1 << HASH_BITS)) & (HASH_MASK << HASH_BITS)) {
+		for (int x = xl; ; x = (x + 1) & HASH_MASK) {
+			Vehicle *v = _new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK];
+			for (; v != NULL; v = v->next_new_hash) {
+				void *a = proc(v, data);
+				if (a != NULL) return a;
+			}
+			if (x == xu) break;
+		}
+		if (y == yu) break;
+	}
+	return NULL;
+}
+void *VehicleFromPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
+{
+	const int COLL_DIST = 6;
+	/* Hash area to scan is from xl,yl to xu,yu */
+	int xl = GB((x - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS);
+	int xu = GB((x + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS);
+	int yl = GB((y - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS;
+	int yu = GB((y + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS;
+	return VehicleFromHash(xl, yl, xu, yu, data, proc);
+}
+void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
+{
+	int x = GB(TileX(tile), HASH_RES, HASH_BITS);
+	int y = GB(TileY(tile), HASH_RES, HASH_BITS) << HASH_BITS;
+	Vehicle *v = _new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK];
+	for (; v != NULL; v = v->next_new_hash) {
+		if (v->tile != tile) continue;
+		void *a = proc(v, data);
+		if (a != NULL) return a;
+	}
+	return NULL;
+}
+static void UpdateNewVehiclePosHash(Vehicle *v, bool remove)
+{
+	Vehicle **old_hash = v->old_new_hash;
+	Vehicle **new_hash;
+	if (remove) {
+		new_hash = NULL;
+	} else {
+		int x = GB(TileX(v->tile), HASH_RES, HASH_BITS);
+		int y = GB(TileY(v->tile), HASH_RES, HASH_BITS) << HASH_BITS;
+		new_hash = &_new_vehicle_position_hash[(x + y) & TOTAL_HASH_MASK];
+	}
+	if (old_hash == new_hash) return;
+	/* Remove from the old position in the hash table */
+	if (old_hash != NULL) {
+		Vehicle *last = NULL;
+		Vehicle *u = *old_hash;
+		while (u != v) {
+			last = u;
+			u = u->next_new_hash;
+			assert(u != NULL);
+		}
+		if (last == NULL) {
+			*old_hash = v->next_new_hash;
+		} else {
+			last->next_new_hash = v->next_new_hash;
+		}
+	}
+	/* Insert vehicle at beginning of the new position in the hash table */
+	if (new_hash != NULL) {
+		v->next_new_hash = *new_hash;
+		*new_hash = v;
+		assert(v != v->next_new_hash);
+	}
+	/* Remember current hash position */
+	v->old_new_hash = new_hash;
+}
 static Vehicle *_vehicle_position_hash[0x1000];
-void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
-{
-	Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, 0);
-	/* The hash area to scan */
-	const int xl = GB(pt.x - 174, 7, 6);
-	const int xu = GB(pt.x + 104, 7, 6);
-	const int yl = GB(pt.y - 294, 6, 6) << 6;
-	const int yu = GB(pt.y +  56, 6, 6) << 6;
-	int x;
-	int y;
-	for (y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) {
-		for (x = xl;; x = (x + 1) & 0x3F) {
-			Vehicle *v = _vehicle_position_hash[(x + y) & 0xFFFF];
-			while (v != NULL) {
-				void* a = proc(v, data);
-				if (a != NULL) return a;
-				v = v->next_hash;
-			}
-			if (x == xu) break;
-		}
-		if (y == yu) break;
-	}
-	return NULL;
-}
 static void UpdateVehiclePosHash(Vehicle* v, int x, int y)
 {
+	UpdateNewVehiclePosHash(v, x == INVALID_COORD);
 	Vehicle **old_hash, **new_hash;
 	int old_x = v->left_coord;
 	int old_y = v->top_coord;
 	new_hash = (x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(x, y)];
 	}
 }
 void ResetVehiclePosHash()
 {
+	Vehicle *v;
+	FOR_ALL_VEHICLES(v) { v->old_new_hash = NULL; }
 	memset(_vehicle_position_hash, 0, sizeof(_vehicle_position_hash));
+	memset(_new_vehicle_position_hash, 0, sizeof(_new_vehicle_position_hash));
 }
 void InitializeVehicles()
 {
 	uint i;
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
 	UpdateVehiclePosHash(v, INVALID_COORD, 0);
 	v->next_hash = NULL;
+	v->next_new_hash = NULL;
 	if (IsPlayerBuildableVehicleType(v)) DeleteVehicleOrders(v);
 	/* Now remove any artic part. This will trigger an other
 	 *  destroy vehicle, which on his turn can remove any
 	 *  other artic parts. */
 /** Learn the price of refitting a certain engine
 * @param engine_type Which engine to refit
 * @return Price for refitting
 */
-int32 GetRefitCost(EngineID engine_type)
+CommandCost GetRefitCost(EngineID engine_type)
 {
-	int32 base_cost = 0;
+	CommandCost base_cost = 0;
 	switch (GetEngine(engine_type)->type) {
 		case VEH_SHIP: base_cost = _eco->GetPrice(CEconomy::SHIP_BASE); break;
 		case VEH_ROAD: base_cost = _eco->GetPrice(CEconomy::ROADVEH_BASE); break;
 		case VEH_AIRCRAFT: base_cost = _eco->GetPrice(CEconomy::AIRCRAFT_BASE); break;
 	const int r = dpi->left + dpi->width;
 	const int t = dpi->top;
 	const int b = dpi->top + dpi->height;
 	/* The hash area to scan */
-	const int xl = GB(l - 70, 7, 6);
+	int xl, xu, yl, yu;
-	const int xu = GB(r,      7, 6);
-	const int yl = GB(t - 70, 6, 6) << 6;
+	if (dpi->width + 70 < (1 << (7 + 6))) {
-	const int yu = GB(b,      6, 6) << 6;
+		xl = GB(l - 70, 7, 6);
+		xu = GB(r,      7, 6);
-	int x;
+	} else {
-	int y;
+		/* scan whole hash row */
+		xl = 0;
-	for (y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) {
+		xu = 0x3F;
-		for (x = xl;; x = (x + 1) & 0x3F) {
+	}
-			const Vehicle *v = _vehicle_position_hash[(x + y) & 0xFFFF];
+	if (dpi->height + 70 < (1 << (6 + 6))) {
+		yl = GB(t - 70, 6, 6) << 6;
+		yu = GB(b,      6, 6) << 6;
+	} else {
+		/* scan whole column */
+		yl = 0;
+		yu = 0x3F << 6;
+	}
+	for (int y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) {
+		for (int x = xl;; x = (x + 1) & 0x3F) {
+			const Vehicle *v = _vehicle_position_hash[x + y]; // already masked & 0xFFF
 			while (v != NULL) {
 				if (!(v->vehstatus & VS_HIDDEN) &&
 						l <= v->right_coord &&
 						t <= v->bottom_coord &&
 *   - bit 0-4 Vehicle type
 *   - bit 5 false = start vehicles, true = stop vehicles
 *   - bit 6 if set, then it's a vehicle list window, not a depot and Tile is ignored in this case
 *   - bit 8-11 Vehicle List Window type (ignored unless bit 1 is set)
 */
-int32 CmdMassStartStopVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdMassStartStopVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle **vl = NULL;
 	uint16 engine_list_length = 0;
 	uint16 engine_count = 0;
-	int32 return_value = CMD_ERROR;
+	CommandCost return_value = CMD_ERROR;
 	uint i;
 	uint stop_command;
 	VehicleType vehicle_type = (VehicleType)GB(p2, 0, 5);
 	bool start_stop = HASBIT(p2, 5);
 	bool vehicle_list_window = HASBIT(p2, 6);
 		BuildDepotVehicleList(vehicle_type, tile, &vl, &engine_list_length, &engine_count, NULL, NULL, NULL);
 	}
 	for (i = 0; i < engine_count; i++) {
 		const Vehicle *v = vl[i];
-		int32 ret;
+		CommandCost ret;
 		if (!!(v->vehstatus & VS_STOPPED) != start_stop) continue;
 		if (!vehicle_list_window) {
 			if (vehicle_type == VEH_TRAIN) {
 			}
 		}
 		ret = DoCommand(tile, v->index, 0, flags, stop_command);
-		if (!CmdFailed(ret)) {
+		if (CmdSucceeded(ret)) {
 			return_value = 0;
 			/* We know that the command is valid for at least one vehicle.
 			 * If we haven't set DC_EXEC, then there is no point in continueing because it will be valid */
 			if (!(flags & DC_EXEC)) break;
 		}
 * @param tile Tile of the depot where the depot is
 * @param flags type of operation
 * @param p1 Vehicle type
 * @param p2 unused
 */
-int32 CmdDepotSellAllVehicles(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdDepotSellAllVehicles(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle **engines = NULL;
 	Vehicle **wagons = NULL;
 	uint16 engine_list_length = 0;
 	uint16 engine_count = 0;
 	uint16 wagon_list_length = 0;
 	uint16 wagon_count = 0;
-	int32 cost = 0;
+	CommandCost cost = 0;
 	uint i, sell_command, total_number_vehicles;
 	VehicleType vehicle_type = (VehicleType)GB(p1, 0, 8);
 	switch (vehicle_type) {
 		case VEH_TRAIN:    sell_command = CMD_SELL_RAIL_WAGON; break;
 						                      &wagons,  &wagon_list_length,  &wagon_count);
 	total_number_vehicles = engine_count + wagon_count;
 	for (i = 0; i < total_number_vehicles; i++) {
 		const Vehicle *v;
-		int32 ret;
+		CommandCost ret;
 		if (i < engine_count) {
 			v = engines[i];
 		} else {
 			v = wagons[i - engine_count];
 		}
 		ret = DoCommand(tile, v->index, 1, flags, sell_command);
-		if (!CmdFailed(ret)) cost += ret;
+		if (CmdSucceeded(ret)) cost += ret;
 	}
 	free(engines);
 	free(wagons);
 	if (cost == 0) return CMD_ERROR; // no vehicles to sell
 * @param tile Tile of the depot where the vehicles are
 * @param flags type of operation
 * @param p1 Type of vehicle
 * @param p2 Unused
 */
-int32 CmdDepotMassAutoReplace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdDepotMassAutoReplace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle **vl = NULL;
 	uint16 engine_list_length = 0;
 	uint16 engine_count = 0;
 	uint i, x = 0, y = 0, z = 0;
-	int32 cost = 0;
+	CommandCost cost = 0;
 	VehicleType vehicle_type = (VehicleType)GB(p1, 0, 8);
 	if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
 	/* Get the list of vehicles in the depot */
 	for (i = 0; i < engine_count; i++) {
 		Vehicle *v = vl[i];
 		bool stopped = !(v->vehstatus & VS_STOPPED);
-		int32 ret;
+		CommandCost ret;
 		/* Ensure that the vehicle completely in the depot */
 		if (!IsVehicleInDepot(v)) continue;
 		x = v->x_pos;
 			v->vehstatus |= VS_STOPPED; // Stop the vehicle
 			v->leave_depot_instantly = true;
 		}
 		ret = MaybeReplaceVehicle(v, !(flags & DC_EXEC), false);
-		if (!CmdFailed(ret)) {
+		if (CmdSucceeded(ret)) {
 			cost += ret;
 			if (!(flags & DC_EXEC)) break;
 			/* There is a problem with autoreplace and newgrf
 			 * It's impossible to tell the length of a train after it's being replaced before it's actually done
 			 * Because of this, we can't estimate costs due to wagon removal and we will have to always return 0 and pay manually
 * @param tile tile of the depot where the cloned vehicle is build
 * @param flags type of operation
 * @param p1 the original vehicle's index
 * @param p2 1 = shared orders, else copied orders
 */
-int32 CmdCloneVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdCloneVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v_front, *v;
 	Vehicle *w_front, *w, *w_rear;
-	int32 cost, total_cost = 0;
+	CommandCost cost, total_cost = 0;
 	uint32 build_argument = 2;
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
 	v_front = v;
 			}
 			if (v->type == VEH_TRAIN && !IsFrontEngine(v)) {
 				/* this s a train car
 				 * add this unit to the end of the train */
-				int32 result = DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);
+				CommandCost result = DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);
 				if (CmdFailed(result)) {
 					/* The train can't be joined to make the same consist as the original.
 					 * Sell what we already made (clean up) and return an error.           */
 					DoCommand(w_front->tile, w_front->index, 1, flags, GetCmdSellVeh(w_front));
 					DoCommand(w_front->tile, w->index,       1, flags, GetCmdSellVeh(w));
 			if (flags & DC_EXEC) {
 				assert(w != NULL);
 				if (w->cargo_type != v->cargo_type || w->cargo_subtype != v->cargo_type) {
 					cost = DoCommand(0, w->index, v->cargo_type | (v->cargo_subtype << 8) | 1U << 16 , flags, GetCmdRefitVeh(v));
-					if (!CmdFailed(cost)) total_cost += cost;
+					if (CmdSucceeded(cost)) total_cost += cost;
 				}
 				if (w->type == VEH_TRAIN && EngineHasArticPart(w)) {
 					w = GetNextArticPart(w);
 				} else if (w->type == VEH_ROAD && RoadVehHasArticPart(w)) {
 * @param service should the vehicles only get service in the depots
 * @param owner PlayerID of owner of the vehicles to send
 * @param vlw_flag tells what kind of list requested the goto depot
 * @return 0 for success and CMD_ERROR if no vehicle is able to go to depot
 */
-int32 SendAllVehiclesToDepot(VehicleType type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id)
+CommandCost SendAllVehiclesToDepot(VehicleType type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id)
 {
 	const Vehicle **sort_list = NULL;
 	uint n, i;
 	uint16 array_length = 0;
 	n = GenerateVehicleSortList(&sort_list, &array_length, type, owner, id, vlw_flag);
 	/* Send all the vehicles to a depot */
 	for (i = 0; i < n; i++) {
 		const Vehicle *v = sort_list[i];
-		int32 ret = DoCommand(v->tile, v->index, (service ? 1 : 0) | DEPOT_DONT_CANCEL, flags, GetCmdSendToDepot(type));
+		CommandCost ret = DoCommand(v->tile, v->index, (service ? 1 : 0) | DEPOT_DONT_CANCEL, flags, GetCmdSendToDepot(type));
 		/* Return 0 if DC_EXEC is not set this is a valid goto depot command)
 			* In this case we know that at least one vehicle can be sent to a depot
 			* and we will issue the command. We can now safely quit the loop, knowing
 			* it will succeed at least once. With DC_EXEC we really need to send them to the depot */
-		if (!CmdFailed(ret) && !(flags & DC_EXEC)) {
+		if (CmdSucceeded(ret) && !(flags & DC_EXEC)) {
 			free((void*)sort_list);
 			return 0;
 		}
 	}
 		t = v->current_order;
 		v->current_order.type = OT_DUMMY;
 		v->current_order.flags = 0;
 		if (t.refit_cargo < NUM_CARGO) {
-			int32 cost;
+			CommandCost cost;
 			_current_player = v->owner;
 			cost = DoCommand(v->tile, v->index, t.refit_cargo | t.refit_subtype << 8, DC_EXEC, GetCmdRefitVeh(v));
 			if (CmdFailed(cost)) {
 * @param tile unused
 * @param flags type of operation
 * @param p1 vehicle ID to name
 * @param p2 unused
 */
-int32 CmdNameVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdNameVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v;
 	StringID str;
 	if (!IsValidVehicleID(p1) || _cmd_text[0] == '\0') return CMD_ERROR;
 * @param tile unused
 * @param flags type of operation
 * @param p1 vehicle ID that is being service-interval-changed
 * @param p2 new service interval
 */
-int32 CmdChangeServiceInt(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdChangeServiceInt(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle* v;
 	uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */
 	if (serv_int != p2 || !IsValidVehicleID(p1)) return CMD_ERROR;

branch	gamebalance
changeset 9913	e79cd19772dd
parent 9912	1ac8aac92385