cpp/openttd-patchpack/source Changeset - r5856:e64c21408d74

Changeset - r5856:e64c21408d74

Parent rev.

Child rev.

[Not reviewed]

master

0 3 0

tron - 18 years ago 2007-01-27 16:45:16
tron@openttd.org

(svn r8430) -Fix

Replace the rather obscure control flow for handling aircraft/ship/train orders by something remotly comprehensible (see r3584)

3 files changed with 73 insertions and 62 deletions:

src/aircraft_cmd.cpp

src/ship_cmd.cpp

src/train_cmd.cpp

0 comments (0 inline, 0 general)

src/aircraft_cmd.cpp

➞

Show inline comments

@@ @@ -1068,409 +1068,413 @@ static bool AircraftController(Vehicle * @@
+		}
 		curz = GetSlopeZ(x, y) + 1;
 		if (curz > z) {
 			z++;
 		} else {
 			int t = max(1U, dist - 4);
 			z -= ((z - curz) + t - 1) / t;
 			if (z < curz) z = curz;
+		}
+	}
 	// We've landed. Decrase speed when we're reaching end of runway.
 	if (amd->flag & AMED_BRAKE) {
 		curz = GetSlopeZ(x, y) + 1;
 		if (z > curz) {
 			z--;
 		} else if (z < curz) {
 			z++;
+		}
 		if (dist < 64 && v->cur_speed > 12) v->cur_speed -= 4;
+	}
 	SetAircraftPosition(v, gp.x, gp.y, z);
 	return false;
+}
 static void HandleCrashedAircraft(Vehicle *v)
+{
 	uint32 r;
 	Station *st;
 	int z;
 	v->u.air.crashed_counter++;
 	st = GetStation(v->u.air.targetairport);
 	// make aircraft crash down to the ground
 	if (v->u.air.crashed_counter < 500 && st->airport_tile==0 && ((v->u.air.crashed_counter % 3) == 0) ) {
 		z = GetSlopeZ(v->x_pos, v->y_pos);
 		v->z_pos -= 1;
 		if (v->z_pos == z) {
 			v->u.air.crashed_counter = 500;
 			v->z_pos++;
+		}
+	}
 	if (v->u.air.crashed_counter < 650) {
 		if (CHANCE16R(1,32,r)) {
 			static const DirDiff delta[] = {
 				DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
 			};
 			v->direction = ChangeDir(v->direction, delta[GB(r, 16, 2)]);
 			SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
 			r = Random();
 			CreateEffectVehicleRel(v,
 				GB(r, 0, 4) + 4,
 				GB(r, 4, 4) + 4,
 				GB(r, 8, 4),
 				EV_EXPLOSION_SMALL);
+		}
 	} else if (v->u.air.crashed_counter >= 10000) {
 		// remove rubble of crashed airplane
 		// clear runway-in on all airports, set by crashing plane
 		// small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc.
 		// but they all share the same number
 		CLRBITS(st->airport_flags, RUNWAY_IN_block);
 		CLRBITS(st->airport_flags, RUNWAY_IN_OUT_block); // commuter airport
 		CLRBITS(st->airport_flags, RUNWAY_IN2_block); // intercontinental
 		BeginVehicleMove(v);
 		EndVehicleMove(v);
 		DoDeleteAircraft(v);
+	}
+}
 static void HandleBrokenAircraft(Vehicle *v)
+{
 	if (v->breakdown_ctr != 1) {
 		v->breakdown_ctr = 1;
 		v->vehstatus |= VS_AIRCRAFT_BROKEN;
 		if (v->breakdowns_since_last_service != 255)
 			v->breakdowns_since_last_service++;
 		InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+	}
+}
 static void HandleAircraftSmoke(Vehicle *v)
+{
 	static const struct {
 		int8 x;
 		int8 y;
 	} smoke_pos[] = {
 		{  5,  5 },
 		{  6,  0 },
 		{  5, -5 },
 		{  0, -6 },
 		{ -5, -5 },
 		{ -6,  0 },
 		{ -5,  5 },
 		{  0,  6 }
 	};
 	if (!(v->vehstatus & VS_AIRCRAFT_BROKEN)) return;
 	if (v->cur_speed < 10) {
 		v->vehstatus &= ~VS_AIRCRAFT_BROKEN;
 		v->breakdown_ctr = 0;
 		return;
+	}
 	if ((v->tick_counter & 0x1F) == 0) {
 		CreateEffectVehicleRel(v,
 			smoke_pos[v->direction].x,
 			smoke_pos[v->direction].y,
 ,
 			EV_SMOKE
 		);
+	}
+}
 static void ProcessAircraftOrder(Vehicle *v)
+{
 	const Order *order;
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
 			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
 					!VehicleNeedsService(v)) {
 				v->cur_order_index++;
+			}
 			break;
 		case OT_LOADING: return;
 		default: break;
