// store consist weight in cache

	v->u.rail.cached_weight = weight;

}

/**

 */

void TrainConsistChanged(Vehicle *v) {

	Vehicle *u;

	uint16 max_speed = 0xFFFF;

	uint32 power = 0;

	for (u = v; u != NULL; u = u->next) {

		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

		// power is the sum of the powers of all engines and powered wagons in the consist

		power += rvi_u->power;

		// check if its a powered wagon

		CLRBIT(u->u.rail.flags, VRF_POWEREDWAGON);

		if ((rvi_v->pow_wag_power != 0) && (rvi_u->flags & RVI_WAGON) && UsesWagonOverride(u)) {

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

			v->subtype = TS_Free_Car;

			if (u != NULL) {

				u->next = v;

				v->subtype = TS_Not_First;

			}

			v->cargo_type = rvi->cargo_type;

			v->cargo_cap = rvi->capacity;

			v->value = value;

//			v->day_counter = 0;

			v->type = VEH_Train;

			v->cur_image = 0xAC2;

			_new_wagon_id = v->index;

			VehiclePositionChanged(v);

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

		}

	}

	return value;

	u->tile = v->tile;

	u->x_pos = v->x_pos;

	u->y_pos = v->y_pos;

	u->z_pos = v->z_pos;

	u->z_height = 6;

	u->u.rail.track = 0x80;

	u->vehstatus = v->vehstatus & ~VS_STOPPED;

	u->subtype = TS_Not_First;

	u->spritenum = v->spritenum + 1;

	u->cargo_type = v->cargo_type;

	u->cargo_cap = v->cargo_cap;

	u->u.rail.railtype = v->u.rail.railtype;

			v->owner = _current_player;

			v->x_pos = (x |= _vehicle_initial_x_fract[dir]);

			v->y_pos = (y |= _vehicle_initial_y_fract[dir]);

			v->z_pos = GetSlopeZ(x,y);

			v->z_height = 6;

			v->u.rail.track = 0x80;

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

			v->spritenum = rvi->image_index;

			v->cargo_type = rvi->cargo_type;

			v->cargo_cap = rvi->capacity;

			v->max_speed = rvi->max_speed;

			v->value = value;

// unlink a rail wagon from the linked list.

// returns the new value of first

static Vehicle *UnlinkWagon(Vehicle *v, Vehicle *first)

{

	Vehicle *u;

	// unlinking the first vehicle of the chain?

	if (v == first) {

		v = v->next;

		if (v == NULL) return NULL;

		v->subtype = TS_Free_Car;

		return v;

	}

	for (u = first; u->next != v; u = u->next) {}

	u->next = v->next;

		if (HASBIT(p2, 0)) {

			// unlink ALL wagons

			if (src != src_head) {

				Vehicle *v = src_head;

				while (v->next != src) v=v->next;

				v->next = NULL;

			}

		} else {

			// unlink single wagon from linked list

			src->next = NULL;

		}

		if (dst == NULL) {

			// move the train to an empty line. for locomotives, we set the type to 0. for wagons, 4.

			if (is_loco) {

				if (src->subtype != TS_Front_Engine) {

					// setting the type to 0 also involves setting up the orders field.

					src->subtype = TS_Front_Engine;

					assert(src->orders == NULL);

					src->num_orders = 0;

				}

			} else {

				src->subtype = TS_Free_Car;

			}

		} else {

			if (src->subtype == TS_Front_Engine) {

				// the vehicle was previously a loco. need to free the order list and delete vehicle windows etc.

				DeleteWindowById(WC_VEHICLE_VIEW, src->index);

				DeleteVehicleOrders(src);

			}

			src->subtype = TS_Not_First;

			src->unitnumber = 0; // doesn't occupy a unitnumber anymore.

			// link in the wagon(s) in the chain.

			{

				Vehicle *v;

				v->next = dst->next;

			}

			dst->next = src;

		}

			TrainConsistChanged(src_head);

		if (dst_head) {

			if (dst_head->subtype == TS_Front_Engine) {

				UpdateTrainAcceleration(dst_head);

			}

		}

		RebuildVehicleLists();

	}

	return 0;

}

				/* 4 If the second wagon was an engine, update it to front_engine

					* which UnlinkWagon() has changed to TS_Free_Car */

				if (switch_engine) first->subtype = TS_Front_Engine;

				/* 5. If the train still exists, update its acceleration, window, etc. */

					TrainConsistChanged(first);

				}

				/* (6.) Borked AI. If it sells an engine it expects all wagons lined

				* up on a new line to be added to the newly built loco. Replace it is.

				* Totally braindead cause building a new engine adds all loco-less

					first = UnlinkWagon(v, first);

					DeleteVehicle(v);

				}

			}

			/* 3. If it is still a valid train after selling, update its acceleration and cached values */

				TrainConsistChanged(first);

			}

		} break;

	}

	return cost;

}

	FOR_ALL_VEHICLES(v) {

		v->first = NULL;

		if (v->type != 0) {

			v->left_coord = INVALID_COORD;

			VehiclePositionChanged(v);

				TrainConsistChanged(v);

		}

	}

}

