openttd-ottdgrfs: comparison src/vehicle.cpp

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 		case VEH_AIRCRAFT: return STR_A015_AIRCRAFT_IN_THE_WAY;
 		default:           return STR_980E_SHIP_IN_THE_WAY;
 	}
 }
-static void *EnsureNoVehicleProc(Vehicle *v, void *data)
-{
-	if (v->tile != *(const TileIndex*)data || v->type == VEH_DISASTER)
-		return NULL;
-	_error_message = VehicleInTheWayErrMsg(v);
-	return v;
-}
-bool EnsureNoVehicle(TileIndex tile)
-{
-	return VehicleFromPos(tile, &tile, EnsureNoVehicleProc) == NULL;
-}
 static void *EnsureNoVehicleProcZ(Vehicle *v, void *data)
 {
 	const TileInfo *ti = (const TileInfo*)data;
-	if (v->tile != ti->tile || v->type == VEH_DISASTER) return NULL;
+	if (v->tile != ti->tile || v->type == VEH_DISASTER || (v->type == VEH_AIRCRAFT && v->subtype == AIR_SHADOW)) return NULL;
 	if (v->z_pos > ti->z) return NULL;
 	_error_message = VehicleInTheWayErrMsg(v);
 	return v;
 }
 	}
 	FOR_ALL_VEHICLES(v) {
 		switch (v->type) {
 			case VEH_ROAD:
-				v->u.road.roadtype = HASBIT(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
+				v->u.road.roadtype = HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
 				v->u.road.compatible_roadtypes = RoadTypeToRoadTypes(v->u.road.roadtype);
 				/* FALL THROUGH */
 			case VEH_TRAIN:
 			case VEH_SHIP:
 				v->cur_image = v->GetImage(v->direction);
 	this->type               = VEH_INVALID;
 	this->left_coord         = INVALID_COORD;
 	this->group_id           = DEFAULT_GROUP;
 	this->fill_percent_te_id = INVALID_TE_ID;
 	this->first              = this;
+	this->colormap           = PAL_NONE;
 }
 /**
 * Get a value for a vehicle's random_bits.
 * @return A random value from 0 to 255.
 	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 ResetVehicleColorMap()
+{
+	Vehicle *v;
+	FOR_ALL_VEHICLES(v) { v->colormap = PAL_NONE; }
+}
 void InitializeVehicles()
 {
 	_Vehicle_pool.CleanPool();
 	_Vehicle_pool.AddBlockToPool();
 	 *  destroy vehicle, which on his turn can remove any
 	 *  other artic parts. */
 	if ((this->type == VEH_TRAIN && EngineHasArticPart(this)) || (this->type == VEH_ROAD && RoadVehHasArticPart(this))) {
 		delete this->Next();
 	}
+	Window *w = FindWindowById(WC_VEHICLE_VIEW, this->index);
+	if (w != NULL && WP(w, vp_d).follow_vehicle == this->index) {
+		ScrollMainWindowTo(this->x_pos, this->y_pos); // lock the main view on the vehicle's last position
+		WP(w, vp_d).follow_vehicle = INVALID_VEHICLE;
+	}
 }
 Vehicle::~Vehicle()
 {
 	DeleteName(this->string_id);
 }
 /**
 * Deletes all vehicles in a chain.
 * @param v The first vehicle in the chain.
-*
-* @warning This function is not valid for any vehicle containing articulated
-* parts.
 */
 void DeleteVehicleChain(Vehicle *v)
 {
-	assert(v->type != VEH_TRAIN && v->type != VEH_ROAD);
+	assert(v->First() == v);
 	do {
 		Vehicle *u = v;
 		v = v->Next();
 		delete u;
 * @param *v vehicle to add
 */
 void VehicleEnteredDepotThisTick(Vehicle *v)
 {
 	/* we need to set v->leave_depot_instantly as we have no control of it's contents at this time */
-	if (HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT) && !HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS) && v->current_order.type == OT_GOTO_DEPOT) {
+	if (HasBit(v->current_order.flags, OFB_HALT_IN_DEPOT) && !HasBit(v->current_order.flags, OFB_PART_OF_ORDERS) && v->current_order.type == OT_GOTO_DEPOT) {
 		/* we keep the vehicle in the depot since the user ordered it to stay */
 		v->leave_depot_instantly = false;
 	} else {
 		/* the vehicle do not plan on stopping in the depot, so we stop it to ensure that it will not reserve the path
 		 * out of the depot before we might autoreplace it to a different engine. The new engine would not own the reserved path
 * @param cid_to check refit to this cargo-type
 * @return true if it is possible, false otherwise
 */
 bool CanRefitTo(EngineID engine_type, CargoID cid_to)
 {
-	return HASBIT(EngInfo(engine_type)->refit_mask, cid_to);
+	return HasBit(EngInfo(engine_type)->refit_mask, cid_to);
 }
 /** Find the first cargo type that an engine can be refitted to.
 * @param engine_type Which engine to find cargo for.
 * @return A climate dependent cargo type. CT_INVALID is returned if not refittable.
 {
 	uint32 refit_mask = EngInfo(engine_type)->refit_mask;
 	if (refit_mask != 0) {
 		for (CargoID cid = 0; cid < NUM_CARGO; cid++) {
-			if (HASBIT(refit_mask, cid)) return cid;
+			if (HasBit(refit_mask, cid)) return cid;
 		}
 	}
 	return CT_INVALID;
 }
 		delete v;
 		return;
 	}
 	if (b->y == 4 && b->x == 1) {
-		if (v->z_pos > 180 || CHANCE16I(1, 96, InteractiveRandom())) {
+		if (v->z_pos > 180 || Chance16I(1, 96, InteractiveRandom())) {
 			v->spritenum = 5;
 			SndPlayVehicleFx(SND_2F_POP, v);
 		}
 		et = 0;
 	}
 	return v;
 }
 Vehicle *CreateEffectVehicleAbove(int x, int y, int z, EffectVehicle type)
 {
-	int safe_x = clamp(x, 0, MapMaxX() * TILE_SIZE);
+	int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
-	int safe_y = clamp(y, 0, MapMaxY() * TILE_SIZE);
+	int safe_y = Clamp(y, 0, MapMaxY() * TILE_SIZE);
 	return CreateEffectVehicle(x, y, GetSlopeZ(safe_x, safe_y) + z, type);
 }
 Vehicle *CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicle type)
 {
 		if ((v->vehstatus & (VS_HIDDEN|VS_UNCLICKABLE)) == 0 &&
 				x >= v->left_coord && x <= v->right_coord &&
 				y >= v->top_coord && y <= v->bottom_coord) {
 			dist = max(
-				myabs( ((v->left_coord + v->right_coord)>>1) - x ),
+				abs( ((v->left_coord + v->right_coord)>>1) - x ),
-				myabs( ((v->top_coord + v->bottom_coord)>>1) - y )
+				abs( ((v->top_coord + v->bottom_coord)>>1) - y )
 			);
 			if (dist < best_dist) {
 				found = v;
 				best_dist = dist;
 	}
 	return found;
 }
+void CheckVehicle32Day(Vehicle *v)
+{
+	if ((v->day_counter & 0x1F) != 0) return;
+	uint16 callback = GetVehicleCallback(CBID_VEHICLE_32DAY_CALLBACK, 0, 0, v->engine_type, v);
+	if (callback == CALLBACK_FAILED) return;
+	if (HasBit(callback, 0)) TriggerVehicle(v, VEHICLE_TRIGGER_CALLBACK_32); // Trigger vehicle trigger 10
+	if (HasBit(callback, 1)) v->colormap = PAL_NONE;                         // Update colormap via callback 2D
+}
 void DecreaseVehicleValue(Vehicle *v)
 {
 	v->value -= v->value >> 8;
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	r = Random();
 	/* increase chance of failure */
 	chance = v->breakdown_chance + 1;
-	if (CHANCE16I(1,25,r)) chance += 25;
+	if (Chance16I(1,25,r)) chance += 25;
 	v->breakdown_chance = min(255, chance);
 	/* calculate reliability value to use in comparison */
 	rel = v->reliability;
 	if (v->type == VEH_SHIP) rel += 0x6666;
 	uint16 engine_count = 0;
 	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 start_stop = HasBit(p2, 5);
-	bool vehicle_list_window = HASBIT(p2, 6);
+	bool vehicle_list_window = HasBit(p2, 6);
 	switch (vehicle_type) {
 		case VEH_TRAIN:    stop_command = CMD_START_STOP_TRAIN;    break;
 		case VEH_ROAD:     stop_command = CMD_START_STOP_ROADVEH;  break;
 		case VEH_SHIP:     stop_command = CMD_START_STOP_SHIP;     break;
 		total_cost.AddCost(cost);
 		if (flags & DC_EXEC) {
 			w = GetVehicle(_new_vehicle_id);
-			if (v->type == VEH_TRAIN && HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {
+			if (v->type == VEH_TRAIN && HasBit(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {
-				SETBIT(w->u.rail.flags, VRF_REVERSE_DIRECTION);
+				SetBit(w->u.rail.flags, VRF_REVERSE_DIRECTION);
 			}
 			if (v->type == VEH_TRAIN && !IsFrontEngine(v)) {
 				/* this s a train car
 				 * add this unit to the end of the train */
 					DoCommand(w_front->tile, w_front->index, 1, flags, GetCmdSellVeh(w_front));
 					DoCommand(w_front->tile, w->index,       1, flags, GetCmdSellVeh(w));
 					return result; // return error and the message returned from CMD_MOVE_RAIL_VEHICLE
 				}
 			} else {
-				/* this is a front engine or not a train. It need orders */
+				/* this is a front engine or not a train. */
 				w_front = w;
 				w->service_interval = v->service_interval;
-				DoCommand(0, (v->index << 16) | w->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER);
 			}
 			w_rear = w; // trains needs to know the last car in the train, so they can add more in next loop
 		}
 	} while (v->type == VEH_TRAIN && (v = GetNextVehicle(v)) != NULL);
 	do {
 		do {
 			if (flags & DC_EXEC) {
 				assert(w != NULL);
-				if (w->cargo_type != v->cargo_type || w->cargo_subtype != v->cargo_type) {
+				if (w->cargo_type != v->cargo_type || w->cargo_subtype != v->cargo_subtype) {
 					cost = DoCommand(0, w->index, v->cargo_type | (v->cargo_subtype << 8) | 1U << 16 , flags, GetCmdRefitVeh(v));
 					if (CmdSucceeded(cost)) total_cost.AddCost(cost);
 				}
 				if (w->type == VEH_TRAIN && EngineHasArticPart(w)) {
 			}
 		} while (v != NULL);
 		if ((flags & DC_EXEC) && v->type == VEH_TRAIN) w = GetNextVehicle(w);
 	} while (v->type == VEH_TRAIN && (v = GetNextVehicle(v)) != NULL);
+	if (flags & DC_EXEC) {
+		/*
+		 * Set the orders of the vehicle. Cannot do it earlier as we need
+		 * the vehicle refitted before doing this, otherwise the moved
+		 * cargo types might not match (passenger vs non-passenger)
+		 */
+		DoCommand(0, (v_front->index << 16) | w_front->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER);
+	}
 	/* Since we can't estimate the cost of cloning a vehicle accurately we must
 	 * check whether the player has enough money manually. */
 	if (!CheckPlayerHasMoney(total_cost)) {
 		if (flags & DC_EXEC) {
 	/* Count up max and used */
 	for (; v != NULL; v = v->Next()) {
 		count += v->cargo.Count();
 		max += v->cargo_cap;
 		if (v->cargo_cap != 0) {
-			unloading += HASBIT(v->vehicle_flags, VF_CARGO_UNLOADING) ? 1 : 0;
+			unloading += HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) ? 1 : 0;
 			loading |= (u->current_order.flags & OF_UNLOAD) == 0 && st->goods[v->cargo_type].days_since_pickup != 255;
 			cars++;
 		}
 	}
 			} else if (v->owner == _local_player && cost.GetCost() != 0) {
 				ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost.GetCost());
 			}
 		}
-		if (HASBIT(t.flags, OFB_PART_OF_ORDERS)) {
+		if (HasBit(t.flags, OFB_PART_OF_ORDERS)) {
 			/* Part of orders */
 			UpdateVehicleTimetable(v, true);
 			v->cur_order_index++;
-		} else if (HASBIT(t.flags, OFB_HALT_IN_DEPOT)) {
+		} else if (HasBit(t.flags, OFB_HALT_IN_DEPOT)) {
 			/* Force depot visit */
 			v->vehstatus |= VS_STOPPED;
 			if (v->owner == _local_player) {
 				StringID string;
 	if (max > 0) {
 		/* Can we actually build the vehicle type? */
 		EngineID e;
 		FOR_ALL_ENGINEIDS_OF_TYPE(e, type) {
-			if (HASBIT(GetEngine(e)->player_avail, _local_player)) return true;
+			if (HasBit(GetEngine(e)->player_avail, _local_player)) return true;
 		}
 		return false;
 	}
 	/* We should be able to build infrastructure when we have the actual vehicle type */
 								}
 							} else {
 								scheme = LS_FREIGHT_WAGON;
 							}
 						} else {
-							bool is_mu = HASBIT(EngInfo(engine_type)->misc_flags, EF_RAIL_IS_MU);
+							bool is_mu = HasBit(EngInfo(engine_type)->misc_flags, EF_RAIL_IS_MU);
 							switch (rvi->engclass) {
 								default: NOT_REACHED();
 								case EC_STEAM:    scheme = LS_STEAM; break;
 								case EC_DIESEL:   scheme = is_mu ? LS_DMU : LS_DIESEL;   break;
 			}
 			case VEH_ROAD: {
 				const RoadVehicleInfo *rvi = RoadVehInfo(engine_type);
 				if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type;
-				if (HASBIT(EngInfo(engine_type)->misc_flags, EF_ROAD_TRAM)) {
+				if (HasBit(EngInfo(engine_type)->misc_flags, EF_ROAD_TRAM)) {
 					/* Tram */
 					scheme = IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_PASSENGER_TRAM : LS_FREIGHT_TRAM;
 				} else {
 					/* Bus or truck */
 					scheme = IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_BUS : LS_TRUCK;
 }
 static SpriteID GetEngineColourMap(EngineID engine_type, PlayerID player, EngineID parent_engine_type, const Vehicle *v)
 {
-	SpriteID map = PAL_NONE;
+	SpriteID map = (v != NULL) ? v->colormap : PAL_NONE;
+	/* Return cached value if any */
+	if (map != PAL_NONE) return map;
 	/* Check if we should use the colour map callback */
-	if (HASBIT(EngInfo(engine_type)->callbackmask, CBM_VEHICLE_COLOUR_REMAP)) {
+	if (HasBit(EngInfo(engine_type)->callbackmask, CBM_VEHICLE_COLOUR_REMAP)) {
 		uint16 callback = GetVehicleCallback(CBID_VEHICLE_COLOUR_MAPPING, 0, 0, engine_type, v);
 		/* A return value of 0xC000 is stated to "use the default two-color
 		 * maps" which happens to be the failure action too... */
 		if (callback != CALLBACK_FAILED && callback != 0xC000) {
 			map = GB(callback, 0, 14);
 			/* If bit 14 is set, then the company colours are applied to the
 			 * map else it's returned as-is. */
-			if (!HASBIT(callback, 14)) return map;
+			if (!HasBit(callback, 14)) {
-		}
+				/* Update cache */
-	}
+				if (v != NULL) ((Vehicle*)v)->colormap = map;
+				return map;
-	bool twocc = HASBIT(EngInfo(engine_type)->misc_flags, EF_USES_2CC);
+			}
+		}
+	}
+	bool twocc = HasBit(EngInfo(engine_type)->misc_flags, EF_USES_2CC);
 	if (map == PAL_NONE) map = twocc ? (SpriteID)SPR_2CCMAP_BASE : (SpriteID)PALETTE_RECOLOR_START;
 	const Livery *livery = GetEngineLivery(engine_type, player, parent_engine_type, v);
 	map += livery->colour1;
 	if (twocc) map += livery->colour2 * 16;
+	/* Update cache */
+	if (v != NULL) ((Vehicle*)v)->colormap = map;
 	return map;
 }
 SpriteID GetEnginePalette(EngineID engine_type, PlayerID player)
 {
 	switch (this->current_order.type) {
 		case OT_LOADING: {
 			uint wait_time = max(this->current_order.wait_time - this->lateness_counter, 0);
 			/* Not the first call for this tick, or still loading */
-			if (mode || !HASBIT(this->vehicle_flags, VF_LOADING_FINISHED) ||
+			if (mode || !HasBit(this->vehicle_flags, VF_LOADING_FINISHED) ||
 					(_patches.timetabling && this->current_order_time < wait_time)) return;
 			this->PlayLeaveStationSound();
 			Order b = this->current_order;

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85