+	}
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	order = GetVehicleOrder(v, v->cur_order_index);
 	if (order == NULL) {
 		v->current_order.type = OT_NOTHING;
 		v->current_order.flags = 0;
 		return;
+	}
 	if (order->type == OT_DUMMY && !CheckForValidOrders(v)) CrashAirplane(v);
 	if (order->type  == v->current_order.type  &&
 			order->flags == v->current_order.flags &&
 			order->dest  == v->current_order.dest)
 		return;
 	v->current_order = *order;
 	// orders are changed in flight, ensure going to the right station
 	if (order->type == OT_GOTO_STATION && v->u.air.state == FLYING) {
 		AircraftNextAirportPos_and_Order(v);
 		v->u.air.targetairport = order->dest;
+	}
 	InvalidateVehicleOrder(v);
 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
+}
 /** Mark all views dirty for an aircraft.
  * @param v vehicle to be redrawn.
  */
 static void MarkAircraftDirty(Vehicle *v)
+{
 		v->cur_image = GetAircraftImage(v, v->direction);
 		if (v->subtype == AIR_HELICOPTER) v->next->next->cur_image = GetRotorImage(v);
 		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+}
 static void HandleAircraftLoading(Vehicle *v, int mode)
+{
 	if (v->current_order.type == OT_NOTHING) return;
 	if (v->current_order.type != OT_DUMMY) {
 		if (v->current_order.type != OT_LOADING) return;
 		if (mode != 0) return;
 		if (--v->load_unload_time_rem != 0) return;
 	switch (v->current_order.type) {
 		case OT_LOADING:
 			if (mode != 0) return;
 			if (--v->load_unload_time_rem != 0) return;
 		if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
 				(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED)))) {
 			SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);
 			if (LoadUnloadVehicle(v, false)) {
 				InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);
 				MarkAircraftDirty(v);
 			if (CanFillVehicle(v) && (
 						v->current_order.flags & OF_FULL_LOAD ||
 						(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED))
 					)) {
 				SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);
 				if (LoadUnloadVehicle(v, false)) {
 					InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);
 					MarkAircraftDirty(v);
+				}
 				return;
+			}
 			return;
+		}
+		{
 			Order b = v->current_order;
 			v->current_order.type = OT_NOTHING;
 			v->current_order.flags = 0;
 			MarkAircraftDirty(v);
 			if (!(b.flags & OF_NON_STOP)) return;
+		}
 			break;
 		case OT_DUMMY: break;
 		default: return;
+	}
 	v->cur_order_index++;
 	InvalidateVehicleOrder(v);
+}
 static void CrashAirplane(Vehicle *v)
+{
 	uint16 amt;
 	Station *st;
 	StringID newsitem;
 	v->vehstatus |= VS_CRASHED;
 	v->u.air.crashed_counter = 0;
 	CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
 	InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 	amt = 2;
 	if (v->cargo_type == CT_PASSENGERS) amt += v->cargo_count;
 	SetDParam(0, amt);
 	v->cargo_count = 0;
 	v->next->cargo_count = 0,
 	st = GetStation(v->u.air.targetairport);
 	if (st->airport_tile == 0) {
 		newsitem = STR_PLANE_CRASH_OUT_OF_FUEL;
 	} else {
 		SetDParam(1, st->index);
 		newsitem = STR_A034_PLANE_CRASH_DIE_IN_FIREBALL;
+	}
 	SetDParam(1, st->index);
 	AddNewsItem(newsitem,
 		NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),
 		v->index,
 );
 	SndPlayVehicleFx(SND_12_EXPLOSION, v);
+}
 static void MaybeCrashAirplane(Vehicle *v)
+{
 	Station *st;
 	uint16 prob;
 	uint i;
 	st = GetStation(v->u.air.targetairport);
 	//FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports
 	prob = 0x10000 / 1500;
 	if (((st->airport_type == AT_SMALL) || (st->airport_type == AT_COMMUTER)) && (AircraftVehInfo(v->engine_type)->subtype & AIR_FAST) && !_cheats.no_jetcrash.value) {
 		prob = 0x10000 / 20;
+	}
 	if (GB(Random(), 0, 16) > prob) return;
 	// Crash the airplane. Remove all goods stored at the station.
 	for (i = 0; i != NUM_CARGO; i++) {
 		st->goods[i].rating = 1;
 		SB(st->goods[i].waiting_acceptance, 0, 12, 0);
+	}
 	CrashAirplane(v);
+}
 // we've landed and just arrived at a terminal
 static void AircraftEntersTerminal(Vehicle *v)
+{
 	Station *st;
 	Order old_order;
 	if (v->current_order.type == OT_GOTO_DEPOT) return;
 	st = GetStation(v->u.air.targetairport);
 	v->last_station_visited = v->u.air.targetairport;
 	/* Check if station was ever visited before */
 	if (!(st->had_vehicle_of_type & HVOT_AIRCRAFT)) {
 		uint32 flags;
 		st->had_vehicle_of_type |= HVOT_AIRCRAFT;
 		SetDParam(0, st->index);
 		// show newsitem of celebrating citizens
 		flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
 		AddNewsItem(
 			STR_A033_CITIZENS_CELEBRATE_FIRST,
 			flags,
 			v->index,
 );
+	}
 	old_order = v->current_order;
 	v->BeginLoading();
 	v->current_order.flags = 0;
 	if (old_order.type == OT_GOTO_STATION &&
 			v->current_order.dest == v->last_station_visited) {
 		v->current_order.flags =
 			(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER)) | OF_NON_STOP;
+	}
 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);
 	LoadUnloadVehicle(v, true);
 	MarkAircraftDirty(v);
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
+}
 static void AircraftLand(Vehicle *v)