static Vehicle *InitializeVehicle(Vehicle *v)

		if ( RailVehInfo(new_engine_type)->flags & RVI_MULTIHEAD )

			build_cost = build_cost >> 1;   //multiheaded engines have EstimateTrainCost() for both engines

		if ( old_engine_type != new_engine_type ) {

			// prevent that the rear engine can get replaced to something else than the front engine

				if ( first->engine_type != new_engine_type ) return CMD_ERROR;

			}

			// checks if the engine is the first one

				if ( RailVehInfo(new_engine_type)->flags & RVI_MULTIHEAD ) {

					if ( u->engine_type == old_engine_type && v->next != NULL) {

						rear_engine_cost = build_cost - u->value;

					} else {

						rear_engine_cost = build_cost;

					}

				/* rvi->image_index is the new sprite for the engine. Adding +1 makes the engine head the other way

				if it is a multiheaded engine (rear engine)

				(rvi->flags & RVI_MULTIHEAD && sprite - rvi2->image_index) is true if the engine is heading the other way, otherwise 0*/

				v->spritenum = rvi->image_index + (( rvi->flags & RVI_MULTIHEAD && sprite - rvi2->image_index) ? 1 : 0);

				// turn the last engine in a multiheaded train if needed

					v->spritenum++;

				v->cargo_type = rvi->cargo_type;

				v->cargo_cap = rvi->capacity;

				v->max_speed = rvi->max_speed;

							u->next = w;

						}

					}

				}

#endif

				InvalidateWindowClasses(WC_TRAINS_LIST);

				UpdateTrainAcceleration(first);

				break;

				}

			case VEH_Road:

				{

		if (!AddBlockIfNeeded(&_vehicle_pool, index))

			error("Vehicles: failed loading savegame: too many vehicles");

		v = GetVehicle(index);

		SlObject(v, _veh_descs[SlReadByte()]);

		/* Old savegames used 'last_station_visited = 0xFF', should be 0xFFFF */

		if (_sl.version < 5 && v->last_station_visited == 0xFF)

			v->last_station_visited = 0xFFFF;

		if (_sl.version < 5) {

			/* Convert the current_order.type (which is a mix of type and flags, because

			    in those versions, they both were 4 bits big) to type and flags */

			v->current_order.flags = (v->current_order.type & 0xF0) >> 4;

			v->current_order.type  =  v->current_order.type & 0x0F;

		}

	}

	/* Check for shared order-lists (we now use pointers for that) */

	if (_sl.full_version < 0x502) {

		FOR_ALL_VEHICLES(v) {

			Vehicle *u;

			if (v->type == 0)