Changeset - r5868:bc3e720ec5f7
[Not reviewed]
master
0 12 0
belugas - 17 years ago 2007-01-30 11:53:35
belugas@openttd.org
(svn r8455) -Codechange: Give a more meaningful name (railveh_type)to member flags of RailVehInfo, as well as changing the code to reflect the fact that it was not a flag but rather a one value only variable. Doing so, some evaluations have been simplified.
-Codechange: Add and use RAILVEH_SINGLEHEAD when railveh_type is set to 0, which was implicit before.
-Cleanup: Remove some extraneous parenthesis.
12 files changed with 89 insertions and 86 deletions:
0 comments (0 inline, 0 general)
src/ai/default/default.cpp
Show inline comments
 
@@ -140,14 +140,14 @@ static EngineID AiChooseTrainToBuild(Rai
 

	
 
	for (i = 0; i < NUM_TRAIN_ENGINES; i++) {
 
		const RailVehicleInfo *rvi = RailVehInfo(i);
 
		const Engine* e = GetEngine(i);
 

	
 
		if (!IsCompatibleRail(rvi->railtype, railtype) ||
 
				rvi->flags & RVI_WAGON ||
 
				(rvi->flags & RVI_MULTIHEAD && flag & 1) ||
 
				rvi->railveh_type == RAILVEH_WAGON ||
 
				(rvi->railveh_type == RAILVEH_MULTIHEAD && flag & 1) ||
 
				!HASBIT(e->player_avail, _current_player) ||
 
				e->reliability < 0x8A3D) {
 
			continue;
 
		}
 

	
 
		ret = DoCommand(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);
 
@@ -2363,13 +2363,13 @@ static EngineID AiFindBestWagon(CargoID 
 

	
 
	for (i = 0; i < NUM_TRAIN_ENGINES; i++) {
 
		const RailVehicleInfo *rvi = RailVehInfo(i);
 
		const Engine* e = GetEngine(i);
 

	
 
		if (!IsCompatibleRail(rvi->railtype, railtype) ||
 
				!(rvi->flags & RVI_WAGON) ||
 
				rvi->railveh_type != RAILVEH_WAGON ||
 
				!HASBIT(e->player_avail, _current_player)) {
 
			continue;
 
		}
 

	
 
		if (rvi->cargo_type != cargo) continue;
 

	
src/autoreplace_gui.cpp
Show inline comments
 
@@ -60,13 +60,13 @@ static void train_engine_drawing_loop(in
 

	
 

	
 
		colour = *sel == 0 ? 0xC : 0x10;
 
		if (!(ENGINE_AVAILABLE && show_outdated && RailVehInfo(i)->power && IsCompatibleRail(rvi->railtype, railtype))) {
 
			if ((!IsCompatibleRail(rvi->railtype, railtype) && show_compatible)
 
				|| (rvi->railtype != railtype && !show_compatible)
 
				|| !(rvi->flags & RVI_WAGON) != is_engine ||
 
				|| (rvi->railveh_type != RAILVEH_WAGON) != is_engine ||
 
				!HASBIT(e->player_avail, _local_player))
 
				continue;
 
#if 0
 
		} else {
 
			// TODO find a nice red colour for vehicles being replaced
 
			if ( _autoreplace_array[i] != i )
src/build_vehicle_gui.cpp
Show inline comments
 
@@ -184,26 +184,26 @@ static int CDECL TrainEngineSpeedSorter(
 

	
 
static int CDECL TrainEnginePowerSorter(const void *a, const void *b)
 
{
 
	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);
 
	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);
 

	
 
	int va = rvi_a->power << (rvi_a->flags & RVI_MULTIHEAD ? 1 : 0);
 
	int vb = rvi_b->power << (rvi_b->flags & RVI_MULTIHEAD ? 1 : 0);
 
	int va = rvi_a->power << (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 
	int vb = rvi_b->power << (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 
	int r = va - vb;
 

	
 
	return _internal_sort_order ? -r : r;
 
}
 

	
 
static int CDECL TrainEngineRunningCostSorter(const void *a, const void *b)
 
{
 
	const RailVehicleInfo *rvi_a = RailVehInfo(*(const EngineID*)a);
 
	const RailVehicleInfo *rvi_b = RailVehInfo(*(const EngineID*)b);
 

	
 
	int va = rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class] * (rvi_a->flags & RVI_MULTIHEAD ? 2 : 1);
 
	int vb = rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class] * (rvi_b->flags & RVI_MULTIHEAD ? 2 : 1);
 
	int va = rvi_a->running_cost_base * _price.running_rail[rvi_a->running_cost_class] * (rvi_a->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
 
	int vb = rvi_b->running_cost_base * _price.running_rail[rvi_b->running_cost_class] * (rvi_b->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1);
 
	int r = va - vb;
 

	
 
	return _internal_sort_order ? -r : r;
 
}
 

	
 
static int CDECL TrainEnginePowerVsRunningCostSorter(const void *a, const void *b)
 
@@ -225,14 +225,14 @@ static int CDECL TrainEnginePowerVsRunni
 
}
 

	
 
static int CDECL TrainEnginesThenWagonsSorter(const void *a, const void *b)
 
{
 
	EngineID va = *(const EngineID*)a;
 
	EngineID vb = *(const EngineID*)b;
 
	int val_a = ((RailVehInfo(va)->flags & RVI_WAGON) != 0) ? 1 : 0;
 
	int val_b = ((RailVehInfo(vb)->flags & RVI_WAGON) != 0) ? 1 : 0;
 
	int val_a = (RailVehInfo(va)->railveh_type != RAILVEH_WAGON ? 1 : 0);
 
	int val_b = (RailVehInfo(vb)->railveh_type != RAILVEH_WAGON ? 1 : 0);
 
	int r = val_a - val_b;
 

	
 
	/* Use EngineID to sort instead since we want consistent sorting */
 
	if (r == 0) return EngineNumberSorter(a, b);
 

	
 
	return _internal_sort_order ? -r : r;
 
@@ -385,13 +385,13 @@ static int DrawRailWagonPurchaseInfo(int
 
	return y;
 
}
 

	
 
/* Draw locomotive specific details */
 
static int DrawRailEnginePurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi)
 
{
 
	int multihead = (rvi->flags&RVI_MULTIHEAD?1:0);
 
	int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 

	
 
	/* Purchase Cost - Engine weight */
 
	SetDParam(0, rvi->base_cost * (_price.build_railvehicle >> 3) >> 5);
 
	SetDParam(1, rvi->weight << multihead);
 
	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);
 
	y += 10;
 
@@ -526,24 +526,24 @@ void DrawVehiclePurchaseInfo(int x, int 
 
	switch (e->type) {
 
		case VEH_Train: {
 
			const RailVehicleInfo *rvi = RailVehInfo(engine_number);
 

	
 
			refitable = (EngInfo(engine_number)->refit_mask != 0) && (rvi->capacity > 0);
 

	
 
			if (rvi->flags & RVI_WAGON) {
 
			if (rvi->railveh_type == RAILVEH_WAGON) {
 
				y = DrawRailWagonPurchaseInfo(x, y, engine_number, rvi);
 
			} else {
 
				y = DrawRailEnginePurchaseInfo(x, y, engine_number, rvi);
 
			}
 

	
 
			/* Cargo type + capacity, or N/A */
 
			if (rvi->capacity == 0) {
 
				SetDParam(0, CT_INVALID);
 
				SetDParam(2, STR_EMPTY);
 
			} else {
 
				int multihead = (rvi->flags & RVI_MULTIHEAD ? 1 : 0);
 
				int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 

	
 
				SetDParam(0, rvi->cargo_type);
 
				SetDParam(1, (rvi->capacity * (CountArticulatedParts(engine_number) + 1)) << multihead);
 
				SetDParam(2, refitable ? STR_9842_REFITTABLE : STR_EMPTY);
 
			}
 
			DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);
 
@@ -563,13 +563,13 @@ void DrawVehiclePurchaseInfo(int x, int 
 
			y = DrawAircraftPurchaseInfo(x, y, engine_number, AircraftVehInfo(engine_number));
 
			refitable = true;
 
			break;
 
	}
 

	
 
	/* Draw details, that applies to all types except rail wagons */
 
	if (e->type != VEH_Train || !(RailVehInfo(engine_number)->flags & RVI_WAGON)) {
 
	if (e->type != VEH_Train || RailVehInfo(engine_number)->railveh_type != RAILVEH_WAGON) {
 
		/* Design date - Life length */
 
		SetDParam(0, ymd.year);
 
		SetDParam(1, e->lifelength);
 
		DrawString(x, y, STR_PURCHASE_INFO_DESIGNED_LIFE, 0);
 
		y += 10;
 

	
 
@@ -604,13 +604,13 @@ static void GenerateBuildTrainList(Windo
 
		const RailVehicleInfo *rvi = RailVehInfo(eid);
 

	
 
		if (bv->filter.railtype != RAILTYPE_END && !HasPowerOnRail(rvi->railtype, bv->filter.railtype)) continue;
 
		if (!IsEngineBuildable(eid, VEH_Train, _local_player)) continue;
 

	
 
		EngList_Add(&bv->eng_list, eid);
 
		if ((rvi->flags & RVI_WAGON) == 0) {
 
		if (rvi->railveh_type != RAILVEH_WAGON) {
 
			num_engines++;
 
		} else {
 
			num_wagons++;
 
		}
 

	
 
		if (eid == bv->sel_engine) sel_id = eid;
 
@@ -823,13 +823,13 @@ static void BuildVehicleClickEvent(Windo
 

	
 
		case BUILD_VEHICLE_WIDGET_BUILD: {
 
			EngineID sel_eng = bv->sel_engine;
 
			if (sel_eng != INVALID_ENGINE) {
 
				switch (bv->vehicle_type) {
 
					case VEH_Train:
 
						DoCommandP(w->window_number, sel_eng, 0, (RailVehInfo(sel_eng)->flags & RVI_WAGON) ? CcBuildWagon : CcBuildLoco,
 
						DoCommandP(w->window_number, sel_eng, 0, (RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) ? CcBuildWagon : CcBuildLoco,
 
								   CMD_BUILD_RAIL_VEHICLE | CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE));
 
						break;
 
					case VEH_Road:
 
						DoCommandP(w->window_number, sel_eng, 0, CcBuildRoadVeh, CMD_BUILD_ROAD_VEH | CMD_MSG(STR_9009_CAN_T_BUILD_ROAD_VEHICLE));
 
						break;
 
					case VEH_Ship:
src/engine.cpp
Show inline comments
 
@@ -282,13 +282,13 @@ int32 CmdWantEnginePreview(TileIndex til
 
	return 0;
 
}
 

	
 
// Determine if an engine type is a wagon (and not a loco)
 
static bool IsWagon(EngineID index)
 
{
 
	return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->flags & RVI_WAGON;
 
	return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->railveh_type == RAILVEH_WAGON;
 
}
 

	
 
static void NewVehicleAvailable(Engine *e)
 
{
 
	Vehicle *v;
 
	Player *p;
src/engine.h
Show inline comments
 
@@ -6,15 +6,21 @@
 
/** @file engine.h */
 

	
 
#include "oldpool.h"
 
#include "rail.h"
 
#include "sound.h"
 

	
 
enum RailVehicleTypes {
 
	RAILVEH_SINGLEHEAD,
 
	RAILVEH_MULTIHEAD,
 
	RAILVEH_WAGON,
 
};
 

	
 
typedef struct RailVehicleInfo {
 
	byte image_index;
 
	byte flags; /* 1=multihead engine, 2=wagon */
 
	RailVehicleTypes railveh_type;
 
	byte base_cost;
 
	RailTypeByte railtype;
 
	uint16 max_speed;
 
	uint16 power;
 
	uint16 weight;
 
	byte running_cost_base;
 
@@ -115,17 +121,12 @@ enum {
 
	EF_ROAD_TRAM  = 0, ///< Road vehicle is a tram/light rail vehicle (unsup)
 
	EF_USES_2CC   = 1, ///< Vehicle uses two company colours
 
	EF_RAIL_IS_MU = 2, ///< Rail vehicle is a multiple-unit (DMU/EMU)
 
};
 

	
 
enum {
 
	RVI_MULTIHEAD = 1,
 
	RVI_WAGON = 2,
 
};
 

	
 
enum {
 
	NUM_VEHICLE_TYPES = 6
 
};
 

	
 
static const EngineID INVALID_ENGINE = 0xFFFF;
 

	
 

	
src/engine_gui.cpp
Show inline comments
 
@@ -119,13 +119,13 @@ void ShowEnginePreviewWindow(EngineID en
 
	AllocateWindowDescFront(&_engine_preview_desc, engine);
 
}
 

	
 
static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw)
 
{
 
	const RailVehicleInfo *rvi = RailVehInfo(engine);
 
	uint multihead = (rvi->flags & RVI_MULTIHEAD) ? 1 : 0;
 
	uint multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD) ? 1 : 0;
 

	
 
	SetDParam(0, (_price.build_railvehicle >> 3) * rvi->base_cost >> 5);
 
	SetDParam(2, rvi->max_speed);
 
	SetDParam(3, rvi->power << multihead);
 
	SetDParam(1, rvi->weight << multihead);
 

	
src/newgrf.cpp
Show inline comments
 
@@ -212,16 +212,16 @@ static void dewagonize(int condition, in
 
{
 
	EngineInfo *ei = &_engine_info[engine];
 
	RailVehicleInfo *rvi = &_rail_vehicle_info[engine];
 

	
 
	if (condition != 0) {
 
		ei->unk2 &= ~0x80;
 
		rvi->flags &= ~2;
 
		rvi->railveh_type = RAILVEH_SINGLEHEAD;
 
	} else {
 
		ei->unk2 |= 0x80;
 
		rvi->flags |= 2;
 
		rvi->railveh_type = RAILVEH_WAGON;
 
	}
 
}
 

	
 
static bool RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
 
{
 
	EngineInfo *ei = &_engine_info[engine];
 
@@ -262,24 +262,24 @@ static bool RailVehicleChangeInfo(uint e
 
			break;
 

	
 
		case 0x0B: /* Power */
 
			FOR_EACH_OBJECT {
 
				uint16 power = grf_load_word(&buf);
 

	
 
				if (rvi[i].flags & RVI_MULTIHEAD) power /= 2;
 
				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) power /= 2;
 

	
 
				rvi[i].power = power;
 
				dewagonize(power, engine + i);
 
			}
 
			break;
 

	
 
		case 0x0D: /* Running cost factor */
 
			FOR_EACH_OBJECT {
 
				uint8 runcostfact = grf_load_byte(&buf);
 

	
 
				if (rvi[i].flags & RVI_MULTIHEAD) runcostfact /= 2;
 
				if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) runcostfact /= 2;
 

	
 
				rvi[i].running_cost_base = runcostfact;
 
			}
 
			break;
 

	
 
		case 0x0E: /* Running cost base */
 
@@ -312,25 +312,25 @@ static bool RailVehicleChangeInfo(uint e
 

	
 
		case 0x13: /* Dual-headed */
 
			FOR_EACH_OBJECT {
 
				uint8 dual = grf_load_byte(&buf);
 

	
 
				if (dual != 0) {
 
					if (!(rvi[i].flags & RVI_MULTIHEAD)) {
 
					if (rvi[i].railveh_type != RAILVEH_MULTIHEAD) {
 
						// adjust power and running cost if needed
 
						rvi[i].power /= 2;
 
						rvi[i].running_cost_base /= 2;
 
					}
 
					rvi[i].flags |= RVI_MULTIHEAD;
 
					rvi[i].railveh_type = RAILVEH_MULTIHEAD;
 
				} else {
 
					if (rvi[i].flags & RVI_MULTIHEAD) {
 
					if (rvi[i].railveh_type == RAILVEH_MULTIHEAD) {
 
						// adjust power and running cost if needed
 
						rvi[i].power *= 2;
 
						rvi[i].running_cost_base *= 2;
 
					}
 
					rvi[i].flags &= ~RVI_MULTIHEAD;
 
					rvi[i].railveh_type = RAILVEH_SINGLEHEAD;
 
				}
 
			}
 
			break;
 

	
 
		case 0x14: /* Cargo capacity */
 
			FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf);
 
@@ -3585,13 +3585,13 @@ static void CalculateRefitMasks(void)
 
			}
 
		} else {
 
			// Don't apply default refit mask to wagons or engines with no capacity
 
			if (xor_mask == 0 && (
 
						GetEngine(engine)->type != VEH_Train || (
 
							RailVehInfo(engine)->capacity != 0 &&
 
							!(RailVehInfo(engine)->flags & RVI_WAGON)
 
							RailVehInfo(engine)->railveh_type != RAILVEH_WAGON
 
						)
 
					)) {
 
				xor_mask = _default_refitmasks[GetEngine(engine)->type - VEH_Train];
 
			}
 
		}
 
		_engine_info[engine].refit_mask = ((mask & ~not_mask) ^ xor_mask) & _landscape_global_cargo_mask[_opt.landscape];
 
@@ -3798,6 +3798,7 @@ void LoadNewGRF(uint load_index, uint fi
 
	CalculateRefitMasks();
 
}
 

	
 

	
 

	
 

	
 

	
src/players.cpp
Show inline comments
 
@@ -653,13 +653,13 @@ byte GetPlayerRailtypes(PlayerID p)
 
		const EngineInfo *ei = EngInfo(i);
 

	
 
		if (e->type == VEH_Train && HASBIT(ei->climates, _opt.landscape) &&
 
				(HASBIT(e->player_avail, p) || _date >= e->intro_date + 365)) {
 
			const RailVehicleInfo *rvi = RailVehInfo(i);
 

	
 
			if (!(rvi->flags & RVI_WAGON)) {
 
			if (rvi->railveh_type != RAILVEH_WAGON) {
 
				assert(rvi->railtype < RAILTYPE_END);
 
				SETBIT(rt, rvi->railtype);
 
			}
 
		}
 
	}
 

	
src/table/engines.h
Show inline comments
 
@@ -326,14 +326,15 @@ const EngineInfo orig_engine_info[] = {
 
 * @param j cargo_type
 
 * @param k ai_rank
 
 * @param l railtype
 
 * Tractive effort coefficient by default is the same as TTDPatch, 0.30*256=76
 
 */
 
#define RVI(a, b, c, d, e, f, g, h, i, j, k, l) { a, b, c, {l}, d, e, f, g, h, h, i, j, k, 0, 0, 0, 0, 76, 0 }
 
#define M RVI_MULTIHEAD
 
#define W RVI_WAGON
 
#define M RAILVEH_MULTIHEAD
 
#define W RAILVEH_WAGON
 
#define G RAILVEH_SINGLEHEAD
 
#define S 0
 
#define D 1
 
#define E 2
 

	
 
#define R RAILTYPE_RAIL
 
#define C RAILTYPE_ELECTRIC
 
@@ -343,37 +344,37 @@ const EngineInfo orig_engine_info[] = {
 
const RailVehicleInfo orig_rail_vehicle_info[NUM_TRAIN_ENGINES] = {
 
	//   image_index  max_speed (kph)      running_cost_base
 
	//   |  flags     |        power (hp)  |  running_cost_class & engclass
 
	//   |  |    base_cost     |    weight |  |   capacity
 
	//   |  |    |    |        |    |      |  |   |  cargo_type
 
	//   |  |    |    |        |    |      |  |   |  |
 
	RVI( 2, 0,   7,  64,     300,  47,    50, S,  0, 0              ,  1, R), //   0
 
	RVI(19, 0,   8,  80,     600,  65,    65, D,  0, 0              ,  4, R), //   1
 
	RVI( 2, 0,  10,  72,     400,  85,    90, S,  0, 0              ,  7, R), //   2
 
	RVI( 0, 0,  15,  96,     900, 130,   130, S,  0, 0              , 19, R), //   3
 
	RVI( 1, 0,  19, 112,    1000, 140,   145, S,  0, 0              , 20, R), //   4
 
	RVI(12, 0,  16, 120,    1400,  95,   125, D,  0, 0              , 30, R), //   5
 
	RVI(14, 0,  20, 152,    2000, 120,   135, D,  0, 0              , 31, R), //   6
 
	RVI( 3, 0,  14,  88,    1100, 145,   130, S,  0, 0              , 19, R), //   7
 
	RVI( 0, 0,  13, 112,    1000, 131,   120, S,  0, 0              , 20, R), //   8
 
	RVI( 1, 0,  19, 128,    1200, 162,   140, S,  0, 0              , 21, R), //   9
 
	RVI( 0, 0,  22, 144,    1600, 170,   130, S,  0, 0              , 22, R), //  10
 
	RVI( 2, G,   7,  64,     300,  47,    50, S,  0, 0              ,  1, R), //   0
 
	RVI(19, G,   8,  80,     600,  65,    65, D,  0, 0              ,  4, R), //   1
 
	RVI( 2, G,  10,  72,     400,  85,    90, S,  0, 0              ,  7, R), //   2
 
	RVI( 0, G,  15,  96,     900, 130,   130, S,  0, 0              , 19, R), //   3
 
	RVI( 1, G,  19, 112,    1000, 140,   145, S,  0, 0              , 20, R), //   4
 
	RVI(12, G,  16, 120,    1400,  95,   125, D,  0, 0              , 30, R), //   5
 
	RVI(14, G,  20, 152,    2000, 120,   135, D,  0, 0              , 31, R), //   6
 
	RVI( 3, G,  14,  88,    1100, 145,   130, S,  0, 0              , 19, R), //   7
 
	RVI( 0, G,  13, 112,    1000, 131,   120, S,  0, 0              , 20, R), //   8
 
	RVI( 1, G,  19, 128,    1200, 162,   140, S,  0, 0              , 21, R), //   9
 
	RVI( 0, G,  22, 144,    1600, 170,   130, S,  0, 0              , 22, R), //  10
 
	RVI( 8, M,  11, 112,   600/2,32/2,  85/2, D, 38, CT_PASSENGERS  , 10, R), //  11
 
	RVI(10, M,  14, 120,   700/2,38/2,  70/2, D, 40, CT_PASSENGERS  , 11, R), //  12
 
	RVI( 4, 0,  15, 128,    1250,  72,    95, D,  0, 0              , 30, R), //  13
 
	RVI( 5, 0,  17, 144,    1750, 101,   120, D,  0, 0              , 31, R), //  14
 
	RVI( 4, 0,  18, 160,    2580, 112,   140, D,  0, 0              , 32, R), //  15
 
	RVI(14, 0,  23,  96,    4000, 150,   135, D,  0, 0              , 33, R), //  16
 
	RVI(12, 0,  16, 112,    2400, 120,   105, D,  0, 0              , 34, R), //  17
 
	RVI(13, 0,  30, 112,    6600, 207,   155, D,  0, 0              , 35, R), //  18
 
	RVI(15, 0,  18, 104,    1500, 110,   105, D,  0, 0              , 29, R), //  19
 
	RVI( 4, G,  15, 128,    1250,  72,    95, D,  0, 0              , 30, R), //  13
 
	RVI( 5, G,  17, 144,    1750, 101,   120, D,  0, 0              , 31, R), //  14
 
	RVI( 4, G,  18, 160,    2580, 112,   140, D,  0, 0              , 32, R), //  15
 
	RVI(14, G,  23,  96,    4000, 150,   135, D,  0, 0              , 33, R), //  16
 
	RVI(12, G,  16, 112,    2400, 120,   105, D,  0, 0              , 34, R), //  17
 
	RVI(13, G,  30, 112,    6600, 207,   155, D,  0, 0              , 35, R), //  18
 
	RVI(15, G,  18, 104,    1500, 110,   105, D,  0, 0              , 29, R), //  19
 
	RVI(16, M,  35, 160,  3500/2,95/2, 205/2, D,  0, 0              , 45, R), //  20
 
	RVI(18, 0,  21, 104,    2200, 120,   145, D,  0, 0              , 32, R), //  21
 
	RVI(18, G,  21, 104,    2200, 120,   145, D,  0, 0              , 32, R), //  21
 
	RVI( 6, M,  20, 200,  4500/2,70/2, 190/2, D,  4, CT_MAIL        , 50, R), //  22
 
	RVI(20, 0,  26, 160,    3600,  84,   180, E,  0, 0              , 40, C), //  23
 
	RVI(20, 0,  30, 176,    5000,  82,   205, E,  0, 0              , 41, C), //  24
 
	RVI(20, G,  26, 160,    3600,  84,   180, E,  0, 0              , 40, C), //  23
 
	RVI(20, G,  30, 176,    5000,  82,   205, E,  0, 0              , 41, C), //  24
 
	RVI(21, M,  40, 240,  7000/2,90/2, 240/2, E,  0, 0              , 51, C), //  25
 
	RVI(23, M,  43, 264,  8000/2,95/2, 250/2, E,  0, 0              , 52, C), //  26
 
	RVI(33, W, 247,   0,       0,  25,     0, 0, 40, CT_PASSENGERS  ,  0, R), //  27
 
	RVI(35, W, 228,   0,       0,  21,     0, 0, 30, CT_MAIL        ,  0, R), //  28
 
	RVI(34, W, 176,   0,       0,  18,     0, 0, 30, CT_COAL        ,  0, R), //  29
 
	RVI(36, W, 200,   0,       0,  24,     0, 0, 30, CT_OIL         ,  0, R), //  30
 
@@ -397,15 +398,15 @@ const RailVehicleInfo orig_rail_vehicle_
 
	RVI(54, W, 182,   0,       0,  24,     0, 0, 25, CT_COLA        ,  0, R), //  48
 
	RVI(55, W, 181,   0,       0,  21,     0, 0, 25, CT_CANDY       ,  0, R), //  49
 
	RVI(56, W, 183,   0,       0,  21,     0, 0, 20, CT_TOYS        ,  0, R), //  50
 
	RVI(57, W, 196,   0,       0,  18,     0, 0, 22, CT_BATTERIES   ,  0, R), //  51
 
	RVI(58, W, 193,   0,       0,  18,     0, 0, 25, CT_FIZZY_DRINKS,  0, R), //  52
 
	RVI(59, W, 191,   0,       0,  18,     0, 0, 30, CT_PLASTIC     ,  0, R), //  53
 
	RVI(25, 0,  52, 304,    9000,  95,   230, E,  0, 0              , 60, O), //  54
 
	RVI(25, G,  52, 304,    9000,  95,   230, E,  0, 0              , 60, O), //  54
 
	RVI(26, M,  60, 336, 10000/2,85/2, 240/2, E, 25, CT_PASSENGERS  , 62, O), //  55
 
	RVI(26, 0,  53, 320,    5000,  95,   230, E,  0, 0              , 63, O), //  56
 
	RVI(26, G,  53, 320,    5000,  95,   230, E,  0, 0              , 63, O), //  56
 
	RVI(60, W, 247,   0,       0,  25,     0, 0, 45, CT_PASSENGERS  ,  0, O), //  57
 
	RVI(62, W, 228,   0,       0,  21,     0, 0, 35, CT_MAIL        ,  0, O), //  58
 
	RVI(61, W, 176,   0,       0,  18,     0, 0, 35, CT_COAL        ,  0, O), //  59
 
	RVI(63, W, 200,   0,       0,  24,     0, 0, 35, CT_OIL         ,  0, O), //  60
 
	RVI(64, W, 192,   0,       0,  20,     0, 0, 30, CT_LIVESTOCK   ,  0, O), //  61
 
	RVI(65, W, 190,   0,       0,  21,     0, 0, 30, CT_GOODS       ,  0, O), //  62
 
@@ -427,17 +428,17 @@ const RailVehicleInfo orig_rail_vehicle_
 
	RVI(54, W, 182,   0,       0,  24,     0, 0, 30, CT_COLA        ,  0, O), //  78
 
	RVI(55, W, 181,   0,       0,  21,     0, 0, 30, CT_CANDY       ,  0, O), //  79
 
	RVI(56, W, 183,   0,       0,  21,     0, 0, 25, CT_TOYS        ,  0, O), //  80
 
	RVI(57, W, 196,   0,       0,  18,     0, 0, 27, CT_BATTERIES   ,  0, O), //  81
 
	RVI(58, W, 193,   0,       0,  18,     0, 0, 30, CT_FIZZY_DRINKS,  0, O), //  82
 
	RVI(59, W, 191,   0,       0,  18,     0, 0, 35, CT_PLASTIC     ,  0, O), //  83
 
	RVI(28, 0,  70, 400,   10000, 105,   250, E,  0, 0              , 70, L), //  84
 
	RVI(29, 0,  74, 448,   12000, 120,   253, E,  0, 0              , 71, L), //  85
 
	RVI(30, 0,  82, 480,   15000, 130,   254, E,  0, 0              , 72, L), //  86
 
	RVI(28, G,  70, 400,   10000, 105,   250, E,  0, 0              , 70, L), //  84
 
	RVI(29, G,  74, 448,   12000, 120,   253, E,  0, 0              , 71, L), //  85
 
	RVI(30, G,  82, 480,   15000, 130,   254, E,  0, 0              , 72, L), //  86
 
	RVI(31, M,  95, 640, 20000/2,150/2,255/2, E,  0, 0              , 73, L), //  87
 
	RVI(28, 0,  70, 480,   10000, 120,   250, E,  0, 0              , 74, L), //  88
 
	RVI(28, G,  70, 480,   10000, 120,   250, E,  0, 0              , 74, L), //  88
 
	RVI(60, W, 247,   0,       0,  25,     0, 0, 47, CT_PASSENGERS  ,  0, L), //  89
 
	RVI(62, W, 228,   0,       0,  21,     0, 0, 37, CT_MAIL        ,  0, L), //  90
 
	RVI(61, W, 176,   0,       0,  18,     0, 0, 37, CT_COAL        ,  0, L), //  91
 
	RVI(63, W, 200,   0,       0,  24,     0, 0, 37, CT_OIL         ,  0, L), //  92
 
	RVI(64, W, 192,   0,       0,  20,     0, 0, 32, CT_LIVESTOCK   ,  0, L), //  93
 
	RVI(65, W, 190,   0,       0,  21,     0, 0, 32, CT_GOODS       ,  0, L), //  94
 
@@ -467,12 +468,13 @@ const RailVehicleInfo orig_rail_vehicle_
 
#undef O
 
#undef C
 
#undef R
 
#undef E
 
#undef D
 
#undef S
 
#undef G
 
#undef W
 
#undef M
 
#undef RVI
 

	
 
/** Writes the properties of a ship into the ShipVehicleInfo struct.
 
 * @see ShipVehicleInfo
src/train_cmd.cpp
Show inline comments
 
@@ -191,17 +191,16 @@ void TrainConsistChanged(Vehicle* v)
 
			if (HASBIT(EngInfo(u->engine_type)->callbackmask, CBM_WAGON_POWER)) {
 
				uint16 callback = GetVehicleCallback(CBID_TRAIN_WAGON_POWER, 0, 0, u->engine_type, u);
 

	
 
				if (callback != CALLBACK_FAILED) u->u.rail.cached_vis_effect = callback;
 
			}
 

	
 
			if ((rvi_v->pow_wag_power != 0) && (rvi_u->flags & RVI_WAGON) && UsesWagonOverride(u)) {
 
				if (u->u.rail.cached_vis_effect < 0x40) {
 
					/* wagon is powered */
 
					SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
 
				}
 
			if (rvi_v->pow_wag_power != 0 && rvi_u->railveh_type == RAILVEH_WAGON &&
 
				UsesWagonOverride(u) && (u->u.rail.cached_vis_effect < 0x40)) {
 
				/* wagon is powered */
 
				SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
 
			}
 

	
 
			/* Do not count powered wagons for the compatible railtypes, as wagons always
 
			   have railtype normal */
 
			if (rvi_u->power > 0) {
 
				v->u.rail.compatible_railtypes |= GetRailTypeInfo(u->u.rail.railtype)->powered_railtypes;
 
@@ -212,15 +211,15 @@ void TrainConsistChanged(Vehicle* v)
 
			if (HASBIT(u->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL)) {
 
				u->u.rail.railtype = RAILTYPE_RAIL;
 
				u->u.rail.compatible_railtypes |= (1 << RAILTYPE_RAIL);
 
			}
 

	
 
			// max speed is the minimum of the speed limits of all vehicles in the consist
 
			if (!(rvi_u->flags & RVI_WAGON) || _patches.wagon_speed_limits)
 
				if (rvi_u->max_speed != 0 && !UsesWagonOverride(u))
 
					max_speed = min(rvi_u->max_speed, max_speed);
 
			if ((rvi_u->railveh_type != RAILVEH_WAGON || _patches.wagon_speed_limits) &&
 
				rvi_u->max_speed != 0 && !UsesWagonOverride(u))
 
				max_speed = min(rvi_u->max_speed, max_speed);
 
		}
 

	
 
		// check the vehicle length (callback)
 
		veh_len = CALLBACK_FAILED;
 
		if (HASBIT(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {
 
			veh_len = GetVehicleCallback(CBID_TRAIN_VEHICLE_LENGTH, 0, 0, u->engine_type, u);
 
@@ -487,13 +486,13 @@ void DrawTrainEngine(int x, int y, Engin
 
		}
 
	}
 
	if (image == 0) {
 
		image = (6 & _engine_sprite_and[img]) + _engine_sprite_base[img];
 
	}
 

	
 
	if (rvi->flags & RVI_MULTIHEAD) {
 
	if (rvi->railveh_type == RAILVEH_MULTIHEAD) {
 
		DrawSprite(image, pal, x - 14, y);
 
		x += 15;
 
		image = 0;
 
		if (is_custom_sprite(img)) {
 
			image = GetCustomVehicleIcon(engine, DIR_E);
 
			if (image == 0) img = orig_rail_vehicle_info[engine].image_index;
 
@@ -762,17 +761,17 @@ int32 CmdBuildRailVehicle(TileIndex tile
 
	rvi = RailVehInfo(p1);
 

	
 
	/* Check if depot and new engine uses the same kind of tracks */
 
	/* We need to see if the engine got power on the tile to avoid eletric engines in non-electric depots */
 
	if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 

	
 
	if (rvi->flags & RVI_WAGON) return CmdBuildRailWagon(p1, tile, flags);
 
	if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);
 

	
 
	value = EstimateTrainCost(rvi);
 

	
 
	num_vehicles = (rvi->flags & RVI_MULTIHEAD) ? 2 : 1;
 
	num_vehicles = (rvi->railveh_type == RAILVEH_MULTIHEAD) ? 2 : 1;
 
	num_vehicles += CountArticulatedParts(p1);
 

	
 
	if (!(flags & DC_QUERY_COST)) {
 
		Vehicle *vl[12]; // Allow for upto 10 artic parts and dual-heads
 

	
 
		memset(&vl, 0, sizeof(vl));
 
@@ -831,13 +830,13 @@ int32 CmdBuildRailVehicle(TileIndex tile
 
			v->subtype = 0;
 
			SetFrontEngine(v);
 
			SetTrainEngine(v);
 

	
 
			VehiclePositionChanged(v);
 

	
 
			if (rvi->flags & RVI_MULTIHEAD) {
 
			if (rvi->railveh_type == RAILVEH_MULTIHEAD) {
 
				SetMultiheaded(v);
 
				AddRearEngineToMultiheadedTrain(vl[0], vl[1], true);
 
				/* Now we need to link the front and rear engines together
 
				 * other_multiheaded_part is the pointer that links to the other half of the engine
 
				 * vl[0] is the front and vl[1] is the rear
 
				 */
 
@@ -1354,13 +1353,13 @@ int32 CmdSellRailWagon(TileIndex tile, u
 
	if (IsMultiheaded(v) && !IsTrainEngine(v)) return_cmd_error(STR_REAR_ENGINE_FOLLOW_FRONT_ERROR);
 

	
 
	if (flags & DC_EXEC) {
 
		if (v == first && IsFrontEngine(first)) {
 
			DeleteWindowById(WC_VEHICLE_VIEW, first->index);
 
		}
 
		if (IsLocalPlayer() && (p1 == 1 || !(RailVehInfo(v->engine_type)->flags & RVI_WAGON))) {
 
		if (IsLocalPlayer() && (p1 == 1 || RailVehInfo(v->engine_type)->railveh_type != RAILVEH_WAGON)) {
 
			InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Train);
 
		}
 
		InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
 
		RebuildVehicleLists();
 
	}
 

	
 
@@ -2087,13 +2086,13 @@ static void HandleLocomotiveSmokeCloud(c
 
		int effect_offset = GB(v->u.rail.cached_vis_effect, 0, 4) - 8;
 
		byte effect_type = GB(v->u.rail.cached_vis_effect, 4, 2);
 
		bool disable_effect = HASBIT(v->u.rail.cached_vis_effect, 6);
 
		int x, y;
 

	
 
		// no smoke?
 
		if ((rvi->flags & RVI_WAGON && effect_type == 0) ||
 
		if ((rvi->railveh_type == RAILVEH_WAGON && effect_type == 0) ||
 
				disable_effect ||
 
				rvi->railtype > RAILTYPE_ELECTRIC ||
 
				v->vehstatus & VS_HIDDEN) {
 
			continue;
 
		}
 

	
 
@@ -3749,35 +3748,35 @@ void ConvertOldMultiheadToNew(void)
 
				BEGIN_ENUM_WAGONS(u) {
 
					const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
 

	
 
					CLRBIT(u->subtype, 7);
 
					switch (u->subtype) {
 
						case 0: /* TS_Front_Engine */
 
							if (rvi->flags & RVI_MULTIHEAD) SetMultiheaded(u);
 
							if (rvi->railveh_type == RAILVEH_MULTIHEAD) SetMultiheaded(u);
 
							SetFrontEngine(u);
 
							SetTrainEngine(u);
 
							break;
 

	
 
						case 1: /* TS_Artic_Part */
 
							u->subtype = 0;
 
							SetArticulatedPart(u);
 
							break;
 

	
 
						case 2: /* TS_Not_First */
 
							u->subtype = 0;
 
							if (rvi->flags & RVI_WAGON) {
 
							if (rvi->railveh_type == RAILVEH_WAGON) {
 
								// normal wagon
 
								SetTrainWagon(u);
 
								break;
 
							}
 
							if (rvi->flags & RVI_MULTIHEAD && rvi->image_index == u->spritenum - 1) {
 
							if (rvi->railveh_type == RAILVEH_MULTIHEAD && rvi->image_index == u->spritenum - 1) {
 
								// rear end of a multiheaded engine
 
								SetMultiheaded(u);
 
								break;
 
							}
 
							if (rvi->flags & RVI_MULTIHEAD) SetMultiheaded(u);
 
							if (rvi->railveh_type == RAILVEH_MULTIHEAD) SetMultiheaded(u);
 
							SetTrainEngine(u);
 
							break;
 

	
 
						case 4: /* TS_Free_Car */
 
							u->subtype = 0;
 
							SetTrainWagon(u);
src/train_gui.cpp
Show inline comments
 
@@ -155,13 +155,13 @@ static void TrainViewWndProc(Window *w, 
 
		DisableWindowWidget(w, 12);
 

	
 
		if (is_localplayer) {
 
			/* See if any vehicle can be refitted */
 
			for (u = v; u != NULL; u = u->next) {
 
				if (EngInfo(u->engine_type)->refit_mask != 0 ||
 
						(!(RailVehInfo(v->engine_type)->flags & RVI_WAGON) && v->cargo_cap != 0)) {
 
						(RailVehInfo(v->engine_type)->railveh_type != RAILVEH_WAGON && v->cargo_cap != 0)) {
 
					EnableWindowWidget(w, 12);
 
					/* We have a refittable carriage, bail out */
 
					break;
 
				}
 
			}
 
		}
 
@@ -338,13 +338,13 @@ static void TrainDetailsCargoTab(const V
 
		DrawString(x, y, str, 0);
 
	}
 
}
 

	
 
static void TrainDetailsInfoTab(const Vehicle *v, int x, int y)
 
{
 
	if (RailVehInfo(v->engine_type)->flags & RVI_WAGON) {
 
	if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {
 
		SetDParam(0, GetCustomEngineName(v->engine_type));
 
		SetDParam(1, v->value);
 
		DrawString(x, y, STR_882D_VALUE, 0x10);
 
	} else {
 
		SetDParam(0, GetCustomEngineName(v->engine_type));
 
		SetDParam(1, v->build_year);
src/vehicle.cpp
Show inline comments
 
@@ -784,13 +784,13 @@ int32 GetRefitCost(EngineID engine_type)
 

	
 
	switch (GetEngine(engine_type)->type) {
 
		case VEH_Ship: base_cost = _price.ship_base; break;
 
		case VEH_Road: base_cost = _price.roadveh_base; break;
 
		case VEH_Aircraft: base_cost = _price.aircraft_base; break;
 
		case VEH_Train:
 
			base_cost = 2 * ((RailVehInfo(engine_type)->flags & RVI_WAGON) ?
 
			base_cost = 2 * ((RailVehInfo(engine_type)->railveh_type == RAILVEH_WAGON) ?
 
							 _price.build_railwagon : _price.build_railvehicle);
 
			break;
 
		default: NOT_REACHED(); break;
 
	}
 
	return (EngInfo(engine_type)->refit_cost * base_cost) >> 10;
 
}
 
@@ -2240,13 +2240,13 @@ static int32 MaybeReplaceVehicle(Vehicle
 
	if (v->type == VEH_Train && p->renew_keep_length) {
 
		Vehicle *temp;
 
		w = v;
 

	
 
		while (v->u.rail.cached_total_length > old_total_length) {
 
			// the train is too long. We will remove cars one by one from the start of the train until it's short enough
 
			while (w != NULL && !(RailVehInfo(w->engine_type)->flags&RVI_WAGON) ) {
 
			while (w != NULL && RailVehInfo(w->engine_type)->railveh_type != RAILVEH_WAGON) {
 
				w = GetNextVehicle(w);
 
			}
 
			if (w == NULL) {
 
				// we failed to make the train short enough
 
				SetDParam(0, v->unitnumber);
 
				AddNewsItem(STR_TRAIN_TOO_LONG_AFTER_REPLACEMENT, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);
 
@@ -2847,13 +2847,13 @@ static SpriteID GetEngineColourMap(Engin
 
				switch (rvi->railtype) {
 
					default: NOT_REACHED();
 
					case RAILTYPE_RAIL:
 
					case RAILTYPE_ELECTRIC:
 
					{
 
						if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type;
 
						if (rvi->flags & RVI_WAGON) {
 
						if (rvi->railveh_type == RAILVEH_WAGON) {
 
							if (cargo_type == CT_PASSENGERS || cargo_type == CT_MAIL || cargo_type == CT_VALUABLES) {
 
								if (parent_engine_type == INVALID_ENGINE) {
 
									scheme = LS_PASSENGER_WAGON_STEAM;
 
								} else {
 
									switch (RailVehInfo(parent_engine_type)->engclass) {
 
										case 0: scheme = LS_PASSENGER_WAGON_STEAM; break;
0 comments (0 inline, 0 general)