+{
 	v->sprite_width = v->sprite_height = 2;
+}
 static void AircraftLandAirplane(Vehicle *v)
+{
 	AircraftLand(v);
 	if (!PlayVehicleSound(v, VSE_TOUCHDOWN)) {
 		SndPlayVehicleFx(SND_17_SKID_PLANE, v);
+	}
 	MaybeCrashAirplane(v);
+}
 // set the right pos when heading to other airports after takeoff
 static void AircraftNextAirportPos_and_Order(Vehicle *v)
+{
 	const Station* st;
 	const AirportFTAClass *apc;
 	if (v->current_order.type == OT_GOTO_STATION ||
 			v->current_order.type == OT_GOTO_DEPOT)
 		v->u.air.targetairport = v->current_order.dest;
 	st = GetStation(v->u.air.targetairport);
 	apc = GetAirport(st->airport_type);
 	v->u.air.pos = v->u.air.previous_pos = apc->entry_point;
+}
 static void AircraftLeaveHangar(Vehicle *v)
+{
 	v->cur_speed = 0;
 	v->subspeed = 0;
 	v->progress = 0;
 	v->direction = DIR_SE;
 	v->vehstatus &= ~VS_HIDDEN;
+	{
 		Vehicle *u = v->next;
 		u->vehstatus &= ~VS_HIDDEN;
 		// Rotor blades
 		u = u->next;
 		if (u != NULL) {
 			u->vehstatus &= ~VS_HIDDEN;
 			u->cur_speed = 80;
+		}
+	}
 	VehicleServiceInDepot(v);
 	SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
+}
 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////   AIRCRAFT MOVEMENT SCHEME  ////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 static void AircraftEventHandler_EnterTerminal(Vehicle *v, const AirportFTAClass *apc)
+{
 	AircraftEntersTerminal(v);
 	v->u.air.state = apc->layout[v->u.air.pos].heading;
+}
 static void AircraftEventHandler_EnterHangar(Vehicle *v, const AirportFTAClass *apc)
+{
 	VehicleEnterDepot(v);
 	v->u.air.state = apc->layout[v->u.air.pos].heading;
+}
 // In an Airport Hangar
 static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *apc)
+{
 	// if we just arrived, execute EnterHangar first
 	if (v->u.air.previous_pos != v->u.air.pos) {
 		AircraftEventHandler_EnterHangar(v, apc);
 		return;
+	}
 	// if we were sent to the depot, stay there
 	if (v->current_order.type == OT_GOTO_DEPOT && (v->vehstatus & VS_STOPPED)) {
 		v->current_order.type = OT_NOTHING;
 		v->current_order.flags = 0;
 		return;

src/ship_cmd.cpp

➞

Show inline comments

@@ @@ -84,406 +84,409 @@ static const Depot* FindClosestShipDepot @@
 	if (_patches.new_pathfinding_all) {
 		NPFFoundTargetData ftd;
 		Trackdir trackdir = GetVehicleTrackdir(v);
 		ftd = NPFRouteToDepotTrialError(v->tile, trackdir, TRANSPORT_WATER, v->owner, INVALID_RAILTYPE);
 		if (ftd.best_bird_dist == 0) {
 			best_depot = GetDepotByTile(ftd.node.tile); /* Found target */
 		} else {
 			best_depot = NULL; /* Did not find target */
+		}
 	} else {
 		FOR_ALL_DEPOTS(depot) {
 			tile = depot->xy;
 			if (IsTileDepotType(tile, TRANSPORT_WATER) && IsTileOwner(tile, v->owner)) {
 				dist = DistanceManhattan(tile, tile2);
 				if (dist < best_dist) {
 					best_dist = dist;
 					best_depot = depot;
+				}
+			}
+		}
+	}
 	return best_depot;
+}
 static void CheckIfShipNeedsService(Vehicle *v)
+{
 	const Depot* depot;
 	if (_patches.servint_ships == 0) return;
 	if (!VehicleNeedsService(v))     return;
 	if (v->vehstatus & VS_STOPPED)   return;
 	if (v->current_order.type == OT_GOTO_DEPOT &&
 			v->current_order.flags & OF_HALT_IN_DEPOT)
 		return;
 	if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;
 	if (IsShipInDepot(v)) {
 		VehicleServiceInDepot(v);
 		return;
+	}
 	depot = FindClosestShipDepot(v);
 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
 		if (v->current_order.type == OT_GOTO_DEPOT) {
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		}
 		return;
+	}
 	v->current_order.type = OT_GOTO_DEPOT;
 	v->current_order.flags = OF_NON_STOP;
 	v->current_order.dest = depot->index;
 	v->dest_tile = depot->xy;
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+}
 void OnNewDay_Ship(Vehicle *v)
+{
 	int32 cost;
 	if ((++v->day_counter & 7) == 0)
 		DecreaseVehicleValue(v);
 	CheckVehicleBreakdown(v);
 	AgeVehicle(v);
 	CheckIfShipNeedsService(v);
 	CheckOrders(v);
 	if (v->vehstatus & VS_STOPPED) return;
 	cost = ShipVehInfo(v->engine_type)->running_cost * _price.ship_running / 364;
 	v->profit_this_year -= cost >> 8;
 	SET_EXPENSES_TYPE(EXPENSES_SHIP_RUN);
 	SubtractMoneyFromPlayerFract(v->owner, cost);
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	//we need this for the profit
 	InvalidateWindowClasses(WC_SHIPS_LIST);
+}
 static void HandleBrokenShip(Vehicle *v)
+{
 	if (v->breakdown_ctr != 1) {
 		v->breakdown_ctr = 1;
 		v->cur_speed = 0;
 		if (v->breakdowns_since_last_service != 255)
 			v->breakdowns_since_last_service++;
 		InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 		if (!PlayVehicleSound(v, VSE_BREAKDOWN)) {
 			SndPlayVehicleFx((_opt.landscape != LT_CANDY) ?
 				SND_10_TRAIN_BREAKDOWN : SND_3A_COMEDY_BREAKDOWN_2, v);
+		}
 		if (!(v->vehstatus & VS_HIDDEN)) {
 			Vehicle *u = CreateEffectVehicleRel(v, 4, 4, 5, EV_BREAKDOWN_SMOKE);
 			if (u != NULL) u->u.special.unk0 = v->breakdown_delay * 2;
+		}
+	}
 	if (!(v->tick_counter & 1)) {
 		if (!--v->breakdown_delay) {
 			v->breakdown_ctr = 0;
 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
+		}
+	}
+}
 static void MarkShipDirty(Vehicle *v)
+{
 	v->cur_image = GetShipImage(v, v->direction);
 	MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+}
 static void PlayShipSound(Vehicle *v)
+{
 	if (!PlayVehicleSound(v, VSE_START)) {
 		SndPlayVehicleFx(ShipVehInfo(v->engine_type)->sfx, v);
+	}
+}
 static void ProcessShipOrder(Vehicle *v)
+{
 	const Order *order;
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
 			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
 					!VehicleNeedsService(v)) {
 				v->cur_order_index++;
+			}
 			break;
 		case OT_LOADING:
 		case OT_LEAVESTATION:
 			return;
 		default: break;
+	}
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	order = GetVehicleOrder(v, v->cur_order_index);
 	if (order == NULL) {
 		v->current_order.type  = OT_NOTHING;
 		v->current_order.flags = 0;
 		v->dest_tile = 0;
 		return;
+	}
 	if (order->type  == v->current_order.type &&
 			order->flags == v->current_order.flags &&
 			order->dest  == v->current_order.dest)
 		return;
 	v->current_order = *order;
 	if (order->type == OT_GOTO_STATION) {
 		const Station *st;
 		if (order->dest == v->last_station_visited)
 			v->last_station_visited = INVALID_STATION;
 		st = GetStation(order->dest);
 		if (st->dock_tile != 0) {
 			v->dest_tile = TILE_ADD(st->dock_tile, ToTileIndexDiff(GetDockOffset(st->dock_tile)));
+		}
 	} else if (order->type == OT_GOTO_DEPOT) {
 		v->dest_tile = GetDepot(order->dest)->xy;
 	} else {
 		v->dest_tile = 0;
+	}
 	InvalidateVehicleOrder(v);
 	InvalidateWindowClasses(WC_SHIPS_LIST);
+}
 static void HandleShipLoading(Vehicle *v)
+{
 	if (v->current_order.type == OT_NOTHING) return;
 	if (v->current_order.type != OT_DUMMY) {
 		if (v->current_order.type != OT_LOADING) return;
 		if (--v->load_unload_time_rem) return;
 	switch (v->current_order.type) {
 		case OT_LOADING:
 			if (--v->load_unload_time_rem) return;
 		if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
 				(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED)))) {
 			SET_EXPENSES_TYPE(EXPENSES_SHIP_INC);
 			if (LoadUnloadVehicle(v, false)) {
 				InvalidateWindow(WC_SHIPS_LIST, v->owner);
 				MarkShipDirty(v);
 			if (CanFillVehicle(v) && (
 						v->current_order.flags & OF_FULL_LOAD ||
 						(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED))
 					)) {
 				SET_EXPENSES_TYPE(EXPENSES_SHIP_INC);
 				if (LoadUnloadVehicle(v, false)) {
 					InvalidateWindow(WC_SHIPS_LIST, v->owner);
 					MarkShipDirty(v);
+				}
 				return;
+			}
 			return;
+		}
 		PlayShipSound(v);
 			PlayShipSound(v);
+		{
 			Order b = v->current_order;
 			v->LeaveStation();
 			if (!(b.flags & OF_NON_STOP)) return;
+		}
 			break;
 		case OT_DUMMY: break;
 		default: return;
+	}
 	v->cur_order_index++;
 	InvalidateVehicleOrder(v);
+}
 static void UpdateShipDeltaXY(Vehicle *v, int dir)
+{
 #define MKIT(d,c,b,a) ((a&0xFF)<<24) | ((b&0xFF)<<16) | ((c&0xFF)<<8) | ((d&0xFF)<<0)
 	static const uint32 _delta_xy_table[8] = {
 		MKIT( -3,  -3,  6,  6),
 		MKIT(-16,  -3, 32,  6),
 		MKIT( -3,  -3,  6,  6),
 		MKIT( -3, -16,  6, 32),
 		MKIT( -3,  -3,  6,  6),
 		MKIT(-16,  -3, 32,  6),
 		MKIT( -3,  -3,  6,  6),
 		MKIT( -3, -16,  6, 32),
 	};
 #undef MKIT
 	uint32 x = _delta_xy_table[dir];
 	v->x_offs        = GB(x,  0, 8);
 	v->y_offs        = GB(x,  8, 8);
 	v->sprite_width  = GB(x, 16, 8);
 	v->sprite_height = GB(x, 24, 8);
+}
 void RecalcShipStuff(Vehicle *v)
+{
 	UpdateShipDeltaXY(v, v->direction);
 	v->cur_image = GetShipImage(v, v->direction);
 	MarkShipDirty(v);
 	InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+}
 static const TileIndexDiffC _ship_leave_depot_offs[] = {
 	{-1,  0},
 	{ 0, -1}
 };
 static void CheckShipLeaveDepot(Vehicle *v)
+{
 	TileIndex tile;
 	Axis axis;
 	uint m;
 	if (!IsShipInDepot(v)) return;
 	tile = v->tile;
 	axis = GetShipDepotAxis(tile);
 	// Check first side
 	if (_ship_sometracks[axis] & GetTileShipTrackStatus(TILE_ADD(tile, ToTileIndexDiff(_ship_leave_depot_offs[axis])))) {
 		m = (axis == AXIS_X) ? 0x101 : 0x207;
 	// Check second side
 	} else if (_ship_sometracks[axis + 2] & GetTileShipTrackStatus(TILE_ADD(tile, -2 * ToTileIndexDiff(_ship_leave_depot_offs[axis])))) {
 		m = (axis == AXIS_X) ? 0x105 : 0x203;
 	} else {
 		return;
+	}
 	v->direction    = (Direction)GB(m, 0, 8);
 	v->u.ship.state = (TrackBits)GB(m, 8, 8);
 	v->vehstatus &= ~VS_HIDDEN;
 	v->cur_speed = 0;
 	RecalcShipStuff(v);
 	PlayShipSound(v);
 	VehicleServiceInDepot(v);
 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	InvalidateWindowClasses(WC_SHIPS_LIST);
+}
 static bool ShipAccelerate(Vehicle *v)
+{
 	uint spd;
 	byte t;
 	spd = min(v->cur_speed + 1, v->max_speed);
 	//updates statusbar only if speed have changed to save CPU time
 	if (spd != v->cur_speed) {
 		v->cur_speed = spd;
 		if (_patches.vehicle_speed)
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+	}
 	// Decrease somewhat when turning
 	if (!(v->direction & 1)) spd = spd * 3 / 4;
 	if (spd == 0) return false;
 	if ((byte)++spd == 0) return true;
 	v->progress = (t = v->progress) - (byte)spd;
 	return (t < v->progress);
+}
 static int32 EstimateShipCost(EngineID engine_type)
+{
 	return ShipVehInfo(engine_type)->base_cost * (_price.ship_base>>3)>>5;
+}
 static void ShipArrivesAt(const Vehicle* v, Station* st)
+{
 	/* Check if station was ever visited before */
 	if (!(st->had_vehicle_of_type & HVOT_SHIP)) {
 		uint32 flags;
 		st->had_vehicle_of_type |= HVOT_SHIP;
 		SetDParam(0, st->index);
 		flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
 		AddNewsItem(
 			STR_9833_CITIZENS_CELEBRATE_FIRST,
 			flags,
 			v->index,
 );
+	}
+}
 typedef struct {
 	TileIndex skiptile;
 	TileIndex dest_coords;
 	uint best_bird_dist;
 	uint best_length;
 } PathFindShip;
 static bool ShipTrackFollower(TileIndex tile, PathFindShip *pfs, int track, uint length, byte *state)
+{
 	// Found dest?
 	if (tile == pfs->dest_coords) {
 		pfs->best_bird_dist = 0;
 		pfs->best_length = minu(pfs->best_length, length);
 		return true;
+	}
 	// Skip this tile in the calculation
 	if (tile != pfs->skiptile) {
 		pfs->best_bird_dist = minu(pfs->best_bird_dist, DistanceMaxPlusManhattan(pfs->dest_coords, tile));
+	}
 	return false;
+}
 static const byte _ship_search_directions[6][4] = {
 	{ 0, 9, 2, 9 },
 	{ 9, 1, 9, 3 },
 	{ 9, 0, 3, 9 },
 	{ 1, 9, 9, 2 },
 	{ 3, 2, 9, 9 },
 	{ 9, 9, 1, 0 },
 };
 static const byte _pick_shiptrack_table[6] = {1, 3, 2, 2, 0, 0};
 static uint FindShipTrack(Vehicle *v, TileIndex tile, DiagDirection dir, TrackBits bits, TileIndex skiptile, Track *track)
+{
 	PathFindShip pfs;
 	Track i, best_track;
 	uint best_bird_dist = 0;
 	uint best_length    = 0;
 	uint r;
 	byte ship_dir = v->direction & 3;
 	pfs.dest_coords = v->dest_tile;
 	pfs.skiptile = skiptile;
 	best_track = INVALID_TRACK;
 	do {
 		i = RemoveFirstTrack(&bits);
 		pfs.best_bird_dist = (uint)-1;
 		pfs.best_length = (uint)-1;
 		FollowTrack(tile, 0x3800 | TRANSPORT_WATER, (DiagDirection)_ship_search_directions[i][dir], (TPFEnumProc*)ShipTrackFollower, NULL, &pfs);
 		if (best_track != INVALID_TRACK) {
 			if (pfs.best_bird_dist != 0) {
 				/* neither reached the destination, pick the one with the smallest bird dist */
 				if (pfs.best_bird_dist > best_bird_dist) goto bad;
 				if (pfs.best_bird_dist < best_bird_dist) goto good;
 			} else {
 				if (pfs.best_length > best_length) goto bad;
 				if (pfs.best_length < best_length) goto good;
+			}
 			/* if we reach this position, there's two paths of equal value so far.
 			 * pick one randomly. */
 			r = GB(Random(), 0, 8);

src/train_cmd.cpp

➞

Show inline comments

@@ @@ -2416,420 +2416,424 @@ static Track ChooseTrainTrack(Vehicle* v @@
 static bool CheckReverseTrain(Vehicle *v)
+{
 	TrainTrackFollowerData fd;
 	int i, r;
 	int best_track;
 	uint best_bird_dist  = 0;
 	uint best_track_dist = 0;
 	uint reverse, reverse_best;
 	if (_opt.diff.line_reverse_mode != 0 ||
 			v->u.rail.track & 0xC0 ||
 			!(v->direction & 1))
 		return false;
 	FillWithStationData(&fd, v);
 	best_track = -1;
 	reverse_best = reverse = 0;
 	assert(v->u.rail.track);
 	i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];
 	if (_patches.yapf.rail_use_yapf) {
 		reverse_best = YapfCheckReverseTrain(v);
 	} else if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */
 		NPFFindStationOrTileData fstd;
 		NPFFoundTargetData ftd;
 		Trackdir trackdir, trackdir_rev;
 		Vehicle* last = GetLastVehicleInChain(v);
 		NPFFillWithOrderData(&fstd, v);
 		trackdir = GetVehicleTrackdir(v);
 		trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
 		assert(trackdir != 0xff);
 		assert(trackdir_rev != 0xff);
 		ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
 		if (ftd.best_bird_dist != 0) {
 			/* We didn't find anything, just keep on going straight ahead */
 			reverse_best = false;
 		} else {
 			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) {
 				reverse_best = true;
 			} else {
 				reverse_best = false;
+			}
+		}
 	} else {
 		for (;;) {
 			fd.best_bird_dist = (uint)-1;
 			fd.best_track_dist = (uint)-1;
 			NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, (DiagDirection)(reverse ^ i), (NTPEnumProc*)NtpCallbFindStation, &fd);
 			if (best_track != -1) {
 				if (best_bird_dist != 0) {
 					if (fd.best_bird_dist != 0) {
 						/* neither reached the destination, pick the one with the smallest bird dist */
 						if (fd.best_bird_dist > best_bird_dist) goto bad;
 						if (fd.best_bird_dist < best_bird_dist) goto good;
 					} else {
 						/* we found the destination for the first time */
 						goto good;
+					}
 				} else {
 					if (fd.best_bird_dist != 0) {
 						/* didn't find destination, but we've found the destination previously */
 						goto bad;
 					} else {
 						/* both old & new reached the destination, compare track length */
 						if (fd.best_track_dist > best_track_dist) goto bad;
 						if (fd.best_track_dist < best_track_dist) goto good;
+					}
+				}
 				/* if we reach this position, there's two paths of equal value so far.
 				 * pick one randomly. */
 				r = GB(Random(), 0, 8);
 				if (_pick_track_table[i] == (v->direction & 3)) r += 80;
 				if (_pick_track_table[best_track] == (v->direction & 3)) r -= 80;
 				if (r <= 127) goto bad;
+			}
 good:;
 			best_track = i;
 			best_bird_dist = fd.best_bird_dist;
 			best_track_dist = fd.best_track_dist;
 			reverse_best = reverse;
 bad:;
 			if (reverse != 0) break;
 			reverse = 2;
+		}
+	}
 	return reverse_best != 0;
+}
 static bool ProcessTrainOrder(Vehicle *v)
+{
 	const Order *order;
 	bool at_waypoint = false;
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return false;
 			if ((v->current_order.flags & OF_SERVICE_IF_NEEDED) &&
 					!VehicleNeedsService(v)) {
 				v->cur_order_index++;
+			}
 			break;
 		case OT_LOADING:
 		case OT_LEAVESTATION:
 			return false;
 		default: break;
+	}
 	// check if we've reached the waypoint?
 	if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
 		v->cur_order_index++;
 		at_waypoint = true;
+	}
 	// check if we've reached a non-stop station while TTDPatch nonstop is enabled..
 	if (_patches.new_nonstop &&
 			v->current_order.flags & OF_NON_STOP &&
 			IsTileType(v->tile, MP_STATION) &&
 			v->current_order.dest == GetStationIndex(v->tile)) {
 		v->cur_order_index++;
+	}
 	// Get the current order
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	order = GetVehicleOrder(v, v->cur_order_index);
 	// If no order, do nothing.
 	if (order == NULL) {
 		v->current_order.type = OT_NOTHING;
 		v->current_order.flags = 0;
 		v->dest_tile = 0;
 		return false;
+	}
 	// If it is unchanged, keep it.
 	if (order->type  == v->current_order.type &&
 			order->flags == v->current_order.flags &&
 			order->dest  == v->current_order.dest)
 		return false;
 	// Otherwise set it, and determine the destination tile.
 	v->current_order = *order;
 	v->dest_tile = 0;
 	InvalidateVehicleOrder(v);
 	switch (order->type) {
 		case OT_GOTO_STATION:
 			if (order->dest == v->last_station_visited)
 				v->last_station_visited = INVALID_STATION;
 			v->dest_tile = GetStation(order->dest)->xy;
 			break;
 		case OT_GOTO_DEPOT:
 			v->dest_tile = GetDepot(order->dest)->xy;
 			break;
 		case OT_GOTO_WAYPOINT:
 			v->dest_tile = GetWaypoint(order->dest)->xy;
 			break;
 		default:
 			return false;
+	}
 	return !at_waypoint && CheckReverseTrain(v);
+}
 static void MarkTrainDirty(Vehicle *v)
+{
 	do {
 		v->cur_image = GetTrainImage(v, v->direction);
 		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
 	} while ((v = v->next) != NULL);
+}
 static void HandleTrainLoading(Vehicle *v, bool mode)
+{
 	if (v->current_order.type == OT_NOTHING) return;
 	if (v->current_order.type != OT_DUMMY) {
 		if (v->current_order.type != OT_LOADING) return;
 		if (mode) return;
 		// don't mark the train as lost if we're loading on the final station.
 		if (v->current_order.flags & OF_NON_STOP)
 			v->u.rail.days_since_order_progr = 0;
 		if (--v->load_unload_time_rem) return;
 		if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
 				(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED)))) {
 			v->u.rail.days_since_order_progr = 0; /* Prevent a train lost message for full loading trains */
 			SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
 			if (LoadUnloadVehicle(v, false)) {
 				InvalidateWindow(WC_TRAINS_LIST, v->owner);
 				MarkTrainDirty(v);
 				// need to update acceleration and cached values since the goods on the train changed.
 				TrainCargoChanged(v);
 				UpdateTrainAcceleration(v);
 	switch (v->current_order.type) {
 		case OT_LOADING:
 			if (mode) return;
 			// don't mark the train as lost if we're loading on the final station.
 			if (v->current_order.flags & OF_NON_STOP) {
 				v->u.rail.days_since_order_progr = 0;
+			}
 			return;
+		}
 		TrainPlayLeaveStationSound(v);
+		{
 			if (--v->load_unload_time_rem) return;
 			if (CanFillVehicle(v) && (
 						v->current_order.flags & OF_FULL_LOAD ||
 						(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED))
 					)) {
 				v->u.rail.days_since_order_progr = 0; /* Prevent a train lost message for full loading trains */
 				SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
 				if (LoadUnloadVehicle(v, false)) {
 					InvalidateWindow(WC_TRAINS_LIST, v->owner);
 					MarkTrainDirty(v);
 					// need to update acceleration and cached values since the goods on the train changed.
 					TrainCargoChanged(v);
 					UpdateTrainAcceleration(v);
+				}
 				return;
+			}
 			TrainPlayLeaveStationSound(v);
 			Order b = v->current_order;
 			v->LeaveStation();
 			// If this was not the final order, don't remove it from the list.
 			if (!(b.flags & OF_NON_STOP)) return;
+		}
 			break;
 		case OT_DUMMY: break;
 		default: return;
+	}
 	v->u.rail.days_since_order_progr = 0;
 	v->cur_order_index++;
 	InvalidateVehicleOrder(v);
+}
 static int UpdateTrainSpeed(Vehicle *v)
+{
 	uint spd;
 	uint accel;
 	if (v->vehstatus & VS_STOPPED || HASBIT(v->u.rail.flags, VRF_REVERSING)) {
 		if (_patches.realistic_acceleration) {
 			accel = GetTrainAcceleration(v, AM_BRAKE) * 2;
 		} else {
 			accel = v->acceleration * -2;
+		}
 	} else {
 		if (_patches.realistic_acceleration) {
 			accel = GetTrainAcceleration(v, AM_ACCEL);
 		} else {
 			accel = v->acceleration;
+		}
+	}
 	spd = v->subspeed + accel * 2;
 	v->subspeed = (byte)spd;
+	{
 		int tempmax = v->max_speed;
 		if (v->cur_speed > v->max_speed)
 			tempmax = v->cur_speed - (v->cur_speed / 10) - 1;
 		v->cur_speed = spd = clamp(v->cur_speed + ((int)spd >> 8), 0, tempmax);
+	}
 	if (!(v->direction & 1)) spd = spd * 3 >> 2;
 	spd += v->progress;
 	v->progress = (byte)spd;
 	return (spd >> 8);
+}
 static void TrainEnterStation(Vehicle *v, StationID station)
+{
 	Station *st;
 	uint32 flags;
 	v->last_station_visited = station;
 	/* check if a train ever visited this station before */
 	st = GetStation(station);
 	if (!(st->had_vehicle_of_type & HVOT_TRAIN)) {
 		st->had_vehicle_of_type |= HVOT_TRAIN;
 		SetDParam(0, st->index);
 		flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
 		AddNewsItem(
 			STR_8801_CITIZENS_CELEBRATE_FIRST,
 			flags,
 			v->index,
 		);
+	}
 	// Did we reach the final destination?
 	if (v->current_order.type == OT_GOTO_STATION &&
 			v->current_order.dest == station) {
 		// Yeah, keep the load/unload flags
 		// Non Stop now means if the order should be increased.
 		v->BeginLoading();
 		v->current_order.flags &= OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER;
 		v->current_order.flags |= OF_NON_STOP;
 	} else {
 		// No, just do a simple load
 		v->BeginLoading();
 		v->current_order.flags = 0;
+	}
 	v->current_order.dest = 0;
 	SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
 	if (LoadUnloadVehicle(v, true) != 0) {
 		InvalidateWindow(WC_TRAINS_LIST, v->owner);
 		TrainCargoChanged(v);
 		UpdateTrainAcceleration(v);
+	}
 	MarkTrainDirty(v);
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+}
 static byte AfterSetTrainPos(Vehicle *v, bool new_tile)
+{
 	byte new_z, old_z;
 	// need this hint so it returns the right z coordinate on bridges.
 	new_z = GetSlopeZ(v->x_pos, v->y_pos);
 	old_z = v->z_pos;
 	v->z_pos = new_z;
 	if (new_tile) {
 		CLRBIT(v->u.rail.flags, VRF_GOINGUP);
 		CLRBIT(v->u.rail.flags, VRF_GOINGDOWN);
 		if (new_z != old_z) {
 			TileIndex tile = TileVirtXY(v->x_pos, v->y_pos);
 			// XXX workaround, whole UP/DOWN detection needs overhaul
 			if (!IsTunnelTile(tile)) {
 				SETBIT(v->u.rail.flags, (new_z > old_z) ? VRF_GOINGUP : VRF_GOINGDOWN);
+			}
+		}
+	}
 	VehiclePositionChanged(v);
 	EndVehicleMove(v);
 	return old_z;
+}
 static const Direction _new_vehicle_direction_table[11] = {
 	DIR_N , DIR_NW, DIR_W , INVALID_DIR,
 	DIR_NE, DIR_N , DIR_SW, INVALID_DIR,
 	DIR_E , DIR_SE, DIR_S
 };
 static Direction GetNewVehicleDirectionByTile(TileIndex new_tile, TileIndex old_tile)
+{
 	uint offs = (TileY(new_tile) - TileY(old_tile) + 1) * 4 +
 							TileX(new_tile) - TileX(old_tile) + 1;
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
+}
 static Direction GetNewVehicleDirection(const Vehicle *v, int x, int y)
+{
 	uint offs = (y - v->y_pos + 1) * 4 + (x - v->x_pos + 1);
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
+}
 static int GetDirectionToVehicle(const Vehicle *v, int x, int y)
+{
 	byte offs;
 	x -= v->x_pos;
 	if (x >= 0) {
 		offs = (x > 2) ? 0 : 1;
 	} else {
 		offs = (x < -2) ? 2 : 1;
+	}
 	y -= v->y_pos;
 	if (y >= 0) {
 		offs += ((y > 2) ? 0 : 1) * 4;
 	} else {
 		offs += ((y < -2) ? 2 : 1) * 4;
+	}
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
+}
 /* Check if the vehicle is compatible with the specified tile */
 static bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
+{
 	return
 		IsTileOwner(tile, v->owner) && (
 			!IsFrontEngine(v) ||
 			HASBIT(
 				v->u.rail.compatible_railtypes,
 				IsTileType(tile, MP_STREET) ? GetRailTypeCrossing(tile) : GetRailType(tile)
+			)
 		);
+}
 typedef struct {
 	byte small_turn, large_turn;
 	byte z_up; // fraction to remove when moving up
 	byte z_down; // fraction to remove when moving down
 } RailtypeSlowdownParams;
 static const RailtypeSlowdownParams _railtype_slowdown[] = {
 	// normal accel
 	{256 / 4, 256 / 2, 256 / 4, 2}, // normal
 	{256 / 4, 256 / 2, 256 / 4, 2}, // electrified
 	{256 / 4, 256 / 2, 256 / 4, 2}, // monorail
 	{0,       256 / 2, 256 / 4, 2}, // maglev
 };
 /* Modify the speed of the vehicle due to a turn */
 static void AffectSpeedByDirChange(Vehicle* v, Direction new_dir)
+{
 	DirDiff diff;
 	const RailtypeSlowdownParams *rsp;

0 comments (0 inline, 0 general)