Index: bauer/hausbauer.cc
===================================================================
--- bauer/hausbauer.cc	(revision 7957)
+++ bauer/hausbauer.cc	(working copy)
@@ -488,7 +488,7 @@
 				gb->set_fab((fabrik_t *)param);
 			}
 			// try to fake old building
-			else if(welt->get_zeit_ms() < 2) {
+			else if(welt->get_ticks() < 2) {
 				// Hajo: after staring a new map, build fake old buildings
 				gb->add_alter(10000);
 			}
Index: bauer/vehikelbauer.cc
===================================================================
--- bauer/vehikelbauer.cc	(revision 7957)
+++ bauer/vehikelbauer.cc	(working copy)
@@ -162,18 +162,18 @@
 }
 
 
-vehicle_t* vehikelbauer_t::baue(koord3d k, player_t* player, convoi_t* cnv, const vehikel_besch_t* vb )
+vehicle_t* vehikelbauer_t::baue(koord3d k, player_t* player, consist_t* cnst, const vehikel_besch_t* vb )
 {
 	vehicle_t* v;
 	switch (vb->get_waytype()) {
-		case road_wt:     v = new road_vehicle_t(      k, vb, player, cnv); break;
-		case monorail_wt: v = new monorail_vehicle_t(k, vb, player, cnv); break;
+		case road_wt:     v = new road_vehicle_t(      k, vb, player, cnst); break;
+		case monorail_wt: v = new monorail_vehicle_t(k, vb, player, cnst); break;
 		case track_wt:
-		case tram_wt:     v = new rail_vehicle_t(         k, vb, player, cnv); break;
-		case water_wt:    v = new water_vehicle_t(         k, vb, player, cnv); break;
-		case air_wt:      v = new air_vehicle_t(       k, vb, player, cnv); break;
-		case maglev_wt:   v = new maglev_vehicle_t(  k, vb, player, cnv); break;
-		case narrowgauge_wt:v = new narrowgauge_vehicle_t(k, vb, player, cnv); break;
+		case tram_wt:     v = new rail_vehicle_t(         k, vb, player, cnst); break;
+		case water_wt:    v = new water_vehicle_t(         k, vb, player, cnst); break;
+		case air_wt:      v = new air_vehicle_t(       k, vb, player, cnst); break;
+		case maglev_wt:   v = new maglev_vehicle_t(  k, vb, player, cnst); break;
+		case narrowgauge_wt:v = new narrowgauge_vehicle_t(k, vb, player, cnst); break;
 
 		default:
 			dbg->fatal("vehikelbauer_t::baue()", "cannot built a vehicle with waytype %i", vb->get_waytype());
@@ -311,7 +311,7 @@
 			continue;
 		}
 
-		// engine, but not allowed to lead a convoi, or no power at all or no electrics allowed
+		// engine, but not allowed to lead a consist, or no power at all or no electrics allowed
 		if(target_weight) {
 			if(test_besch->get_leistung()==0  ||  !test_besch->can_follow(NULL)  ||  (!include_electric  &&  test_besch->get_engine_type()==vehikel_besch_t::electric) ) {
 				continue;
@@ -400,7 +400,7 @@
 
 /* extended search for vehicles for replacement on load time
  * tries to get best match (no random action)
- * if prev_besch==NULL, then the convoi must be able to lead a convoi
+ * if prev_besch==NULL, then the consist must be able to lead a consist
  * @author prissi
  */
 const vehikel_besch_t *vehikelbauer_t::get_best_matching( waytype_t wt, const uint16 month_now, const uint32 target_weight, const uint32 target_power, const sint32 target_speed, const ware_besch_t * target_freight, bool not_obsolete, const vehikel_besch_t *prev_veh, bool is_last )
@@ -419,12 +419,12 @@
 		}
 
 		// not allowed as last vehicle
-		if(is_last  &&  test_besch->get_nachfolger_count()>0  &&  test_besch->get_nachfolger(0)!=NULL  ) {
+		if(is_last  &&  test_besch->get_trailing_count()>0  &&  test_besch->get_trailing(0)!=NULL  ) {
 			continue;
 		}
 
 		// not allowed as non-last vehicle
-		if(!is_last  &&  test_besch->get_nachfolger_count()==1  &&  test_besch->get_nachfolger(0)==NULL  ) {
+		if(!is_last  &&  test_besch->get_trailing_count()==1  &&  test_besch->get_trailing(0)==NULL  ) {
 			continue;
 		}
 
Index: bauer/vehikelbauer.h
===================================================================
--- bauer/vehikelbauer.h	(revision 7957)
+++ bauer/vehikelbauer.h	(working copy)
@@ -15,7 +15,7 @@
 
 class vehicle_t;
 class player_t;
-class convoi_t;
+class consist_t;
 class vehikel_besch_t;
 class ware_besch_t;
 template <class T> class slist_tpl;
@@ -37,7 +37,7 @@
 	static bool register_besch(const vehikel_besch_t *besch);
 	static bool alles_geladen();
 
-	static vehicle_t* baue(koord3d k, player_t* player, convoi_t* cnv, const vehikel_besch_t* vb );
+	static vehicle_t* baue(koord3d k, player_t* player, consist_t* cnst, const vehikel_besch_t* vb );
 
 	static const vehikel_besch_t * get_info(const char *name);
 	static slist_tpl<vehikel_besch_t const*> const& get_info(waytype_t);
@@ -48,7 +48,7 @@
 	static const vehikel_besch_t *vehikel_search(waytype_t typ,const uint16 month_now,const uint32 target_power,const sint32 target_speed, const ware_besch_t * target_freight, bool include_electric, bool not_obsolete );
 
 	/* for replacement during load time
-	 * prev_veh==NULL equals leading of convoi
+	 * prev_veh==NULL equals leading of consist
 	 */
 	static const vehikel_besch_t *get_best_matching( waytype_t wt, const uint16 month_now, const uint32 target_weight, const uint32 target_power, const sint32 target_speed, const ware_besch_t * target_freight, bool not_obsolete, const vehikel_besch_t *prev_veh, bool is_last );
 };
Index: besch/reader/vehicle_reader.cc
===================================================================
--- besch/reader/vehicle_reader.cc	(revision 7957)
+++ besch/reader/vehicle_reader.cc	(working copy)
@@ -61,8 +61,8 @@
 
 		besch->wt = decode_uint8(p);
 		besch->sound = decode_sint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 
 		besch->obsolete_date = (DEFAULT_RETIRE_DATE*16);
 	}
@@ -81,8 +81,8 @@
 
 		besch->wt = decode_uint8(p);
 		besch->sound = decode_sint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->engine_type = decode_uint8(p);
 
 		besch->obsolete_date = (DEFAULT_RETIRE_DATE*16);
@@ -105,8 +105,8 @@
 
 		besch->wt = decode_uint8(p);
 		besch->sound = decode_sint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->engine_type = decode_uint8(p);
 	}
 	else if (version==6) {
@@ -126,8 +126,8 @@
 		besch->wt = decode_uint8(p);
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 	}
 	else if (version==7) {
 		// different length of cars ...
@@ -147,8 +147,8 @@
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
 		besch->len = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 	}
 	else if (version==8) {
 		// multiple freight images...
@@ -167,8 +167,8 @@
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
 		besch->len = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->freight_image_type = decode_uint8(p);
 	}
 	else if (version==9) {
@@ -191,8 +191,8 @@
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
 		besch->len = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->freight_image_type = decode_uint8(p);
 	}
 	else if (version==10) {
@@ -215,8 +215,8 @@
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
 		besch->len = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->freight_image_type = decode_uint8(p);
 	}
 	else if (version==11) {
@@ -239,8 +239,8 @@
 		besch->sound = decode_sint8(p);
 		besch->engine_type = decode_uint8(p);
 		besch->len = decode_uint8(p);
-		besch->vorgaenger = decode_uint8(p);
-		besch->nachfolger = decode_uint8(p);
+		besch->leading = decode_uint8(p);
+		besch->trailing = decode_uint8(p);
 		besch->freight_image_type = decode_uint8(p);
 	}
 	else {
@@ -257,8 +257,8 @@
 		besch->leistung = decode_uint16(p);
 		besch->running_cost = decode_uint16(p);
 		besch->sound = (sint8)decode_sint16(p);
-		besch->vorgaenger = (sint8)decode_uint16(p);
-		besch->nachfolger = (sint8)decode_uint16(p);
+		besch->leading = (sint8)decode_uint16(p);
+		besch->trailing = (sint8)decode_uint16(p);
 
 		besch->intro_date = DEFAULT_INTRO_DATE*16;
 		besch->obsolete_date = (DEFAULT_RETIRE_DATE*16);
@@ -346,8 +346,8 @@
 		besch->leistung,
 		besch->running_cost,
 		besch->sound,
-		besch->vorgaenger,
-		besch->nachfolger,
+		besch->leading,
+		besch->trailing,
 		(besch->intro_date%12)+1,
 		besch->intro_date/12,
 		besch->gear,
Index: besch/vehikel_besch.cc
===================================================================
--- besch/vehikel_besch.cc	(revision 7957)
+++ besch/vehikel_besch.cc	(working copy)
@@ -13,14 +13,14 @@
 	chk->input(fixed_cost);
 	chk->input(gear);
 	chk->input(len);
-	chk->input(vorgaenger);
-	chk->input(nachfolger);
+	chk->input(leading);
+	chk->input(trailing);
 	chk->input(engine_type);
 	// freight
 	const xref_besch_t *xref = get_child<xref_besch_t>(2);
 	chk->input(xref ? xref->get_name() : "NULL");
 	// vehicle constraints
-	for(uint16 i=0; i<vorgaenger+nachfolger; i++) {
+	for(uint16 i=0; i<leading+trailing; i++) {
 		const xref_besch_t *xref = get_child<xref_besch_t>(6+i);
 		chk->input(xref ? xref->get_name() : "NULL");
 	}
Index: besch/vehikel_besch.h
===================================================================
--- besch/vehikel_besch.h	(revision 7957)
+++ besch/vehikel_besch.h	(working copy)
@@ -77,8 +77,8 @@
 	uint8 len;			// length (=8 is half a tile, the old default)
 	sint8 sound;
 
-	uint8  vorgaenger;	// all defined leading vehicles
-	uint8  nachfolger;	// all defined trailer
+	uint8  leading;	// all defined leading vehicles
+	uint8  trailing;	// all defined trailer
 
 	uint8  engine_type; // diesel, steam, electric (requires electrified ways), fuel_cell, etc.
 
@@ -92,7 +92,7 @@
 	// default vehicle (used for way seach and similar tasks)
 	// since it has no images and not even a name knot any calls to this will case a crash
 	vehikel_besch_t(uint8 wtyp, uint16 speed, engine_t engine) {
-		freight_image_type = cost = zuladung = axle_load = running_cost = fixed_cost = intro_date = vorgaenger = nachfolger = 0;
+		freight_image_type = cost = zuladung = axle_load = running_cost = fixed_cost = intro_date = leading = trailing = 0;
 		leistung = gewicht = 1;
 		loading_time = 1000;
 		gear = 64;
@@ -127,7 +127,7 @@
 			sint8 ware_index=0; // freight images: if not found use first freight
 
 			for( sint8 i=0;  i<freight_image_type;  i++  ) {
-				if (ware == get_child<ware_besch_t>(6 + nachfolger + vorgaenger + i)) {
+				if (ware == get_child<ware_besch_t>(6 + trailing + leading + i)) {
 					ware_index = i;
 					break;
 				}
@@ -169,43 +169,43 @@
 	}
 
 	// Liefert die erlaubten Vorgaenger.
-	// liefert get_vorgaenger(0) == NULL, so bedeutet das entweder alle
+	// liefert get_leading(0) == NULL, so bedeutet das entweder alle
 	// Vorgänger sind erlaubt oder keine. Um das zu unterscheiden, sollte man
-	// vorher hat_vorgaenger() befragen
-	const vehikel_besch_t *get_vorgaenger(uint8 i) const
+	// vorher hat_leading() befragen
+	const vehikel_besch_t *get_leading(uint8 i) const
 	{
-		if(  i >= vorgaenger  ) {
+		if(  i >= leading  ) {
 			return 0;
 		}
 		return get_child<vehikel_besch_t>(6 + i);
 	}
 
-	uint8 get_vorgaenger_count() const { return vorgaenger; }
+	uint8 get_leading_count() const { return leading; }
 
 	// Liefert die erlaubten Nachfolger.
-	// liefert get_nachfolger(0) == NULL, so bedeutet das entweder alle
+	// liefert get_trailing(0) == NULL, so bedeutet das entweder alle
 	// Nachfolger sind erlaubt oder keine. Um das zu unterscheiden, sollte
-	// man vorher hat_nachfolger() befragen
-	const vehikel_besch_t *get_nachfolger(uint8 i) const
+	// man vorher hat_trailing() befragen
+	const vehikel_besch_t *get_trailing(uint8 i) const
 	{
-		if(  i >= nachfolger  ) {
+		if(  i >= trailing  ) {
 			return 0;
 		}
-		return get_child<vehikel_besch_t>(6 + vorgaenger + i);
+		return get_child<vehikel_besch_t>(6 + leading + i);
 	}
 
-	uint8 get_nachfolger_count() const { return nachfolger; }
+	uint8 get_trailing_count() const { return trailing; }
 
 	/* returns true, if this veh can be before the next_veh
-	 * uses NULL to indicate end of convoi
+	 * uses NULL to indicate end of consist
 	 */
 	bool can_lead(const vehikel_besch_t *next_veh) const
 	{
-		if(  nachfolger==0  ) {
+		if(  trailing==0  ) {
 			return true;
 		}
-		for( uint8 i=0;  i<nachfolger;  i++  ) {
-			vehikel_besch_t const* const veh = get_child<vehikel_besch_t>(6 + vorgaenger + i);
+		for( uint8 i=0;  i<trailing;  i++  ) {
+			vehikel_besch_t const* const veh = get_child<vehikel_besch_t>(6 + leading + i);
 			if(veh==next_veh) {
 				return true;
 			}
@@ -215,14 +215,14 @@
 	}
 
 	/* returns true, if this veh can be after the prev_veh
-	 * uses NULL to indicate front of convoi
+	 * uses NULL to indicate front of consist
 	 */
 	bool can_follow(const vehikel_besch_t *prev_veh) const
 	{
-		if(  vorgaenger==0  ) {
+		if(  leading==0  ) {
 			return true;
 		}
-		for( uint8 i=0;  i<vorgaenger;  i++  ) {
+		for( uint8 i=0;  i<leading;  i++  ) {
 			vehikel_besch_t const* const veh = get_child<vehikel_besch_t>(6 + i);
 			if(veh==prev_veh) {
 				return true;
@@ -232,7 +232,7 @@
 		return false;
 	}
 
-	bool can_follow_any() const { return nachfolger==0; }
+	bool can_follow_any() const { return trailing==0; }
 
 	uint16 get_zuladung() const { return zuladung; }
 	uint16 get_loading_time() const { return loading_time; } // ms per full loading/unloading
Index: besch/writer/vehicle_writer.cc
===================================================================
--- besch/writer/vehicle_writer.cc	(revision 7957)
+++ besch/writer/vehicle_writer.cc	(working copy)
@@ -285,14 +285,14 @@
 	//
 	// Vorgänger/Nachfolgerbedingungen
 	//
-	uint8 besch_vorgaenger = 0;
+	uint8 besch_leading = 0;
 	bool found;
 	do {
 		char buf[40];
 
 		// Hajodoc: Constraints for previous vehicles
-		// Hajoval: string, "none" means only suitable at front of an convoi
-		sprintf(buf, "constraint[prev][%d]", besch_vorgaenger);
+		// Hajoval: string, "none" means only suitable at front of an consist
+		sprintf(buf, "constraint[prev][%d]", besch_leading);
 
 		str = obj.get(buf);
 		found = !str.empty();
@@ -301,17 +301,17 @@
 				str = "";
 			}
 			xref_writer_t::instance()->write_obj(fp, node, obj_vehicle, str.c_str(), false);
-			besch_vorgaenger++;
+			besch_leading++;
 		}
 	} while (found);
 
-	uint8 besch_nachfolger = 0;
+	uint8 besch_trailing = 0;
 	do {
 		char buf[40];
 
 		// Hajodoc: Constraints for successing vehicles
 		// Hajoval: string, "none" to disallow any followers
-		sprintf(buf, "constraint[next][%d]", besch_nachfolger);
+		sprintf(buf, "constraint[next][%d]", besch_trailing);
 
 		str = obj.get(buf);
 		found = !str.empty();
@@ -320,7 +320,7 @@
 				str = "";
 			}
 			xref_writer_t::instance()->write_obj(fp, node, obj_vehicle, str.c_str(), false);
-			besch_nachfolger++;
+			besch_trailing++;
 		}
 	} while (found);
 
@@ -351,9 +351,9 @@
 		xref_writer_t::instance()->write_obj(fp, node, obj_good, freight, false);
 	}
 
-	node.write_sint8(fp, besch_vorgaenger, pos);
+	node.write_sint8(fp, besch_leading, pos);
 	pos += sizeof(uint8);
-	node.write_sint8(fp, besch_nachfolger, pos);
+	node.write_sint8(fp, besch_trailing, pos);
 	pos += sizeof(uint8);
 	node.write_uint8(fp, (uint8) freight_max, pos);
 	pos += sizeof(uint8);
Index: boden/grund.h
===================================================================
--- boden/grund.h	(revision 7957)
+++ boden/grund.h	(working copy)
@@ -707,10 +707,10 @@
 	inline bool ist_uebergang() const { return (flags&has_way2)!=0  &&  ((weg_t *)objlist.bei(1))->get_besch()->get_styp()!=7; }
 
 	/**
-	* returns the vehicle of a convoi (if there)
+	* returns the vehicle of a consist (if there)
 	* @author V. Meyer
 	*/
-	obj_t *get_convoi_vehicle() const { return objlist.get_convoi_vehicle(); }
+	obj_t *get_consist_vehicle() const { return objlist.get_consist_vehicle(); }
 
 	virtual slope_t::type get_weg_hang() const { return get_grund_hang(); }
 
Index: boden/wasser.cc
===================================================================
--- boden/wasser.cc	(revision 7957)
+++ boden/wasser.cc	(working copy)
@@ -23,7 +23,7 @@
 void wasser_t::prepare_for_refresh()
 {
 	if(!welt->is_fast_forward()  &&  env_t::water_animation>0) {
-		int new_stage = (welt->get_zeit_ms() / env_t::water_animation) % grund_besch_t::water_animation_stages;
+		int new_stage = (welt->get_ticks() / env_t::water_animation) % grund_besch_t::water_animation_stages;
 		wasser_t::change_stage = (new_stage != stage);
 		wasser_t::stage = new_stage;
 	}
Index: boden/wege/schiene.cc
===================================================================
--- boden/wege/schiene.cc	(revision 7957)
+++ boden/wege/schiene.cc	(working copy)
@@ -7,7 +7,7 @@
 
 #include <stdio.h>
 
-#include "../../simconvoi.h"
+#include "../../simconsist.h"
 #include "../../simworld.h"
 #include "../../vehicle/simvehicle.h"
 
@@ -27,7 +27,7 @@
 
 schiene_t::schiene_t() : weg_t()
 {
-	reserved = convoihandle_t();
+	reserved = consist_handle_t();
 	set_besch(schiene_t::default_schiene);
 }
 
@@ -34,7 +34,7 @@
 
 schiene_t::schiene_t(loadsave_t *file) : weg_t()
 {
-	reserved = convoihandle_t();
+	reserved = consist_handle_t();
 	rdwr(file);
 }
 
@@ -73,7 +73,7 @@
  * true, if this rail can be reserved
  * @author prissi
  */
-bool schiene_t::reserve(convoihandle_t c, ribi_t::ribi dir  )
+bool schiene_t::reserve(consist_handle_t c, ribi_t::ribi dir  )
 {
 	if(can_reserve(c)) {
 		reserved = c;
@@ -102,11 +102,11 @@
 * only true, if there was something to release
 * @author prissi
 */
-bool schiene_t::unreserve(convoihandle_t c)
+bool schiene_t::unreserve(consist_handle_t c)
 {
 	// is this tile reserved by us?
 	if(reserved.is_bound()  &&  reserved==c) {
-		reserved = convoihandle_t();
+		reserved = consist_handle_t();
 		if(schiene_t::show_reservations) {
 			set_flag( obj_t::dirty );
 		}
@@ -129,7 +129,7 @@
 		return true;
 	}
 //	if(!welt->lookup(get_pos())->suche_obj(v->get_typ())) {
-		reserved = convoihandle_t();
+		reserved = consist_handle_t();
 		if(schiene_t::show_reservations) {
 			set_flag( obj_t::dirty );
 		}
Index: boden/wege/schiene.h
===================================================================
--- boden/wege/schiene.h	(revision 7957)
+++ boden/wege/schiene.h	(working copy)
@@ -10,7 +10,7 @@
 
 
 #include "weg.h"
-#include "../../convoihandle_t.h"
+#include "../../consist_handle_t.h"
 
 class vehicle_t;
 
@@ -25,10 +25,10 @@
 {
 protected:
 	/**
-	* Bound when this block was successfully reserved by the convoi
+	* Bound when this block was successfully reserved by the consist
 	* @author prissi
 	*/
-	convoihandle_t reserved;
+	consist_handle_t reserved;
 
 public:
 	static const weg_besch_t *default_schiene;
@@ -55,7 +55,7 @@
 	* true, if this rail can be reserved
 	* @author prissi
 	*/
-	bool can_reserve(convoihandle_t c) const { return !reserved.is_bound()  ||  c==reserved; }
+	bool can_reserve(consist_handle_t c) const { return !reserved.is_bound()  ||  c==reserved; }
 
 	/**
 	* true, if this rail can be reserved
@@ -67,13 +67,13 @@
 	* true, then this rail was reserved
 	* @author prissi
 	*/
-	bool reserve(convoihandle_t c, ribi_t::ribi dir);
+	bool reserve(consist_handle_t c, ribi_t::ribi dir);
 
 	/**
 	* releases previous reservation
 	* @author prissi
 	*/
-	bool unreserve( convoihandle_t c);
+	bool unreserve( consist_handle_t c);
 
 	/**
 	* releases previous reservation
@@ -87,10 +87,10 @@
 	virtual void cleanup(player_t *player);
 
 	/**
-	* gets the related convoi
+	* gets the related consist
 	* @author prissi
 	*/
-	convoihandle_t get_reserved_convoi() const {return reserved;}
+	consist_handle_t get_reserved_consist() const {return reserved;}
 
 	void rdwr(loadsave_t *file);
 
Index: boden/wege/weg.cc
===================================================================
--- boden/wege/weg.cc	(revision 7957)
+++ boden/wege/weg.cc	(working copy)
@@ -247,7 +247,7 @@
 	}
 
 #if 1
-	buf.printf(translator::translate("convoi passed last\nmonth %i\n"), statistics[1][1]);
+	buf.printf(translator::translate("consist passed last\nmonth %i\n"), statistics[1][1]);
 #else
 	// Debug - output stats
 	buf.append("\n");
Index: boden/wege/weg.h
===================================================================
--- boden/wege/weg.h	(revision 7957)
+++ boden/wege/weg.h	(working copy)
@@ -29,7 +29,7 @@
 
 enum way_statistics {
 	WAY_STAT_GOODS   = 0, ///< number of goods transported over this weg
-	WAY_STAT_CONVOIS = 1  ///< number of convois that passed this weg
+	WAY_STAT_CONVOIS = 1  ///< number of consists that passed this weg
 };
 
 
Index: dataobj/crossing_logic.cc
===================================================================
--- dataobj/crossing_logic.cc	(revision 7957)
+++ dataobj/crossing_logic.cc	(working copy)
@@ -132,7 +132,7 @@
 }
 
 
-// called after passing of the last vehicle (in a convoi)
+// called after passing of the last vehicle (in a consist)
 // or of a city car; releases the crossing which may switch state
 void crossing_logic_t::release_crossing( const vehicle_base_t *v )
 {
Index: dataobj/gameinfo.cc
===================================================================
--- dataobj/gameinfo.cc	(revision 7957)
+++ dataobj/gameinfo.cc	(working copy)
@@ -62,7 +62,7 @@
 	total_pass_transported = welt->get_finance_history_month(1,karte_t::WORLD_PAS_RATIO);
 	total_mail_transported = welt->get_finance_history_month(1,karte_t::WORLD_MAIL_RATIO);
 	total_goods_transported = welt->get_finance_history_month(1,karte_t::WORLD_GOODS_RATIO);
-	convoi_count = welt->convoys().get_count();
+	consist_count = welt->consists().get_count();
 
 	for(  int i=0;  i<MAX_PLAYER_COUNT;  i++ ) {
 		player_type[i] = player_t::EMPTY;
@@ -139,7 +139,7 @@
 	file->rdwr_long( city_count );
 	file->rdwr_long( einwohnerzahl );
 
-	file->rdwr_short( convoi_count );
+	file->rdwr_short( consist_count );
 	file->rdwr_short( halt_count );
 
 	file->rdwr_longlong( total_pass_transported );
Index: dataobj/gameinfo.h
===================================================================
--- dataobj/gameinfo.h	(revision 7957)
+++ dataobj/gameinfo.h	(working copy)
@@ -22,7 +22,7 @@
 	sint32 city_count;
 	sint32 einwohnerzahl;
 
-	uint16 convoi_count;
+	uint16 consist_count;
 	uint16 halt_count;
 
 	sint64 total_pass_transported;
@@ -65,7 +65,7 @@
 	sint32 get_city_count() const {return city_count;}
 	sint32 get_einwohnerzahl() const {return einwohnerzahl;}
 
-	sint32 get_convoi_count() const {return convoi_count;}
+	sint32 get_consist_count() const {return consist_count;}
 	sint32 get_halt_count() const {return halt_count;}
 
 	uint8 get_use_timeline() const {return use_timeline;}
Index: dataobj/objlist.cc
===================================================================
--- dataobj/objlist.cc	(revision 7957)
+++ dataobj/objlist.cc	(working copy)
@@ -753,7 +753,7 @@
 }
 
 
-obj_t *objlist_t::get_convoi_vehicle() const
+obj_t *objlist_t::get_consist_vehicle() const
 {
 	if(  top == 0  ) {
 		return NULL;
@@ -1068,7 +1068,7 @@
 				||  new_obj->get_typ()==obj_t::field
 				// do not save factory buildings => factory will reconstruct them
 				||  (new_obj->get_typ()==obj_t::gebaeude  &&  ((gebaeude_t *)new_obj)->get_fabrik())
-				// things with convoi will not be saved
+				// things with consist will not be saved
 				||  (new_obj->get_typ()>=66  &&  new_obj->get_typ()<82)
 				||  (env_t::server  &&  new_obj->get_typ()==obj_t::baum  &&  file->get_version()>=110001)
 			) {
Index: dataobj/objlist.h
===================================================================
--- dataobj/objlist.h	(revision 7957)
+++ dataobj/objlist.h	(working copy)
@@ -48,7 +48,7 @@
 
 	// since this is often needed, it is defined here
 	obj_t * get_leitung() const;
-	obj_t * get_convoi_vehicle() const;
+	obj_t * get_consist_vehicle() const;
 
 	// show all info about the current list and its objects
 	void dump() const;
Index: dataobj/records.cc
===================================================================
--- dataobj/records.cc	(revision 7957)
+++ dataobj/records.cc	(working copy)
@@ -8,7 +8,7 @@
 #include "../player/simplay.h"
 #include "../simcolor.h"
 #include "../simmesg.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../utils/cbuffer_t.h"
 #include "../vehicle/simvehicle.h"
 
@@ -38,10 +38,10 @@
 	max_air_speed.speed = 0;
 }
 
-void records_t::notify_record( convoihandle_t cnv, sint32 max_speed, koord k, uint32 current_month )
+void records_t::notify_record( consist_handle_t cnst, sint32 max_speed, koord k, uint32 current_month )
 {
 	speed_record_t *sr = NULL;
-	switch (cnv->front()->get_waytype()) {
+	switch (cnst->front()->get_waytype()) {
 		case road_wt: sr = &max_road_speed; break;
 		case track_wt:
 		case tram_wt: sr = &max_rail_speed; break;
@@ -53,8 +53,8 @@
 		default: assert(0);
 	}
 
-	// avoid the case of two convois with identical max speed ...
-	if(cnv!=sr->cnv  &&  sr->speed+1==max_speed) {
+	// avoid the case of two consists with identical max speed ...
+	if(cnst!=sr->cnst  &&  sr->speed+1==max_speed) {
 		return;
 	}
 
@@ -61,7 +61,7 @@
 	// really new/faster?
 	if(k!=sr->pos  ||  sr->speed+1<max_speed) {
 		// update it
-		sr->cnv = cnv;
+		sr->cnst = cnst;
 		sr->speed = max_speed-1;
 		sr->year_month = current_month;
 		sr->pos = k;
@@ -68,17 +68,17 @@
 		sr->owner = NULL; // will be set, when accepted
 	}
 	else {
-		sr->cnv = cnv;
+		sr->cnst = cnst;
 		sr->speed = max_speed-1;
 		sr->pos = k;
 
-		// same convoi and same position
+		// same consist and same position
 		if(sr->owner==NULL  &&  current_month!=sr->year_month) {
 			// notify the world of this new record
 			sr->speed = max_speed-1;
-			sr->owner = cnv->get_owner();
+			sr->owner = cnst->get_owner();
 			const char* text;
-			switch (cnv->front()->get_waytype()) {
+			switch (cnst->front()->get_waytype()) {
 				default: NOT_REACHED
 				case road_wt:     text = "New world record for motorcars: %.1f km/h by %s."; break;
 				case track_wt:
@@ -90,7 +90,7 @@
 				case air_wt:      text = "New world record for planes: %.1f km/h by %s.";    break;
 			}
 			cbuffer_t buf;
-			buf.printf( translator::translate(text), speed_to_kmh(10*sr->speed)/10.0, sr->cnv->get_name() );
+			buf.printf( translator::translate(text), speed_to_kmh(10*sr->speed)/10.0, sr->cnst->get_name() );
 			msg->add_message( buf, sr->pos, message_t::new_vehicle, PLAYER_FLAG|sr->owner->get_player_nr() );
 		}
 	}
Index: dataobj/records.h
===================================================================
--- dataobj/records.h	(revision 7957)
+++ dataobj/records.h	(working copy)
@@ -7,7 +7,7 @@
 #define records_h
 
 #include "koord.h"
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 
 class message_t;
 class player_t;
@@ -26,7 +26,7 @@
 	sint32 get_record_speed( waytype_t w ) const;
 
 	/** Posts a message that a new speed record has been set. */
-	void notify_record( convoihandle_t cnv, sint32 max_speed, koord k, uint32 current_month );
+	void notify_record( consist_handle_t cnst, sint32 max_speed, koord k, uint32 current_month );
 
 	/** Resets all speed records. */
 	void clear_speed_records();
@@ -40,13 +40,13 @@
 	 */
 	class speed_record_t {
 	public:
-		convoihandle_t cnv;
+		consist_handle_t cnst;
 		sint32	speed;
 		koord	pos;
 		player_t *owner;  // Owner
 		uint32 year_month;
 
-		speed_record_t() : cnv(), speed(0), pos(koord::invalid), owner(NULL), year_month(0) {}
+		speed_record_t() : cnst(), speed(0), pos(koord::invalid), owner(NULL), year_month(0) {}
 	};
 
 	/// World rail speed record
Index: dataobj/ribi.cc
===================================================================
--- dataobj/ribi.cc	(revision 7957)
+++ dataobj/ribi.cc	(working copy)
@@ -55,7 +55,7 @@
 	northsouth,	// north-south
 	northwest,	// south-east
 	west,		// north-south-east
-	east,		// west
+	east,		// westrueckwaerts 
 	southeast,	// north-west
 	eastwest,	// east-west
 	south,		// north-east-west
Index: dataobj/route.cc
===================================================================
--- dataobj/route.cc	(revision 7957)
+++ dataobj/route.cc	(working copy)
@@ -685,7 +685,7 @@
 		route.append(start); // just to be safe
 		return no_route;
 	}
-	// advance so all convoi fits into a halt (only set for trains and cars)
+	// advance so all consist fits into a halt (only set for trains and cars)
 	else if(  max_len>1  ) {
 
 		// we need a halt of course ...
Index: dataobj/settings.cc
===================================================================
--- dataobj/settings.cc	(revision 7957)
+++ dataobj/settings.cc	(working copy)
@@ -217,7 +217,7 @@
 		startingmoneyperyear[i].interpol = 0;
 	}
 
-	// six month time frame for starting first convoi
+	// six month time frame for starting first consist
 	remove_dummy_player_months = 6;
 
 	// off
Index: display/simview.cc
===================================================================
--- display/simview.cc	(revision 7957)
+++ display/simview.cc	(working copy)
@@ -132,7 +132,7 @@
 	else {
 		// calculate also days if desired
 		uint32 month = welt->get_last_month();
-		const uint32 ticks_this_month = welt->get_zeit_ms() % welt->ticks_per_world_month;
+		const uint32 ticks_this_month = welt->get_ticks() % welt->ticks_per_world_month;
 		uint32 stunden2;
 		if (env_t::show_month > env_t::DATE_FMT_MONTH) {
 			static sint32 tage_per_month[12]={31,28,31,30,31,30,31,31,30,31,30,31};
Index: display/viewport.cc
===================================================================
--- display/viewport.cc	(revision 7957)
+++ display/viewport.cc	(working copy)
@@ -99,10 +99,10 @@
 
 
 // change the center viewport position for a certain ground tile
-// any possible convoi to follow will be disabled
+// any possible consist to follow will be disabled
 void viewport_t::change_world_position( const koord3d& new_ij )
 {
-	follow_convoi = convoihandle_t();
+	follow_consist = consist_handle_t();
 	change_world_position( get_map2d_coord( new_ij ) );
 }
 
@@ -320,7 +320,7 @@
 	this->world = world;
 	assert(world);
 
-	follow_convoi = convoihandle_t();
+	follow_consist = consist_handle_t();
 
 	this->ij_off = ij_off;
 	this->x_off = x_off;
Index: display/viewport.h
===================================================================
--- display/viewport.h	(revision 7957)
+++ display/viewport.h	(working copy)
@@ -11,7 +11,7 @@
 #include "scr_coord.h"
 #include "../dataobj/koord.h"
 #include "../dataobj/koord3d.h"
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 
 class karte_t;
 class grund_t;
@@ -83,10 +83,10 @@
 	void set_viewport_ij_offset( const koord &k );
 
 	/*
-	 * The current convoi to follow.
+	 * The current consist to follow.
 	 * @author prissi
 	 */
-	convoihandle_t follow_convoi;
+	consist_handle_t follow_consist;
 
 	/**
 	 * Converts map_coord to map2d_coord actually used for main view.
@@ -238,14 +238,14 @@
 	 */
 
 	/**
-	 * Function for following a convoi on the map give an unbound handle to unset.
+	 * Function for following a consist on the map give an unbound handle to unset.
 	 */
-	void set_follow_convoi(convoihandle_t cnv) { follow_convoi = cnv; }
+	void set_follow_consist(consist_handle_t cnst) { follow_consist = cnst; }
 
 	/**
-	 * Returns the convoi this viewport is following (if any).
+	 * Returns the consist this viewport is following (if any).
 	 */
-	convoihandle_t get_follow_convoi() const { return follow_convoi; }
+	consist_handle_t get_follow_consist() const { return follow_consist; }
 
 	/**
 	 * @}
Index: freight_list_sorter.cc
===================================================================
--- freight_list_sorter.cc	(revision 7957)
+++ freight_list_sorter.cc	(working copy)
@@ -97,7 +97,7 @@
 	}
 	buf.printf("%u", sum);
 	if(  max != 0  ) {
-		// convois
+		// consists
 		buf.printf("/%u", max);
 	}
 	ware_besch_t const& desc = *ware->get_besch();
Index: freight_list_sorter.h
===================================================================
--- freight_list_sorter.h	(revision 7957)
+++ freight_list_sorter.h	(working copy)
@@ -1,7 +1,7 @@
 #ifndef freight_list_sorter_h
 #define freight_list_sorter_h
 
-// same sorting for stations and vehicle/convoi freight ...
+// same sorting for stations and vehicle/consist freight ...
 
 #include "simtypes.h"
 
Index: gui/depot_frame.cc
===================================================================
--- gui/depot_frame.cc	(revision 7957)
+++ gui/depot_frame.cc	(working copy)
@@ -6,7 +6,7 @@
  */
 
 /*
- * The depot window, where to buy convois
+ * The depot window, where to buy consists
  */
 
 #include <stdio.h>
@@ -14,7 +14,7 @@
 #include "../simunits.h"
 #include "../simworld.h"
 #include "../vehicle/simvehicle.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simdepot.h"
 #include "simwin.h"
 #include "../simcolor.h"
@@ -31,7 +31,7 @@
 #include "fahrplan_gui.h"
 #include "line_management_gui.h"
 #include "line_item.h"
-#include "convoy_item.h"
+#include "consist_item.h"
 #include "components/gui_image_list.h"
 #include "messagebox.h"
 #include "depot_frame.h"
@@ -75,11 +75,11 @@
 depot_frame_t::depot_frame_t(depot_t* depot) :
 	gui_frame_t( translator::translate(depot->get_name()), depot->get_owner()),
 	depot(depot),
-	icnv(depot->convoi_count()-1),
-	lb_convoi_line("Serves Line:", SYSCOL_TEXT, gui_label_t::left),
+	icnv(depot->consist_count()-1),
+	lb_consist_line("Serves Line:", SYSCOL_TEXT, gui_label_t::left),
 	lb_veh_action("Fahrzeuge:", SYSCOL_TEXT, gui_label_t::right),
-	convoi_pics(depot->get_max_convoi_length()),
-	convoi(&convoi_pics),
+	consist_pics(depot->get_max_consist_length()),
+	consist(&consist_pics),
 	pas(&pas_vec),
 	electrics(&electrics_vec),
 	loks(&loks_vec),
@@ -92,7 +92,7 @@
 {
 	scr_size size = scr_size(0,0);
 
-DBG_DEBUG("depot_frame_t::depot_frame_t()","get_max_convoi_length()=%i",depot->get_max_convoi_length());
+DBG_DEBUG("depot_frame_t::depot_frame_t()","get_max_consist_length()=%i",depot->get_max_consist_length());
 	last_selected_line = depot->get_last_selected_line();
 	no_schedule_text     = translator::translate("<no schedule set>");
 	clear_schedule_text  = translator::translate("<clear schedule>");
@@ -99,17 +99,17 @@
 	unique_schedule_text = translator::translate("<individual schedule>");
 	new_line_text        = translator::translate("<create new line>");
 	line_seperator       = translator::translate("--------------------------------");
-	new_convoy_text      = translator::translate("new convoi");
+	new_consist_text      = translator::translate("new consist");
 	promote_to_line_text = translator::translate("<promote to line>");
 
 	/*
 	* [SELECT]:
 	*/
-	add_component(&lb_convois);
+	add_component(&lb_consists);
 
-	convoy_selector.add_listener(this);
-	convoy_selector.set_highlight_color( depot->get_owner()->get_player_color1() + 1);
-	add_component(&convoy_selector);
+	consist_selector.add_listener(this);
+	consist_selector.set_highlight_color( depot->get_owner()->get_player_color1() + 1);
+	add_component(&consist_selector);
 
 	/*
 	* [SELECT ROUTE]:
@@ -129,33 +129,33 @@
 	/*
 	* [CONVOI]
 	*/
-	convoi.set_player_nr(depot->get_player_nr());
-	convoi.add_listener(this);
+	consist.set_player_nr(depot->get_player_nr());
+	consist.add_listener(this);
 
-	add_component(&convoi);
-	add_component(&lb_convoi_count);
-	add_component(&lb_convoi_speed);
-	add_component(&lb_convoi_cost);
-	add_component(&lb_convoi_value);
-	add_component(&lb_convoi_line);
-	add_component(&lb_convoi_power);
-	add_component(&lb_convoi_weight);
-	add_component(&cont_convoi_capacity);
+	add_component(&consist);
+	add_component(&lb_consist_count);
+	add_component(&lb_consist_speed);
+	add_component(&lb_consist_cost);
+	add_component(&lb_consist_value);
+	add_component(&lb_consist_line);
+	add_component(&lb_consist_power);
+	add_component(&lb_consist_weight);
+	add_component(&cont_consist_capacity);
 
-	sb_convoi_length.set_base( depot->get_max_convoi_length() * CARUNITS_PER_TILE / 2 - 1);
-	sb_convoi_length.set_vertical(false);
-	convoi_length_ok_sb = 0;
-	convoi_length_slower_sb = 0;
-	convoi_length_too_slow_sb = 0;
-	convoi_tile_length_sb = 0;
+	sb_consist_length.set_base( depot->get_max_consist_length() * CARUNITS_PER_TILE / 2 - 1);
+	sb_consist_length.set_vertical(false);
+	consist_length_ok_sb = 0;
+	consist_length_slower_sb = 0;
+	consist_length_too_slow_sb = 0;
+	consist_tile_length_sb = 0;
 	new_vehicle_length_sb = 0;
-	if(  depot->get_typ() != depot_t::schiffdepot  &&  depot->get_typ() != depot_t::airdepot  ) { // no convoy length bar for ships or aircraft
-		sb_convoi_length.add_color_value(&convoi_tile_length_sb, COL_BROWN);
-		sb_convoi_length.add_color_value(&new_vehicle_length_sb, COL_DARK_GREEN);
-		sb_convoi_length.add_color_value(&convoi_length_ok_sb, COL_GREEN);
-		sb_convoi_length.add_color_value(&convoi_length_slower_sb, COL_ORANGE);
-		sb_convoi_length.add_color_value(&convoi_length_too_slow_sb, COL_RED);
-		add_component(&sb_convoi_length);
+	if(  depot->get_typ() != depot_t::schiffdepot  &&  depot->get_typ() != depot_t::airdepot  ) { // no consist length bar for ships or aircraft
+		sb_consist_length.add_color_value(&consist_tile_length_sb, COL_BROWN);
+		sb_consist_length.add_color_value(&new_vehicle_length_sb, COL_DARK_GREEN);
+		sb_consist_length.add_color_value(&consist_length_ok_sb, COL_GREEN);
+		sb_consist_length.add_color_value(&consist_length_slower_sb, COL_ORANGE);
+		sb_consist_length.add_color_value(&consist_length_too_slow_sb, COL_RED);
+		add_component(&sb_consist_length);
 	}
 
 	/*
@@ -171,10 +171,10 @@
 	bt_schedule.set_tooltip("Give the selected vehicle(s) an individual schedule"); // translated to "Edit the selected vehicle(s) individual schedule or assigned line"
 	add_component(&bt_schedule);
 
-	bt_copy_convoi.set_typ(button_t::roundbox);
-	bt_copy_convoi.add_listener(this);
-	bt_copy_convoi.set_tooltip("Copy the selected convoi and its schedule or line");
-	add_component(&bt_copy_convoi);
+	bt_copy_consist.set_typ(button_t::roundbox);
+	bt_copy_consist.add_listener(this);
+	bt_copy_consist.set_tooltip("Copy the selected consist and its schedule or line");
+	add_component(&bt_copy_consist);
 
 	bt_sell.set_typ(button_t::roundbox);
 	bt_sell.add_listener(this);
@@ -232,13 +232,13 @@
 	build_vehicle_lists();
 
 	// text will be translated by ourselves (after update data)!
-	lb_convois.set_text_pointer( txt_convois );
-	lb_convoi_count.set_text_pointer( txt_convoi_count );
-	lb_convoi_speed.set_text_pointer( txt_convoi_speed );
-	lb_convoi_cost.set_text_pointer( txt_convoi_cost );
-	lb_convoi_value.set_text_pointer( txt_convoi_value );
-	lb_convoi_power.set_text_pointer( txt_convoi_power );
-	lb_convoi_weight.set_text_pointer( txt_convoi_weight );
+	lb_consists.set_text_pointer( txt_consists );
+	lb_consist_count.set_text_pointer( txt_consist_count );
+	lb_consist_speed.set_text_pointer( txt_consist_speed );
+	lb_consist_cost.set_text_pointer( txt_consist_cost );
+	lb_consist_value.set_text_pointer( txt_consist_value );
+	lb_consist_power.set_text_pointer( txt_consist_power );
+	lb_consist_weight.set_text_pointer( txt_consist_weight );
 
 	// Bolt image for electrified depots:
 	add_component(&img_bolt);
@@ -308,9 +308,9 @@
 	*
 	*	Main structure are these parts from top to bottom:
 	*
-	*	    [SELECT]		convoi-selector
-	*	    [CONVOI]		current convoi
-	*	    [ACTIONS]		convoi action buttons
+	*	    [SELECT]		consist-selector
+	*	    [CONVOI]		current consist
+	*	    [ACTIONS]		consist action buttons
 	*	    [PANEL]		vehicle panel
 	*	    [VINFO]		vehicle infotext
 	*
@@ -323,11 +323,11 @@
 	*  PREV and NEXT are small buttons - Label is adjusted to total width.
 	*/
 	const scr_coord_val SELECT_HEIGHT = 14;
-	const scr_coord_val selector_x = max(max(max(max(max(102, proportional_string_width(translator::translate("no convois")) + 4),
-		proportional_string_width(translator::translate("1 convoi")) + 4),
-		proportional_string_width(translator::translate("%d convois")) + 4),
-		proportional_string_width(translator::translate("convoi %d of %d")) + 4),
-		line_button.get_size().w + 2 + proportional_string_width(translator::translate(lb_convoi_line.get_text_pointer())) + 4
+	const scr_coord_val selector_x = max(max(max(max(max(102, proportional_string_width(translator::translate("no consists")) + 4),
+		proportional_string_width(translator::translate("1 consist")) + 4),
+		proportional_string_width(translator::translate("%d consists")) + 4),
+		proportional_string_width(translator::translate("consist %d of %d")) + 4),
+		line_button.get_size().w + 2 + proportional_string_width(translator::translate(lb_consist_line.get_text_pointer())) + 4
 		);
 
 	/*
@@ -338,7 +338,7 @@
 	*
 	* The image list is horizontally "condensed".
 	*/
-	const scr_coord_val CLIST_WIDTH = depot->get_max_convoi_length() * (grid.x - grid_dx) + 2 * gui_image_list_t::BORDER;
+	const scr_coord_val CLIST_WIDTH = depot->get_max_consist_length() * (grid.x - grid_dx) + 2 * gui_image_list_t::BORDER;
 	const scr_coord_val CLIST_HEIGHT = grid.y + 2 * gui_image_list_t::BORDER + 5;
 	const scr_coord_val CINFO_HEIGHT = LINESPACE * 4 + 1;
 	const scr_coord_val CONVOI_WIDTH = CLIST_WIDTH + placement_dx;
@@ -413,12 +413,12 @@
 	/*
 	 * [SELECT]:
 	 */
-	lb_convois.set_pos(scr_coord(D_MARGIN_LEFT, SELECT_VSTART + 3));
-	lb_convois.set_width( selector_x - D_H_SPACE );
+	lb_consists.set_pos(scr_coord(D_MARGIN_LEFT, SELECT_VSTART + 3));
+	lb_consists.set_width( selector_x - D_H_SPACE );
 
-	convoy_selector.set_pos(scr_coord(D_MARGIN_LEFT + selector_x, SELECT_VSTART));
-	convoy_selector.set_size(scr_size(DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT - selector_x, D_BUTTON_HEIGHT));
-	convoy_selector.set_max_size(scr_size(DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT - selector_x, LINESPACE * 13 + 2 + 16));
+	consist_selector.set_pos(scr_coord(D_MARGIN_LEFT + selector_x, SELECT_VSTART));
+	consist_selector.set_size(scr_size(DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT - selector_x, D_BUTTON_HEIGHT));
+	consist_selector.set_max_size(scr_size(DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT - selector_x, LINESPACE * 13 + 2 + 16));
 
 	/*
 	 * [SELECT ROUTE]:
@@ -425,8 +425,8 @@
 	 * @author hsiegeln
 	 */
 	line_button.set_pos(scr_coord(D_MARGIN_LEFT, SELECT_VSTART + D_BUTTON_HEIGHT + 3));
-	lb_convoi_line.set_pos(scr_coord(D_MARGIN_LEFT + line_button.get_size().w + 2, SELECT_VSTART + D_BUTTON_HEIGHT + 3));
-	lb_convoi_line.set_width( selector_x - line_button.get_size().w - 2 - D_H_SPACE );
+	lb_consist_line.set_pos(scr_coord(D_MARGIN_LEFT + line_button.get_size().w + 2, SELECT_VSTART + D_BUTTON_HEIGHT + 3));
+	lb_consist_line.set_width( selector_x - line_button.get_size().w - 2 - D_H_SPACE );
 
 	line_selector.set_pos(scr_coord(D_MARGIN_LEFT + selector_x, SELECT_VSTART + D_BUTTON_HEIGHT));
 	line_selector.set_size(scr_size(DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT - selector_x, D_BUTTON_HEIGHT));
@@ -435,31 +435,31 @@
 	/*
 	 * [CONVOI]
 	 */
-	convoi.set_grid(scr_coord(grid.x - grid_dx, grid.y));
-	convoi.set_placement(scr_coord(placement.x - placement_dx, placement.y));
-	convoi.set_pos(scr_coord((DEPOT_FRAME_WIDTH-CLIST_WIDTH) / 2, CONVOI_VSTART));
-	convoi.set_size(scr_size(CLIST_WIDTH, CLIST_HEIGHT));
+	consist.set_grid(scr_coord(grid.x - grid_dx, grid.y));
+	consist.set_placement(scr_coord(placement.x - placement_dx, placement.y));
+	consist.set_pos(scr_coord((DEPOT_FRAME_WIDTH-CLIST_WIDTH) / 2, CONVOI_VSTART));
+	consist.set_size(scr_size(CLIST_WIDTH, CLIST_HEIGHT));
 
-	sb_convoi_length.set_pos(scr_coord((DEPOT_FRAME_WIDTH-CLIST_WIDTH) / 2 + 5,CONVOI_VSTART + grid.y + 5));
-	sb_convoi_length.set_size(scr_size(CLIST_WIDTH - 10, 4));
+	sb_consist_length.set_pos(scr_coord((DEPOT_FRAME_WIDTH-CLIST_WIDTH) / 2 + 5,CONVOI_VSTART + grid.y + 5));
+	sb_consist_length.set_size(scr_size(CLIST_WIDTH - 10, 4));
 
-	lb_convoi_count.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART));
-	lb_convoi_count.set_width( second_column_w - D_H_SPACE );
-	cont_convoi_capacity.set_pos(scr_coord(second_column_x, CINFO_VSTART));
-	cont_convoi_capacity.set_width(second_column_w);
+	lb_consist_count.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART));
+	lb_consist_count.set_width( second_column_w - D_H_SPACE );
+	cont_consist_capacity.set_pos(scr_coord(second_column_x, CINFO_VSTART));
+	cont_consist_capacity.set_width(second_column_w);
 
-	lb_convoi_cost.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 1));
-	lb_convoi_cost.set_width( second_column_w - D_H_SPACE );
-	lb_convoi_value.set_pos(scr_coord(second_column_x, CINFO_VSTART + LINESPACE * 1));
-	lb_convoi_value.set_width(second_column_w);
+	lb_consist_cost.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 1));
+	lb_consist_cost.set_width( second_column_w - D_H_SPACE );
+	lb_consist_value.set_pos(scr_coord(second_column_x, CINFO_VSTART + LINESPACE * 1));
+	lb_consist_value.set_width(second_column_w);
 
-	lb_convoi_power.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 2));
-	lb_convoi_power.set_width( second_column_w - D_H_SPACE );
-	lb_convoi_weight.set_pos(scr_coord(second_column_x, CINFO_VSTART + LINESPACE * 2));
-	lb_convoi_weight.set_width(second_column_w);
+	lb_consist_power.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 2));
+	lb_consist_power.set_width( second_column_w - D_H_SPACE );
+	lb_consist_weight.set_pos(scr_coord(second_column_x, CINFO_VSTART + LINESPACE * 2));
+	lb_consist_weight.set_width(second_column_w);
 
-	lb_convoi_speed.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 3));
-	lb_convoi_speed.set_width( DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT );
+	lb_consist_speed.set_pos(scr_coord(D_MARGIN_LEFT, CINFO_VSTART + LINESPACE * 3));
+	lb_consist_speed.set_width( DEPOT_FRAME_WIDTH - D_MARGIN_RIGHT - D_MARGIN_LEFT );
 
 	/*
 	 * [ACTIONS]
@@ -472,9 +472,9 @@
 	bt_schedule.set_size(scr_size((DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 2 / 4 - (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) / 4 - 3, D_BUTTON_HEIGHT));
 	bt_schedule.set_text("Fahrplan");
 
-	bt_copy_convoi.set_pos(scr_coord(D_MARGIN_LEFT + (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 2 / 4 + 2, ACTIONS_VSTART));
-	bt_copy_convoi.set_size(scr_size((DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 3 / 4 - (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 2 / 4 - 3, D_BUTTON_HEIGHT));
-	bt_copy_convoi.set_text("Copy Convoi");
+	bt_copy_consist.set_pos(scr_coord(D_MARGIN_LEFT + (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 2 / 4 + 2, ACTIONS_VSTART));
+	bt_copy_consist.set_size(scr_size((DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 3 / 4 - (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 2 / 4 - 3, D_BUTTON_HEIGHT));
+	bt_copy_consist.set_text("Copy Convoi");
 
 	bt_sell.set_pos(scr_coord(D_MARGIN_LEFT + (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 3 / 4 + 3, ACTIONS_VSTART));
 	bt_sell.set_size(scr_size((DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) - (DEPOT_FRAME_WIDTH - D_MARGIN_LEFT - D_MARGIN_RIGHT) * 3 / 4 - 3, D_BUTTON_HEIGHT));
@@ -567,11 +567,11 @@
 }
 
 
-void depot_frame_t::activate_convoi( convoihandle_t c )
+void depot_frame_t::activate_consist( consist_handle_t c )
 {
 	icnv = -1;	// deselect
-	for(  uint i = 0;  i < depot->convoi_count();  i++  ) {
-		if(  c == depot->get_convoi(i)  ) {
+	for(  uint i = 0;  i < depot->consist_count();  i++  ) {
+		if(  c == depot->get_consist(i)  ) {
 			icnv = i;
 			break;
 		}
@@ -690,9 +690,9 @@
 		// list only matching ones
 		FOR(slist_tpl<vehikel_besch_t const*>, const info, depot->get_vehicle_type()) {
 			const vehikel_besch_t *veh = NULL;
-			convoihandle_t cnv = depot->get_convoi(icnv);
-			if(cnv.is_bound() && cnv->get_vehicle_count()>0) {
-				veh = (veh_action == va_insert ? cnv->front() : cnv->back())->get_besch();
+			consist_handle_t cnst = depot->get_consist(icnv);
+			if(cnst.is_bound() && cnst->get_vehicle_count()>0) {
+				veh = (veh_action == va_insert ? cnst->front() : cnst->back())->get_besch();
 			}
 
 			// current vehicle
@@ -735,27 +735,27 @@
 
 	bt_veh_action.set_text(txt_veh_action[veh_action]);
 
-	txt_convois.clear();
-	switch(  depot->convoi_count()  ) {
+	txt_consists.clear();
+	switch(  depot->consist_count()  ) {
 		case 0: {
-			txt_convois.append( translator::translate("no convois") );
+			txt_consists.append( translator::translate("no consists") );
 			break;
 		}
 		case 1: {
 			if(  icnv == -1  ) {
-				txt_convois.append( translator::translate("1 convoi") );
+				txt_consists.append( translator::translate("1 consist") );
 			}
 			else {
-				txt_convois.printf( translator::translate("convoi %d of %d"), icnv + 1, depot->convoi_count() );
+				txt_consists.printf( translator::translate("consist %d of %d"), icnv + 1, depot->consist_count() );
 			}
 			break;
 		}
 		default: {
 			if(  icnv == -1  ) {
-				txt_convois.printf( translator::translate("%d convois"), depot->convoi_count() );
+				txt_consists.printf( translator::translate("%d consists"), depot->consist_count() );
 			}
 			else {
-				txt_convois.printf( translator::translate("convoi %d of %d"), icnv + 1, depot->convoi_count() );
+				txt_consists.printf( translator::translate("consist %d of %d"), icnv + 1, depot->consist_count() );
 			}
 			break;
 		}
@@ -764,60 +764,60 @@
 	/*
 	* Reset counts and check for valid vehicles
 	*/
-	convoihandle_t cnv = depot->get_convoi( icnv );
+	consist_handle_t cnst = depot->get_consist( icnv );
 
-	// update convoy selector
-	convoy_selector.clear_elements();
-	convoy_selector.append_element( new gui_scrolled_list_t::const_text_scrollitem_t( new_convoy_text, SYSCOL_TEXT ) );
-	convoy_selector.set_selection(0);
+	// update consist selector
+	consist_selector.clear_elements();
+	consist_selector.append_element( new gui_scrolled_list_t::const_text_scrollitem_t( new_consist_text, SYSCOL_TEXT ) );
+	consist_selector.set_selection(0);
 
-	// check all matching convoys
-	FOR(slist_tpl<convoihandle_t>, const c, depot->get_convoy_list()) {
-		convoy_selector.append_element( new convoy_scrollitem_t(c) );
-		if(  cnv.is_bound()  &&  c == cnv  ) {
-			convoy_selector.set_selection( convoy_selector.count_elements() - 1 );
+	// check all matching consists
+	FOR(slist_tpl<consist_handle_t>, const c, depot->get_consist_list()) {
+		consist_selector.append_element( new consist_scrollitem_t(c) );
+		if(  cnst.is_bound()  &&  c == cnst  ) {
+			consist_selector.set_selection( consist_selector.count_elements() - 1 );
 		}
 	}
 
 	const vehikel_besch_t *veh = NULL;
 
-	clear_ptr_vector( convoi_pics );
-	if(  cnv.is_bound()  &&  cnv->get_vehicle_count() > 0  ) {
-		for(  unsigned i=0;  i < cnv->get_vehicle_count();  i++  ) {
+	clear_ptr_vector( consist_pics );
+	if(  cnst.is_bound()  &&  cnst->get_vehicle_count() > 0  ) {
+		for(  unsigned i=0;  i < cnst->get_vehicle_count();  i++  ) {
 			// just make sure, there is this vehicle also here!
-			const vehikel_besch_t *info=cnv->get_vehikel(i)->get_besch();
+			const vehikel_besch_t *info=cnst->get_vehikel(i)->get_besch();
 			if(  vehicle_map.get( info ) == NULL  ) {
 				add_to_vehicle_list( info );
 			}
 
 			gui_image_list_t::image_data_t* img_data = new gui_image_list_t::image_data_t(info->get_name(), info->get_basis_bild());
-			convoi_pics.append(img_data);
+			consist_pics.append(img_data);
 		}
 
-		/* color bars for current convoi: */
-		convoi_pics[0]->lcolor = cnv->front()->get_besch()->can_follow(NULL) ? COL_GREEN : COL_YELLOW;
+		/* color bars for current consist: */
+		consist_pics[0]->lcolor = cnst->front()->get_besch()->can_follow(NULL) ? COL_GREEN : COL_YELLOW;
 		{
 			unsigned i;
-			for(  i = 1;  i < cnv->get_vehicle_count();  i++  ) {
-				convoi_pics[i - 1]->rcolor = cnv->get_vehikel(i-1)->get_besch()->can_lead(cnv->get_vehikel(i)->get_besch()) ? COL_GREEN : COL_RED;
-				convoi_pics[i]->lcolor     = cnv->get_vehikel(i)->get_besch()->can_follow(cnv->get_vehikel(i-1)->get_besch()) ? COL_GREEN : COL_RED;
+			for(  i = 1;  i < cnst->get_vehicle_count();  i++  ) {
+				consist_pics[i - 1]->rcolor = cnst->get_vehikel(i-1)->get_besch()->can_lead(cnst->get_vehikel(i)->get_besch()) ? COL_GREEN : COL_RED;
+				consist_pics[i]->lcolor     = cnst->get_vehikel(i)->get_besch()->can_follow(cnst->get_vehikel(i-1)->get_besch()) ? COL_GREEN : COL_RED;
 			}
-			convoi_pics[i - 1]->rcolor = cnv->get_vehikel(i-1)->get_besch()->can_lead(NULL) ? COL_GREEN : COL_YELLOW;
+			consist_pics[i - 1]->rcolor = cnst->get_vehikel(i-1)->get_besch()->can_lead(NULL) ? COL_GREEN : COL_YELLOW;
 		}
 
 		// change green into blue for vehicles that are not available
-		for(  unsigned i = 0;  i < cnv->get_vehicle_count();  i++  ) {
-			if(  !cnv->get_vehikel(i)->get_besch()->is_available(month_now)  ) {
-				if(  convoi_pics[i]->lcolor == COL_GREEN  ) {
-					convoi_pics[i]->lcolor = COL_BLUE;
+		for(  unsigned i = 0;  i < cnst->get_vehicle_count();  i++  ) {
+			if(  !cnst->get_vehikel(i)->get_besch()->is_available(month_now)  ) {
+				if(  consist_pics[i]->lcolor == COL_GREEN  ) {
+					consist_pics[i]->lcolor = COL_BLUE;
 				}
-				if(  convoi_pics[i]->rcolor == COL_GREEN  ) {
-					convoi_pics[i]->rcolor = COL_BLUE;
+				if(  consist_pics[i]->rcolor == COL_GREEN  ) {
+					consist_pics[i]->rcolor = COL_BLUE;
 				}
 			}
 		}
 
-		veh = (veh_action == va_insert ? cnv->front() : cnv->back())->get_besch();
+		veh = (veh_action == va_insert ? cnst->front() : cnst->back())->get_besch();
 	}
 
 	FOR(vehicle_image_map, const& i, vehicle_map) {
@@ -830,7 +830,7 @@
 		img.rcolor = ok_color;
 
 		/*
-		* color bars for current convoi:
+		* color bars for current consist:
 		*  green/green	okay to append/insert
 		*  red/red		cannot be appended/inserted
 		*  green/yellow	append okay, cannot be end of train
@@ -894,8 +894,8 @@
 	if(  last_selected_line.is_bound()  ) {
 		line_selector.insert_element( new line_scrollitem_t( last_selected_line ) );
 	}
-	if(  cnv.is_bound()  &&  cnv->get_schedule()  &&  !cnv->get_schedule()->empty()  ) {
-		if(  cnv->get_line().is_bound()  ) {
+	if(  cnst.is_bound()  &&  cnst->get_schedule()  &&  !cnst->get_schedule()->empty()  ) {
+		if(  cnst->get_line().is_bound()  ) {
 			line_selector.insert_element( new gui_scrolled_list_t::const_text_scrollitem_t( new_line_text, SYSCOL_TEXT ) );
 			line_selector.insert_element( new gui_scrolled_list_t::const_text_scrollitem_t( clear_schedule_text, SYSCOL_TEXT ) );
 		}
@@ -915,8 +915,8 @@
 	line_selector.append_element( new gui_scrolled_list_t::const_text_scrollitem_t( line_seperator, SYSCOL_TEXT ) );
 
 	// check all matching lines
-	if(  cnv.is_bound()  ) {
-		selected_line = cnv->get_line();
+	if(  cnst.is_bound()  ) {
+		selected_line = cnst->get_line();
 	}
 	vector_tpl<linehandle_t> lines;
 	get_line_list(depot, &lines);
@@ -965,33 +965,33 @@
 {
 	if(  bild_data->lcolor != COL_RED  &&  bild_data->rcolor != COL_RED  ) {
 		if(  veh_action == va_sell  ) {
-			depot->call_depot_tool('s', convoihandle_t(), bild_data->text );
+			depot->call_depot_tool('s', consist_handle_t(), bild_data->text );
 		}
 		else {
-			convoihandle_t cnv = depot->get_convoi( icnv );
-			if(  !cnv.is_bound()  &&   !depot->get_owner()->is_locked()  ) {
-				// adding new convoi, block depot actions until command executed
-				// otherwise in multiplayer it's likely multiple convois get created
-				// rather than one new convoi with multiple vehicles
+			consist_handle_t cnst = depot->get_consist( icnv );
+			if(  !cnst.is_bound()  &&   !depot->get_owner()->is_locked()  ) {
+				// adding new consist, block depot actions until command executed
+				// otherwise in multiplayer it's likely multiple consists get created
+				// rather than one new consist with multiple vehicles
 				depot->set_command_pending();
 			}
-			depot->call_depot_tool( veh_action == va_insert ? 'i' : 'a', cnv, bild_data->text );
+			depot->call_depot_tool( veh_action == va_insert ? 'i' : 'a', cnst, bild_data->text );
 		}
 	}
 }
 
 
-void depot_frame_t::image_from_convoi_list(uint nr, bool to_end)
+void depot_frame_t::image_from_consist_list(uint nr, bool to_end)
 {
-	const convoihandle_t cnv = depot->get_convoi( icnv );
-	if(  cnv.is_bound()  &&  nr < cnv->get_vehicle_count()  ) {
+	const consist_handle_t cnst = depot->get_consist( icnv );
+	if(  cnst.is_bound()  &&  nr < cnst->get_vehicle_count()  ) {
 		// we remove all connected vehicles together!
 		// find start
 		unsigned start_nr = nr;
 		while(  start_nr > 0  ) {
 			start_nr--;
-			const vehikel_besch_t *info = cnv->get_vehikel(start_nr)->get_besch();
-			if(  info->get_nachfolger_count() != 1  ) {
+			const vehikel_besch_t *info = cnst->get_vehikel(start_nr)->get_besch();
+			if(  info->get_trailing_count() != 1  ) {
 				start_nr++;
 				break;
 			}
@@ -1001,7 +1001,7 @@
 		start.printf("%u", start_nr);
 
 		const char tool = to_end ? 'R' : 'r';
-		depot->call_depot_tool( tool, cnv, start );
+		depot->call_depot_tool( tool, cnst, start );
 	}
 }
 
@@ -1008,7 +1008,7 @@
 
 bool depot_frame_t::action_triggered( gui_action_creator_t *comp, value_t p)
 {
-	convoihandle_t cnv = depot->get_convoi( icnv );
+	consist_handle_t cnst = depot->get_consist( icnv );
 
 	if(  depot->is_command_pending()  ) {
 		// block new commands until last command is executed
@@ -1017,12 +1017,12 @@
 
 	if(  comp != NULL  ) {	// message from outside!
 		if(  comp == &bt_start  ) {
-			if(  cnv.is_bound()  ) {
+			if(  cnst.is_bound()  ) {
 				//first: close schedule (will update schedule on clients)
-				destroy_win( (ptrdiff_t)cnv->get_schedule() );
+				destroy_win( (ptrdiff_t)cnst->get_schedule() );
 				// only then call the tool to start
 				char tool = event_get_last_control_shift() == 2 ? 'B' : 'b'; // start all with CTRL-click
-				depot->call_depot_tool( tool, cnv, NULL);
+				depot->call_depot_tool( tool, cnst, NULL);
 			}
 		}
 		else if(  comp == &bt_schedule  ) {
@@ -1029,13 +1029,13 @@
 			if(  line_selector.get_selection() == 1  &&  !line_selector.is_dropped()  ) { // create new line
 				// promote existing individual schedule to line
 				cbuffer_t buf;
-				if(  cnv.is_bound()  &&  !selected_line.is_bound()  ) {
-					schedule_t* fpl = cnv->get_schedule();
+				if(  cnst.is_bound()  &&  !selected_line.is_bound()  ) {
+					schedule_t* fpl = cnst->get_schedule();
 					if(  fpl  ) {
 						fpl->sprintf_schedule( buf );
 					}
 				}
-				depot->call_depot_tool('l', convoihandle_t(), buf);
+				depot->call_depot_tool('l', consist_handle_t(), buf);
 				return true;
 			}
 			else {
@@ -1044,17 +1044,17 @@
 			}
 		}
 		else if(  comp == &line_button  ) {
-			if(  cnv.is_bound()  ) {
-				cnv->get_owner()->simlinemgmt.show_lineinfo( cnv->get_owner(), cnv->get_line() );
+			if(  cnst.is_bound()  ) {
+				cnst->get_owner()->simlinemgmt.show_lineinfo( cnst->get_owner(), cnst->get_line() );
 				welt->set_dirty();
 			}
 		}
 		else if(  comp == &bt_sell  ) {
-			depot->call_depot_tool('v', cnv, NULL);
+			depot->call_depot_tool('v', cnst, NULL);
 		}
 		// image list selection here ...
-		else if(  comp == &convoi  ) {
-			image_from_convoi_list( p.i, last_meta_event_get_class() == EVENT_DOUBLE_CLICK);
+		else if(  comp == &consist  ) {
+			image_from_consist_list( p.i, last_meta_event_get_class() == EVENT_DOUBLE_CLICK);
 		}
 		else if(  comp == &pas  &&  last_meta_event_get_class() != EVENT_DOUBLE_CLICK  ) {
 			image_from_storage_list(pas_vec[p.i]);
@@ -1068,7 +1068,7 @@
 		else if(  comp == &waggons  &&  last_meta_event_get_class() != EVENT_DOUBLE_CLICK  ) {
 			image_from_storage_list(waggons_vec[p.i]);
 		}
-		// convoi filters
+		// consist filters
 		else if(  comp == &bt_obsolete  ) {
 			show_retired_vehicles = (show_retired_vehicles == 0);
 			depot_t::update_all_win();
@@ -1085,10 +1085,10 @@
 				veh_action = veh_action + 1;
 			}
 		}
-		else if(  comp == &bt_copy_convoi  ) {
-			if(  cnv.is_bound()  ) {
-				if(  !welt->use_timeline()  ||  welt->get_settings().get_allow_buying_obsolete_vehicles()  ||  depot->check_obsolete_inventory( cnv )  ) {
-					depot->call_depot_tool('c', cnv, NULL);
+		else if(  comp == &bt_copy_consist  ) {
+			if(  cnst.is_bound()  ) {
+				if(  !welt->use_timeline()  ||  welt->get_settings().get_allow_buying_obsolete_vehicles()  ||  depot->check_obsolete_inventory( cnst )  ) {
+					depot->call_depot_tool('c', cnst, NULL);
 				}
 				else {
 					create_win( new news_img("Can't buy obsolete vehicles!"), w_time_delete, magic_none );
@@ -1096,13 +1096,13 @@
 			}
 			return true;
 		}
-		else if(  comp == &convoy_selector  ) {
+		else if(  comp == &consist_selector  ) {
 			icnv = p.i - 1;
-			if(  !depot->get_convoi(icnv).is_bound()  ) {
+			if(  !depot->get_consist(icnv).is_bound()  ) {
 				set_focus( NULL );
 			}
 			else {
-				set_focus( (gui_component_t *)&convoy_selector );
+				set_focus( (gui_component_t *)&consist_selector );
 			}
 		}
 		else if(  comp == &line_selector  ) {
@@ -1122,8 +1122,8 @@
 				if(  line_selector.is_dropped()  ) { // but not from next/prev buttons
 					// promote existing individual schedule to line
 					cbuffer_t buf;
-					if(  cnv.is_bound()  &&  !selected_line.is_bound()  ) {
-						schedule_t* fpl = cnv->get_schedule();
+					if(  cnst.is_bound()  &&  !selected_line.is_bound()  ) {
+						schedule_t* fpl = cnst->get_schedule();
 						if(  fpl  ) {
 							fpl->sprintf_schedule( buf );
 						}
@@ -1130,7 +1130,7 @@
 					}
 					line_selector.set_focusable( false );
 					last_selected_line = linehandle_t();	// clear last selected line so we can get a new one ...
-					depot->call_depot_tool('l', convoihandle_t(), buf);
+					depot->call_depot_tool('l', consist_handle_t(), buf);
 				}
 				return true;
 			}
@@ -1176,7 +1176,7 @@
 	const bool action_allowed = welt->get_active_player() == depot->get_owner();
 	bt_new_line.enable( action_allowed );
 	bt_change_line.enable( action_allowed );
-	bt_copy_convoi.enable( action_allowed );
+	bt_copy_consist.enable( action_allowed );
 	bt_apply_line.enable( action_allowed );
 	bt_start.enable( action_allowed );
 	bt_schedule.enable( action_allowed );
@@ -1186,7 +1186,7 @@
 	bt_show_all.enable( action_allowed );
 	bt_veh_action.enable( action_allowed );
 	line_button.enable( action_allowed );
-//	convoy_selector.
+//	consist_selector.
 	if(  !action_allowed  &&  ev->ev_class <= INFOWIN  ) {
 		return false;
 	}
@@ -1236,9 +1236,9 @@
 	}
 	else {
 		if(IS_LEFTCLICK(ev)  ) {
-			if(  !convoy_selector.getroffen(ev->cx, ev->cy-D_TITLEBAR_HEIGHT)  &&  convoy_selector.is_dropped()  ) {
+			if(  !consist_selector.getroffen(ev->cx, ev->cy-D_TITLEBAR_HEIGHT)  &&  consist_selector.is_dropped()  ) {
 				// close combo box; we must do it ourselves, since the box does not receive outside events ...
-				convoy_selector.close_box();
+				consist_selector.close_box();
 			}
 			if(  line_selector.is_dropped()  &&  !line_selector.getroffen(ev->cx, ev->cy-D_TITLEBAR_HEIGHT)  ) {
 				// close combo box; we must do it ourselves, since the box does not receive outside events ...
@@ -1267,7 +1267,7 @@
 	const bool action_allowed = welt->get_active_player() == depot->get_owner();
 	bt_new_line.enable( action_allowed );
 	bt_change_line.enable( action_allowed );
-	bt_copy_convoi.enable( action_allowed );
+	bt_copy_consist.enable( action_allowed );
 	bt_apply_line.enable( action_allowed );
 	bt_start.enable( action_allowed );
 	bt_schedule.enable( action_allowed );
@@ -1278,12 +1278,12 @@
 	bt_veh_action.enable( action_allowed );
 	line_button.enable( action_allowed );
 
-	convoihandle_t cnv = depot->get_convoi(icnv);
+	consist_handle_t cnst = depot->get_consist(icnv);
 	// check for data inconsistencies (can happen with withdraw-all and vehicle in depot)
-	if(  !cnv.is_bound()  &&  !convoi_pics.empty()  ) {
+	if(  !cnst.is_bound()  &&  !consist_pics.empty()  ) {
 		icnv=0;
 		update_data();
-		cnv = depot->get_convoi(icnv);
+		cnst = depot->get_consist(icnv);
 	}
 
 	uint32 total_pax = 0;
@@ -1297,8 +1297,8 @@
 	uint32 total_min_weight = 0;
 	bool use_sel_weight = true;
 
-	if(  cnv.is_bound()  ) {
-		if(  cnv->get_vehicle_count() > 0  ) {
+	if(  cnst.is_bound()  ) {
+		if(  cnst->get_vehicle_count() > 0  ) {
 			uint8 selected_good_index = 0;
 			if(  depot->selected_filter > VEHICLE_FILTER_RELEVANT  ) {
 				// Filter is set to specific good
@@ -1308,8 +1308,8 @@
 				}
 			}
 
-			for(  unsigned i = 0;  i < cnv->get_vehicle_count();  i++  ) {
-				const vehikel_besch_t *besch = cnv->get_vehikel(i)->get_besch();
+			for(  unsigned i = 0;  i < cnst->get_vehicle_count();  i++  ) {
+				const vehikel_besch_t *besch = cnst->get_vehikel(i)->get_besch();
 
 				total_power += besch->get_leistung()*besch->get_gear();
 
@@ -1366,105 +1366,105 @@
 			}
 
 			sint32 empty_kmh, sel_kmh, max_kmh, min_kmh;
-			if(  cnv->front()->get_waytype() == air_wt  ) {
+			if(  cnst->front()->get_waytype() == air_wt  ) {
 				// flying aircraft have 0 friction --> speed not limited by power, so just use top_speed
-				empty_kmh = sel_kmh = max_kmh = min_kmh = speed_to_kmh( cnv->get_min_top_speed() );
+				empty_kmh = sel_kmh = max_kmh = min_kmh = speed_to_kmh( cnst->get_min_top_speed() );
 			}
 			else {
-				empty_kmh = speed_to_kmh(convoi_t::calc_max_speed(total_power, total_empty_weight, cnv->get_min_top_speed()));
-				sel_kmh =   speed_to_kmh(convoi_t::calc_max_speed(total_power, total_selected_weight, cnv->get_min_top_speed()));
-				max_kmh =   speed_to_kmh(convoi_t::calc_max_speed(total_power, total_min_weight,   cnv->get_min_top_speed()));
-				min_kmh =   speed_to_kmh(convoi_t::calc_max_speed(total_power, total_max_weight,   cnv->get_min_top_speed()));
+				empty_kmh = speed_to_kmh(consist_t::calc_max_speed(total_power, total_empty_weight, cnst->get_min_top_speed()));
+				sel_kmh =   speed_to_kmh(consist_t::calc_max_speed(total_power, total_selected_weight, cnst->get_min_top_speed()));
+				max_kmh =   speed_to_kmh(consist_t::calc_max_speed(total_power, total_min_weight,   cnst->get_min_top_speed()));
+				min_kmh =   speed_to_kmh(consist_t::calc_max_speed(total_power, total_max_weight,   cnst->get_min_top_speed()));
 			}
 
-			const sint32 convoi_length = (cnv->get_vehicle_count()) * CARUNITS_PER_TILE / 2 - 1;
-			convoi_tile_length_sb = convoi_length + (cnv->get_tile_length() * CARUNITS_PER_TILE - cnv->get_length());
+			const sint32 consist_length = (cnst->get_vehicle_count()) * CARUNITS_PER_TILE / 2 - 1;
+			consist_tile_length_sb = consist_length + (cnst->get_tile_length() * CARUNITS_PER_TILE - cnst->get_length());
 
-			txt_convoi_count.clear();
-			txt_convoi_count.printf("%s %i",translator::translate("Station tiles:"), cnv->get_tile_length() );
+			txt_consist_count.clear();
+			txt_consist_count.printf("%s %i",translator::translate("Station tiles:"), cnst->get_tile_length() );
 
-			txt_convoi_speed.clear();
+			txt_consist_speed.clear();
 			if(  empty_kmh != (use_sel_weight ? sel_kmh : min_kmh)  ) {
-				convoi_length_ok_sb = 0;
+				consist_length_ok_sb = 0;
 				if(  max_kmh != min_kmh  &&  !use_sel_weight  ) {
-					txt_convoi_speed.printf("%s %d km/h, %d-%d km/h %s", translator::translate("Max. speed:"), empty_kmh, min_kmh, max_kmh, translator::translate("loaded") );
+					txt_consist_speed.printf("%s %d km/h, %d-%d km/h %s", translator::translate("Max. speed:"), empty_kmh, min_kmh, max_kmh, translator::translate("loaded") );
 					if(  max_kmh != empty_kmh  ) {
-						convoi_length_slower_sb = 0;
-						convoi_length_too_slow_sb = convoi_length;
+						consist_length_slower_sb = 0;
+						consist_length_too_slow_sb = consist_length;
 					}
 					else {
-						convoi_length_slower_sb = convoi_length;
-						convoi_length_too_slow_sb = 0;
+						consist_length_slower_sb = consist_length;
+						consist_length_too_slow_sb = 0;
 					}
 				}
 				else {
-					txt_convoi_speed.printf("%s %d km/h, %d km/h %s", translator::translate("Max. speed:"), empty_kmh, use_sel_weight ? sel_kmh : min_kmh, translator::translate("loaded") );
-					convoi_length_slower_sb = 0;
-					convoi_length_too_slow_sb = convoi_length;
+					txt_consist_speed.printf("%s %d km/h, %d km/h %s", translator::translate("Max. speed:"), empty_kmh, use_sel_weight ? sel_kmh : min_kmh, translator::translate("loaded") );
+					consist_length_slower_sb = 0;
+					consist_length_too_slow_sb = consist_length;
 				}
 			}
 			else {
-					txt_convoi_speed.printf("%s %d km/h", translator::translate("Max. speed:"), empty_kmh );
-					convoi_length_ok_sb = convoi_length;
-					convoi_length_slower_sb = 0;
-					convoi_length_too_slow_sb = 0;
+					txt_consist_speed.printf("%s %d km/h", translator::translate("Max. speed:"), empty_kmh );
+					consist_length_ok_sb = consist_length;
+					consist_length_slower_sb = 0;
+					consist_length_too_slow_sb = 0;
 			}
 
 			{
 				char buf[128];
-				txt_convoi_value.clear();
-				money_to_string(  buf, cnv->calc_restwert() / 100.0, false );
-				txt_convoi_value.printf("%s %8s", translator::translate("Restwert:"), buf );
+				txt_consist_value.clear();
+				money_to_string(  buf, cnst->calc_restwert() / 100.0, false );
+				txt_consist_value.printf("%s %8s", translator::translate("Restwert:"), buf );
 
-				txt_convoi_cost.clear();
-				if(  sint64 fix_cost = welt->scale_with_month_length((sint64)cnv->get_fix_cost())  ) {
+				txt_consist_cost.clear();
+				if(  sint64 fix_cost = welt->scale_with_month_length((sint64)cnst->get_fix_cost())  ) {
 					money_to_string(  buf, (double)fix_cost / 100.0, false );
-					txt_convoi_cost.printf( translator::translate("Cost: %8s (%.2f$/km %.2f$/m)\n"), buf, (double)cnv->get_running_cost()/100.0, (double)fix_cost/100.0 );
+					txt_consist_cost.printf( translator::translate("Cost: %8s (%.2f$/km %.2f$/m)\n"), buf, (double)cnst->get_running_cost()/100.0, (double)fix_cost/100.0 );
 				}
 				else {
-					money_to_string(  buf, cnv->get_purchase_cost() / 100.0, false );
-					txt_convoi_cost.printf( translator::translate("Cost: %8s (%.2f$/km)\n"), buf, (double)cnv->get_running_cost() / 100.0 );
+					money_to_string(  buf, cnst->get_purchase_cost() / 100.0, false );
+					txt_consist_cost.printf( translator::translate("Cost: %8s (%.2f$/km)\n"), buf, (double)cnst->get_running_cost() / 100.0 );
 				}
 			}
 
-			txt_convoi_power.clear();
-			txt_convoi_power.printf( translator::translate("Power: %4d kW\n"), cnv->get_sum_leistung() );
+			txt_consist_power.clear();
+			txt_consist_power.printf( translator::translate("Power: %4d kW\n"), cnst->get_sum_leistung() );
 
-			txt_convoi_weight.clear();
+			txt_consist_weight.clear();
 			if(  total_empty_weight != (use_sel_weight ? total_selected_weight : total_max_weight)  ) {
 				if(  total_min_weight != total_max_weight  &&  !use_sel_weight  ) {
-					txt_convoi_weight.printf("%s %.1ft, %.1f-%.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0, total_min_weight / 1000.0, total_max_weight / 1000.0 );
+					txt_consist_weight.printf("%s %.1ft, %.1f-%.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0, total_min_weight / 1000.0, total_max_weight / 1000.0 );
 				}
 				else {
-					txt_convoi_weight.printf("%s %.1ft, %.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0, (use_sel_weight ? total_selected_weight : total_max_weight) / 1000.0 );
+					txt_consist_weight.printf("%s %.1ft, %.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0, (use_sel_weight ? total_selected_weight : total_max_weight) / 1000.0 );
 				}
 			}
 			else {
-					txt_convoi_weight.printf("%s %.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0 );
+					txt_consist_weight.printf("%s %.1ft", translator::translate("Weight:"), total_empty_weight / 1000.0 );
 			}
 		}
 		else {
-			txt_convoi_count.clear();
-			txt_convoi_count.append( translator::translate("keine Fahrzeuge") );
-			txt_convoi_value.clear();
-			txt_convoi_cost.clear();
-			txt_convoi_power.clear();
-			txt_convoi_weight.clear();
+			txt_consist_count.clear();
+			txt_consist_count.append( translator::translate("keine Fahrzeuge") );
+			txt_consist_value.clear();
+			txt_consist_cost.clear();
+			txt_consist_power.clear();
+			txt_consist_weight.clear();
 		}
 
-		sb_convoi_length.set_visible(true);
-		cont_convoi_capacity.set_totals( total_pax, total_mail, total_goods );
-		cont_convoi_capacity.set_visible(true);
+		sb_consist_length.set_visible(true);
+		cont_consist_capacity.set_totals( total_pax, total_mail, total_goods );
+		cont_consist_capacity.set_visible(true);
 	}
 	else {
-		txt_convoi_count.clear();
-		txt_convoi_speed.clear();
-		txt_convoi_value.clear();
-		txt_convoi_cost.clear();
-		txt_convoi_power.clear();
-		txt_convoi_weight.clear();
-		sb_convoi_length.set_visible(false);
-		cont_convoi_capacity.set_visible(false);
+		txt_consist_count.clear();
+		txt_consist_speed.clear();
+		txt_consist_value.clear();
+		txt_consist_cost.clear();
+		txt_consist_power.clear();
+		txt_consist_weight.clear();
+		sb_consist_length.set_visible(false);
+		cont_consist_capacity.set_visible(false);
 	}
 
 	bt_obsolete.pressed = show_retired_vehicles;	// otherwise the button would not show depressed
@@ -1478,9 +1478,9 @@
 void depot_frame_t::apply_line()
 {
 	if(  icnv > -1  ) {
-		convoihandle_t cnv = depot->get_convoi( icnv );
-		// if no convoi is selected, do nothing
-		if(  !cnv.is_bound()  ) {
+		consist_handle_t cnst = depot->get_consist( icnv );
+		// if no consist is selected, do nothing
+		if(  !cnst.is_bound()  ) {
 			return;
 		}
 
@@ -1488,17 +1488,17 @@
 			// set new route only, a valid route is selected:
 			char id[16];
 			sprintf( id, "%i", selected_line.get_id() );
-			cnv->call_convoi_tool('l', id );
+			cnst->call_consist_tool('l', id );
 		}
 		else {
-			// sometimes the user might wish to remove convoy from line
+			// sometimes the user might wish to remove consist from line
 			// => we clear the schedule completely
-			schedule_t *dummy = cnv->create_schedule()->copy();
+			schedule_t *dummy = cnst->create_schedule()->copy();
 			dummy->eintrag.clear();
 
 			cbuffer_t buf;
 			dummy->sprintf_schedule(buf);
-			cnv->call_convoi_tool('g', (const char*)buf );
+			cnst->call_consist_tool('g', (const char*)buf );
 
 			delete dummy;
 		}
@@ -1508,19 +1508,19 @@
 
 void depot_frame_t::fahrplaneingabe()
 {
-	convoihandle_t cnv = depot->get_convoi( icnv );
+	consist_handle_t cnst = depot->get_consist( icnv );
 
-	if(  cnv.is_bound()  &&  cnv->get_vehicle_count() > 0  ) {
+	if(  cnst.is_bound()  &&  cnst->get_vehicle_count() > 0  ) {
 		if(  selected_line.is_bound()  &&  event_get_last_control_shift() == 2  ) { // update line with CTRL-click
 			create_win( new line_management_gui_t( selected_line, depot->get_owner() ), w_info, (ptrdiff_t)selected_line.get_rep() );
 		}
 		else { // edit individual schedule
 			// this can happen locally, since any update of the schedule is done during closing window
-			schedule_t *fpl = cnv->create_schedule();
+			schedule_t *fpl = cnst->create_schedule();
 			assert(fpl!=NULL);
 			gui_frame_t *fplwin = win_get_magic( (ptrdiff_t)fpl );
 			if(  fplwin == NULL  ) {
-				cnv->open_schedule_window( welt->get_active_player() == cnv->get_owner() );
+				cnst->open_schedule_window( welt->get_active_player() == cnst->get_owner() );
 			}
 			else {
 				top_win( fplwin );
@@ -1566,12 +1566,12 @@
 		}
 	}
 	else {
-		// cursor over a vehicle in the convoi
-		sel_index = convoi.index_at( pos , x, y - D_TITLEBAR_HEIGHT);
+		// cursor over a vehicle in the consist
+		sel_index = consist.index_at( pos , x, y - D_TITLEBAR_HEIGHT);
 		if(  sel_index != -1  ) {
-			convoihandle_t cnv = depot->get_convoi( icnv );
-			veh_type = cnv->get_vehikel( sel_index )->get_besch();
-			resale_value = cnv->get_vehikel( sel_index )->calc_sale_value();
+			consist_handle_t cnst = depot->get_consist( icnv );
+			veh_type = cnst->get_vehikel( sel_index )->get_besch();
+			resale_value = cnst->get_vehikel( sel_index )->calc_sale_value();
 			new_vehicle_length_sb_force_zero = true;
 		}
 	}
@@ -1683,7 +1683,7 @@
 		display_multiline_text( pos.x + second_column_x, pos.y + D_TITLEBAR_HEIGHT + bt_show_all.get_pos().y + bt_show_all.get_size().h + D_V_SPACE + LINESPACE, buf, SYSCOL_TEXT);
 
 		// update speedbar
-		new_vehicle_length_sb = new_vehicle_length_sb_force_zero ? 0 : convoi_length_ok_sb + convoi_length_slower_sb + convoi_length_too_slow_sb + veh_type->get_length();
+		new_vehicle_length_sb = new_vehicle_length_sb_force_zero ? 0 : consist_length_ok_sb + consist_length_slower_sb + consist_length_too_slow_sb + veh_type->get_length();
 	}
 	else {
 		new_vehicle_length_sb = 0;
@@ -1740,7 +1740,7 @@
 }
 
 
-depot_convoi_capacity_t::depot_convoi_capacity_t()
+depot_consist_capacity_t::depot_consist_capacity_t()
 {
 	total_pax = 0;
 	total_mail = 0;
@@ -1748,7 +1748,7 @@
 }
 
 
-void depot_convoi_capacity_t::set_totals(uint32 pax, uint32 mail, uint32 goods)
+void depot_consist_capacity_t::set_totals(uint32 pax, uint32 mail, uint32 goods)
 {
 	total_pax = pax;
 	total_mail = mail;
@@ -1756,7 +1756,7 @@
 }
 
 
-void depot_convoi_capacity_t::draw(scr_coord off)
+void depot_consist_capacity_t::draw(scr_coord off)
 {
 	cbuffer_t cbuf;
 
Index: gui/depot_frame.h
===================================================================
--- gui/depot_frame.h	(revision 7957)
+++ gui/depot_frame.h	(working copy)
@@ -6,7 +6,7 @@
  */
 
 /*
- * The depot window, where to buy convois
+ * The depot window, where to buy consists
  */
 
 #ifndef gui_depot_frame2_t_h
@@ -33,7 +33,7 @@
 class vehikel_besch_t;
 
 
-class depot_convoi_capacity_t : public gui_container_t
+class depot_consist_capacity_t : public gui_container_t
 {
 private:
 	uint32 total_pax;
@@ -40,7 +40,7 @@
 	uint32 total_mail;
 	uint32 total_goods;
 public:
-	depot_convoi_capacity_t();
+	depot_consist_capacity_t();
 	void set_totals(uint32 pax, uint32 mail, uint32 goods);
 	void draw(scr_coord offset);
 };
@@ -63,7 +63,7 @@
 	depot_t *depot;
 
 	/**
-	 * The current convoi to display.
+	 * The current consist to display.
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
@@ -84,26 +84,26 @@
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
-	gui_label_t lb_convois;
+	gui_label_t lb_consists;
 
-	/// contains the current translation of "new convoi"
-	const char* new_convoy_text;
-	gui_combobox_t convoy_selector;
+	/// contains the current translation of "new consist"
+	const char* new_consist_text;
+	gui_combobox_t consist_selector;
 
 	button_t line_button;	// goto line ...
 
-	gui_label_t lb_convoi_count;
-	gui_label_t lb_convoi_speed;
-	gui_label_t lb_convoi_cost;
-	gui_label_t lb_convoi_value;
-	gui_label_t lb_convoi_power;
-	gui_label_t lb_convoi_weight;
-	gui_label_t lb_convoi_line;
+	gui_label_t lb_consist_count;
+	gui_label_t lb_consist_speed;
+	gui_label_t lb_consist_cost;
+	gui_label_t lb_consist_value;
+	gui_label_t lb_consist_power;
+	gui_label_t lb_consist_weight;
+	gui_label_t lb_consist_line;
 
-	depot_convoi_capacity_t cont_convoi_capacity;
+	depot_consist_capacity_t cont_consist_capacity;
 
-	gui_speedbar_t sb_convoi_length;
-	sint32 convoi_length_ok_sb, convoi_length_slower_sb, convoi_length_too_slow_sb, convoi_tile_length_sb, new_vehicle_length_sb;
+	gui_speedbar_t sb_consist_length;
+	sint32 consist_length_ok_sb, consist_length_slower_sb, consist_length_too_slow_sb, consist_tile_length_sb, new_vehicle_length_sb;
 
 	button_t bt_start;
 	button_t bt_schedule;
@@ -125,11 +125,11 @@
 	 */
 	button_t bt_new_line;
 	button_t bt_change_line;
-	button_t bt_copy_convoi;
+	button_t bt_copy_consist;
 	button_t bt_apply_line;
 
-	vector_tpl<gui_image_list_t::image_data_t*> convoi_pics;
-	gui_image_list_t convoi;
+	vector_tpl<gui_image_list_t::image_data_t*> consist_pics;
+	gui_image_list_t consist;
 
 	/// image list of passenger cars
 	vector_tpl<gui_image_list_t::image_data_t*> pas_vec;
@@ -175,14 +175,14 @@
 
 	linehandle_t selected_line, last_selected_line;
 
-	cbuffer_t txt_convois;
+	cbuffer_t txt_consists;
 
-	cbuffer_t txt_convoi_count;
-	cbuffer_t txt_convoi_value;
-	cbuffer_t txt_convoi_speed;
-	cbuffer_t txt_convoi_cost;
-	cbuffer_t txt_convoi_power;
-	cbuffer_t txt_convoi_weight;
+	cbuffer_t txt_consist_count;
+	cbuffer_t txt_consist_value;
+	cbuffer_t txt_consist_speed;
+	cbuffer_t txt_consist_cost;
+	cbuffer_t txt_consist_power;
+	cbuffer_t txt_consist_weight;
 
 	scr_coord_val second_column_x; // x position of the second text column
 
@@ -227,14 +227,14 @@
 	// add a single vehicle (helper function)
 	void add_to_vehicle_list(const vehikel_besch_t *info);
 
-	// for convoi image
-	void image_from_convoi_list(uint nr, bool to_end);
+	// for consist image
+	void image_from_consist_list(uint nr, bool to_end);
 
 	void image_from_storage_list(gui_image_list_t::image_data_t *bild_data);
 
 public:
 	// the next two are only needed for depot_t update notifications
-	void activate_convoi( convoihandle_t cnv );
+	void activate_consist( consist_handle_t cnst );
 
 	int get_icnv() const { return icnv; }
 
Index: gui/display_settings.cc
===================================================================
--- gui/display_settings.cc	(revision 7957)
+++ gui/display_settings.cc	(working copy)
@@ -250,9 +250,9 @@
 	buttons[1].set_typ(button_t::arrowright);
 
 	// Convoy tooltip label
-	convoy_tooltip_label.init("", cursor + scr_coord (buttons[0].get_size().w + D_H_SPACE,0) );
-	convoy_tooltip_label.align_to(&buttons[0], ALIGN_CENTER_V);
-	add_component(&convoy_tooltip_label);
+	consist_tooltip_label.init("", cursor + scr_coord (buttons[0].get_size().w + D_H_SPACE,0) );
+	consist_tooltip_label.align_to(&buttons[0], ALIGN_CENTER_V);
+	add_component(&consist_tooltip_label);
 	cursor.y += buttons[0].get_size().h + D_V_SPACE;
 
 	// Show schedule's stop checkbox
@@ -602,9 +602,9 @@
 
 	// Update label buffers
 	hide_buildings_label.set_text( env_t::hide_buildings==0 ? "no buildings hidden" : (env_t::hide_buildings==1 ? "hide city building" : "hide all building") );
-	convoy_tooltip_label.set_text( env_t::show_vehicle_states==0 ? "convoi error tooltips" : (env_t::show_vehicle_states==1 ? "convoi mouseover tooltips" : "all convoi tooltips") );
+	consist_tooltip_label.set_text( env_t::show_vehicle_states==0 ? "consist error tooltips" : (env_t::show_vehicle_states==1 ? "consist mouseover tooltips" : "all consist tooltips") );
 	sprintf(frame_time_buf," %d ms", get_frame_time() );
-	sprintf(idle_time_buf, " %d ms", welt->get_schlaf_zeit() );
+	sprintf(idle_time_buf, " %d ms", welt->get_idle_time() );
 
 	// fps_label
 	uint8  color;
Index: gui/display_settings.h
===================================================================
--- gui/display_settings.h	(revision 7957)
+++ gui/display_settings.h	(working copy)
@@ -38,7 +38,7 @@
 		scrollspeed_label,
 		hide_buildings_label,
 		traffic_density_label,
-		convoy_tooltip_label,
+		consist_tooltip_label,
 		frame_time_label,
 		frame_time_value_label,
 		idle_time_label,
Index: gui/enlarge_map_frame_t.cc
===================================================================
--- gui/enlarge_map_frame_t.cc	(revision 7957)
+++ gui/enlarge_map_frame_t.cc	(working copy)
@@ -27,7 +27,7 @@
 #include "../simcity.h"
 #include "../vehicle/simvehicle.h"
 #include "../player/simplay.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 
 #include "../simcolor.h"
 
@@ -263,7 +263,7 @@
 	const sint32 memory = (
 		sizeof(karte_t) +
 		sizeof(player_t) * 8 +
-		sizeof(convoi_t) * 1000 +
+		sizeof(consist_t) * 1000 +
 		(sizeof(schiene_t) + sizeof(vehicle_t)) * 10 * (sx + sy) +
 		sizeof(stadt_t) * sets->get_city_count() +
 		(
Index: gui/extend_edit.h
===================================================================
--- gui/extend_edit.h	(revision 7957)
+++ gui/extend_edit.h	(working copy)
@@ -12,7 +12,7 @@
 #include "components/gui_image.h"
 #include "components/gui_fixedwidth_textarea.h"
 
-#include "components/gui_convoiinfo.h"
+#include "components/gui_consistinfo.h"
 #include "../utils/cbuffer_t.h"
 #include "../simtypes.h"
 
Index: gui/fahrplan_gui.cc
===================================================================
--- gui/fahrplan_gui.cc	(revision 7957)
+++ gui/fahrplan_gui.cc	(working copy)
@@ -12,7 +12,7 @@
 #include "../simhalt.h"
 #include "../simworld.h"
 #include "../simmenu.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../display/simgraph.h"
 #include "../display/viewport.h"
 
@@ -227,7 +227,7 @@
 	if(  player  ) {
 		update_tool( false );
 		// hide schedule on minimap (may not current, but for safe)
-		reliefkarte_t::get_karte()->set_current_cnv( convoihandle_t() );
+		reliefkarte_t::get_karte()->set_current_cnv( consist_handle_t() );
 	}
 	delete fpl;
 
@@ -235,7 +235,7 @@
 
 
 
-fahrplan_gui_t::fahrplan_gui_t(schedule_t* fpl_, player_t* player_, convoihandle_t cnv_) :
+fahrplan_gui_t::fahrplan_gui_t(schedule_t* fpl_, player_t* player_, consist_handle_t cnv_) :
 	gui_frame_t( translator::translate("Fahrplan"), player_),
 	lb_line("Serves Line:"),
 	lb_wait("month wait time"),
@@ -245,25 +245,25 @@
 	scrolly(&stats),
 	old_fpl(fpl_),
 	player(player_),
-	cnv(cnv_)
+	cnst(cnv_)
 {
 	old_fpl->eingabe_beginnen();
 	fpl = old_fpl->copy();
 	stats.set_fahrplan(fpl);
-	if(  !cnv.is_bound()  ) {
+	if(  !cnst.is_bound()  ) {
 		old_line = new_line = linehandle_t();
 		show_line_selector(false);
 	}
 	else {
 		// set this schedule as current to show on minimap if possible
-		reliefkarte_t::get_karte()->set_current_cnv( cnv );
+		reliefkarte_t::get_karte()->set_current_cnv( cnst );
 		old_line = new_line = cnv_->get_line();
 	}
 	old_line_count = 0;
 
 	scr_coord_val ypos = 0;
-	if(  cnv.is_bound()  ) {
-		// things, only relevant to convois, like creating/selecting lines
+	if(  cnst.is_bound()  ) {
+		// things, only relevant to consists, like creating/selecting lines
 		bt_promote_to_line.init( button_t::roundbox, "promote to line", scr_coord( BUTTON3_X, ypos ) );
 		bt_promote_to_line.set_tooltip("Create a new line based on this schedule");
 		bt_promote_to_line.add_listener(this);
@@ -481,31 +481,31 @@
 		fpl->cleanup();
 		fpl->eingabe_abschliessen();
 		// now apply the changes
-		if(  cnv.is_bound()  ) {
-			// do not send changes if the convoi is about to be deleted
-			if(  cnv->get_state() != convoi_t::SELF_DESTRUCT  ) {
+		if(  cnst.is_bound()  ) {
+			// do not send changes if the consist is about to be deleted
+			if(  cnst->get_state() != consist_t::SELF_DESTRUCT  ) {
 				// if a line is selected
 				if(  new_line.is_bound()  ) {
-					// if the selected line is different to the convoi's line, apply it
-					if(  new_line!=cnv->get_line()  ) {
+					// if the selected line is different to the consist's line, apply it
+					if(  new_line!=cnst->get_line()  ) {
 						char id[16];
 						sprintf( id, "%i,%i", new_line.get_id(), fpl->get_aktuell() );
-						cnv->call_convoi_tool( 'l', id );
+						cnst->call_consist_tool( 'l', id );
 					}
 					else {
 						cbuffer_t buf;
 						fpl->sprintf_schedule( buf );
-						cnv->call_convoi_tool( 'g', buf );
+						cnst->call_consist_tool( 'g', buf );
 					}
 				}
 				else {
 					cbuffer_t buf;
 					fpl->sprintf_schedule( buf );
-					cnv->call_convoi_tool( 'g', buf );
+					cnst->call_consist_tool( 'g', buf );
 				}
 
-				if(  cnv->in_depot()  ) {
-					const grund_t *const ground = welt->lookup( cnv->get_home_depot() );
+				if(  cnst->in_depot()  ) {
+					const grund_t *const ground = welt->lookup( cnst->get_home_depot() );
 					if(  ground  ) {
 						const depot_t *const depot = ground->get_depot();
 						if(  depot  ) {
@@ -619,7 +619,7 @@
 		delete tool;
 	}
 	// recheck lines
-	if(  cnv.is_bound()  ) {
+	if(  cnst.is_bound()  ) {
 		// unequal to line => remove from line ...
 		if(  new_line.is_bound()  &&  !fpl->matches(welt,new_line->get_schedule())  ) {
 			new_line = linehandle_t();
@@ -690,10 +690,10 @@
 	}
 
 	// after loading in network games, the schedule might still being updated
-	if(  cnv.is_bound()  &&  cnv->get_state()==convoi_t::FAHRPLANEINGABE  &&  fpl->ist_abgeschlossen()  ) {
-		assert( convoi_t::FAHRPLANEINGABE==1 ); // convoi_t::FAHRPLANEINGABE is 1
+	if(  cnst.is_bound()  &&  cnst->get_state()==consist_t::FAHRPLANEINGABE  &&  fpl->ist_abgeschlossen()  ) {
+		assert( consist_t::FAHRPLANEINGABE==1 ); // consist_t::FAHRPLANEINGABE is 1
 		fpl->eingabe_beginnen();
-		cnv->call_convoi_tool( 's', "1" );
+		cnst->call_consist_tool( 's', "1" );
 	}
 
 	// always dirty, to cater for shortening of halt names and change of selections
@@ -736,7 +736,7 @@
 	fpl(NULL),
 	old_fpl(NULL),
 	player(NULL),
-	cnv()
+	cnst()
 {
 	// just a dummy
 }
@@ -744,7 +744,7 @@
 
 void fahrplan_gui_t::rdwr(loadsave_t *file)
 {
-	// this handles only schedules of bound convois
+	// this handles only schedules of bound consists
 	// lines are handled by line_management_gui_t
 
 	// window size
@@ -751,7 +751,7 @@
 	scr_size size = get_windowsize();
 	size.rdwr( file );
 
-	// convoy data
+	// consist data
 	if (file->get_version() <=112002) {
 		// dummy data
 		uint8 player_nr = 0;
@@ -764,7 +764,7 @@
 	}
 	else {
 		// handle
-		convoi_t::rdwr_convoihandle_t(file, cnv);
+		consist_t::rdwr_consist_handle_t(file, cnst);
 	}
 
 	// schedules
@@ -777,24 +777,24 @@
 	fpl->rdwr(file);
 
 	if(  file->is_loading()  ) {
-		if(  cnv.is_bound() ) {
+		if(  cnst.is_bound() ) {
 			// now we can open the window ...
 			scr_coord const& pos = win_get_pos(this);
-			fahrplan_gui_t *w = new fahrplan_gui_t( cnv->get_schedule(), cnv->get_owner(), cnv );
-			create_win(pos.x, pos.y, w, w_info, (ptrdiff_t)cnv->get_schedule());
+			fahrplan_gui_t *w = new fahrplan_gui_t( cnst->get_schedule(), cnst->get_owner(), cnst );
+			create_win(pos.x, pos.y, w, w_info, (ptrdiff_t)cnst->get_schedule());
 			w->set_windowsize( size );
 			w->fpl->copy_from( fpl );
-			cnv->get_schedule()->eingabe_abschliessen();
+			cnst->get_schedule()->eingabe_abschliessen();
 			w->fpl->eingabe_abschliessen();
 		}
 		else {
-			dbg->error( "fahrplan_gui_t::rdwr", "Could not restore schedule window for (%d)", cnv.get_id() );
+			dbg->error( "fahrplan_gui_t::rdwr", "Could not restore schedule window for (%d)", cnst.get_id() );
 		}
 		player = NULL;
 		delete old_fpl;
 		delete fpl;
 		fpl = old_fpl = NULL;
-		cnv = convoihandle_t();
+		cnst = consist_handle_t();
 		destroy_win( this );
 	}
 }
Index: gui/fahrplan_gui.h
===================================================================
--- gui/fahrplan_gui.h	(revision 7957)
+++ gui/fahrplan_gui.h	(working copy)
@@ -20,7 +20,7 @@
 #include "components/gui_textarea.h"
 #include "components/gui_scrollpane.h"
 
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 #include "../linehandle_t.h"
 #include "../gui/simwin.h"
 #include "../tpl/vector_tpl.h"
@@ -112,12 +112,12 @@
 	schedule_t *fpl;
 	schedule_t* old_fpl;
 	player_t *player;
-	convoihandle_t cnv;
+	consist_handle_t cnst;
 
 	linehandle_t new_line, old_line;
 
 public:
-	fahrplan_gui_t(schedule_t* fpl, player_t* player, convoihandle_t cnv);
+	fahrplan_gui_t(schedule_t* fpl, player_t* player, consist_handle_t cnst);
 
 	virtual ~fahrplan_gui_t();
 
Index: gui/halt_detail.cc
===================================================================
--- gui/halt_detail.cc	(revision 7957)
+++ gui/halt_detail.cc	(working copy)
@@ -12,7 +12,7 @@
 #include "../simfab.h"
 #include "../simhalt.h"
 #include "../simline.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 
 #include "../besch/ware_besch.h"
 #include "../bauer/warenbauer.h"
@@ -69,13 +69,13 @@
 		cont.remove_component( b );
 		delete b;
 	}
-	while(!convoylabels.empty()) {
-		gui_label_t *l = convoylabels.remove_first();
+	while(!consistlabels.empty()) {
+		gui_label_t *l = consistlabels.remove_first();
 		cont.remove_component( l );
 		delete l;
 	}
-	while(!convoybuttons.empty()) {
-		button_t *b = convoybuttons.remove_first();
+	while(!consistbuttons.empty()) {
+		button_t *b = consistbuttons.remove_first();
 		cont.remove_component( b );
 		delete b;
 	}
@@ -107,13 +107,13 @@
 		cont.remove_component( b );
 		delete b;
 	}
-	while(!convoylabels.empty()) {
-		gui_label_t *l = convoylabels.remove_first();
+	while(!consistlabels.empty()) {
+		gui_label_t *l = consistlabels.remove_first();
 		cont.remove_component( l );
 		delete l;
 	}
-	while(!convoybuttons.empty()) {
-		button_t *b = convoybuttons.remove_first();
+	while(!consistbuttons.empty()) {
+		button_t *b = consistbuttons.remove_first();
 		cont.remove_component( b );
 		delete b;
 	}
@@ -223,29 +223,29 @@
 		offset_y += LINESPACE;
 	}
 
-	// Knightly : add lineless convoys which serve this stop
+	// Knightly : add lineless consists which serve this stop
 	buf.append("\n");
 	offset_y += LINESPACE;
 
-	buf.append( translator::translate("Lineless convoys serving this stop") );
+	buf.append( translator::translate("Lineless consists serving this stop") );
 	buf.append("\n");
 	offset_y += LINESPACE;
 
-	if(  !halt->registered_convoys.empty()  ) {
-		for(  uint32 i=0;  i<halt->registered_convoys.get_count();  ++i  ) {
+	if(  !halt->registered_consists.empty()  ) {
+		for(  uint32 i=0;  i<halt->registered_consists.get_count();  ++i  ) {
 			// Convoy buttons
 			button_t *b = new button_t();
 			b->init( button_t::posbutton, NULL, scr_coord(D_MARGIN_LEFT, offset_y) );
 			b->set_targetpos( koord(-2, i) );
 			b->add_listener( this );
-			convoybuttons.append( b );
+			consistbuttons.append( b );
 			cont.add_component( b );
 
 			// Line labels with color of player
-			label_names.append( strdup(halt->registered_convoys[i]->get_name()) );
-			gui_label_t *l = new gui_label_t( label_names.back(), PLAYER_FLAG|(halt->registered_convoys[i]->get_owner()->get_player_color1()+0) );
+			label_names.append( strdup(halt->registered_consists[i]->get_name()) );
+			gui_label_t *l = new gui_label_t( label_names.back(), PLAYER_FLAG|(halt->registered_consists[i]->get_owner()->get_player_color1()+0) );
 			l->set_pos( scr_coord(D_MARGIN_LEFT+D_BUTTON_HEIGHT+D_H_SPACE, offset_y) );
-			convoylabels.append( l );
+			consistlabels.append( l );
 			cont.add_component( l );
 			buf.append("\n");
 			offset_y += LINESPACE;
@@ -317,7 +317,7 @@
 	// ok, we have now this counter for pending updates
 	destination_counter = halt->get_reconnect_counter();
 	cached_line_count = halt->registered_lines.get_count();
-	cached_convoy_count = halt->registered_convoys.get_count();
+	cached_consist_count = halt->registered_consists.get_count();
 }
 
 
@@ -345,11 +345,11 @@
 			}
 		}
 		else if(  k.x==-2  ) {
-			// Knightly : lineless convoy button pressed
+			// Knightly : lineless consist button pressed
 			uint16 j = k.y;
-			if(  j<halt->registered_convoys.get_count()  ) {
-				convoihandle_t convoy = halt->registered_convoys[j];
-				convoy->open_info_window();
+			if(  j<halt->registered_consists.get_count()  ) {
+				consist_handle_t consist = halt->registered_consists[j];
+				consist->open_info_window();
 			}
 		}
 	}
@@ -362,7 +362,7 @@
 {
 	if(halt.is_bound()) {
 		if(  halt->get_reconnect_counter()!=destination_counter  ||  cached_active_player!=welt->get_active_player()
-				||  halt->registered_lines.get_count()!=cached_line_count  ||  halt->registered_convoys.get_count()!=cached_convoy_count  ) {
+				||  halt->registered_lines.get_count()!=cached_line_count  ||  halt->registered_consists.get_count()!=cached_consist_count  ) {
 			// fill buffer with halt detail
 			halt_detail_info();
 			cached_active_player=welt->get_active_player();
Index: gui/halt_detail.h
===================================================================
--- gui/halt_detail.h	(revision 7957)
+++ gui/halt_detail.h	(working copy)
@@ -33,7 +33,7 @@
 	uint8 destination_counter;	// last destination counter of the halt; if mismatch to current, then redraw destinations
 	player_t *cached_active_player; // So that, if different from current, change line links
 	uint32 cached_line_count;
-	uint32 cached_convoy_count;
+	uint32 cached_consist_count;
 
 	cbuffer_t buf;
 
@@ -44,8 +44,8 @@
 	slist_tpl<button_t *>posbuttons;
 	slist_tpl<gui_label_t *>linelabels;
 	slist_tpl<button_t *>linebuttons;
-	slist_tpl<gui_label_t *> convoylabels;
-	slist_tpl<button_t *> convoybuttons;
+	slist_tpl<gui_label_t *> consistlabels;
+	slist_tpl<button_t *> consistbuttons;
 	slist_tpl<char*> label_names;
 
 public:
Index: gui/halt_info.cc
===================================================================
--- gui/halt_info.cc	(revision 7957)
+++ gui/halt_info.cc	(working copy)
@@ -15,7 +15,7 @@
 #include "../simworld.h"
 #include "../simware.h"
 #include "../simcolor.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simintr.h"
 #include "../display/simgraph.h"
 #include "../display/viewport.h"
@@ -346,15 +346,15 @@
 }
 
 
-// a sophisticated guess of a convois arrival time, taking into account the braking too and the current convoi state
-uint32 halt_info_t::calc_ticks_until_arrival( convoihandle_t cnv )
+// a sophisticated guess of a consists arrival time, taking into account the braking too and the current consist state
+uint32 halt_info_t::calc_ticks_until_arrival( consist_handle_t cnst )
 {
 	/* calculate the time needed:
 	 *   tiles << (8+12) / (kmh_to_speed(max_kmh) = ticks
 	 */
 	uint32 delta_t = 0;
-	sint32 delta_tiles = cnv->get_route()->get_count() - cnv->front()->get_route_index();
-	uint32 kmh_average = (cnv->get_average_kmh()*900 ) / 1024u;
+	sint32 delta_tiles = cnst->get_route()->get_count() - cnst->front()->get_route_index();
+	uint32 kmh_average = (cnst->get_average_kmh()*900 ) / 1024u;
 
 	// last braking tile
 	if(  delta_tiles > 1  &&  kmh_average > 25  ) {
@@ -372,7 +372,7 @@
 		delta_t += 819; // ( (1 << (8+12)) / kmh_to_speed(100) );
 	}
 	// waiting at signal?
-	if(  cnv->get_state() != convoi_t::DRIVING  ) {
+	if(  cnst->get_state() != consist_t::DRIVING  ) {
 		// extra time for acceleration
 		delta_t += kmh_average * 25;
 	}
@@ -393,7 +393,7 @@
 	destinations.clear();
 	origins.clear();
 
-	const uint32 cur_ticks = welt->get_zeit_ms() % welt->ticks_per_world_month;
+	const uint32 cur_ticks = welt->get_ticks() % welt->ticks_per_world_month;
 	static uint32 last_ticks = 0;
 
 	if(  last_ticks > cur_ticks  ) {
@@ -402,15 +402,15 @@
 	}
 	last_ticks = cur_ticks;
 
-	// iterate over all convoys stopping here
-	FOR(  slist_tpl<convoihandle_t>, cnv, halt->get_loading_convois() ) {
-		halthandle_t next_halt = cnv->get_schedule()->get_next_halt(cnv->get_owner(),halt);
+	// iterate over all consists stopping here
+	FOR(  slist_tpl<consist_handle_t>, cnst, halt->get_loading_consists() ) {
+		halthandle_t next_halt = cnst->get_schedule()->get_next_halt(cnst->get_owner(),halt);
 		if(  next_halt.is_bound()  ) {
-			halt_info_t::dest_info_t next( next_halt, 0, cnv );
+			halt_info_t::dest_info_t next( next_halt, 0, cnst );
 			destinations.append_unique( next );
-			if(  grund_t *gr = welt->lookup( cnv->get_vehikel(0)->last_stop_pos )  ) {
+			if(  grund_t *gr = welt->lookup( cnst->get_vehikel(0)->last_stop_pos )  ) {
 				if(  gr->get_halt().is_bound()  &&  gr->get_halt() != halt  ) {
-					halt_info_t::dest_info_t prev( gr->get_halt(), 0, cnv );
+					halt_info_t::dest_info_t prev( gr->get_halt(), 0, cnst );
 					origins.append_unique( prev );
 				}
 			}
@@ -417,18 +417,18 @@
 		}
 	}
 
-	// now exactly the same for convoys en route; the only change is that we estimate their arrival time too
+	// now exactly the same for consists en route; the only change is that we estimate their arrival time too
 	FOR(  vector_tpl<linehandle_t>, line, halt->registered_lines ) {
-		for(  uint j = 0;  j < line->count_convoys();  j++  ) {
-			convoihandle_t cnv = line->get_convoy(j);
-			if(  cnv.is_bound()  &&  ( cnv->get_state() == convoi_t::DRIVING  ||  cnv->is_waiting() )  &&  haltestelle_t::get_halt( cnv->get_schedule()->get_current_eintrag().pos, cnv->get_owner() ) == halt  ) {
-				halthandle_t prev_halt = haltestelle_t::get_halt( cnv->front()->last_stop_pos, cnv->get_owner() );
-				sint32 delta_t = cur_ticks + calc_ticks_until_arrival( cnv );
+		for(  uint j = 0;  j < line->count_consists();  j++  ) {
+			consist_handle_t cnst = line->get_consist(j);
+			if(  cnst.is_bound()  &&  ( cnst->get_state() == consist_t::DRIVING  ||  cnst->is_waiting() )  &&  haltestelle_t::get_halt( cnst->get_schedule()->get_current_eintrag().pos, cnst->get_owner() ) == halt  ) {
+				halthandle_t prev_halt = haltestelle_t::get_halt( cnst->front()->last_stop_pos, cnst->get_owner() );
+				sint32 delta_t = cur_ticks + calc_ticks_until_arrival( cnst );
 				if(  prev_halt.is_bound()  ) {
-					halt_info_t::dest_info_t prev( prev_halt, delta_t, cnv );
+					halt_info_t::dest_info_t prev( prev_halt, delta_t, cnst );
 					// smooth times a little
 					FOR( vector_tpl<dest_info_t>, &elem, old_origins ) {
-						if(  elem.cnv == cnv ) {
+						if(  elem.cnst == cnst ) {
 							delta_t = ( delta_t + 3*elem.delta_ticks ) / 4;
 							prev.delta_ticks = delta_t;
 							break;
@@ -436,9 +436,9 @@
 					}
 					origins.insert_ordered( prev, compare_hi );
 				}
-				halthandle_t next_halt = cnv->get_schedule()->get_next_halt(cnv->get_owner(),halt);
+				halthandle_t next_halt = cnst->get_schedule()->get_next_halt(cnst->get_owner(),halt);
 				if(  next_halt.is_bound()  ) {
-					halt_info_t::dest_info_t next( next_halt, delta_t+2000, cnv );
+					halt_info_t::dest_info_t next( next_halt, delta_t+2000, cnst );
 					destinations.insert_ordered( next, compare_hi );
 				}
 			}
@@ -445,15 +445,15 @@
 		}
 	}
 
-	FOR( vector_tpl<convoihandle_t>, cnv, halt->registered_convoys ) {
-		if(  cnv.is_bound()  &&  ( cnv->get_state() == convoi_t::DRIVING  ||  cnv->is_waiting() )  &&  haltestelle_t::get_halt( cnv->get_schedule()->get_current_eintrag().pos, cnv->get_owner() ) == halt  ) {
-			halthandle_t prev_halt = haltestelle_t::get_halt( cnv->front()->last_stop_pos, cnv->get_owner() );
-			sint32 delta_t = cur_ticks + calc_ticks_until_arrival( cnv );
+	FOR( vector_tpl<consist_handle_t>, cnst, halt->registered_consists ) {
+		if(  cnst.is_bound()  &&  ( cnst->get_state() == consist_t::DRIVING  ||  cnst->is_waiting() )  &&  haltestelle_t::get_halt( cnst->get_schedule()->get_current_eintrag().pos, cnst->get_owner() ) == halt  ) {
+			halthandle_t prev_halt = haltestelle_t::get_halt( cnst->front()->last_stop_pos, cnst->get_owner() );
+			sint32 delta_t = cur_ticks + calc_ticks_until_arrival( cnst );
 			if(  prev_halt.is_bound()  ) {
-				halt_info_t::dest_info_t prev( prev_halt, delta_t, cnv );
+				halt_info_t::dest_info_t prev( prev_halt, delta_t, cnst );
 				// smooth times a little
 				FOR( vector_tpl<dest_info_t>, &elem, old_origins ) {
-					if(  elem.cnv == cnv ) {
+					if(  elem.cnst == cnst ) {
 						delta_t = ( delta_t + 3*elem.delta_ticks ) / 4;
 						prev.delta_ticks = delta_t;
 						break;
@@ -461,9 +461,9 @@
 				}
 				origins.insert_ordered( prev, compare_hi );
 			}
-			halthandle_t next_halt = cnv->get_schedule()->get_next_halt(cnv->get_owner(),halt);
+			halthandle_t next_halt = cnst->get_schedule()->get_next_halt(cnst->get_owner(),halt);
 			if(  next_halt.is_bound()  ) {
-				halt_info_t::dest_info_t next( next_halt, delta_t+2000, cnv );
+				halt_info_t::dest_info_t next( next_halt, delta_t+2000, cnst );
 				destinations.insert_ordered( next, compare_hi );
 			}
 		}
Index: gui/halt_info.h
===================================================================
--- gui/halt_info.h	(revision 7957)
+++ gui/halt_info.h	(working copy)
@@ -63,10 +63,10 @@
 		bool compare( const dest_info_t &other ) const;
 		halthandle_t halt;
 		sint32 delta_ticks;
-		convoihandle_t cnv;
+		consist_handle_t cnst;
 		dest_info_t() : delta_ticks(0) {}
-		dest_info_t( halthandle_t h, sint32 d_t, convoihandle_t c ) : halt(h), delta_ticks(d_t), cnv(c) {}
-		bool operator == (const dest_info_t &other) const { return ( this->cnv==other.cnv ); }
+		dest_info_t( halthandle_t h, sint32 d_t, consist_handle_t c ) : halt(h), delta_ticks(d_t), cnst(c) {}
+		bool operator == (const dest_info_t &other) const { return ( this->cnst==other.cnst ); }
 	};
 
 	static bool compare_hi(const dest_info_t &a, const dest_info_t &b) { return a.delta_ticks <= b.delta_ticks; }
@@ -78,7 +78,7 @@
 	// if nothing changed, this is the next refresh to recalculate the content of the departure board
 	sint8 next_refresh;
 
-	uint32 calc_ticks_until_arrival( convoihandle_t cnv );
+	uint32 calc_ticks_until_arrival( consist_handle_t cnst );
 
 	void update_departures();
 
Index: gui/halt_list_frame.cc
===================================================================
--- gui/halt_list_frame.cc	(revision 7957)
+++ gui/halt_list_frame.cc	(working copy)
@@ -365,7 +365,7 @@
 					j++;
 				}
 			}
-			// let gui_convoiinfo_t() handle this, since then it will be automatically consistent
+			// let gui_consistinfo_t() handle this, since then it will be automatically consistent
 			return stops[i-1].infowin_event( ev );
 		}
 	}
Index: gui/help_frame.cc
===================================================================
--- gui/help_frame.cc	(revision 7957)
+++ gui/help_frame.cc	(working copy)
@@ -116,8 +116,8 @@
 	add_helpfile( toolbars, NULL, "removal_tool.txt", true, 0 );
 	add_helpfile( toolbars, "LISTTOOLS", "list.txt", false, 0 );
 	add_helpfile( toolbars, NULL, "citylist_filter.txt", false, 1 );
-	add_helpfile( toolbars, NULL, "convoi.txt", false, 1 );
-	add_helpfile( toolbars, NULL, "convoi_filter.txt", false, 2 );
+	add_helpfile( toolbars, NULL, "consist.txt", false, 1 );
+	add_helpfile( toolbars, NULL, "consist_filter.txt", false, 2 );
 	add_helpfile( toolbars, NULL, "curiositylist_filter.txt", false, 1 );
 	add_helpfile( toolbars, NULL, "factorylist_filter.txt", false, 1 );
 	add_helpfile( toolbars, NULL, "goods_filter.txt", false, 1 );
@@ -139,8 +139,8 @@
 	add_helpfile( how_to_play, NULL, "underground.txt", true, 0 );
 	add_helpfile( how_to_play, NULL, "citywindow.txt", true, 0 );
 	add_helpfile( how_to_play, NULL, "depot.txt", false, 0 );
-	add_helpfile( how_to_play, NULL, "convoiinfo.txt", false, 0 );
-	add_helpfile( how_to_play, NULL, "convoidetail.txt", false, 1 );
+	add_helpfile( how_to_play, NULL, "consistinfo.txt", false, 0 );
+	add_helpfile( how_to_play, NULL, "consistdetail.txt", false, 1 );
 	add_helpfile( how_to_play, "Line Management", "linemanagement.txt", false, 0 );
 	add_helpfile( how_to_play, "Fahrplan", "schedule.txt", false, 1 );
 	add_helpfile( how_to_play, NULL, "station.txt", false, 0 );
Index: gui/karte.cc
===================================================================
--- gui/karte.cc	(revision 7957)
+++ gui/karte.cc	(working copy)
@@ -1,6 +1,6 @@
 #include "../simevent.h"
 #include "../simcolor.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../vehicle/simvehicle.h"
 #include "../simworld.h"
 #include "../simdepot.h"
@@ -105,13 +105,13 @@
 
 
 // add the schedule to the map (if there is a valid one)
-void reliefkarte_t::add_to_schedule_cache( convoihandle_t cnv, bool with_waypoints )
+void reliefkarte_t::add_to_schedule_cache( consist_handle_t cnst, bool with_waypoints )
 {
 	// make sure this is valid!
-	if(  !cnv.is_bound()  ) {
+	if(  !cnst.is_bound()  ) {
 		return;
 	}
-	schedule_t *fpl = cnv->get_schedule();
+	schedule_t *fpl = cnst->get_schedule();
 	if(  !show_network_load_factor  ) {
 		colore += 8;
 		if(  colore >= 208  ) {
@@ -125,10 +125,10 @@
 		//TODO: extract common part from with schedule_list_gui_t::display()
 		int capacity = 0, load = 0; // total capacity and load of line (=sum of all conv's cap/load)
 
-		if(cnv->get_line().is_bound()) {
-			for(  uint i = 0;  i < cnv->get_line()->count_convoys();  i++  ) {
-				convoihandle_t const cnv_in_line = cnv->get_line()->get_convoy(i);
-				// we do not want to count the capacity of depot convois
+		if(cnst->get_line().is_bound()) {
+			for(  uint i = 0;  i < cnst->get_line()->count_consists();  i++  ) {
+				consist_handle_t const cnv_in_line = cnst->get_line()->get_consist(i);
+				// we do not want to count the capacity of depot consists
 				if(  !cnv_in_line->in_depot()  ) {
 					for(  unsigned j = 0;  j < cnv_in_line->get_vehicle_count();  j++  ) {
 						capacity += cnv_in_line->get_vehikel(j)->get_cargo_max();
@@ -138,11 +138,11 @@
 			}
 		}
 		else {
-			// we do not want to count the capacity of depot convois
-			if(!cnv->in_depot()) {
-				for(unsigned j = 0; j < cnv->get_vehicle_count(); j++) {
-					capacity += cnv->get_vehikel(j)->get_cargo_max();
-					load += cnv->get_vehikel(j)->get_total_cargo();
+			// we do not want to count the capacity of depot consists
+			if(!cnst->in_depot()) {
+				for(unsigned j = 0; j < cnst->get_vehicle_count(); j++) {
+					capacity += cnst->get_vehikel(j)->get_cargo_max();
+					load += cnst->get_vehikel(j)->get_total_cargo();
 				}
 			}
 		}
@@ -159,7 +159,7 @@
 	}
 
 	// ok, add this schedule to map
-	// from here on we have a valid convoi
+	// from here on we have a valid consist
 	int stops = 0;
 	uint8 old_offset = 0, first_offset = 0, temp_offset = 0;
 	koord old_stop, first_stop, temp_stop;
@@ -170,7 +170,7 @@
 
 		//cycle on stops
 		//try to read station's coordinates if there's a station at this schedule stop
-		halthandle_t station = haltestelle_t::get_halt( cur.pos, cnv->get_owner() );
+		halthandle_t station = haltestelle_t::get_halt( cur.pos, cnst->get_owner() );
 		if(  station.is_bound()  ) {
 			stop_cache.append_unique( station );
 			temp_stop = station->get_basis_pos();
@@ -208,7 +208,7 @@
 			if(  (temp_stop.x-old_stop.x)*(temp_stop.y-old_stop.y) == 0  ) {
 				last_diagonal = false;
 			}
-			if(  !schedule_cache.insert_unique_ordered( line_segment_t( temp_stop, temp_offset, old_stop, old_offset, fpl, cnv->get_owner(), colore, last_diagonal ), LineSegmentOrdering() )  &&  add_schedule  ) {
+			if(  !schedule_cache.insert_unique_ordered( line_segment_t( temp_stop, temp_offset, old_stop, old_offset, fpl, cnst->get_owner(), colore, last_diagonal ), LineSegmentOrdering() )  &&  add_schedule  ) {
 				// append if added and not yet there
 				if(  !pt_list->is_contained( fpl )  ) {
 					pt_list->append( fpl );
@@ -237,7 +237,7 @@
 	if(  stops > 2  ) {
 		// connect to start
 		last_diagonal ^= true;
-		schedule_cache.insert_unique_ordered( line_segment_t( first_stop, first_offset, old_stop, old_offset, fpl, cnv->get_owner(), colore, last_diagonal ), LineSegmentOrdering() );
+		schedule_cache.insert_unique_ordered( line_segment_t( first_stop, first_offset, old_stop, old_offset, fpl, cnst->get_owner(), colore, last_diagonal ), LineSegmentOrdering() );
 	}
 }
 
@@ -578,7 +578,7 @@
 {
 	// if map is in normal mode, set new color for map
 	// otherwise do nothing
-	// result: convois will not "paint over" special maps
+	// result: consists will not "paint over" special maps
 	if (relief==NULL  ||  !welt->is_within_limits(k_)) {
 		return;
 	}
@@ -764,7 +764,7 @@
 	}
 	const grund_t *gr=plan->get_boden_bei(plan->get_boden_count()-1);
 
-	if(  mode!=MAP_PAX_DEST  &&  gr->get_convoi_vehicle()  ) {
+	if(  mode!=MAP_PAX_DEST  &&  gr->get_consist_vehicle()  ) {
 		set_relief_farbe( k, VEHIKEL_KENN );
 		return;
 	}
@@ -822,7 +822,7 @@
 			}
 			break;
 
-		// show traffic (=convois/month)
+		// show traffic (=consists/month)
 		case MAP_TRAFFIC:
 			// need to init the maximum?
 			if(  max_passed==0  ) {
@@ -1029,7 +1029,7 @@
 	max_building_level = max_cargo = max_passed = 0;
 	max_tourist_ziele = max_waiting = max_origin = max_transfer = max_service = 1;
 	last_schedule_counter = welt->get_schedule_counter()-1;
-	set_current_cnv(convoihandle_t());
+	set_current_cnv(consist_handle_t());
 }
 
 
@@ -1066,7 +1066,7 @@
 
 	// recenter
 	if(IS_LEFTCLICK(ev) || IS_LEFTDRAG(ev)) {
-		welt->get_viewport()->set_follow_convoi( convoihandle_t() );
+		welt->get_viewport()->set_follow_consist( consist_handle_t() );
 		int z = 0;
 		if(welt->is_within_limits(k)) {
 			z = welt->min_hgt(k);
@@ -1107,7 +1107,7 @@
 			if (fab2) {
 				const scr_coord end = karte_to_screen( lieferziel ) + pos;
 				display_direct_line(fabpos.x, fabpos.y, end.x, end.y, colour);
-				display_fillbox_wh_clip(end.x, end.y, 3, 3, ((welt->get_zeit_ms() >> 10) & 1) == 0 ? COL_RED : COL_WHITE, true);
+				display_fillbox_wh_clip(end.x, end.y, 3, 3, ((welt->get_ticks() >> 10) & 1) == 0 ? COL_RED : COL_WHITE, true);
 
 				scr_coord boxpos = end + scr_coord(10, 0);
 				const char * name = translator::translate(fab2->get_name());
@@ -1122,7 +1122,7 @@
 
 
 // show the schedule on the minimap
-void reliefkarte_t::set_current_cnv( convoihandle_t c )
+void reliefkarte_t::set_current_cnv( consist_handle_t c )
 {
 	current_cnv = c;
 	schedule_cache.clear();
@@ -1238,53 +1238,53 @@
 							continue;
 						}
 
-						// ware matches; now find at least a running convoi on this line ...
-						convoihandle_t cnv;
-						for(  uint32 k = 0;  k < linee[j]->count_convoys();  k++  ) {
-							convoihandle_t test_cnv = linee[j]->get_convoy(k);
+						// ware matches; now find at least a running consist on this line ...
+						consist_handle_t cnst;
+						for(  uint32 k = 0;  k < linee[j]->count_consists();  k++  ) {
+							consist_handle_t test_cnv = linee[j]->get_consist(k);
 							if(  test_cnv.is_bound()  ) {
 								int state = test_cnv->get_state();
-								if( state != convoi_t::INITIAL  &&  state != convoi_t::ENTERING_DEPOT  &&  state != convoi_t::SELF_DESTRUCT  ) {
-									cnv = test_cnv;
+								if( state != consist_t::INITIAL  &&  state != consist_t::ENTERING_DEPOT  &&  state != consist_t::SELF_DESTRUCT  ) {
+									cnst = test_cnv;
 									break;
 								}
 							}
 						}
-						if(  !cnv.is_bound()  ) {
+						if(  !cnst.is_bound()  ) {
 							continue;
 						}
-						int state = cnv->get_state();
-						if( state != convoi_t::INITIAL  &&  state != convoi_t::ENTERING_DEPOT  &&  state != convoi_t::SELF_DESTRUCT  ) {
-							add_to_schedule_cache( cnv, false );
+						int state = cnst->get_state();
+						if( state != consist_t::INITIAL  &&  state != consist_t::ENTERING_DEPOT  &&  state != consist_t::SELF_DESTRUCT  ) {
+							add_to_schedule_cache( cnst, false );
 						}
 					}
 				}
 			}
 
-			// now add all unbound convois
+			// now add all unbound consists
 			player_t * required_vehicle_owner = NULL;
 			if (player_showed_on_map != -1) {
 				required_vehicle_owner = welt->get_player(player_showed_on_map);
 			}
-			FOR( vector_tpl<convoihandle_t>, cnv, welt->convoys() ) {
-				if(  !cnv.is_bound()  ||  cnv->get_line().is_bound()  ) {
+			FOR( vector_tpl<consist_handle_t>, cnst, welt->consists() ) {
+				if(  !cnst.is_bound()  ||  cnst->get_line().is_bound()  ) {
 					// not there or already part of a line
 					continue;
 				}
-				if(  required_vehicle_owner!= NULL  &&  required_vehicle_owner != cnv->get_owner()  ) {
+				if(  required_vehicle_owner!= NULL  &&  required_vehicle_owner != cnst->get_owner()  ) {
 					continue;
 				}
 				if(  transport_type_showed_on_map != simline_t::line  ) {
-					if(  transport_type_showed_on_map != simline_t::get_linetype(cnv->front()->get_waytype())  ) {
+					if(  transport_type_showed_on_map != simline_t::get_linetype(cnst->front()->get_waytype())  ) {
 						continue;
 					}
 				}
-				int state = cnv->get_state();
-				if(  state != convoi_t::INITIAL  &&  state != convoi_t::ENTERING_DEPOT  &&  state != convoi_t::SELF_DESTRUCT  ) {
-					if(  !is_matching_freight_catg(cnv->get_goods_catg_index())  ) {
+				int state = cnst->get_state();
+				if(  state != consist_t::INITIAL  &&  state != consist_t::ENTERING_DEPOT  &&  state != consist_t::SELF_DESTRUCT  ) {
+					if(  !is_matching_freight_catg(cnst->get_goods_catg_index())  ) {
 						continue;
 					}
-					add_to_schedule_cache( cnv, false );
+					add_to_schedule_cache( cnst, false );
 				}
 			}
 		}
@@ -1346,7 +1346,7 @@
 
 			COLOR_VAL color = seg.colorcount;
 			if(  event_get_last_control_shift()==2  ||  current_cnv.is_bound()  ) {
-				// on control / single convoi use only player colors
+				// on control / single consist use only player colors
 				static COLOR_VAL last_color = color;
 				color = seg.player->get_player_color1()+1;
 				// all lines same thickness if same color
@@ -1725,7 +1725,7 @@
 
 bool reliefkarte_t::is_matching_freight_catg(const minivec_tpl<uint8> &goods_catg_index)
 {
-	// does this line/convoi has a matching freight
+	// does this line/consist has a matching freight
 	if(  freight_type_group_index_showed_on_map == warenbauer_t::passagiere  ) {
 		return goods_catg_index.is_contained(warenbauer_t::INDEX_PAS);
 	}
Index: gui/karte.h
===================================================================
--- gui/karte.h	(revision 7957)
+++ gui/karte.h	(working copy)
@@ -4,7 +4,7 @@
 #include "components/gui_komponente.h"
 #include "../halthandle_t.h"
 #include "../simline.h"
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 #include "../dataobj/schedule.h"
 #include "../tpl/array2d_tpl.h"
 #include "../tpl/vector_tpl.h"
@@ -118,12 +118,12 @@
 		bool operator()(const reliefkarte_t::line_segment_t& a, const reliefkarte_t::line_segment_t& b) const;
 	};
 	vector_tpl<line_segment_t> schedule_cache;
-	convoihandle_t current_cnv;
+	consist_handle_t current_cnv;
 	uint8 last_schedule_counter;
 	vector_tpl<halthandle_t> stop_cache;
 
 	// adds a schedule to cache
-	void add_to_schedule_cache( convoihandle_t cnv, bool with_waypoints );
+	void add_to_schedule_cache( consist_handle_t cnst, bool with_waypoints );
 
 	/**
 	 * map mode: -1) normal; everything else: special map
@@ -195,7 +195,7 @@
 	// needed for town passenger map
 	static uint8 calc_relief_farbe(const grund_t *gr);
 
-	// public, since the convoi updates need this
+	// public, since the consist updates need this
 	// nonstatic, if we have someday many maps ...
 	void set_relief_farbe(koord k, int color);
 
@@ -235,7 +235,7 @@
 
 	void draw(scr_coord pos);
 
-	void set_current_cnv( convoihandle_t c );
+	void set_current_cnv( consist_handle_t c );
 
 	void set_city( const stadt_t* _city );
 
Index: gui/line_item.cc
===================================================================
--- gui/line_item.cc	(revision 7957)
+++ gui/line_item.cc	(working copy)
@@ -63,7 +63,7 @@
 			case SORT_BY_CONVOIS:
 				return (a->get_line()->get_finance_history(1,LINE_CONVOIS) - b->get_line()->get_finance_history(1,LINE_CONVOIS))<0;
 			case SORT_BY_DISTANCE:
-				// normalizing to the number of convoys to get the fastest ones ...
+				// normalizing to the number of consists to get the fastest ones ...
 				return (a->get_line()->get_finance_history(1,LINE_DISTANCE)/max(1,a->get_line()->get_finance_history(1,LINE_CONVOIS)) -
 						b->get_line()->get_finance_history(1,LINE_DISTANCE)/max(1,b->get_line()->get_finance_history(1,LINE_CONVOIS)) )<0;
 			default: break;
Index: gui/line_management_gui.cc
===================================================================
--- gui/line_management_gui.cc	(revision 7957)
+++ gui/line_management_gui.cc	(working copy)
@@ -17,12 +17,12 @@
 #include "line_management_gui.h"
 
 line_management_gui_t::line_management_gui_t(linehandle_t line, player_t* player_) :
-	fahrplan_gui_t(line->get_schedule()->copy(), player_, convoihandle_t() )
+	fahrplan_gui_t(line->get_schedule()->copy(), player_, consist_handle_t() )
 {
 	this->line = line;
-	// has this line a single running convoi?
-	if(  line->count_convoys() > 0  ) {
-		reliefkarte_t::get_karte()->set_current_cnv( line->get_convoy(0) );
+	// has this line a single running consist?
+	if(  line->count_consists() > 0  ) {
+		reliefkarte_t::get_karte()->set_current_cnv( line->get_consist(0) );
 	}
 	show_line_selector(false);
 }
@@ -79,7 +79,7 @@
 
 void line_management_gui_t::rdwr(loadsave_t *file)
 {
-	// this handles only schedules of bound convois
+	// this handles only schedules of bound consists
 	// lines are handled by line_management_gui_t
 	uint8 player_nr;
 	scr_size size = get_windowsize();
Index: gui/map_frame.cc
===================================================================
--- gui/map_frame.cc	(revision 7957)
+++ gui/map_frame.cc	(working copy)
@@ -89,7 +89,7 @@
 	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Status", "Show capacity and if halt is overcrowded", reliefkarte_t::MAP_STATUS },
 	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "hl_btn_sort_waiting", "Show how many people/much is waiting at halts", reliefkarte_t::MAP_WAITING },
 	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Queueing", "Show the change of waiting at halts", reliefkarte_t::MAP_WAITCHANGE },
-	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Service", "Show how many convoi reach a station", reliefkarte_t::MAP_SERVICE },
+	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Service", "Show how many consist reach a station", reliefkarte_t::MAP_SERVICE },
 	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Transfers", "Sum of departure/arrivals at halts", reliefkarte_t::MAP_TRANSFER },
 	{ COL_LIGHT_PURPLE, COL_DARK_PURPLE, "Origin", "Show initial passenger departure", reliefkarte_t::MAP_ORIGIN },
 	{ COL_WHITE,        COL_GREY5,       "Traffic", "Show usage of network", reliefkarte_t::MAP_TRAFFIC },
Index: gui/schedule_list.cc
===================================================================
--- gui/schedule_list.cc	(revision 7957)
+++ gui/schedule_list.cc	(working copy)
@@ -12,7 +12,7 @@
 #include "messagebox.h"
 #include "schedule_list.h"
 #include "line_management_gui.h"
-#include "components/gui_convoiinfo.h"
+#include "components/gui_consistinfo.h"
 #include "line_item.h"
 #include "simwin.h"
 
@@ -23,7 +23,7 @@
 #include "../simevent.h"
 #include "../display/simgraph.h"
 #include "../simskin.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../vehicle/simvehicle.h"
 #include "../simlinemgmt.h"
 #include "../simmenu.h"
@@ -117,7 +117,7 @@
 schedule_list_gui_t::schedule_list_gui_t(player_t *player_) :
 	gui_frame_t( translator::translate("Line Management"), player_),
 	player(player_),
-	scrolly_convois(&cont),
+	scrolly_consists(&cont),
 	scrolly_haltestellen(&cont_haltestellen),
 	scl(gui_scrolled_list_t::listskin),
 	lbl_filter("Line Filter")
@@ -211,7 +211,7 @@
 	bt_delete_line.init(button_t::roundbox, "Delete Line",
 		scr_coord(D_MARGIN_LEFT+2*(D_BUTTON_WIDTH+D_H_SPACE), D_MARGIN_TOP+SCL_HEIGHT+D_V_SPACE+D_BUTTON_HEIGHT+D_V_SPACE),
 		scr_size(D_BUTTON_WIDTH, D_BUTTON_HEIGHT));
-	bt_delete_line.set_tooltip("Delete the selected line (if without associated convois).");
+	bt_delete_line.set_tooltip("Delete the selected line (if without associated consists).");
 	bt_delete_line.add_listener(this);
 	bt_delete_line.disable();
 	add_component(&bt_delete_line);
@@ -237,13 +237,13 @@
 	filled_bar.set_visible(false);
 	add_component(&filled_bar);
 
-	// convoi list
+	// consist list
 	cont.set_size(scr_size(200, 40));
-	scrolly_convois.set_pos(scr_coord(RIGHT_COLUMN_OFFSET, D_MARGIN_TOP + SCL_HEIGHT+ 2*D_BUTTON_HEIGHT+D_V_SPACE+2*LINESPACE+D_V_SPACE));
-	scrolly_convois.set_show_scroll_x(true);
-	scrolly_convois.set_scroll_amount_y(40);
-	scrolly_convois.set_visible(false);
-	add_component(&scrolly_convois);
+	scrolly_consists.set_pos(scr_coord(RIGHT_COLUMN_OFFSET, D_MARGIN_TOP + SCL_HEIGHT+ 2*D_BUTTON_HEIGHT+D_V_SPACE+2*LINESPACE+D_V_SPACE));
+	scrolly_consists.set_show_scroll_x(true);
+	scrolly_consists.set_scroll_amount_y(40);
+	scrolly_consists.set_visible(false);
+	add_component(&scrolly_consists);
 
 
 	bt_withdraw_line.init(button_t::roundbox_state, "Withdraw All",
@@ -313,16 +313,16 @@
 	if(  ev->ev_class == INFOWIN  ) {
 		if(  ev->ev_code == WIN_CLOSE  ) {
 			// hide schedule on minimap (may not current, but for safe)
-			reliefkarte_t::get_karte()->set_current_cnv( convoihandle_t() );
+			reliefkarte_t::get_karte()->set_current_cnv( consist_handle_t() );
 		}
 		else if(  (ev->ev_code==WIN_OPEN  ||  ev->ev_code==WIN_TOP)  &&  line.is_bound() ) {
-			if(  line->count_convoys()>0  ) {
+			if(  line->count_consists()>0  ) {
 				// set this schedule as current to show on minimap if possible
-				reliefkarte_t::get_karte()->set_current_cnv( line->get_convoy(0) );
+				reliefkarte_t::get_karte()->set_current_cnv( line->get_consist(0) );
 			}
 			else {
 				// set this schedule as current to show on minimap if possible
-				reliefkarte_t::get_karte()->set_current_cnv( convoihandle_t() );
+				reliefkarte_t::get_karte()->set_current_cnv( consist_handle_t() );
 			}
 		}
 	}
@@ -481,7 +481,7 @@
 	gui_frame_t::draw(pos, size);
 
 	if(  line.is_bound()  ) {
-		if(  (!line->get_schedule()->empty()  &&  !line->get_schedule()->matches( welt, last_schedule ))  ||  last_vehicle_count != line->count_convoys()  ) {
+		if(  (!line->get_schedule()->empty()  &&  !line->get_schedule()->matches( welt, last_schedule ))  ||  last_vehicle_count != line->count_consists()  ) {
 			update_lineinfo( line );
 		}
 		PUSH_CLIP( pos.x + 1, pos.y + D_TITLEBAR_HEIGHT, size.w - 2, size.h - D_TITLEBAR_HEIGHT);
@@ -493,7 +493,7 @@
 
 void schedule_list_gui_t::display(scr_coord pos)
 {
-	uint32 icnv = line->count_convoys();
+	uint32 icnv = line->count_consists();
 
 	cbuffer_t buf;
 	char ctmp[128];
@@ -503,12 +503,12 @@
 	sint64 profit = line->get_finance_history(0,LINE_PROFIT);
 
 	for(  uint32 i=0;  i<icnv;  i++  ) {
-		convoihandle_t const cnv = line->get_convoy(i);
-		// we do not want to count the capacity of depot convois
-		if(  !cnv->in_depot()  ) {
-			for(  unsigned j=0;  j<cnv->get_vehicle_count();  j++  ) {
-				capacity += cnv->get_vehikel(j)->get_cargo_max();
-				load += cnv->get_vehikel(j)->get_total_cargo();
+		consist_handle_t const cnst = line->get_consist(i);
+		// we do not want to count the capacity of depot consists
+		if(  !cnst->in_depot()  ) {
+			for(  unsigned j=0;  j<cnst->get_vehicle_count();  j++  ) {
+				capacity += cnst->get_vehikel(j)->get_cargo_max();
+				load += cnst->get_vehikel(j)->get_total_cargo();
 			}
 		}
 	}
@@ -522,15 +522,15 @@
 
 	switch(  icnv  ) {
 		case 0: {
-			buf.append( translator::translate("no convois") );
+			buf.append( translator::translate("no consists") );
 			break;
 		}
 		case 1: {
-			buf.append( translator::translate("1 convoi") );
+			buf.append( translator::translate("1 consist") );
 			break;
 		}
 		default: {
-			buf.printf( translator::translate("%d convois"), icnv) ;
+			buf.printf( translator::translate("%d consists"), icnv) ;
 			break;
 		}
 	}
@@ -562,7 +562,7 @@
 	int button_per_row = max(1, (rest_width+D_H_SPACE)/(D_BUTTON_WIDTH+D_H_SPACE));
 	int button_rows = MAX_LINE_COST/button_per_row + ((MAX_LINE_COST%button_per_row)!=0);
 
-	scrolly_convois.set_size( scr_size(rest_width, get_client_windowsize().h-scrolly_convois.get_pos().y) );
+	scrolly_consists.set_size( scr_size(rest_width, get_client_windowsize().h-scrolly_consists.get_pos().y) );
 	scrolly_haltestellen.set_size( scr_size(RIGHT_COLUMN_OFFSET-2*D_V_SPACE, get_client_windowsize().h-scrolly_haltestellen.get_pos().y) );
 
 	chart.set_size( scr_size( rest_width, SCL_HEIGHT-D_MARGIN_TOP-(button_rows*(D_BUTTON_HEIGHT+D_H_SPACE)) ) );
@@ -614,21 +614,21 @@
 	}
 	if(  new_line.is_bound()  ) {
 		// ok, this line is visible
-		scrolly_convois.set_visible(true);
+		scrolly_consists.set_visible(true);
 		scrolly_haltestellen.set_visible(true);
 		inp_name.set_visible(true);
 		filled_bar.set_visible(true);
 
-		// fill container with info of line's convoys
+		// fill container with info of line's consists
 		// we do it here, since this list needs only to be
 		// refreshed when the user selects a new line
 		uint32 icnv = 0;
-		icnv = new_line->count_convoys();
-		// display convoys of line
+		icnv = new_line->count_consists();
+		// display consists of line
 		cont.remove_all();
 		scr_coord_val ypos = 0;
 		for(  uint32 i=0;  i<icnv;  i++  ) {
-			gui_convoiinfo_t* const cinfo = new gui_convoiinfo_t(new_line->get_convoy(i));
+			gui_consistinfo_t* const cinfo = new gui_consistinfo_t(new_line->get_consist(i));
 			cinfo->set_pos(scr_coord(0, ypos));
 			cinfo->set_size(scr_size(400, 40));
 			cont.add_component(cinfo);
@@ -674,18 +674,18 @@
 		}
 		chart.set_visible(true);
 
-		// has this line a single running convoy?
-		if(  new_line.is_bound()  &&  new_line->count_convoys()>0  ) {
+		// has this line a single running consist?
+		if(  new_line.is_bound()  &&  new_line->count_consists()>0  ) {
 			// set this schedule as current to show on minimap if possible
-			reliefkarte_t::get_karte()->set_current_cnv( new_line->get_convoy(0) );
+			reliefkarte_t::get_karte()->set_current_cnv( new_line->get_consist(0) );
 		}
 		else {
-			reliefkarte_t::get_karte()->set_current_cnv( convoihandle_t() );
+			reliefkarte_t::get_karte()->set_current_cnv( consist_handle_t() );
 		}
 
 		delete last_schedule;
 		last_schedule = new_line->get_schedule()->copy();
-		last_vehicle_count = new_line->count_convoys();
+		last_vehicle_count = new_line->count_consists();
 	}
 	else if(  inp_name.is_visible()  ) {
 		// previously a line was visible
@@ -693,7 +693,7 @@
 		cont.remove_all();
 		inp_name.set_visible(false);
 		filled_bar.set_visible(false);
-		scrolly_convois.set_visible(false);
+		scrolly_consists.set_visible(false);
 		scrolly_haltestellen.set_visible(false);
 		inp_name.set_visible(false);
 		filled_bar.set_visible(false);
@@ -706,7 +706,7 @@
 		chart.set_visible(true);
 
 		// hide schedule on minimap (may not current, but for safe)
-		reliefkarte_t::get_karte()->set_current_cnv( convoihandle_t() );
+		reliefkarte_t::get_karte()->set_current_cnv( consist_handle_t() );
 
 		delete last_schedule;
 		last_schedule = NULL;
@@ -765,8 +765,8 @@
 	sint32 cont_xoff, cont_yoff, halt_xoff, halt_yoff;
 	if(  file->is_saving()  ) {
 		size = get_windowsize();
-		cont_xoff = scrolly_convois.get_scroll_x();
-		cont_yoff = scrolly_convois.get_scroll_y();
+		cont_xoff = scrolly_consists.get_scroll_x();
+		cont_yoff = scrolly_consists.get_scroll_y();
 		halt_xoff = scrolly_haltestellen.get_scroll_x();
 		halt_yoff = scrolly_haltestellen.get_scroll_y();
 	}
@@ -789,7 +789,7 @@
 		show_lineinfo( line );
 		set_windowsize( size );
 		resize( scr_coord(0,0) );
-		scrolly_convois.set_scroll_position( cont_xoff, cont_yoff );
+		scrolly_consists.set_scroll_position( cont_xoff, cont_yoff );
 		scrolly_haltestellen.set_scroll_position( halt_xoff, halt_yoff );
 	}
 }
Index: gui/schedule_list.h
===================================================================
--- gui/schedule_list.h	(revision 7957)
+++ gui/schedule_list.h	(working copy)
@@ -18,7 +18,7 @@
 #include "components/gui_scrolled_list.h"
 #include "components/gui_scrollpane.h"
 #include "components/gui_tab_panel.h"
-#include "components/gui_convoiinfo.h"
+#include "components/gui_consistinfo.h"
 #include "../simline.h"
 
 class player_t;
@@ -33,7 +33,7 @@
 
 	button_t bt_new_line, bt_edit_line, bt_delete_line, bt_withdraw_line;
 	gui_container_t cont, cont_haltestellen;
-	gui_scrollpane_t scrolly_convois, scrolly_haltestellen;
+	gui_scrollpane_t scrolly_consists, scrolly_haltestellen;
 	gui_scrolled_list_t scl;
 	gui_speedbar_t filled_bar;
 	gui_textinput_t inp_name, inp_filter;
Index: gui/server_frame.cc
===================================================================
--- gui/server_frame.cc	(revision 7957)
+++ gui/server_frame.cc	(working copy)
@@ -244,7 +244,7 @@
 	number_to_string( temp, gi.get_einwohnerzahl(), 0 );
 	buf.printf( "%s %s\n", translator::translate("citicens"), temp );
 	buf.printf( "%s %u\n", translator::translate("Factories"), gi.get_industries() );
-	buf.printf( "%s %u\n", translator::translate("Convoys"), gi.get_convoi_count() );
+	buf.printf( "%s %u\n", translator::translate("Convoys"), gi.get_consist_count() );
 	buf.printf( "%s %u\n", translator::translate("Stops"), gi.get_halt_count() );
 
 	revision_buf.clear();
Index: gui/simwin.cc
===================================================================
--- gui/simwin.cc	(revision 7957)
+++ gui/simwin.cc	(working copy)
@@ -62,8 +62,8 @@
 #include "money_frame.h"
 #include "halt_detail.h"
 #include "halt_info.h"
-#include "convoi_detail_t.h"
-#include "convoi_info_t.h"
+#include "consist_detail_t.h"
+#include "consist_info_t.h"
 #include "fahrplan_gui.h"
 #include "line_management_gui.h"
 #include "schedule_list.h"
@@ -501,8 +501,8 @@
 					case magic_none: return;
 
 					// actual dialogues to restore
-					case magic_convoi_info:    w = new convoi_info_t(); break;
-					case magic_convoi_detail:  w = new convoi_detail_t(); break;
+					case magic_consist_info:    w = new consist_info_t(); break;
+					case magic_consist_detail:  w = new consist_detail_t(); break;
 					case magic_themes:         w = new themeselector_t(); break;
 					case magic_halt_info:      w = new halt_info_t(); break;
 					case magic_halt_detail:    w = new halt_detail_t(); break;
@@ -1587,7 +1587,7 @@
 		}
 	}
 
-	char const *time = tick_to_string( wl->get_zeit_ms(), true );
+	char const *time = tick_to_string( wl->get_ticks(), true );
 
 	// statusbar background
 	display_set_clip_wh( 0, 0, disp_width, disp_height );
Index: gui/simwin.h
===================================================================
--- gui/simwin.h	(revision 7957)
+++ gui/simwin.h	(working copy)
@@ -69,9 +69,9 @@
 	magic_mainhelp,
 	// player dependent stuff => 16 times present
 	magic_finances_t,
-	magic_convoi_list=magic_finances_t+MAX_PLAYER_COUNT,
-	magic_convoi_list_filter=magic_convoi_list+MAX_PLAYER_COUNT,
-	magic_line_list=magic_convoi_list_filter+MAX_PLAYER_COUNT,
+	magic_consist_list=magic_finances_t+MAX_PLAYER_COUNT,
+	magic_consist_list_filter=magic_consist_list+MAX_PLAYER_COUNT,
+	magic_line_list=magic_consist_list_filter+MAX_PLAYER_COUNT,
 	magic_halt_list=magic_line_list+MAX_PLAYER_COUNT,
 	magic_line_management_t=magic_halt_list+MAX_PLAYER_COUNT,
 	magic_ai_options_t=magic_line_management_t+MAX_PLAYER_COUNT,
@@ -98,10 +98,10 @@
 	magic_schedule_rdwr_dummy,	// only used to save/load schedules
 	magic_line_schedule_rdwr_dummy,	// only used to save/load line schedules
 	magic_motd,
-	magic_convoi_info,
+	magic_consist_info,
 	magic_factory_info,
-	magic_convoi_detail=magic_convoi_info+65536,
-	magic_halt_info=magic_convoi_detail+65536,
+	magic_consist_detail=magic_consist_info+65536,
+	magic_halt_info=magic_consist_detail+65536,
 	magic_halt_detail=magic_halt_info+65536,
 	magic_toolbar=magic_halt_detail+65536,
 	magic_info_pointer=magic_toolbar+256,
Index: gui/welt.cc
===================================================================
--- gui/welt.cc	(revision 7957)
+++ gui/welt.cc	(working copy)
@@ -41,7 +41,7 @@
 #include "../simcity.h"
 #include "../vehicle/simvehicle.h"
 #include "../player/simplay.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 
 #include "../simcolor.h"
 
@@ -646,7 +646,7 @@
 	const uint64 memory = (
 		(uint64)sizeof(karte_t) +
 		sizeof(player_t) * 8 +
-		sizeof(convoi_t) * 1000 +
+		sizeof(consist_t) * 1000 +
 		(sizeof(schiene_t) + sizeof(vehicle_t)) * 10 * (sx + sy) +
 		sizeof(stadt_t) * sets->get_city_count() +
 		(
Index: ifc/simtestdriver.h
===================================================================
--- ifc/simtestdriver.h	(revision 7957)
+++ ifc/simtestdriver.h	(working copy)
@@ -32,7 +32,7 @@
 
 	virtual waytype_t get_waytype() const = 0;
 
-	// how expensive to go here (for way search) with the maximum convoi speed as second parameter
+	// how expensive to go here (for way search) with the maximum consist speed as second parameter
 	virtual int get_cost(const grund_t *, const sint32, koord from_pos) const = 0;
 
 	// returns true for the way search to an unknown target.
Index: obj/field.cc
===================================================================
--- obj/field.cc	(revision 7957)
+++ obj/field.cc	(working copy)
@@ -66,7 +66,7 @@
 	}
 	else {
 		// resolution 1/8th month (0..95)
-		const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_zeit_ms()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
+		const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_ticks()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
 		const image_id bild = s->get_bild_nr( (count*yearsteps-1)/96 );
 		if((count*yearsteps-1)%96<count) {
 			mark_image_dirty( bild, 0 );
Index: obj/gebaeude.cc
===================================================================
--- obj/gebaeude.cc	(revision 7957)
+++ obj/gebaeude.cc	(working copy)
@@ -66,7 +66,7 @@
 	background_animated = false;
 	remove_ground = true;
 	anim_frame = 0;
-//	insta_zeit = 0; // init in set_tile()
+//	build_time = 0; // init in set_tile()
 	ptr.fab = NULL;
 }
 
@@ -176,9 +176,9 @@
 		if(  haus_besch->get_b(layout) > new_offset.x  &&  haus_besch->get_h(layout) > new_offset.y  ) {
 			const haus_tile_besch_t* const new_tile = haus_besch->get_tile(layout, new_offset.x, new_offset.y);
 			// add new tile: but make them old (no construction)
-			uint32 old_insta_zeit = insta_zeit;
+			uint32 old_build_time = build_time;
 			set_tile( new_tile, false );
-			insta_zeit = old_insta_zeit;
+			build_time = old_build_time;
 			if(  haus_besch->get_utyp() != haus_besch_t::dock  &&  !tile->has_image()  ) {
 				// may have a rotation, that is not recoverable
 				if(  !is_factory  &&  new_offset!=koord(0,0)  ) {
@@ -234,13 +234,13 @@
 /* make this building without construction */
 void gebaeude_t::add_alter(uint32 a)
 {
-	insta_zeit -= min(a,insta_zeit);
+	build_time -= min(a,build_time);
 }
 
 
 void gebaeude_t::set_tile( const haus_tile_besch_t *new_tile, bool start_with_construction )
 {
-	insta_zeit = welt->get_zeit_ms();
+	build_time = welt->get_ticks();
 
 	if(!zeige_baugrube  &&  tile!=NULL) {
 		// mark old tile dirty
@@ -285,7 +285,7 @@
 {
 	if(  zeige_baugrube  ) {
 		// still under construction?
-		if(  welt->get_zeit_ms() - insta_zeit > 5000  ) {
+		if(  welt->get_ticks() - build_time > 5000  ) {
 			set_flag( obj_t::dirty );
 			mark_image_dirty( get_image(), 0 );
 			zeige_baugrube = false;
@@ -710,7 +710,7 @@
 		file->rdwr_str(buf, lengthof(buf));
 	}
 	file->rdwr_short(idx);
-	file->rdwr_long(insta_zeit);
+	file->rdwr_long(build_time);
 
 	if(file->is_loading()) {
 		tile = hausbauer_t::find_tile(buf, idx);
Index: obj/gebaeude.h
===================================================================
--- obj/gebaeude.h	(revision 7957)
+++ obj/gebaeude.h	(working copy)
@@ -68,7 +68,7 @@
 	 * Zeitpunkt an dem das Gebaeude Gebaut wurde
 	 * @author Hj. Malthaner
 	 */
-	uint32 insta_zeit;
+	uint32 build_time;
 
 	/**
 	* either point to a factory or a city
Index: obj/groundobj.cc
===================================================================
--- obj/groundobj.cc	(revision 7957)
+++ obj/groundobj.cc	(working copy)
@@ -133,7 +133,7 @@
 				}
 				else {
 					// resolution 1/8th month (0..95)
-					const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_zeit_ms()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
+					const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_ticks()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
 					season = (seasons*yearsteps-1)/96;
 				}
 				break;
Index: obj/roadsign.cc
===================================================================
--- obj/roadsign.cc	(revision 7957)
+++ obj/roadsign.cc	(working copy)
@@ -468,7 +468,7 @@
 	}
 	else {
 		// change every ~32s
-		uint32 ticks = ((welt->get_zeit_ms()>>10)+ticks_offset) % (ticks_ns+ticks_ow);
+		uint32 ticks = ((welt->get_ticks()>>10)+ticks_offset) % (ticks_ns+ticks_ow);
 
 		uint8 new_zustand = (ticks >= ticks_ns) ^ (welt->get_settings().get_rotation() & 1);
 		if(zustand!=new_zustand) {
Index: obj/wolke.cc
===================================================================
--- obj/wolke.cc	(revision 7957)
+++ obj/wolke.cc	(working copy)
@@ -41,7 +41,7 @@
 	base_y_off = clamp( (sint16)y_off - 8, -128, 127 );
 	set_xoff( x_off );
 	set_yoff( base_y_off );
-	insta_zeit = 0;
+	build_time = 0;
 }
 
 
@@ -49,7 +49,7 @@
 wolke_t::~wolke_t()
 {
 	mark_image_dirty( get_image(), 0 );
-	if(  insta_zeit != 2499  ) {
+	if(  build_time != 2499  ) {
 		welt->sync_way_eyecandy.remove( this );
 	}
 }
@@ -65,7 +65,7 @@
 image_id wolke_t::get_image() const
 {
 	const skin_besch_t *besch = all_clouds[cloud_nr];
-	return besch->get_bild_nr( (insta_zeit*besch->get_count())/2500 );
+	return besch->get_bild_nr( (build_time*besch->get_count())/2500 );
 }
 
 
@@ -78,7 +78,7 @@
 	obj_t::rdwr( file );
 
 	cloud_nr = 0;
-	insta_zeit = 0;
+	build_time = 0;
 
 	uint32 ldummy = 0;
 	file->rdwr_long(ldummy);
@@ -95,14 +95,14 @@
 
 sync_result wolke_t::sync_step(uint32 delta_t)
 {
-	insta_zeit += delta_t;
-	if(insta_zeit>=2499) {
+	build_time += delta_t;
+	if(build_time>=2499) {
 		// delete wolke ...
-		insta_zeit = 2499;
+		build_time = 2499;
 		return SYNC_DELETE;
 	}
 	// move cloud up
-	sint8 ymove = ((insta_zeit*OBJECT_OFFSET_STEPS) >> 12);
+	sint8 ymove = ((build_time*OBJECT_OFFSET_STEPS) >> 12);
 	if(  base_y_off-ymove!=get_yoff()  ) {
 		// move/change cloud ... (happens much more often than image change => image change will be always done when drawing)
 		if(!get_flag(obj_t::dirty)) {
@@ -123,7 +123,7 @@
 	obj_t::rotate90();
 	// .. and recalc smoke offsets
 	base_y_off = clamp( (sint16)get_yoff()-8, -128, 127 );
-	set_yoff( base_y_off - ((insta_zeit*OBJECT_OFFSET_STEPS) >> 12) );
+	set_yoff( base_y_off - ((build_time*OBJECT_OFFSET_STEPS) >> 12) );
 }
 
 /***************************** just for compatibility, the old raucher and smoke clouds *********************************/
Index: obj/wolke.h
===================================================================
--- obj/wolke.h	(revision 7957)
+++ obj/wolke.h	(working copy)
@@ -17,7 +17,7 @@
 private:
 	static vector_tpl<const skin_besch_t *>all_clouds;
 
-	uint16 insta_zeit;	// clouds vanish when insta_zeit>2500 => maximum 5 images ...
+	uint16 build_time;	// clouds vanish when build_time>2500 => maximum 5 images ...
 	sint8 base_y_off;
 	sint8 cloud_nr;
 
Index: player/ai.cc
===================================================================
--- player/ai.cc	(revision 7957)
+++ player/ai.cc	(working copy)
@@ -11,7 +11,7 @@
 #include "ai.h"
 
 #include "../simcity.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simhalt.h"
 #include "../simintr.h"
 #include "../simmenu.h"
Index: player/ai_goods.cc
===================================================================
--- player/ai_goods.cc	(revision 7957)
+++ player/ai_goods.cc	(working copy)
@@ -1,7 +1,7 @@
 
 /* standard good AI code */
 
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simfab.h"
 #include "../simmenu.h"
 #include "../simtypes.h"
@@ -359,10 +359,10 @@
 	const vehikel_besch_t *v_second = NULL;
 	if(ship_vehicle->get_leistung()==0) {
 		v_second = ship_vehicle;
-		if(v_second->get_vorgaenger_count()==0  ||  v_second->get_vorgaenger(0)==NULL) {
+		if(v_second->get_leading_count()==0  ||  v_second->get_leading(0)==NULL) {
 			// pushed barge?
-			if(ship_vehicle->get_nachfolger_count()>0  &&  ship_vehicle->get_nachfolger(0)!=NULL) {
-				v_second = ship_vehicle->get_nachfolger(0);
+			if(ship_vehicle->get_trailing_count()>0  &&  ship_vehicle->get_trailing(0)!=NULL) {
+				v_second = ship_vehicle->get_trailing(0);
 			}
 			else {
 				return false;
@@ -369,13 +369,13 @@
 			}
 		}
 		else {
-			ship_vehicle = v_second->get_vorgaenger(0);
+			ship_vehicle = v_second->get_leading(0);
 		}
 	}
 	DBG_MESSAGE( "ai_goods_t::create_ship_transport_vehikel()", "for %i ships", anz_vehikel );
 
-	if(  convoihandle_t::is_exhausted()  ) {
-		// too many convois => cannot do anything about this ...
+	if(  consist_handle_t::is_exhausted()  ) {
+		// too many consists => cannot do anything about this ...
 		return false;
 	}
 
@@ -422,26 +422,26 @@
 	linehandle_t line=simlinemgmt.create_line(simline_t::shipline,this,fpl);
 	delete fpl;
 
-	// now create all vehicles as convois
+	// now create all vehicles as consists
 	for(int i=0;  i<anz_vehikel;  i++) {
-		if(  convoihandle_t::is_exhausted()  ) {
-			// too many convois => cannot do anything about this ...
+		if(  consist_handle_t::is_exhausted()  ) {
+			// too many consists => cannot do anything about this ...
 			return i>0;
 		}
 		vehicle_t* v = vehikelbauer_t::baue( qfab->get_pos(), this, NULL, ship_vehicle);
-		convoi_t* cnv = new convoi_t(this);
-		// V.Meyer: give the new convoi name from first vehicle
-		cnv->set_name(v->get_besch()->get_name());
-		cnv->add_vehikel( v );
+		consist_t* cnst = new consist_t(this);
+		// V.Meyer: give the new consist name from first vehicle
+		cnst->set_name(v->get_besch()->get_name());
+		cnst->add_vehikel( v );
 
 		// two part consist
 		if(v_second!=NULL) {
 			v = vehikelbauer_t::baue( qfab->get_pos(), this, NULL, v_second );
-			cnv->add_vehikel( v );
+			cnst->add_vehikel( v );
 		}
 
-		cnv->set_line(line);
-		cnv->start();
+		cnst->set_line(line);
+		cnst->start();
 	}
 	clean_marker(platz1,size1);
 	clean_marker(platz2,size2);
@@ -485,20 +485,20 @@
 		linehandle_t line=simlinemgmt.create_line(simline_t::truckline,this,fpl);
 		delete fpl;
 
-		// now create all vehicles as convois
+		// now create all vehicles as consists
 		for(int i=0;  i<anz_vehikel;  i++) {
-			if(  convoihandle_t::is_exhausted()  ) {
-				// too many convois => cannot do anything about this ...
+			if(  consist_handle_t::is_exhausted()  ) {
+				// too many consists => cannot do anything about this ...
 				return;
 			}
 			vehicle_t* v = vehikelbauer_t::baue(startpos, this, NULL, road_vehicle);
-			convoi_t* cnv = new convoi_t(this);
-			// V.Meyer: give the new convoi name from first vehicle
-			cnv->set_name(v->get_besch()->get_name());
-			cnv->add_vehikel( v );
+			consist_t* cnst = new consist_t(this);
+			// V.Meyer: give the new consist name from first vehicle
+			cnst->set_name(v->get_besch()->get_name());
+			cnst->add_vehikel( v );
 
-			cnv->set_line(line);
-			cnv->start();
+			cnst->set_line(line);
+			cnst->start();
 		}
 	}
 }
@@ -511,11 +511,11 @@
 void ai_goods_t::create_rail_transport_vehikel(const koord platz1, const koord platz2, int anz_vehikel, int ladegrad)
 {
 	schedule_t *fpl;
-	if(  convoihandle_t::is_exhausted()  ) {
-		// too many convois => cannot do anything about this ...
+	if(  consist_handle_t::is_exhausted()  ) {
+		// too many consists => cannot do anything about this ...
 		return;
 	}
-	convoi_t* cnv = new convoi_t(this);
+	consist_t* cnst = new consist_t(this);
 	koord3d pos1= welt->lookup_kartenboden(platz1)->get_pos();
 	koord3d pos2 = welt->lookup_kartenboden(platz2)->get_pos();
 
@@ -534,9 +534,9 @@
 	koord3d start_pos = welt->lookup_kartenboden(pos1.get_2d() + (abs(size1.x)>abs(size1.y) ? koord(size1.x,0) : koord(0,size1.y)))->get_pos();
 	vehicle_t* v = vehikelbauer_t::baue( start_pos, this, NULL, rail_engine);
 
-	// V.Meyer: give the new convoi name from first vehicle
-	cnv->set_name(rail_engine->get_name());
-	cnv->add_vehikel( v );
+	// V.Meyer: give the new consist name from first vehicle
+	cnst->set_name(rail_engine->get_name());
+	cnst->add_vehikel( v );
 
 	DBG_MESSAGE( "ai_goods_t::create_rail_transport_vehikel","for %i cars",anz_vehikel);
 
@@ -546,10 +546,10 @@
 	for(int i = 0; i < anz_vehikel; i++) {
 		// use the vehicle we searched before
 		vehicle_t* v = vehikelbauer_t::baue(start_pos, this, NULL, rail_vehicle);
-		cnv->add_vehikel( v );
+		cnst->add_vehikel( v );
 	}
 
-	fpl = cnv->front()->generate_new_schedule();
+	fpl = cnst->front()->generate_new_schedule();
 
 	fpl->set_aktuell( 0 );
 	fpl->append(welt->lookup(pos1), ladegrad);
@@ -556,8 +556,8 @@
 	fpl->append(welt->lookup(pos2), 0);
 	fpl->eingabe_abschliessen();
 
-	cnv->set_schedule(fpl);
-	cnv->start();
+	cnst->set_schedule(fpl);
+	cnst->start();
 }
 
 
@@ -789,7 +789,7 @@
 	}
 
 	if(  finance->get_netwealth() < (finance->get_starting_money()/8)  ) {
-		// nothing to do but to remove unneeded convois to gain some money
+		// nothing to do but to remove unneeded consists to gain some money
 		state = CHECK_CONVOI;
 	}
 
@@ -816,7 +816,7 @@
 					root = pick_any_weighted(start_fabs);
 				}
 			}
-			// still nothing => we have to check convois ...
+			// still nothing => we have to check consists ...
 			if(root==NULL) {
 				state = CHECK_CONVOI;
 			}
@@ -1153,11 +1153,11 @@
 						linehandle_t line = lines.back();
 						schedule_t *fpl=line->get_schedule();
 						if(fpl->get_count()>1  &&  haltestelle_t::get_halt(fpl->eintrag[0].pos,this)==start_halt) {
-							while(line->count_convoys()>0) {
-								convoihandle_t cnv = line->get_convoy(0);
-								cnv->self_destruct();
-								if(cnv.is_bound()) {
-									cnv->step();
+							while(line->count_consists()>0) {
+								consist_handle_t cnst = line->get_consist(0);
+								cnst->self_destruct();
+								if(cnst.is_bound()) {
+									cnst->step();
 								}
 							}
 							simlinemgmt.delete_line( line );
@@ -1212,33 +1212,33 @@
 		{
 			next_construction_steps = welt->get_steps() + ((1+finance->get_account_overdrawn())>0)*simrand( ai_t::construction_speed ) + 25;
 
-			for (size_t i = welt->convoys().get_count(); i-- != 0;) {
-				convoihandle_t const cnv = welt->convoys()[i];
-				if(!cnv.is_bound()  ||  cnv->get_owner()!=this) {
+			for (size_t i = welt->consists().get_count(); i-- != 0;) {
+				consist_handle_t const cnst = welt->consists()[i];
+				if(!cnst.is_bound()  ||  cnst->get_owner()!=this) {
 					continue;
 				}
 
-				if (cnv->front()->get_waytype() == water_wt) {
-					// ships will be only deleted together with the connecting convoi
+				if (cnst->front()->get_waytype() == water_wt) {
+					// ships will be only deleted together with the connecting consist
 					continue;
 				}
 
 				sint64 gewinn = 0;
 				for( int j=0;  j<12;  j++  ) {
-					gewinn += cnv->get_finance_history( j, convoi_t::CONVOI_PROFIT );
+					gewinn += cnst->get_finance_history( j, consist_t::CONVOI_PROFIT );
 				}
 
 				// apparently we got the toatlly wrong vehicle here ...
 				// (but we will delete it only, if we need, because it may be needed for a chain)
-				bool delete_this = (finance->get_account_overdrawn() > 0)  &&  (gewinn < -cnv->calc_restwert());
+				bool delete_this = (finance->get_account_overdrawn() > 0)  &&  (gewinn < -cnst->calc_restwert());
 
 				// check for empty vehicles (likely stucked) that are making no plus and remove them ...
 				// take care, that the vehicle is old enough ...
-				if (!delete_this && (welt->get_current_month() - cnv->front()->get_purchase_time()) > 6 && gewinn <= 0) {
+				if (!delete_this && (welt->get_current_month() - cnst->front()->get_purchase_time()) > 6 && gewinn <= 0) {
 					sint64 goods=0;
 					// no goods for six months?
 					for( int i=0;  i<6;  i ++) {
-						goods += cnv->get_finance_history( i, convoi_t::CONVOI_TRANSPORTED_GOODS );
+						goods += cnst->get_finance_history( i, consist_t::CONVOI_TRANSPORTED_GOODS );
 					}
 					delete_this = (goods==0);
 				}
@@ -1245,24 +1245,24 @@
 
 				// well, then delete this (likely stucked somewhere) or insanely unneeded
 				if(delete_this) {
-					waytype_t const wt = cnv->front()->get_besch()->get_waytype();
-					linehandle_t line = cnv->get_line();
-					DBG_MESSAGE("ai_goods_t::do_ki()","%s retires convoi %s!", get_name(), cnv->get_name());
+					waytype_t const wt = cnst->front()->get_besch()->get_waytype();
+					linehandle_t line = cnst->get_line();
+					DBG_MESSAGE("ai_goods_t::do_ki()","%s retires consist %s!", get_name(), cnst->get_name());
 
 					koord3d start_pos, end_pos;
-					schedule_t *fpl = cnv->get_schedule();
+					schedule_t *fpl = cnst->get_schedule();
 					if(fpl  &&  fpl->get_count()>1) {
 						start_pos = fpl->eintrag[0].pos;
 						end_pos = fpl->eintrag[1].pos;
 					}
 
-					cnv->self_destruct();
-					if(cnv.is_bound()) {
-						cnv->step();	// to really get rid of it
+					cnst->self_destruct();
+					if(cnst.is_bound()) {
+						cnst->step();	// to really get rid of it
 					}
 
 					// last vehicle on that connection (no line => railroad)
-					if(  !line.is_bound()  ||  line->count_convoys()==0  ) {
+					if(  !line.is_bound()  ||  line->count_consists()==0  ) {
 						// check if a conncetion boat must be removed
 						halthandle_t start_halt = haltestelle_t::get_halt(start_pos,this);
 						if(start_halt.is_bound()  &&  (start_halt->get_station_type()&haltestelle_t::dock)!=0) {
@@ -1274,11 +1274,11 @@
 								schedule_t *fpl=line->get_schedule();
 								if(fpl->get_count()>1  &&  haltestelle_t::get_halt(fpl->eintrag[0].pos,this)==start_halt) {
 									water_stop = koord( (start_pos.x+fpl->eintrag[0].pos.x)/2, (start_pos.y+fpl->eintrag[0].pos.y)/2 );
-									while(line->count_convoys()>0) {
-										convoihandle_t cnv = line->get_convoy(0);
-										cnv->self_destruct();
-										if(cnv.is_bound()) {
-											cnv->step();
+									while(line->count_consists()>0) {
+										consist_handle_t cnst = line->get_consist(0);
+										cnst->self_destruct();
+										if(cnst.is_bound()) {
+											cnst->step();
 										}
 									}
 									simlinemgmt.delete_line( line );
@@ -1300,8 +1300,8 @@
 						tool.exit( this );
 					}
 					else {
-						// last convoi => remove completely<
-						if(line.is_bound()  &&  line->count_convoys()==0) {
+						// last consist => remove completely<
+						if(line.is_bound()  &&  line->count_consists()==0) {
 							simlinemgmt.delete_line( line );
 
 							char param[16];
@@ -1311,7 +1311,7 @@
 							tool.init( this );
 							tool.work( this, start_pos );
 							if(tool.work( this, end_pos )!=NULL) {
-								// cannot remove all => likely some other convois there too
+								// cannot remove all => likely some other consists there too
 								// remove loading bays and road on start and end, if we cannot remove the whole way
 								tool.work( this, start_pos );
 								tool.work( this, start_pos );
@@ -1509,14 +1509,14 @@
  * @author prissi
  * @date 30-Dec-2008
  */
-void ai_goods_t::report_vehicle_problem(convoihandle_t cnv,const koord3d ziel)
+void ai_goods_t::report_vehicle_problem(consist_handle_t cnst,const koord3d ziel)
 {
-	if(  cnv->get_state() == convoi_t::NO_ROUTE  &&  this!=welt->get_active_player()  ) {
-			DBG_MESSAGE("ai_passenger_t::bescheid_vehikel_problem","Vehicle %s can't find a route to (%i,%i)!", cnv->get_name(),ziel.x,ziel.y);
-			cnv->self_destruct();
+	if(  cnst->get_state() == consist_t::NO_ROUTE  &&  this!=welt->get_active_player()  ) {
+			DBG_MESSAGE("ai_passenger_t::bescheid_vehikel_problem","Vehicle %s can't find a route to (%i,%i)!", cnst->get_name(),ziel.x,ziel.y);
+			cnst->self_destruct();
 			return;
 	}
-	player_t::report_vehicle_problem( cnv, ziel );
+	player_t::report_vehicle_problem( cnst, ziel );
 }
 
 
Index: player/ai_goods.h
===================================================================
--- player/ai_goods.h	(revision 7957)
+++ player/ai_goods.h	(working copy)
@@ -48,7 +48,7 @@
 	const vehikel_besch_t *road_vehicle;
 	const vehikel_besch_t *ship_vehicle;
 
-	// and the convoi will run on this track:
+	// and the consist will run on this track:
 	const weg_besch_t *rail_weg;
 	const weg_besch_t *road_weg;
 
@@ -118,7 +118,7 @@
 
 	virtual void rdwr(loadsave_t *file);
 
-	virtual void report_vehicle_problem(convoihandle_t cnv,const koord3d ziel);
+	virtual void report_vehicle_problem(consist_handle_t cnst,const koord3d ziel);
 
 	bool set_active( bool b );
 
Index: player/ai_passenger.cc
===================================================================
--- player/ai_passenger.cc	(revision 7957)
+++ player/ai_passenger.cc	(working copy)
@@ -8,7 +8,7 @@
 /* simple passenger AI (not using trains, not preoptimized network) */
 
 #include "../simcity.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simfab.h"
 #include "../simhalt.h"
 #include "../simline.h"
@@ -185,8 +185,8 @@
 		return false;
 	}
 
-	if(  convoihandle_t::is_exhausted()  ) {
-		// too many convois => cannot do anything about this ...
+	if(  consist_handle_t::is_exhausted()  ) {
+		// too many consists => cannot do anything about this ...
 		return false;
 	}
 
@@ -428,11 +428,11 @@
 
 	// now create one ship
 	vehicle_t* v = vehikelbauer_t::baue( koord3d( start_pos, welt->get_water_hgt( start_pos ) ), this, NULL, v_besch );
-	convoi_t* cnv = new convoi_t(this);
-	cnv->set_name(v->get_besch()->get_name());
-	cnv->add_vehikel( v );
-	cnv->set_line(line);
-	cnv->start();
+	consist_t* cnst = new consist_t(this);
+	cnst->set_name(v->get_besch()->get_name());
+	cnst->add_vehikel( v );
+	cnst->set_line(line);
+	cnst->start();
 
 	// eventually build a shuttle bus ...
 	if(start_connect_hub.is_bound()  &&  start_connect_hub!=start_hub) {
@@ -625,8 +625,8 @@
 		return false;
 	}
 
-	if(  convoihandle_t::is_exhausted()  ) {
-		// too many convois => cannot do anything about this ...
+	if(  consist_handle_t::is_exhausted()  ) {
+		// too many consists => cannot do anything about this ...
 		return false;
 	}
 
@@ -747,11 +747,11 @@
 
 	// now create one plane
 	vehicle_t* v = vehikelbauer_t::baue( start->get_pos(), this, NULL, v_besch);
-	convoi_t* cnv = new convoi_t(this);
-	cnv->set_name(v->get_besch()->get_name());
-	cnv->add_vehikel( v );
-	cnv->set_line(line);
-	cnv->start();
+	consist_t* cnst = new consist_t(this);
+	cnst->set_name(v->get_besch()->get_name());
+	cnst->add_vehikel( v );
+	cnst->set_line(line);
+	cnst->start();
 
 	// eventually build a airport shuttle bus ...
 	if(start_connect_hub.is_bound()  &&  start_connect_hub!=start_hub) {
@@ -789,20 +789,20 @@
 	linehandle_t line=simlinemgmt.create_line(simline_t::truckline,this,fpl);
 	delete fpl;
 
-	// now create all vehicles as convois
+	// now create all vehicles as consists
 	for(int i=0;  i<anz_vehikel;  i++) {
 		vehicle_t* v = vehikelbauer_t::baue(startpos, this, NULL, road_vehicle);
-		if(  convoihandle_t::is_exhausted()  ) {
-			// too many convois => cannot do anything about this ...
+		if(  consist_handle_t::is_exhausted()  ) {
+			// too many consists => cannot do anything about this ...
 			return;
 		}
-		convoi_t* cnv = new convoi_t(this);
-		// V.Meyer: give the new convoi name from first vehicle
-		cnv->set_name(v->get_besch()->get_name());
-		cnv->add_vehikel( v );
+		consist_t* cnst = new consist_t(this);
+		// V.Meyer: give the new consist name from first vehicle
+		cnst->set_name(v->get_besch()->get_name());
+		cnst->add_vehikel( v );
 
-		cnv->set_line(line);
-		cnv->start();
+		cnst->set_line(line);
+		cnst->start();
 	}
 }
 
@@ -875,7 +875,7 @@
 					const haus_besch_t* bs = hausbauer_t::get_random_station(haus_besch_t::generic_stop, road_wt, welt->get_timeline_year_month(), haltestelle_t::PAX);
 					if(  call_general_tool( TOOL_BUILD_STATION, to->get_pos().get_2d(), bs->get_name() )  ) {
 						//add to line
-						line->get_schedule()->append(to,0); // no need to register it yet; done automatically, when convois will be assinged
+						line->get_schedule()->append(to,0); // no need to register it yet; done automatically, when consists will be assinged
 					}
 				}
 				// start road, but no houses anywhere => stop searching
@@ -895,8 +895,8 @@
  */
 void ai_passenger_t::cover_city_with_bus_route(koord start_pos, int number_of_stops)
 {
-	if(  convoihandle_t::is_exhausted()  ) {
-		// too many convois => cannot do anything about this ...
+	if(  consist_handle_t::is_exhausted()  ) {
+		// too many consists => cannot do anything about this ...
 		return;
 	}
 
@@ -916,13 +916,13 @@
 	if( line->get_schedule()->get_count()>1  ) {
 		// success: add a bus to the line
 		vehicle_t* v = vehikelbauer_t::baue(start->get_pos(), this, NULL, road_vehicle);
-		convoi_t* cnv = new convoi_t(this);
+		consist_t* cnst = new consist_t(this);
 
-		cnv->set_name(v->get_besch()->get_name());
-		cnv->add_vehikel( v );
+		cnst->set_name(v->get_besch()->get_name());
+		cnst->add_vehikel( v );
 
-		cnv->set_line(line);
-		cnv->start();
+		cnst->set_line(line);
+		cnst->start();
 	}
 	else {
 		simlinemgmt.delete_line( line );
@@ -1283,7 +1283,7 @@
 				}
 
 				// remove empty lines
-				if(line->count_convoys()==0) {
+				if(line->count_consists()==0) {
 					simlinemgmt.delete_line(line);
 					break;
 				}
@@ -1294,37 +1294,37 @@
 				// made loss with this line
 				if(line->get_finance_history(0,LINE_PROFIT)<0) {
 					// try to update the vehicles
-					if(welt->use_timeline()  &&  line->count_convoys()>1) {
+					if(welt->use_timeline()  &&  line->count_consists()>1) {
 						// do not update unimportant lines with single vehicles
-						slist_tpl <convoihandle_t> obsolete;
+						slist_tpl <consist_handle_t> obsolete;
 						uint32 capacity = 0;
-						for(  uint i=0;  i<line->count_convoys();  i++  ) {
-							convoihandle_t cnv = line->get_convoy(i);
-							if(cnv->has_obsolete_vehicles()) {
-								obsolete.append(cnv);
-								capacity += cnv->front()->get_besch()->get_zuladung();
+						for(  uint i=0;  i<line->count_consists();  i++  ) {
+							consist_handle_t cnst = line->get_consist(i);
+							if(cnst->has_obsolete_vehicles()) {
+								obsolete.append(cnst);
+								capacity += cnst->front()->get_besch()->get_zuladung();
 							}
 						}
 						if(capacity>0) {
 							// now try to finde new vehicle
-							vehicle_t              const& v       = *line->get_convoy(0)->front();
+							vehicle_t              const& v       = *line->get_consist(0)->front();
 							waytype_t              const  wt      = v.get_waytype();
 							vehikel_besch_t const* const  v_besch = vehikelbauer_t::vehikel_search(wt, welt->get_current_month(), 50, welt->get_average_speed(wt), warenbauer_t::passagiere, false, true);
 							if (!v_besch->is_retired(welt->get_current_month()) && v_besch != v.get_besch()) {
 								// there is a newer one ...
 								for(  uint32 new_capacity=0;  capacity>new_capacity;  new_capacity+=v_besch->get_zuladung()) {
-									if(  convoihandle_t::is_exhausted()  ) {
-										// too many convois => cannot do anything about this ...
+									if(  consist_handle_t::is_exhausted()  ) {
+										// too many consists => cannot do anything about this ...
 										break;
 									}
 									vehicle_t* v = vehikelbauer_t::baue( line->get_schedule()->eintrag[0].pos, this, NULL, v_besch  );
-									convoi_t* new_cnv = new convoi_t(this);
+									consist_t* new_cnv = new consist_t(this);
 									new_cnv->set_name( v->get_besch()->get_name() );
 									new_cnv->add_vehikel( v );
 									new_cnv->set_line(line);
 									new_cnv->start();
 								}
-								// delete all old convois
+								// delete all old consists
 								while(!obsolete.empty()) {
 									obsolete.remove_first()->self_destruct();
 								}
@@ -1333,7 +1333,7 @@
 						}
 					}
 				}
-				// next: check for stucked convois ...
+				// next: check for stucked consists ...
 
 				sint64	free_cap = line->get_finance_history(0,LINE_CAPACITY);
 				sint64	used_cap = line->get_finance_history(0,LINE_TRANSPORTED_GOODS);
@@ -1345,15 +1345,15 @@
 				sint32 ratio = (sint32)((free_cap*100l)/(free_cap+used_cap));
 
 				// next: check for overflowing lines, i.e. running with 3/4 of the capacity
-				if(  ratio<10  &&  !convoihandle_t::is_exhausted()  ) {
-					// else add the first convoi again
-					vehicle_t* const v = vehikelbauer_t::baue(line->get_schedule()->eintrag[0].pos, this, NULL, line->get_convoy(0)->front()->get_besch());
-					convoi_t* new_cnv = new convoi_t(this);
+				if(  ratio<10  &&  !consist_handle_t::is_exhausted()  ) {
+					// else add the first consist again
+					vehicle_t* const v = vehikelbauer_t::baue(line->get_schedule()->eintrag[0].pos, this, NULL, line->get_consist(0)->front()->get_besch());
+					consist_t* new_cnv = new consist_t(this);
 					new_cnv->set_name( v->get_besch()->get_name() );
 					new_cnv->add_vehikel( v );
 					new_cnv->set_line( line );
 					// on waiting line, wait at alternating stations for load balancing
-					if(  line->get_schedule()->eintrag[1].ladegrad==90  &&  line->get_linetype()!=simline_t::truckline  &&  (line->count_convoys()&1)==0  ) {
+					if(  line->get_schedule()->eintrag[1].ladegrad==90  &&  line->get_linetype()!=simline_t::truckline  &&  (line->count_consists()&1)==0  ) {
 						new_cnv->get_schedule()->eintrag[0].ladegrad = 90;
 						new_cnv->get_schedule()->eintrag[1].ladegrad = 0;
 					}
@@ -1362,9 +1362,9 @@
 				}
 
 				// next: check for too many cars, i.e. running with too many cars
-				if(  ratio>40  &&  line->count_convoys()>1) {
-					// remove one convoi
-					line->get_convoy(0)->self_destruct();
+				if(  ratio>40  &&  line->count_consists()>1) {
+					// remove one consist
+					line->get_consist(0)->self_destruct();
 					return;
 				}
 			}
@@ -1453,14 +1453,14 @@
  * @author prissi
  * @date 30-Dec-2008
  */
-void ai_passenger_t::report_vehicle_problem(convoihandle_t cnv,const koord3d ziel)
+void ai_passenger_t::report_vehicle_problem(consist_handle_t cnst,const koord3d ziel)
 {
-	if(  cnv->get_state() == convoi_t::NO_ROUTE  &&  this!=welt->get_active_player()  ) {
-			DBG_MESSAGE("ai_passenger_t::bescheid_vehikel_problem","Vehicle %s can't find a route to (%i,%i)!", cnv->get_name(),ziel.x,ziel.y);
-			cnv->self_destruct();
+	if(  cnst->get_state() == consist_t::NO_ROUTE  &&  this!=welt->get_active_player()  ) {
+			DBG_MESSAGE("ai_passenger_t::bescheid_vehikel_problem","Vehicle %s can't find a route to (%i,%i)!", cnst->get_name(),ziel.x,ziel.y);
+			cnst->self_destruct();
 			return;
 	}
-	player_t::report_vehicle_problem( cnv, ziel );
+	player_t::report_vehicle_problem( cnst, ziel );
 }
 
 
Index: player/ai_passenger.h
===================================================================
--- player/ai_passenger.h	(revision 7957)
+++ player/ai_passenger.h	(working copy)
@@ -33,7 +33,7 @@
 	// we will use this vehicle!
 	const vehikel_besch_t *road_vehicle;
 
-	// and the convoi will run on this track:
+	// and the consist will run on this track:
 	const weg_besch_t *road_weg ;
 
 	// time to wait before next contruction
@@ -86,7 +86,7 @@
 	// cannot do rail
 	virtual void set_rail_transport( bool ) { rail_transport = false; }
 
-	virtual void report_vehicle_problem(convoihandle_t cnv,const koord3d ziel);
+	virtual void report_vehicle_problem(consist_handle_t cnst,const koord3d ziel);
 
 	virtual void rdwr(loadsave_t *file);
 
Index: player/ai_scripted.h
===================================================================
--- player/ai_scripted.h	(revision 7957)
+++ player/ai_scripted.h	(working copy)
@@ -65,7 +65,7 @@
 	void finish_rd() OVERRIDE;
 
 
-// 	void report_vehicle_problem(convoihandle_t cnv,const koord3d position) OVERRIDE;
+// 	void report_vehicle_problem(consist_handle_t cnst,const koord3d position) OVERRIDE;
 	/**
 	 * Tells the player that the factory
 	 * is going to be deleted (flag==0)
Index: player/finance.cc
===================================================================
--- player/finance.cc	(revision 7957)
+++ player/finance.cc	(working copy)
@@ -406,7 +406,7 @@
 	COST_TRANSPORTED_PAS,	// number of passengers that actually reached destination
 	COST_TRANSPORTED_MAIL,
 	COST_TRANSPORTED_GOOD,
-	COST_ALL_CONVOIS,		// number of convois
+	COST_ALL_CONVOIS,		// number of consists
 	COST_SCENARIO_COMPLETED,// scenario success (only useful if there is one ... )
 	COST_WAY_TOLLS,
 	// OLD_MAX_PLAYER_COST = 19
Index: player/finance.h
===================================================================
--- player/finance.h	(revision 7957)
+++ player/finance.h	(working copy)
@@ -199,10 +199,10 @@
 	}
 
 	/**
-	 * Adds count to number of convois in statistics.
+	 * Adds count to number of consists in statistics.
 	 * @author jk271
 	 */
-	inline void book_convoi_number( const int count ) {
+	inline void book_consist_number( const int count ) {
 		com_year[0][ATC_ALL_CONVOIS] += count;
 		com_month[0][ATC_ALL_CONVOIS] += count;
 	}
@@ -417,9 +417,9 @@
 	sint64 get_vehicle_maintenance_with_bits(transport_type tt=TT_ALL) const;
 
 	/**
-	 * @returns TRUE if there is at least one convoi, otherwise returns false
+	 * @returns TRUE if there is at least one consist, otherwise returns false
 	 */
-	bool has_convoi() const { return (com_year[0][ATC_ALL_CONVOIS] > 0); }
+	bool has_consist() const { return (com_year[0][ATC_ALL_CONVOIS] > 0); }
 
 	/**
 	 * returns TRUE if net wealth > 0 (but this of course requires that we keep netwealth up to date!)
Index: player/simplay.cc
===================================================================
--- player/simplay.cc	(revision 7957)
+++ player/simplay.cc	(working copy)
@@ -12,7 +12,7 @@
 #include <stdlib.h>
 #include <math.h>
 
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simdebug.h"
 #include "../simdepot.h"
 #include "../simhalt.h"
@@ -317,7 +317,7 @@
 				}
 			}
 			// no assets => nothing to go bankrupt about again
-			else if(  finance->get_maintenance(TT_ALL) != 0  ||  finance->has_convoi()  ) {
+			else if(  finance->get_maintenance(TT_ALL) != 0  ||  finance->has_consist()  ) {
 
 				// for AI, we only declare bankrupt, if total assets are below zero
 				if(  finance->get_netwealth() < 0  ) {
@@ -355,7 +355,7 @@
 			for(  uint16 y=0;  y<years  &&  no_cnv;  y++  ) {
 				no_cnv &= finance->get_history_com_year(y, ATC_ALL_CONVOIS)==0;
 			}
-			// never run a convoi => dummy
+			// never run a consist => dummy
 			if(  no_cnv  ) {
 				return false; // remove immediately
 			}
@@ -372,7 +372,7 @@
 			for(  uint16 y = 0;  y < years  &&  abandoned;  y++  ) {
 				abandoned &= finance->get_history_veh_year(TT_ALL, y, ATV_NEW_VEHICLE)==0  &&  finance->get_history_veh_year(TT_ALL, y, ATV_CONSTRUCTION_COST)==0;
 			}
-			// never changed convoi, never built => abandoned
+			// never changed consist, never built => abandoned
 			if(  abandoned  ) {
 				pwd_hash.clear();
 				locked = false;
@@ -396,16 +396,16 @@
 	for(int i=0; i < TT_MAX; ++i){
 		assets[i] = 0;
 	}
-	// all convois
-	FOR(vector_tpl<convoihandle_t>, const cnv, welt->convoys()) {
-		if(  cnv->get_owner() == this  ) {
-			sint64 restwert = cnv->calc_restwert();
+	// all consists
+	FOR(vector_tpl<consist_handle_t>, const cnst, welt->consists()) {
+		if(  cnst->get_owner() == this  ) {
+			sint64 restwert = cnst->calc_restwert();
 			assets[TT_ALL] += restwert;
-			assets[finance->translate_waytype_to_tt(cnv->front()->get_waytype())] += restwert;
+			assets[finance->translate_waytype_to_tt(cnst->front()->get_waytype())] += restwert;
 		}
 	}
 
-	// all vehikels stored in depot not part of a convoi
+	// all vehikels stored in depot not part of a consist
 	FOR(slist_tpl<depot_t*>, const depot, depot_t::get_depot_list()) {
 		if(  depot->get_player_nr() == player_nr  ) {
 			FOR(slist_tpl<vehicle_t*>, const veh, depot->get_vehicle_list()) {
@@ -448,24 +448,24 @@
 {
 	player_t *const psplayer = welt->get_public_player();
 
-	DBG_MESSAGE("player_t::ai_bankrupt()","Removing convois");
+	DBG_MESSAGE("player_t::ai_bankrupt()","Removing consists");
 
-	for (size_t i = welt->convoys().get_count(); i-- != 0;) {
-		convoihandle_t const cnv = welt->convoys()[i];
-		if(cnv->get_owner()!=this) {
+	for (size_t i = welt->consists().get_count(); i-- != 0;) {
+		consist_handle_t const cnst = welt->consists()[i];
+		if(cnst->get_owner()!=this) {
 			continue;
 		}
 
-		linehandle_t line = cnv->get_line();
+		linehandle_t line = cnst->get_line();
 
-		cnv->self_destruct();
-		// convois not in depots must step to really get rid of them
-		if(  cnv->get_state() != convoi_t::INITIAL  ) {
-			cnv->step();
+		cnst->self_destruct();
+		// consists not in depots must step to really get rid of them
+		if(  cnst->get_state() != consist_t::INITIAL  ) {
+			cnst->step();
 		}
 
 		// last vehicle on that connection (no line => railroad)
-		if(  !line.is_bound()  ||  line->count_convoys()==0  ) {
+		if(  !line.is_bound()  ||  line->count_consists()==0  ) {
 			simlinemgmt.delete_line( line );
 		}
 	}
@@ -773,32 +773,32 @@
 }
 
 
-void player_t::report_vehicle_problem(convoihandle_t cnv,const koord3d position)
+void player_t::report_vehicle_problem(consist_handle_t cnst,const koord3d position)
 {
-	switch(cnv->get_state()) {
+	switch(cnst->get_state()) {
 
-		case convoi_t::NO_ROUTE:
-DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s can't find a route to (%i,%i)!", cnv->get_name(),position.x,position.y);
+		case consist_t::NO_ROUTE:
+DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s can't find a route to (%i,%i)!", cnst->get_name(),position.x,position.y);
 			{
 				cbuffer_t buf;
-				buf.printf( translator::translate("Vehicle %s can't find a route!"), cnv->get_name());
-				welt->get_message()->add_message( (const char *)buf, cnv->get_pos().get_2d(), message_t::problems, PLAYER_FLAG | player_nr, cnv->front()->get_base_image());
+				buf.printf( translator::translate("Vehicle %s can't find a route!"), cnst->get_name());
+				welt->get_message()->add_message( (const char *)buf, cnst->get_pos().get_2d(), message_t::problems, PLAYER_FLAG | player_nr, cnst->front()->get_base_image());
 			}
 			break;
 
-		case convoi_t::WAITING_FOR_CLEARANCE_ONE_MONTH:
-		case convoi_t::CAN_START_ONE_MONTH:
-		case convoi_t::CAN_START_TWO_MONTHS:
-DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s stuck!", cnv->get_name(),position.x,position.y);
+		case consist_t::WAITING_FOR_CLEARANCE_ONE_MONTH:
+		case consist_t::CAN_START_ONE_MONTH:
+		case consist_t::CAN_START_TWO_MONTHS:
+DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s stuck!", cnst->get_name(),position.x,position.y);
 			{
 				cbuffer_t buf;
-				buf.printf( translator::translate("Vehicle %s is stucked!"), cnv->get_name());
-				welt->get_message()->add_message( (const char *)buf, cnv->get_pos().get_2d(), message_t::warnings, PLAYER_FLAG | player_nr, cnv->front()->get_base_image());
+				buf.printf( translator::translate("Vehicle %s is stucked!"), cnst->get_name());
+				welt->get_message()->add_message( (const char *)buf, cnst->get_pos().get_2d(), message_t::warnings, PLAYER_FLAG | player_nr, cnst->front()->get_base_image());
 			}
 			break;
 
 		default:
-DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s, state %i!", cnv->get_name(), cnv->get_state());
+DBG_MESSAGE("player_t::report_vehicle_problem","Vehicle %s, state %i!", cnst->get_name(), cnst->get_state());
 	}
 	(void)position;
 }
@@ -929,9 +929,9 @@
 }
 
 
-void player_t::book_convoi_number(int count)
+void player_t::book_consist_number(int count)
 {
-	finance->book_convoi_number(count);
+	finance->book_consist_number(count);
 }
 
 
Index: player/simplay.h
===================================================================
--- player/simplay.h	(revision 7957)
+++ player/simplay.h	(working copy)
@@ -12,7 +12,7 @@
 #include "../simlinemgmt.h"
 
 #include "../halthandle_t.h"
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 
 #include "../dataobj/koord.h"
 
@@ -118,11 +118,11 @@
 
 public:
 	/**
-	 * Sums up "count" with number of convois in statistics,
+	 * Sums up "count" with number of consists in statistics,
 	 * supersedes buche( count, COST_ALL_CONVOIS).
 	 * @author jk271
 	 */
-	void book_convoi_number(int count);
+	void book_consist_number(int count);
 
 	/**
 	 * Adds construction costs to accounting statistics.
@@ -354,7 +354,7 @@
 	 * @author Hansjörg Malthaner
 	 * @date 26-Nov-2001
 	 */
-	virtual void report_vehicle_problem(convoihandle_t cnv,const koord3d position);
+	virtual void report_vehicle_problem(consist_handle_t cnst,const koord3d position);
 
 	/**
 	 * Tells the player the result of tool-work commands.
Index: script/api/api.h
===================================================================
--- script/api/api.h	(revision 7957)
+++ script/api/api.h	(working copy)
@@ -8,7 +8,7 @@
 
 void export_city(HSQUIRRELVM vm);
 void export_control(HSQUIRRELVM vm);
-void export_convoy(HSQUIRRELVM vm);
+void export_consist(HSQUIRRELVM vm);
 void export_factory(HSQUIRRELVM vm);
 void export_goods_desc(HSQUIRRELVM vm);
 void export_gui(HSQUIRRELVM vm, bool scenario);
Index: script/api/api_halt.cc
===================================================================
--- script/api/api_halt.cc	(revision 7957)
+++ script/api/api_halt.cc	(working copy)
@@ -51,11 +51,11 @@
 }
 
 
-SQInteger halt_export_convoy_list(HSQUIRRELVM vm)
+SQInteger halt_export_consist_list(HSQUIRRELVM vm)
 {
 	halthandle_t halt = param<halthandle_t>::get(vm, 1);
 	if (halt.is_bound()) {
-		push_instance(vm, "convoy_list_x");
+		push_instance(vm, "consist_list_x");
 		set_slot(vm, "halt_id", halt.get_id());
 		return 1;
 	}
@@ -219,10 +219,10 @@
 	 */
 	register_method_fv(vm, &get_halt_stat, "get_noroute", freevariable<sint32>(HALT_NOROUTE), true);
 	/**
-	 * Get monthly statistics of number of convoys that stopped at this station.
+	 * Get monthly statistics of number of consists that stopped at this station.
 	 * @returns array, index [0] corresponds to current month
 	 */
-	register_method_fv(vm, &get_halt_stat, "get_convoys", freevariable<sint32>(HALT_CONVOIS_ARRIVED), true);
+	register_method_fv(vm, &get_halt_stat, "get_consists", freevariable<sint32>(HALT_CONVOIS_ARRIVED), true);
 	/**
 	 * Get monthly statistics of number of passengers that could walk to their destination.
 	 * @returns array, index [0] corresponds to current month
@@ -229,10 +229,10 @@
 	 */
 	register_method_fv(vm, &get_halt_stat, "get_walked", freevariable<sint32>(HALT_WALKED), true);
 	/**
-	 * Exports list of convoys that stop at this halt.
-	 * @typemask convoy_list_x()
+	 * Exports list of consists that stop at this halt.
+	 * @typemask consist_list_x()
 	 */
-	register_function(vm, &halt_export_convoy_list, "get_convoy_list", 1, param<halthandle_t>::typemask());
+	register_function(vm, &halt_export_consist_list, "get_consist_list", 1, param<halthandle_t>::typemask());
 	/**
 	 * Exports list of lines that serve this halt.
 	 * @typemask line_list_x()
Index: script/api/api_line.cc
===================================================================
--- script/api/api_line.cc	(revision 7957)
+++ script/api/api_line.cc	(working copy)
@@ -70,11 +70,11 @@
 	return "Invalid schedule provided";
 }
 
-SQInteger line_export_convoy_list(HSQUIRRELVM vm)
+SQInteger line_export_consist_list(HSQUIRRELVM vm)
 {
 	linehandle_t line = param<linehandle_t>::get(vm, 1);
 	if (line.is_bound()) {
-		push_instance(vm, "convoy_list_x");
+		push_instance(vm, "consist_list_x");
 		set_slot(vm, "line_id", line.get_id());
 		return 1;
 	}
@@ -181,7 +181,7 @@
 	 */
 	register_method(vm, &simline_t::get_schedule, "get_schedule");
 	/**
-	 * Returns array of goods categories that can be transported by this convoy.
+	 * Returns array of goods categories that can be transported by this consist.
 	 * @returns array
 	 */
 	register_method(vm, &simline_t::get_goods_catg_index, "get_goods_catg_index");
@@ -196,10 +196,10 @@
 	 */
 	register_method_fv(vm, &get_line_stat, "get_transported_goods", freevariable<sint32>(LINE_TRANSPORTED_GOODS), true );
 	/**
-	 * Get monthly statistics of number of convoys in this line.
+	 * Get monthly statistics of number of consists in this line.
 	 * @returns array, index [0] corresponds to current month
 	 */
-	register_method_fv(vm, &get_line_stat, "get_convoy_count",      freevariable<sint32>(LINE_CONVOIS), true );
+	register_method_fv(vm, &get_line_stat, "get_consist_count",      freevariable<sint32>(LINE_CONVOIS), true );
 	/**
 	 * Get monthly statistics of revenue.
 	 * @returns array, index [0] corresponds to current month
@@ -226,10 +226,10 @@
 	 */
 	register_method_fv(vm, &get_line_stat, "get_way_tolls",         freevariable<sint32>(LINE_WAYTOLL), true );
 	/**
-	 * Exports list of convoys belonging to this line.
-	 * @typemask convoy_list_x()
+	 * Exports list of consists belonging to this line.
+	 * @typemask consist_list_x()
 	 */
-	register_function(vm, &line_export_convoy_list, "get_convoy_list", 1, param<linehandle_t>::typemask());
+	register_function(vm, &line_export_consist_list, "get_consist_list", 1, param<linehandle_t>::typemask());
 
 	/**
 	 * @return waytype of the line
Index: script/api/api_map_objects.cc
===================================================================
--- script/api/api_map_objects.cc	(revision 7957)
+++ script/api/api_map_objects.cc	(working copy)
@@ -17,7 +17,7 @@
 #include "../../obj/label.h"
 
 // for depot tools
-#include "../../simconvoi.h"
+#include "../../simconsist.h"
 #include "../../simmenu.h"
 #include "../../besch/vehikel_besch.h"
 
@@ -258,7 +258,7 @@
 }
 
 // depot
-call_tool_init depot_append_vehicle(depot_t *depot, player_t *player, convoihandle_t cnv, const vehikel_besch_t *besch)
+call_tool_init depot_append_vehicle(depot_t *depot, player_t *player, consist_handle_t cnst, const vehikel_besch_t *besch)
 {
 	if (besch == NULL) {
 		return "Invalid vehicle_desc_x provided";
@@ -266,18 +266,18 @@
 	// see depot_frame_t::image_from_storage_list: tool = 'a'
 	// see depot_t::call_depot_tool for command string composition
 	cbuffer_t buf;
-	buf.printf( "%c,%s,%hu,%s", 'a', depot->get_pos().get_str(), cnv.get_id(), besch->get_name());
+	buf.printf( "%c,%s,%hu,%s", 'a', depot->get_pos().get_str(), cnst.get_id(), besch->get_name());
 
 	return call_tool_init(TOOL_CHANGE_DEPOT | SIMPLE_TOOL, buf, 0, player);
 }
 
-call_tool_init depot_start_convoy(depot_t *depot, player_t *player, convoihandle_t cnv)
+call_tool_init depot_start_consist(depot_t *depot, player_t *player, consist_handle_t cnst)
 {
 	// see depot_frame_t::action_triggered: tool = 'b'
 	// see depot_t::call_depot_tool for command string composition
 	cbuffer_t buf;
-	if (cnv.is_bound()) {
-		buf.printf( "%c,%s,%hu", 'b', depot->get_pos().get_str(), cnv->self.get_id());
+	if (cnst.is_bound()) {
+		buf.printf( "%c,%s,%hu", 'b', depot->get_pos().get_str(), cnst->self.get_id());
 	}
 	else {
 		buf.printf( "%c,%s,%hu", 'B', depot->get_pos().get_str(), 0);
@@ -286,17 +286,17 @@
 	return call_tool_init(TOOL_CHANGE_DEPOT | SIMPLE_TOOL, buf, 0, player);
 }
 
-vector_tpl<convoihandle_t> const& depot_get_convoy_list(depot_t *depot)
+vector_tpl<consist_handle_t> const& depot_get_consist_list(depot_t *depot)
 {
-	static vector_tpl<convoihandle_t> list;
+	static vector_tpl<consist_handle_t> list;
 	list.clear();
 	if (depot==NULL) {
 		return list;
 	}
 	// fill list
-	slist_tpl<convoihandle_t> const& slist = depot->get_convoy_list();
+	slist_tpl<consist_handle_t> const& slist = depot->get_consist_list();
 
-	for(slist_tpl<convoihandle_t>::const_iterator i = slist.begin(), end = slist.end(); i!=end; ++i) {
+	for(slist_tpl<consist_handle_t>::const_iterator i = slist.begin(), end = slist.end(); i!=end; ++i) {
 		list.append(*i);
 	}
 	return list;
@@ -412,31 +412,31 @@
 
 	/**
 	 * Class to access depots.
-	 * Main purpose is the manipulation of convoys in depots.
+	 * Main purpose is the manipulation of consists in depots.
 	 */
 	begin_obj_class<depot_t>(vm, "depot_x", "building_x");
 	/**
-	 * Append a car to the convoy in this depot. If the convoy does not exist, a new one is created first.
-	 * @param pl player owns the convoy
-	 * @param cnv the convoy
+	 * Append a car to the consist in this depot. If the consist does not exist, a new one is created first.
+	 * @param pl player owns the consist
+	 * @param cnst the consist
 	 * @param desc decriptor of the vehicle
 	 * @ingroup game_cmd
 	 */
 	register_method(vm, depot_append_vehicle, "append_vehicle", true);
 	/**
-	 * Start the convoy in this depot.
+	 * Start the consist in this depot.
 	 * @ingroup game_cmd
 	 */
-	register_method(vm, depot_start_convoy, "start_convoy", true);
+	register_method(vm, depot_start_consist, "start_consist", true);
 	/**
-	 * Start all convoys in this depot.
+	 * Start all consists in this depot.
 	 * @ingroup game_cmd
 	 */
-	register_method_fv(vm, depot_start_convoy, "start_all_convoys", freevariable<convoihandle_t>(convoihandle_t()), true);
+	register_method_fv(vm, depot_start_consist, "start_all_consists", freevariable<consist_handle_t>(consist_handle_t()), true);
 	/**
-	 * @returns list of convoys sitting in this depot
+	 * @returns list of consists sitting in this depot
 	 */
-	register_method(vm, &depot_get_convoy_list, "get_convoy_list", true);
+	register_method(vm, &depot_get_consist_list, "get_consist_list", true);
 	end_class(vm);
 
 	/**
Index: script/api/api_obj_desc.cc
===================================================================
--- script/api/api_obj_desc.cc	(revision 7957)
+++ script/api/api_obj_desc.cc	(working copy)
@@ -166,9 +166,9 @@
 {
 	static vector_tpl<const vehikel_besch_t*> dummy;
 	dummy.clear();
-	for(int i=0; i<besch->get_vorgaenger_count(); i++) {
-		if (besch->get_vorgaenger(i)) {
-			dummy.append(besch->get_vorgaenger(i));
+	for(int i=0; i<besch->get_leading_count(); i++) {
+		if (besch->get_leading(i)) {
+			dummy.append(besch->get_leading(i));
 		}
 	}
 	return dummy;
@@ -178,9 +178,9 @@
 {
 	static vector_tpl<const vehikel_besch_t*> dummy;
 	dummy.clear();
-	for(int i=0; i<besch->get_nachfolger_count(); i++) {
-		if (besch->get_nachfolger(i)) {
-			dummy.append(besch->get_nachfolger(i));
+	for(int i=0; i<besch->get_trailing_count(); i++) {
+		if (besch->get_trailing(i)) {
+			dummy.append(besch->get_trailing(i));
 		}
 	}
 	return dummy;
@@ -310,11 +310,11 @@
 	 */
 	begin_besch_class(vm, "vehicle_desc_x", "obj_desc_transport_x", (GETBESCHFUNC)param<const vehikel_besch_t*>::getfunc());
 	/**
-	 * @returns true if this vehicle can lead a convoy
+	 * @returns true if this vehicle can lead a consist
 	 */
 	register_method(vm, &can_be_first, "can_be_first", true);
 	/**
-	 * @returns true if this vehicle can be the last of a convoy
+	 * @returns true if this vehicle can be the last of a consist
 	 */
 	register_method(vm, &can_be_last, "can_be_last", true);
 	/**
Index: script/api/api_player.cc
===================================================================
--- script/api/api_player.cc	(revision 7957)
+++ script/api/api_player.cc	(working copy)
@@ -250,10 +250,10 @@
 	 */
 	register_method_fv(vm, &get_player_stat, "get_transported_goods", freevariable3<sint32,sint32,bool>(ATV_TRANSPORTED_GOOD, TT_ALL, true), true);
 	/**
-	 * Get monthly statistics of number of convoys.
+	 * Get monthly statistics of number of consists.
 	 * @returns array, index [0] corresponds to current month
 	 */
-	register_method_fv(vm, &get_player_stat, "get_convoys",           freevariable3<sint32,sint32,bool>(ATC_ALL_CONVOIS, -1, true), true);
+	register_method_fv(vm, &get_player_stat, "get_consists",           freevariable3<sint32,sint32,bool>(ATC_ALL_CONVOIS, -1, true), true);
 	/**
 	 * Get monthly statistics of income/loss due to way tolls.
 	 * @returns array, index [0] corresponds to current month
Index: script/api/api_settings.cc
===================================================================
--- script/api/api_settings.cc	(revision 7957)
+++ script/api/api_settings.cc	(working copy)
@@ -76,7 +76,7 @@
 	register_method(vm, &settings_t::get_factory_worker_minimum_towns, "get_factory_worker_minimum_towns");
 	/// @returns maximum number of cities to supply workers for a factory
 	register_method(vm, &settings_t::get_factory_worker_maximum_towns, "get_factory_worker_maximum_towns");
-	/// @returns freight will not enter convoy if next transfer halt is overcrowded
+	/// @returns freight will not enter consist if next transfer halt is overcrowded
 	register_method(vm, &settings_t::is_avoid_overcrowding, "avoid_overcrowding");
 	/// @returns freight will not start when best route goes through overcrowded halt
 	register_method(vm, &settings_t::is_no_routing_over_overcrowding, "no_routing_over_overcrowding");
Index: script/api/api_world.cc
===================================================================
--- script/api/api_world.cc	(revision 7957)
+++ script/api/api_world.cc	(working copy)
@@ -15,7 +15,7 @@
 
 mytime_ticks_t world_get_time(karte_t*)
 {
-	return mytime_ticks_t(welt->get_current_month(), welt->get_zeit_ms(), welt->scale_with_month_length(1<<18), welt->get_next_month_ticks());
+	return mytime_ticks_t(welt->get_current_month(), welt->get_ticks(), welt->scale_with_month_length(1<<18), welt->get_next_month_ticks());
 }
 
 
@@ -90,9 +90,9 @@
 }
 
 
-SQInteger world_get_convoy_list(HSQUIRRELVM vm)
+SQInteger world_get_consist_list(HSQUIRRELVM vm)
 {
-	push_instance(vm, "convoy_list_x");
+	push_instance(vm, "consist_list_x");
 	set_slot<bool>(vm, "use_world", true);
 	return 1;
 }
@@ -178,10 +178,10 @@
 	 */
 	STATIC register_method_fv(vm, &get_world_stat, "get_factories",         freevariable2<bool,sint32>(true, karte_t::WORLD_FACTORIES), true );
 	/**
-	 * Get monthly statistics of total number of convoys.
+	 * Get monthly statistics of total number of consists.
 	 * @returns array, index [0] corresponds to current month
 	 */
-	STATIC register_method_fv(vm, &get_world_stat, "get_convoys",           freevariable2<bool,sint32>(true, karte_t::WORLD_CONVOIS), true );
+	STATIC register_method_fv(vm, &get_world_stat, "get_consists",           freevariable2<bool,sint32>(true, karte_t::WORLD_CONVOIS), true );
 	/**
 	 * Get monthly statistics of total number of citycars.
 	 * @returns array, index [0] corresponds to current month
@@ -243,10 +243,10 @@
 	 */
 	STATIC register_method_fv(vm, &get_world_stat, "get_year_factories",         freevariable2<bool,sint32>(false, karte_t::WORLD_FACTORIES), true );
 	/**
-	 * Get per year statistics of total number of convoys.
+	 * Get per year statistics of total number of consists.
 	 * @returns array, index [0] corresponds to current year
 	 */
-	STATIC register_method_fv(vm, &get_world_stat, "get_year_convoys",           freevariable2<bool,sint32>(false, karte_t::WORLD_CONVOIS), true );
+	STATIC register_method_fv(vm, &get_world_stat, "get_year_consists",           freevariable2<bool,sint32>(false, karte_t::WORLD_CONVOIS), true );
 	/**
 	 * Get per year statistics of total number of citycars.
 	 * @returns array, index [0] corresponds to current year
@@ -299,11 +299,11 @@
 	 */
 	STATIC register_function(vm, world_get_attraction_list, "get_attraction_list", 1, ".");
 	/**
-	 * Returns list of convoys on the map.
-	 * @returns convoy list
-	 * @typemask convoy_list_x()
+	 * Returns list of consists on the map.
+	 * @returns consist list
+	 * @typemask consist_list_x()
 	 */
-	STATIC register_function(vm, world_get_convoy_list, "get_convoy_list", 1, ".");
+	STATIC register_function(vm, world_get_consist_list, "get_consist_list", 1, ".");
 	/**
 	 * Returns size of the map.
 	 * @typemask coord()
Index: script/api_param.cc
===================================================================
--- script/api_param.cc	(revision 7957)
+++ script/api_param.cc	(working copy)
@@ -336,13 +336,13 @@
 
 // pointers to classes
 
-	convoi_t* param<convoi_t*>::get(HSQUIRRELVM vm, SQInteger index)
+	consist_t* param<consist_t*>::get(HSQUIRRELVM vm, SQInteger index)
 	{
-		convoihandle_t cnv = param<convoihandle_t>::get(vm, index);
-		if (!cnv.is_bound()) {
-			sq_raise_error(vm, "Invalid convoi id %d", cnv.get_id());
+		consist_handle_t cnst = param<consist_handle_t>::get(vm, index);
+		if (!cnst.is_bound()) {
+			sq_raise_error(vm, "Invalid consist id %d", cnst.get_id());
 		}
-		return cnv.get_rep();
+		return cnst.get_rep();
 	}
 
 	fabrik_t* param<fabrik_t*>::get(HSQUIRRELVM vm, SQInteger index)
Index: script/api_param.h
===================================================================
--- script/api_param.h	(revision 7957)
+++ script/api_param.h	(working copy)
@@ -11,7 +11,7 @@
 #include "../boden/wege/weg.h" // weg_t::system_type
 
 class baum_t;
-class convoi_t;
+class consist_t;
 class fabrik_t;
 class fabrik_lieferant_besch_t;
 class fabrik_produkt_besch_t;
@@ -337,7 +337,7 @@
 	declare_specialized_param(koord, "t|x|y", "coord");
 	declare_specialized_param(koord3d, "t|x|y", "coord3d");
 
-	declare_specialized_param(convoi_t*, "t|x|y", "convoy_x");
+	declare_specialized_param(consist_t*, "t|x|y", "convoy_x");
 	declare_specialized_param(fabrik_t*, "t|x|y", "factory_x");
 	declare_specialized_param(grund_t*, "t|x|y", "tile_x");
 	declare_specialized_param(const haltestelle_t*, "t|x|y", "halt_x");
Index: script/export_objs.cc
===================================================================
--- script/export_objs.cc	(revision 7957)
+++ script/export_objs.cc	(working copy)
@@ -16,7 +16,7 @@
 
 	export_city(vm);
 	export_control(vm);
-	export_convoy(vm);
+	export_consist(vm);
 	export_factory(vm);
 	export_goods_desc(vm);
 	export_gui(vm, scenario);
Index: simconst.h
===================================================================
--- simconst.h	(revision 7957)
+++ simconst.h	(working copy)
@@ -51,7 +51,7 @@
 
 /*********************** Useful things for debugging ... ********************/
 
-/* will highlite marked areas and convoi will leave traces */
+/* will highlite marked areas and consist will leave traces */
 //#define DEBUG_ROUTES
 
 /* shows which tiles are drawn as dings (used in boden/grund.cc) */
Index: simdepot.cc
===================================================================
--- simdepot.cc	(revision 7957)
+++ simdepot.cc	(working copy)
@@ -9,7 +9,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "simconvoi.h"
+#include "simconsist.h"
 #include "vehicle/simvehicle.h"
 #include "gui/simwin.h"
 #include "player/simplay.h"
@@ -114,12 +114,12 @@
 
 
 // again needed for server
-void depot_t::call_depot_tool( char tool, convoihandle_t cnv, const char *extra)
+void depot_t::call_depot_tool( char tool, consist_handle_t cnst, const char *extra)
 {
 	// call depot tool
 	tool_t *tmp_tool = create_tool( TOOL_CHANGE_DEPOT | SIMPLE_TOOL );
 	cbuffer_t buf;
-	buf.printf( "%c,%s,%hu", tool, get_pos().get_str(), cnv.get_id() );
+	buf.printf( "%c,%s,%hu", tool, get_pos().get_str(), cnst.get_id() );
 	if(  extra  ) {
 		buf.append( "," );
 		buf.append( extra );
@@ -132,13 +132,13 @@
 
 
 /* this is called on two occasions:
- * first a convoy reaches the depot during its journey
- * second during loading a convoi is stored in a depot => only store it again
+ * first a consist reaches the depot during its journey
+ * second during loading a consist is stored in a depot => only store it again
  */
-void depot_t::convoi_arrived(convoihandle_t acnv, bool fpl_adjust)
+void depot_t::consist_arrived(consist_handle_t acnv, bool fpl_adjust)
 {
 	if(fpl_adjust) {
-		// here a regular convoi arrived
+		// here a regular consist arrived
 
 		for(unsigned i=0; i<acnv->get_vehicle_count(); i++) {
 			vehicle_t *v = acnv->get_vehikel(i);
@@ -151,7 +151,7 @@
 		// Volker: remove depot from schedule
 		schedule_t *fpl = acnv->get_schedule();
 		for(  int i=0;  i<fpl->get_count();  i++  ) {
-			// only if convoi found
+			// only if consist found
 			if(fpl->eintrag[i].pos==get_pos()) {
 				fpl->set_aktuell( i );
 				fpl->remove();
@@ -160,14 +160,14 @@
 			}
 		}
 	}
-	// this part stores the convoi in the depot
-	convois.append(acnv);
+	// this part stores the consist in the depot
+	consists.append(acnv);
 	depot_frame_t *depot_frame = dynamic_cast<depot_frame_t *>(win_get_magic( (ptrdiff_t)this ));
 	if(depot_frame) {
 		depot_frame->action_triggered(NULL,(long int)0);
 	}
 	acnv->set_home_depot( get_pos() );
-	DBG_MESSAGE("depot_t::convoi_arrived()", "convoi %d, %p entered depot", acnv.get_id(), acnv.get_rep());
+	DBG_MESSAGE("depot_t::consist_arrived()", "consist %d, %p entered depot", acnv.get_id(), acnv.get_rep());
 }
 
 
@@ -189,21 +189,21 @@
 }
 
 
-void depot_t::append_vehicle(convoihandle_t cnv, vehicle_t* veh, bool infront, bool local_execution)
+void depot_t::append_vehicle(consist_handle_t cnst, vehicle_t* veh, bool infront, bool local_execution)
 {
-	/* create  a new convoi, if necessary */
-	if (!cnv.is_bound()) {
-		cnv = add_convoi( local_execution );
+	/* create  a new consist, if necessary */
+	if (!cnst.is_bound()) {
+		cnst = add_consist( local_execution );
 	}
 	veh->set_pos(get_pos());
-	cnv->add_vehikel(veh, infront);
+	cnst->add_vehikel(veh, infront);
 	vehicles.remove(veh);
 }
 
 
-void depot_t::remove_vehicle(convoihandle_t cnv, int ipos)
+void depot_t::remove_vehicle(consist_handle_t cnst, int ipos)
 {
-	vehicle_t* veh = cnv->remove_vehikel_bei( ipos );
+	vehicle_t* veh = cnst->remove_vehikel_bei( ipos );
 	if(  veh  ) {
 		vehicles.append( veh );
 	}
@@ -210,9 +210,9 @@
 }
 
 
-void depot_t::remove_vehicles_to_end(convoihandle_t cnv, int ipos)
+void depot_t::remove_vehicles_to_end(consist_handle_t cnst, int ipos)
 {
-	while(  vehicle_t* veh = cnv->remove_vehikel_bei( ipos )  ) {
+	while(  vehicle_t* veh = cnst->remove_vehikel_bei( ipos )  ) {
 		vehicles.append( veh );
 	}
 }
@@ -244,26 +244,26 @@
 }
 
 
-convoihandle_t depot_t::add_convoi(bool local_execution)
+consist_handle_t depot_t::add_consist(bool local_execution)
 {
-	convoi_t* new_cnv = new convoi_t(get_owner());
+	consist_t* new_cnv = new consist_t(get_owner());
 	new_cnv->set_home_depot(get_pos());
-	convois.append(new_cnv->self);
+	consists.append(new_cnv->self);
 	depot_frame_t *win = dynamic_cast<depot_frame_t *>(win_get_magic( (ptrdiff_t)this ));
 	if(  win  &&  local_execution  ) {
-		win->activate_convoi( new_cnv->self );
+		win->activate_consist( new_cnv->self );
 	}
 	return new_cnv->self;
 }
 
 
-bool depot_t::check_obsolete_inventory(convoihandle_t cnv)
+bool depot_t::check_obsolete_inventory(consist_handle_t cnst)
 {
 	bool ok = true;
 	slist_tpl<vehicle_t*> veh_tmp_list;
 
-	for(  int i = 0;  i < cnv->get_vehicle_count();  i++  ) {
-		const vehikel_besch_t* const vb = cnv->get_vehikel(i)->get_besch();
+	for(  int i = 0;  i < cnst->get_vehicle_count();  i++  ) {
+		const vehikel_besch_t* const vb = cnst->get_vehikel(i)->get_besch();
 		if(  vb  ) {
 			// search storage for matching vehicle
 			vehicle_t* veh = NULL;
@@ -294,12 +294,12 @@
 }
 
 
-convoihandle_t depot_t::copy_convoi(convoihandle_t old_cnv, bool local_execution)
+consist_handle_t depot_t::copy_consist(consist_handle_t old_cnv, bool local_execution)
 {
-	if(  old_cnv.is_bound()  &&  !convoihandle_t::is_exhausted()  &&
+	if(  old_cnv.is_bound()  &&  !consist_handle_t::is_exhausted()  &&
 		old_cnv->get_vehicle_count() > 0  &&  get_waytype() == old_cnv->front()->get_besch()->get_waytype() ) {
 
-		convoihandle_t new_cnv = add_convoi( false );
+		consist_handle_t new_cnv = add_consist( false );
 		new_cnv->set_name(old_cnv->get_internal_name());
 		int vehicle_count = old_cnv->get_vehicle_count();
 		for (int i = 0; i<vehicle_count; i++) {
@@ -329,11 +329,11 @@
 			}
 		}
 
-		// make this the current selected convoi
+		// make this the current selected consist
 		depot_frame_t *win = dynamic_cast<depot_frame_t *>(win_get_magic( (ptrdiff_t)this ));
 		if(  win  ) {
 			if(  local_execution  ) {
-				win->activate_convoi( new_cnv );
+				win->activate_consist( new_cnv );
 			}
 			else {
 				win->update_data();
@@ -342,16 +342,16 @@
 
 		return new_cnv;
 	}
-	return convoihandle_t();
+	return consist_handle_t();
 }
 
 
-bool depot_t::disassemble_convoi(convoihandle_t cnv, bool sell)
+bool depot_t::disassemble_consist(consist_handle_t cnst, bool sell)
 {
-	if(  cnv.is_bound()  ) {
+	if(  cnst.is_bound()  ) {
 		if(  !sell  ) {
 			// store vehicles in depot
-			while(  vehicle_t* const v = cnv->remove_vehikel_bei(0)  ) {
+			while(  vehicle_t* const v = cnst->remove_vehikel_bei(0)  ) {
 				v->discard_cargo();
 				v->set_leading(false);
 				v->set_last(false);
@@ -360,10 +360,10 @@
 		}
 
 		// remove from depot lists
-		remove_convoi( cnv );
+		remove_consist( cnst );
 
 		// and remove from welt
-		cnv->self_destruct();
+		cnst->self_destruct();
 		return true;
 	}
 	return false;
@@ -370,61 +370,61 @@
 }
 
 
-bool depot_t::start_all_convoys()
+bool depot_t::start_all_consists()
 {
 	uint32 i = 0;
-	while(  i < convois.get_count()  ) {
-		if(  !start_convoi( convois.at(i), false )  ) {
+	while(  i < consists.get_count()  ) {
+		if(  !start_consist( consists.at(i), false )  ) {
 			i++;
 		}
 	}
-	return (convois.get_count() == 0);
+	return (consists.get_count() == 0);
 }
 
 
-bool depot_t::start_convoi(convoihandle_t cnv, bool local_execution)
+bool depot_t::start_consist(consist_handle_t cnst, bool local_execution)
 {
 	// close schedule window if not yet closed
-	if(cnv.is_bound() &&  cnv->get_schedule()!=NULL) {
-		if(!cnv->get_schedule()->ist_abgeschlossen()) {
+	if(cnst.is_bound() &&  cnst->get_schedule()!=NULL) {
+		if(!cnst->get_schedule()->ist_abgeschlossen()) {
 			// close the schedule window
-			destroy_win((ptrdiff_t)cnv->get_schedule());
+			destroy_win((ptrdiff_t)cnst->get_schedule());
 		}
 	}
 
-	// convoi not in depot anymore, maybe user double-clicked on start-button
-	if(!convois.is_contained(cnv)) {
+	// consist not in depot anymore, maybe user double-clicked on start-button
+	if(!consists.is_contained(cnst)) {
 		return false;
 	}
 
-	if (cnv.is_bound() && cnv->get_schedule() && !cnv->get_schedule()->empty()) {
+	if (cnst.is_bound() && cnst->get_schedule() && !cnst->get_schedule()->empty()) {
 		// if next schedule entry is this depot => advance to next entry
-		const koord3d& cur_pos = cnv->get_schedule()->get_current_eintrag().pos;
+		const koord3d& cur_pos = cnst->get_schedule()->get_current_eintrag().pos;
 		if (cur_pos == get_pos()) {
-			cnv->get_schedule()->advance();
+			cnst->get_schedule()->advance();
 		}
 
-		// check if convoi is complete
-		if(cnv->get_sum_leistung() == 0 || !cnv->pruefe_alle()) {
+		// check if consist is complete
+		if(cnst->get_sum_leistung() == 0 || !cnst->pruefe_alle()) {
 			if (local_execution) {
 				create_win( new news_img("Diese Zusammenstellung kann nicht fahren!\n"), w_time_delete, magic_none);
 			}
 		}
-		else if(  !cnv->front()->calc_route(this->get_pos(), cur_pos, cnv->get_min_top_speed(), cnv->access_route())  ) {
+		else if(  !cnst->front()->calc_route(this->get_pos(), cur_pos, cnst->get_min_top_speed(), cnst->access_route())  ) {
 			// no route to go ...
 			if(local_execution) {
 				static cbuffer_t buf;
 				buf.clear();
-				buf.printf( translator::translate("Vehicle %s can't find a route!"), cnv->get_name() );
+				buf.printf( translator::translate("Vehicle %s can't find a route!"), cnst->get_name() );
 				create_win( new news_img(buf), w_time_delete, magic_none);
 			}
 		}
 		else {
-			// convoi can start now
-			cnv->start();
+			// consist can start now
+			cnst->start();
 
 			// remove from depot lists
-			remove_convoi( cnv );
+			remove_consist( cnst );
 
 			return true;
 		}
@@ -434,12 +434,12 @@
 			create_win( new news_img("Noch kein Fahrzeug\nmit Fahrplan\nvorhanden\n"), w_time_delete, magic_none);
 		}
 
-		if (!cnv.is_bound()) {
-			dbg->warning("depot_t::start_convoi()","No convoi to start!");
-		} else if (!cnv->get_schedule()) {
-			dbg->warning("depot_t::start_convoi()","No schedule for convoi.");
-		} else if (!cnv->get_schedule()->ist_abgeschlossen()) {
-			dbg->warning("depot_t::start_convoi()","Schedule is incomplete/not finished");
+		if (!cnst.is_bound()) {
+			dbg->warning("depot_t::start_consist()","No consist to start!");
+		} else if (!cnst->get_schedule()) {
+			dbg->warning("depot_t::start_consist()","No schedule for consist.");
+		} else if (!cnst->get_schedule()->ist_abgeschlossen()) {
+			dbg->warning("depot_t::start_consist()","Schedule is incomplete/not finished");
 		}
 	}
 	return false;
@@ -446,25 +446,25 @@
 }
 
 
-void depot_t::remove_convoi( convoihandle_t cnv )
+void depot_t::remove_consist( consist_handle_t cnst )
 {
 	depot_frame_t *win = dynamic_cast<depot_frame_t *>(win_get_magic( (ptrdiff_t)this ));
 	if(  win  ) {
-		// get currently selected convoi to restore selection if not removed
+		// get currently selected consist to restore selection if not removed
 		int icnv = win->get_icnv();
-		convoihandle_t c = icnv > -1 ? get_convoi( icnv ) : convoihandle_t();
+		consist_handle_t c = icnv > -1 ? get_consist( icnv ) : consist_handle_t();
 
-		icnv = convois.index_of( cnv );
-		convois.remove( cnv );
+		icnv = consists.index_of( cnst );
+		consists.remove( cnst );
 
-		if(  c == cnv  ) {
+		if(  c == cnst  ) {
 			// removing currently selected, select next in list or last instead
-			c = !convois.empty() ? convois.at( min((uint32)icnv, convois.get_count() - 1) ) : convoihandle_t();
+			c = !consists.empty() ? consists.at( min((uint32)icnv, consists.get_count() - 1) ) : consist_handle_t();
 		}
-		win->activate_convoi( c );
+		win->activate_consist( c );
 	}
 	else {
-		convois.remove( cnv );
+		consists.remove( cnst );
 	}
 }
 
@@ -537,7 +537,7 @@
 	else {
 		FOR(slist_tpl<vehicle_t*>, const v, list) {
 			file->wr_obj_id(v->get_typ());
-			v->rdwr_from_convoi(file);
+			v->rdwr_from_consist(file);
 		}
 	}
 }
@@ -556,7 +556,7 @@
 		return "There are still vehicles\nstored in this depot!\n";
 	}
 
-	FOR(slist_tpl<convoihandle_t>, const c, convois) {
+	FOR(slist_tpl<consist_handle_t>, const c, consists) {
 		if (c->get_vehicle_count() > 0) {
 			return "There are still vehicles\nstored in this depot!\n";
 		}
@@ -610,7 +610,7 @@
 }
 
 
-unsigned bahndepot_t::get_max_convoi_length() const
+unsigned bahndepot_t::get_max_consist_length() const
 {
-	return convoi_t::max_rail_vehicle;
+	return consist_t::max_rail_vehicle;
 }
Index: simdepot.h
===================================================================
--- simdepot.h	(revision 7957)
+++ simdepot.h	(working copy)
@@ -10,7 +10,7 @@
 
 #include "tpl/slist_tpl.h"
 #include "obj/gebaeude.h"
-#include "convoihandle_t.h"
+#include "consist_handle_t.h"
 #include "simline.h"
 
 #define VEHICLE_FILTER_RELEVANT 1
@@ -34,8 +34,8 @@
 	 * Reworked depot data!
 	 *
 	 * It can now contain any number of vehicles bought by the user (as before).
-	 * And it can hold any number of convois (before only one).
-	 * It is possible to have 0 convois in a depot, but an empty one shall be
+	 * And it can hold any number of consists (before only one).
+	 * It is possible to have 0 consists in a depot, but an empty one shall be
 	 * automatically created, when necessary.
 	 * Convois are numbered 0...(n-1).
 	 * Vehicles are accessed by type.
@@ -44,7 +44,7 @@
 	 * @date  30.05.2003
 	 */
 	slist_tpl<vehicle_t *> vehicles;
-	slist_tpl<convoihandle_t> convois;
+	slist_tpl<consist_handle_t> consists;
 
 	void rdwr_vehikel(slist_tpl<vehicle_t*> &list, loadsave_t *file);
 
@@ -63,7 +63,7 @@
 	depot_t(koord3d pos, player_t *player, const haus_tile_besch_t *t);
 	virtual ~depot_t();
 
-	void call_depot_tool( char tool, convoihandle_t cnv, const char *extra );
+	void call_depot_tool( char tool, consist_handle_t cnst, const char *extra );
 
 	virtual simline_t::linetype get_line_type() const = 0;
 
@@ -78,71 +78,71 @@
 	vehicle_t* find_oldest_newest(const vehikel_besch_t* besch, bool old);
 
 	/**
-	 * Access to convoi list.
+	 * Access to consist list.
 	 * @author Volker Meyer
 	 * @date  30.05.2003
 	 */
-	unsigned convoi_count() const { return convois.get_count(); }
+	unsigned consist_count() const { return consists.get_count(); }
 
-	convoihandle_t get_convoi(unsigned int icnv) const { return icnv < convoi_count() ? convois.at(icnv) : convoihandle_t(); }
+	consist_handle_t get_consist(unsigned int icnv) const { return icnv < consist_count() ? consists.at(icnv) : consist_handle_t(); }
 
-	convoihandle_t add_convoi(bool local_execution);
+	consist_handle_t add_consist(bool local_execution);
 
-	slist_tpl<convoihandle_t> const& get_convoy_list() { return convois; }
+	slist_tpl<consist_handle_t> const& get_consist_list() { return consists; }
 
-	// checks if cnv can be copied by using only stored vehicles and non-obsolete purchased vehicles
-	bool check_obsolete_inventory(convoihandle_t cnv);
+	// checks if cnst can be copied by using only stored vehicles and non-obsolete purchased vehicles
+	bool check_obsolete_inventory(consist_handle_t cnst);
 
 	/**
-	 * copies convoi and its schedule or line
+	 * copies consist and its schedule or line
 	 * @author hsiegeln
 	 */
-	convoihandle_t copy_convoi(convoihandle_t old_cnv, bool local_execution);
+	consist_handle_t copy_consist(consist_handle_t old_cnv, bool local_execution);
 
 	/**
-	 * Let convoi leave the depot.
+	 * Let consist leave the depot.
 	 * If not possible, a message is displayed and the function returns false.
 	 * @param if local_execution is true, this method creates pop-ups in case of errors
 	 * @author Volker Meyer, Dwachs
 	 * @date  09.06.2003 / 27.04.2010
 	 */
-	bool start_convoi(convoihandle_t cnv, bool local_execution);
+	bool start_consist(consist_handle_t cnst, bool local_execution);
 
-	bool start_all_convoys();
+	bool start_all_consists();
 
 	/**
-	 * Destroy the convoi and put the vehicles in the vehicles list (sell==false),
+	 * Destroy the consist and put the vehicles in the vehicles list (sell==false),
 	 * or sell all immediately (sell==true).
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
-	bool disassemble_convoi(convoihandle_t cnv, bool sell);
+	bool disassemble_consist(consist_handle_t cnst, bool sell);
 
 	/**
-	 * Remove the convoi from the depot lists
+	 * Remove the consist from the depot lists
 	 * updating depot gui frame as necessary
 	 */
-	void remove_convoi( convoihandle_t cnv );
+	void remove_consist( consist_handle_t cnst );
 
 	/**
-	 * Remove vehicle from vehicle list and add it to the convoi. Two positions
+	 * Remove vehicle from vehicle list and add it to the consist. Two positions
 	 * are possible - in front or at the rear.
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
-	void append_vehicle(convoihandle_t cnv, vehicle_t* veh, bool infront, bool local_execution);
+	void append_vehicle(consist_handle_t cnst, vehicle_t* veh, bool infront, bool local_execution);
 
 	/**
-	 * Remove the vehicle at given position from the convoi and put it in the
+	 * Remove the vehicle at given position from the consist and put it in the
 	 * vehicle list.
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
-	void remove_vehicle(convoihandle_t cnv, int ipos);
-	void remove_vehicles_to_end(convoihandle_t cnv, int ipos);
+	void remove_vehicle(consist_handle_t cnst, int ipos);
+	void remove_vehicles_to_end(consist_handle_t cnst, int ipos);
 
 	/**
-	 * Access to vehicles not bound to a convoi. They are not ordered
+	 * Access to vehicles not bound to a consist. They are not ordered
 	 * in any way.
 	 * @author Volker Meyer
 	 * @date  30.05.2003
@@ -171,12 +171,12 @@
 	slist_tpl<vehikel_besch_t const*> const& get_vehicle_type() const;
 
 	/**
-	 * A convoi arrived at the depot and is added to the convoi list.
+	 * A consist arrived at the depot and is added to the consist list.
 	 * If fpl_adjust is true, the current depot is removed from schedule.
 	 * @author Volker Meyer
 	 * @date  09.06.2003
 	 */
-	void convoi_arrived(convoihandle_t cnv, bool fpl_adjust);
+	void consist_arrived(consist_handle_t cnst, bool fpl_adjust);
 
 	/**
 	 * Parameters to determine layout and behaviour of the depot_frame_t.
@@ -187,7 +187,7 @@
 	virtual int get_y_grid() const = 0;
 	virtual int get_x_placement() const = 0;
 	virtual int get_y_placement() const = 0;
-	virtual unsigned get_max_convoi_length() const = 0;
+	virtual unsigned get_max_consist_length() const = 0;
 
 	/**
 	 * Opens a new info window for that object.
@@ -231,9 +231,9 @@
 	linehandle_t last_selected_line;
 
 	/**
-	 * Used to block new actions from depot frame gui when convois are being added to the depot.
-	 * Otherwise lag in multipler results in actions being performed on the wrong convoi.
-	 * Only works for a single client making changes in a depot at once. Multiple clients can still result in wrong convois being changed.
+	 * Used to block new actions from depot frame gui when consists are being added to the depot.
+	 * Otherwise lag in multipler results in actions being performed on the wrong consist.
+	 * Only works for a single client making changes in a depot at once. Multiple clients can still result in wrong consists being changed.
 	 */
 	bool command_pending;
 
@@ -270,7 +270,7 @@
 	int get_y_placement() const {return -28; }
 	int get_x_grid() const { return 24; }
 	int get_y_grid() const { return 24; }
-	unsigned get_max_convoi_length() const;
+	unsigned get_max_consist_length() const;
 
 	virtual obj_t::typ get_typ() const { return bahndepot; }
 	virtual const char *get_name() const {return "Bahndepot"; }
@@ -355,7 +355,7 @@
 	int get_y_placement() const { return -25; }
 	int get_x_grid() const { return 24; }
 	int get_y_grid() const { return 24; }
-	unsigned get_max_convoi_length() const { return 4; }
+	unsigned get_max_consist_length() const { return 4; }
 
 	obj_t::typ get_typ() const { return strassendepot; }
 	const char *get_name() const {return "Strassendepot";}
@@ -392,7 +392,7 @@
 	int get_x_grid() const { return 60; }
 	int get_y_grid() const { return 46; }
 
-	unsigned get_max_convoi_length() const { return 4; }
+	unsigned get_max_consist_length() const { return 4; }
 	obj_t::typ get_typ() const { return schiffdepot; }
 	const char *get_name() const {return "Schiffdepot";}
 };
@@ -422,7 +422,7 @@
 	int get_y_placement() const {return -23; }
 	int get_x_grid() const { return 36; }
 	int get_y_grid() const { return 36; }
-	unsigned get_max_convoi_length() const { return 1; }
+	unsigned get_max_consist_length() const { return 1; }
 
 	obj_t::typ get_typ() const { return airdepot; }
 	const char *get_name() const {return "Hangar";}
Index: simhalt.cc
===================================================================
--- simhalt.cc	(revision 7957)
+++ simhalt.cc	(working copy)
@@ -17,7 +17,7 @@
 
 #include "simcity.h"
 #include "simcolor.h"
-#include "simconvoi.h"
+#include "simconsist.h"
 #include "simdebug.h"
 #include "simfab.h"
 #include "simhalt.h"
@@ -75,7 +75,7 @@
 uint8 haltestelle_t::reconnect_counter = 0;
 
 
-static vector_tpl<convoihandle_t>stale_convois;
+static vector_tpl<consist_handle_t>stale_consists;
 static vector_tpl<linehandle_t>stale_lines;
 
 
@@ -87,11 +87,11 @@
 
 void haltestelle_t::step_all()
 {
-	// tell all stale convois to reroute their goods
-	if(  !stale_convois.empty()  ) {
-		convoihandle_t cnv = stale_convois.pop_back();
-		if(  cnv.is_bound()  ) {
-			cnv->check_freight();
+	// tell all stale consists to reroute their goods
+	if(  !stale_consists.empty()  ) {
+		consist_handle_t cnst = stale_consists.pop_back();
+		if(  cnst.is_bound()  ) {
+			cnst->check_freight();
 		}
 	}
 	// same for stale lines
@@ -847,22 +847,22 @@
 
 
 
-// add convoi to loading
-void haltestelle_t::request_loading( convoihandle_t cnv )
+// add consist to loading
+void haltestelle_t::request_loading( consist_handle_t cnst )
 {
-	if(  !loading_here.is_contained( cnv )  ) {
-		loading_here.append( cnv );
+	if(  !loading_here.is_contained( cnst )  ) {
+		loading_here.append( cnst );
 	}
 	if(  last_loading_step != welt->get_steps()  ) {
 		last_loading_step = welt->get_steps();
-		// now iterate over all convois
-		for(  slist_tpl<convoihandle_t>::iterator i = loading_here.begin(), end = loading_here.end();  i != end;  ) {
-			convoihandle_t const c = *i;
-			if (c.is_bound() && c->get_state() == convoi_t::LOADING) {
-				// now we load into convoi
+		// now iterate over all consists
+		for(  slist_tpl<consist_handle_t>::iterator i = loading_here.begin(), end = loading_here.end();  i != end;  ) {
+			consist_handle_t const c = *i;
+			if (c.is_bound() && c->get_state() == consist_t::LOADING) {
+				// now we load into consist
 				c->hat_gehalten(self);
 			}
-			if (c.is_bound() && c->get_state() == convoi_t::LOADING) {
+			if (c.is_bound() && c->get_state() == consist_t::LOADING) {
 				++i;
 			}
 			else {
@@ -1090,18 +1090,18 @@
 	 * In the first loops:
 	 * lines==true => search for lines
 	 * After this:
-	 * lines==false => search for single convoys without lines
+	 * lines==false => search for single consists without lines
 	 */
 	bool lines = true;
 	uint32 current_index = 0;
-	while(  lines  ||  current_index < registered_convoys.get_count()  ) {
+	while(  lines  ||  current_index < registered_consists.get_count()  ) {
 
-		// Now, collect the "fpl", "owner" and "add_catg_index" from line resp. convoy.
+		// Now, collect the "fpl", "owner" and "add_catg_index" from line resp. consist.
 		if(  lines  ) {
 			if(  current_index >= registered_lines.get_count()  ) {
 				// We have looped over all lines.
 				lines = false;
-				current_index = 0;	// Knightly : start over for registered lineless convoys
+				current_index = 0;	// Knightly : start over for registered lineless consists
 				continue;
 			}
 
@@ -1113,12 +1113,12 @@
 			goods_catg_index = &line->get_goods_catg_index();
 		}
 		else {
-			const convoihandle_t cnv = registered_convoys[current_index];
+			const consist_handle_t cnst = registered_consists[current_index];
 			++current_index;
 
-			owner = cnv->get_owner();
-			fpl = cnv->get_schedule();
-			goods_catg_index = &cnv->get_goods_catg_index();
+			owner = cnst->get_owner();
+			fpl = cnst->get_schedule();
+			goods_catg_index = &cnst->get_goods_catg_index();
 		}
 
 		// find the index from which to start processing
@@ -1139,7 +1139,7 @@
 		}
 
 		if(  supported_catg_index.empty()  ) {
-			// this halt does not support the goods categories handled by the line/lineless convoy
+			// this halt does not support the goods categories handled by the line/lineless consist
 			continue;
 		}
 
@@ -2722,7 +2722,7 @@
 {
 	verbinde_fabriken();
 
-	stale_convois.clear();
+	stale_consists.clear();
 	stale_lines.clear();
 	// fix good destination coordinates
 	for(unsigned i=0; i<warenbauer_t::get_max_catg_index(); i++) {
@@ -3022,10 +3022,10 @@
 		verbinde_fabriken();
 	}
 
-	// check if we have to register line(s) and/or lineless convoy(s) which serve this halt
+	// check if we have to register line(s) and/or lineless consist(s) which serve this halt
 	vector_tpl<linehandle_t> check_line(0);
 
-	// public halt: must iterate over all players lines / convoys
+	// public halt: must iterate over all players lines / consists
 	bool public_halt = get_owner() == welt->get_public_player();
 
 	uint8 const pl_min = public_halt ? 0                : get_owner()->get_player_nr();
@@ -3036,7 +3036,7 @@
 			player->simlinemgmt.get_lines(simline_t::line, &check_line);
 			FOR(  vector_tpl<linehandle_t>, const j, check_line  ) {
 				// only add unknown lines
-				if(  !registered_lines.is_contained(j)  &&  j->count_convoys() > 0  ) {
+				if(  !registered_lines.is_contained(j)  &&  j->count_consists() > 0  ) {
 					FOR(  minivec_tpl<linieneintrag_t>, const& k, j->get_schedule()->eintrag  ) {
 						if(  get_halt(k.pos, player) == self  ) {
 							registered_lines.append(j);
@@ -3047,14 +3047,14 @@
 			}
 		}
 	}
-	// Knightly : iterate over all convoys
-	FOR(vector_tpl<convoihandle_t>, const cnv, welt->convoys()) {
-		// only check lineless convoys which have matching ownership and which are not yet registered
-		if(  !cnv->get_line().is_bound()  &&  (public_halt  ||  cnv->get_owner()==get_owner())  &&  !registered_convoys.is_contained(cnv)  ) {
-			if(  const schedule_t *const fpl = cnv->get_schedule()  ) {
+	// Knightly : iterate over all consists
+	FOR(vector_tpl<consist_handle_t>, const cnst, welt->consists()) {
+		// only check lineless consists which have matching ownership and which are not yet registered
+		if(  !cnst->get_line().is_bound()  &&  (public_halt  ||  cnst->get_owner()==get_owner())  &&  !registered_consists.is_contained(cnst)  ) {
+			if(  const schedule_t *const fpl = cnst->get_schedule()  ) {
 				FOR(minivec_tpl<linieneintrag_t>, const& k, fpl->eintrag) {
-					if (get_halt(k.pos, cnv->get_owner()) == self) {
-						registered_convoys.append(cnv);
+					if (get_halt(k.pos, cnst->get_owner()) == self) {
+						registered_consists.append(cnst);
 						break;
 					}
 				}
@@ -3174,11 +3174,11 @@
 		}
 	}
 
-	// Knightly : remove registered lineless convoys as well
-	for(  size_t j = registered_convoys.get_count();  j-- != 0;  ) {
+	// Knightly : remove registered lineless consists as well
+	for(  size_t j = registered_consists.get_count();  j-- != 0;  ) {
 		bool ok = false;
-		FOR(  minivec_tpl<linieneintrag_t>, const& k, registered_convoys[j]->get_schedule()->eintrag  ) {
-			if(  get_halt(k.pos, registered_convoys[j]->get_owner()) == self  ) {
+		FOR(  minivec_tpl<linieneintrag_t>, const& k, registered_consists[j]->get_schedule()->eintrag  ) {
+			if(  get_halt(k.pos, registered_consists[j]->get_owner()) == self  ) {
 				ok = true;
 				break;
 			}
@@ -3185,8 +3185,8 @@
 		}
 		// need removal?
 		if(  !ok  ) {
-			stale_convois.append_unique( registered_convoys[j] );
-			registered_convoys.remove_at(j);
+			stale_consists.append_unique( registered_consists[j] );
+			registered_consists.remove_at(j);
 		}
 	}
 
@@ -3260,11 +3260,11 @@
 /* checks, if there is an unoccupied loading bay for this kind of thing
  * @author prissi
  */
-bool haltestelle_t::find_free_position(const waytype_t w,convoihandle_t cnv,const obj_t::typ d) const
+bool haltestelle_t::find_free_position(const waytype_t w,consist_handle_t cnst,const obj_t::typ d) const
 {
 	// iterate over all tiles
 	FOR(slist_tpl<tile_t>, const& i, tiles) {
-		if (i.reservation == cnv || !i.reservation.is_bound()) {
+		if (i.reservation == cnst || !i.reservation.is_bound()) {
 			// not reserved
 			grund_t* const gr = i.grund;
 			assert(gr);
@@ -3282,12 +3282,12 @@
 /* reserves a position (caution: railblocks work differently!
  * @author prissi
  */
-bool haltestelle_t::reserve_position(grund_t *gr,convoihandle_t cnv)
+bool haltestelle_t::reserve_position(grund_t *gr,consist_handle_t cnst)
 {
 	slist_tpl<tile_t>::iterator i = std::find(tiles.begin(), tiles.end(), gr);
 	if (i != tiles.end()) {
-		if (i->reservation == cnv) {
-//DBG_MESSAGE("haltestelle_t::reserve_position()","gr=%d,%d already reserved by cnv=%d",gr->get_pos().x,gr->get_pos().y,cnv.get_id());
+		if (i->reservation == cnst) {
+//DBG_MESSAGE("haltestelle_t::reserve_position()","gr=%d,%d already reserved by cnst=%d",gr->get_pos().x,gr->get_pos().y,cnst.get_id());
 			return true;
 		}
 		// not reserved
@@ -3295,17 +3295,17 @@
 			grund_t* gr = i->grund;
 			if(gr) {
 				// found a stop for this waytype but without object d ...
-				vehicle_t const& v = *cnv->front();
+				vehicle_t const& v = *cnst->front();
 				if (gr->hat_weg(v.get_waytype()) && !gr->suche_obj(v.get_typ())) {
 					// not occupied
-//DBG_MESSAGE("haltestelle_t::reserve_position()","success for gr=%i,%i cnv=%d",gr->get_pos().x,gr->get_pos().y,cnv.get_id());
-					i->reservation = cnv;
+//DBG_MESSAGE("haltestelle_t::reserve_position()","success for gr=%i,%i cnst=%d",gr->get_pos().x,gr->get_pos().y,cnst.get_id());
+					i->reservation = cnst;
 					return true;
 				}
 			}
 		}
 	}
-//DBG_MESSAGE("haltestelle_t::reserve_position()","failed for gr=%i,%i, cnv=%d",gr->get_pos().x,gr->get_pos().y,cnv.get_id());
+//DBG_MESSAGE("haltestelle_t::reserve_position()","failed for gr=%i,%i, cnst=%d",gr->get_pos().x,gr->get_pos().y,cnst.get_id());
 	return false;
 }
 
@@ -3313,12 +3313,12 @@
 /* frees a reserved  position (caution: railblocks work differently!
  * @author prissi
  */
-bool haltestelle_t::unreserve_position(grund_t *gr, convoihandle_t cnv)
+bool haltestelle_t::unreserve_position(grund_t *gr, consist_handle_t cnst)
 {
 	slist_tpl<tile_t>::iterator i = std::find(tiles.begin(), tiles.end(), gr);
 	if (i != tiles.end()) {
-		if (i->reservation == cnv) {
-			i->reservation = convoihandle_t();
+		if (i->reservation == cnst) {
+			i->reservation = consist_handle_t();
 			return true;
 		}
 	}
@@ -3327,21 +3327,21 @@
 }
 
 
-/* can a convoi reserve this position?
+/* can a consist reserve this position?
  * @author prissi
  */
-bool haltestelle_t::is_reservable(const grund_t *gr, convoihandle_t cnv) const
+bool haltestelle_t::is_reservable(const grund_t *gr, consist_handle_t cnst) const
 {
 	FOR(slist_tpl<tile_t>, const& i, tiles) {
 		if (gr == i.grund) {
-			if (i.reservation == cnv) {
-DBG_MESSAGE("haltestelle_t::is_reservable()","gr=%d,%d already reserved by cnv=%d",gr->get_pos().x,gr->get_pos().y,cnv.get_id());
+			if (i.reservation == cnst) {
+DBG_MESSAGE("haltestelle_t::is_reservable()","gr=%d,%d already reserved by cnst=%d",gr->get_pos().x,gr->get_pos().y,cnst.get_id());
 				return true;
 			}
 			// not reserved
 			if (!i.reservation.is_bound()) {
 				// found a stop for this waytype but without object d ...
-				vehicle_t const& v = *cnv->front();
+				vehicle_t const& v = *cnst->front();
 				if (gr->hat_weg(v.get_waytype()) && !gr->suche_obj(v.get_typ())) {
 					// not occupied
 					return true;
@@ -3350,7 +3350,7 @@
 			return false;
 		}
 	}
-DBG_MESSAGE("haltestelle_t::reserve_position()","failed for gr=%i,%i, cnv=%d",gr->get_pos().x,gr->get_pos().y,cnv.get_id());
+DBG_MESSAGE("haltestelle_t::reserve_position()","failed for gr=%i,%i, cnst=%d",gr->get_pos().x,gr->get_pos().y,cnst.get_id());
 	return false;
 }
 
Index: simhalt.h
===================================================================
--- simhalt.h	(revision 7957)
+++ simhalt.h	(working copy)
@@ -8,7 +8,7 @@
 #ifndef simhalt_h
 #define simhalt_h
 
-#include "convoihandle_t.h"
+#include "consist_handle_t.h"
 #include "linehandle_t.h"
 #include "halthandle_t.h"
 
@@ -41,7 +41,7 @@
 #define HALT_HAPPY		3 // number of happy passengers
 #define HALT_UNHAPPY		4 // number of unhappy passengers
 #define HALT_NOROUTE         5 // number of no-route passengers
-#define HALT_CONVOIS_ARRIVED             6 // number of convois arrived this month
+#define HALT_CONVOIS_ARRIVED             6 // number of consists arrived this month
 #define HALT_WALKED 7 // could walk to destination
 
 class cbuffer_t;
@@ -64,7 +64,7 @@
  * @author Hj. Malthaner
  * @see stadt_t
  * @see fabrik_t
- * @see convoi_t
+ * @see consist_t
  */
 class haltestelle_t
 {
@@ -115,7 +115,7 @@
 
 	static uint8 status_step;	// NONE or SCHEDULING or REROUTING
 
-	slist_tpl<convoihandle_t> loading_here;
+	slist_tpl<consist_handle_t> loading_here;
 	sint32 last_loading_step;
 
 	koord init_pos;	// for halt without grounds, created during game initialisation
@@ -127,10 +127,10 @@
 	halthandle_t self;
 
 public:
-	const slist_tpl<convoihandle_t> &get_loading_convois() const { return loading_here; }
+	const slist_tpl<consist_handle_t> &get_loading_consists() const { return loading_here; }
 
-	// add convoi to loading queue
-	void request_loading( convoihandle_t cnv );
+	// add consist to loading queue
+	void request_loading( consist_handle_t cnst );
 
 	/* recalculates the station bar */
 	void recalc_status();
@@ -214,7 +214,7 @@
 		bool operator !=(const tile_t& o) { return grund != o.grund; }
 
 		grund_t*       grund;
-		convoihandle_t reservation;
+		consist_handle_t reservation;
 	};
 
 	const slist_tpl<tile_t> &get_tiles() const { return tiles; };
@@ -254,8 +254,8 @@
 		vector_tpl<connection_t> connections;
 
 		/**
-		 * A transfer/interchange is a halt whereby ware can change line or lineless convoy.
-		 * Thus, if a halt is served by 2 or more schedules (of lines or lineless convoys)
+		 * A transfer/interchange is a halt whereby ware can change line or lineless consist.
+		 * Thus, if a halt is served by 2 or more schedules (of lines or lineless consists)
 		 * for a particular ware type, it is a transfer/interchange for that ware type.
 		 * Route searching is accelerated by differentiating transfer and non-transfer halts.
 		 * @author Knightly
@@ -658,22 +658,22 @@
 	/* checks, if there is an unoccupied loading bay for this kind of thing
 	* @author prissi
 	*/
-	bool find_free_position(const waytype_t w ,convoihandle_t cnv,const obj_t::typ d) const;
+	bool find_free_position(const waytype_t w ,consist_handle_t cnst,const obj_t::typ d) const;
 
 	/* reserves a position (caution: railblocks work differently!
 	* @author prissi
 	*/
-	bool reserve_position(grund_t *gr,convoihandle_t cnv);
+	bool reserve_position(grund_t *gr,consist_handle_t cnst);
 
 	/* frees a reserved  position (caution: railblocks work differently!
 	* @author prissi
 	*/
-	bool unreserve_position(grund_t *gr, convoihandle_t cnv);
+	bool unreserve_position(grund_t *gr, consist_handle_t cnst);
 
 	/* true, if this can be reserved
 	* @author prissi
 	*/
-	bool is_reservable(const grund_t *gr, convoihandle_t cnv) const;
+	bool is_reservable(const grund_t *gr, consist_handle_t cnst) const;
 
 	void info(cbuffer_t & buf) const;
 
@@ -755,22 +755,22 @@
 	vector_tpl<linehandle_t> registered_lines;
 
 	/**
-	 * Register a lineless convoy which serves this stop
+	 * Register a lineless consist which serves this stop
 	 * @author Knightly
 	 */
-	void add_convoy(convoihandle_t convoy) { registered_convoys.append_unique(convoy); }
+	void add_consist(consist_handle_t consist) { registered_consists.append_unique(consist); }
 
 	/**
-	 * Unregister a lineless convoy
+	 * Unregister a lineless consist
 	 * @author Knightly
 	 */
-	void remove_convoy(convoihandle_t convoy) { registered_convoys.remove(convoy); }
+	void remove_consist(consist_handle_t consist) { registered_consists.remove(consist); }
 
 	/**
-	 * A list of lineless convoys serving this stop
+	 * A list of lineless consists serving this stop
 	 * @author Knightly
 	 */
-	vector_tpl<convoihandle_t> registered_convoys;
+	vector_tpl<consist_handle_t> registered_consists;
 
 	/**
 	 * book a certain amount into the halt's financial history
Index: siminteraction.cc
===================================================================
--- siminteraction.cc	(revision 7957)
+++ siminteraction.cc	(working copy)
@@ -376,7 +376,7 @@
 	}
 	else if(IS_RIGHTDRAG(&ev)) {
 		// unset following
-		world->get_viewport()->set_follow_convoi( convoihandle_t() );
+		world->get_viewport()->set_follow_consist( consist_handle_t() );
 		move_view(ev);
 	}
 	else if(  (left_drag  ||  world->get_tool(world->get_active_player_nr())->get_id() == (TOOL_QUERY | GENERAL_TOOL))  &&  IS_LEFTDRAG(&ev)  ) {
@@ -386,7 +386,7 @@
 			display_show_pointer(false);
 			left_drag = true;
 		}
-		world->get_viewport()->set_follow_convoi( convoihandle_t() );
+		world->get_viewport()->set_follow_consist( consist_handle_t() );
 		move_view(ev);
 		ev.ev_code = EVENT_NONE;
 	}
Index: simintr.cc
===================================================================
--- simintr.cc	(revision 7957)
+++ simintr.cc	(working copy)
@@ -99,7 +99,7 @@
 	DBG_DEBUG4("interrupt_check", "called from (%s)", caller_info);
 	if(enabled) {
 		static uint32 last_ms = 0;
-		if(  !welt_modell->is_fast_forward()  ||  welt_modell->get_zeit_ms() != last_ms  ) {
+		if(  !welt_modell->is_fast_forward()  ||  welt_modell->get_ticks() != last_ms  ) {
 			const uint32 now = dr_time();
 			if((now-last_time)*FRAME_TIME_MULTI < frame_time) {
 				return;
@@ -112,7 +112,7 @@
 				enabled = true;
 			}
 		}
-		last_ms = welt_modell->get_zeit_ms();
+		last_ms = welt_modell->get_ticks();
 	}
 	(void)caller_info;
 }
@@ -244,7 +244,7 @@
 
 		// suppress as much as possible, assuming this is an relative offset to the current month
 		sint32 num_days = ( ticks * (env_t::show_month==env_t::DATE_FMT_MONTH? 3 : tage_per_month[month]) ) >> welt_modell->ticks_per_world_month_shift;
-		num_days -= ( (welt_modell->get_zeit_ms() % welt_modell->ticks_per_world_month) * (env_t::show_month==env_t::DATE_FMT_MONTH? 3 : tage_per_month[month]) ) >> welt_modell->ticks_per_world_month_shift;
+		num_days -= ( (welt_modell->get_ticks() % welt_modell->ticks_per_world_month) * (env_t::show_month==env_t::DATE_FMT_MONTH? 3 : tage_per_month[month]) ) >> welt_modell->ticks_per_world_month_shift;
 		char days[64];
 		days[0] = 0;
 		if(  num_days!=0  ) {
Index: simline.cc
===================================================================
--- simline.cc	(revision 7957)
+++ simline.cc	(working copy)
@@ -12,18 +12,18 @@
 #include "player/simplay.h"
 #include "player/finance.h" // convert_money
 #include "vehicle/simvehicle.h"
-#include "simconvoi.h"
-#include "convoihandle_t.h"
+#include "simconsist.h"
+#include "consist_handle_t.h"
 #include "simlinemgmt.h"
 
-uint8 convoi_to_line_catgory_[convoi_t::MAX_CONVOI_COST] = {
+uint8 consist_to_line_catgory_[consist_t::MAX_CONVOI_COST] = {
 	LINE_CAPACITY, LINE_TRANSPORTED_GOODS, LINE_REVENUE, LINE_OPERATIONS, LINE_PROFIT, LINE_DISTANCE, LINE_MAXSPEED, LINE_WAYTOLL
 };
 
-uint8 simline_t::convoi_to_line_catgory(uint8 cnv_cost)
+uint8 simline_t::consist_to_line_catgory(uint8 cnv_cost)
 {
-	assert(cnv_cost < convoi_t::MAX_CONVOI_COST);
-	return convoi_to_line_catgory_[cnv_cost];
+	assert(cnv_cost < consist_t::MAX_CONVOI_COST);
+	return consist_to_line_catgory_[cnv_cost];
 }
 
 
@@ -70,7 +70,7 @@
 {
 	DBG_DEBUG("simline_t::~simline_t()", "deleting fpl=%p", fpl);
 
-	assert(count_convoys()==0);
+	assert(count_consists()==0);
 	unregister_stops();
 
 	delete fpl;
@@ -122,18 +122,18 @@
 }
 
 
-void simline_t::add_convoy(convoihandle_t cnv)
+void simline_t::add_consist(consist_handle_t cnst)
 {
-	if (line_managed_convoys.empty()  &&  self.is_bound()) {
-		// first convoi -> ok, now we can announce this connection to the stations
+	if (line_managed_consists.empty()  &&  self.is_bound()) {
+		// first consist -> ok, now we can announce this connection to the stations
 		// unbound self can happen during loading if this line had line_id=0
 		register_stops(fpl);
 	}
 
-	// first convoi may change line type
-	if (type == trainline  &&  line_managed_convoys.empty() &&  cnv.is_bound()) {
+	// first consist may change line type
+	if (type == trainline  &&  line_managed_consists.empty() &&  cnst.is_bound()) {
 		// check, if needed to convert to tram/monorail line
-		if (vehicle_t const* const v = cnv->front()) {
+		if (vehicle_t const* const v = cnst->front()) {
 			switch (v->get_besch()->get_waytype()) {
 				case tram_wt:     type = simline_t::tramline;     break;
 				// elevated monorail were saved with wrong coordinates for some versions.
@@ -143,13 +143,13 @@
 			}
 		}
 	}
-	// only add convoy if not already member of line
-	line_managed_convoys.append_unique(cnv);
+	// only add consist if not already member of line
+	line_managed_consists.append_unique(cnst);
 
 	// what goods can this line transport?
 	bool update_schedules = false;
-	if(  cnv->get_state()!=convoi_t::INITIAL  ) {
-		FOR(minivec_tpl<uint8>, const catg_index, cnv->get_goods_catg_index()) {
+	if(  cnst->get_state()!=consist_t::INITIAL  ) {
+		FOR(minivec_tpl<uint8>, const catg_index, cnst->get_goods_catg_index()) {
 			if(  !goods_catg_index.is_contained( catg_index )  ) {
 				goods_catg_index.append( catg_index, 1 );
 				update_schedules = true;
@@ -158,7 +158,7 @@
 	}
 
 	// will not hurt ...
-	financial_history[0][LINE_CONVOIS] = count_convoys();
+	financial_history[0][LINE_CONVOIS] = count_consists();
 	recalc_status();
 
 	// do we need to tell the world about our new schedule?
@@ -168,15 +168,15 @@
 }
 
 
-void simline_t::remove_convoy(convoihandle_t cnv)
+void simline_t::remove_consist(consist_handle_t cnst)
 {
-	if(line_managed_convoys.is_contained(cnv)) {
-		line_managed_convoys.remove(cnv);
+	if(line_managed_consists.is_contained(cnst)) {
+		line_managed_consists.remove(cnst);
 		recalc_catg_index();
-		financial_history[0][LINE_CONVOIS] = count_convoys();
+		financial_history[0][LINE_CONVOIS] = count_consists();
 		recalc_status();
 	}
-	if(line_managed_convoys.empty()) {
+	if(line_managed_consists.empty()) {
 		unregister_stops();
 	}
 }
@@ -275,7 +275,7 @@
 	}
 
 	// otherwise inintialized to zero if loading ...
-	financial_history[0][LINE_CONVOIS] = count_convoys();
+	financial_history[0][LINE_CONVOIS] = count_consists();
 }
 
 
@@ -288,7 +288,7 @@
 		assert( self.get_rep() == this );
 		DBG_MESSAGE("simline_t::finish_rd", "assigned id=%d to line %s", self.get_id(), get_name());
 	}
-	if (!line_managed_convoys.empty()) {
+	if (!line_managed_consists.empty()) {
 		register_stops(fpl);
 	}
 	recalc_status();
@@ -332,7 +332,7 @@
 
 void simline_t::renew_stops()
 {
-	if (!line_managed_convoys.empty()) {
+	if (!line_managed_consists.empty()) {
 		register_stops( fpl );
 		DBG_DEBUG("simline_t::renew_stops()", "Line id=%d, name='%s'", self.get_id(), name.c_str());
 	}
@@ -341,7 +341,7 @@
 
 void simline_t::check_freight()
 {
-	FOR(vector_tpl<convoihandle_t>, const i, line_managed_convoys) {
+	FOR(vector_tpl<consist_handle_t>, const i, line_managed_consists) {
 		i->check_freight();
 	}
 }
@@ -352,10 +352,10 @@
 	recalc_status();
 	// then calculate maxspeed
 	sint64 line_max_speed = 0, line_max_speed_count = 0;
-	FOR(vector_tpl<convoihandle_t>, const i, line_managed_convoys) {
+	FOR(vector_tpl<consist_handle_t>, const i, line_managed_consists) {
 		if (!i->in_depot()) {
-			// since convoi stepped first, our history is in month 1 ...
-			line_max_speed += i->get_finance_history(1, convoi_t::CONVOI_MAXSPEED);
+			// since consist stepped first, our history is in month 1 ...
+			line_max_speed += i->get_finance_history(1, consist_t::CONVOI_MAXSPEED);
 			line_max_speed_count ++;
 		}
 	}
@@ -371,7 +371,7 @@
 		}
 		financial_history[0][j] = 0;
 	}
-	financial_history[0][LINE_CONVOIS] = count_convoys();
+	financial_history[0][LINE_CONVOIS] = count_consists();
 }
 
 
@@ -384,12 +384,12 @@
 
 /*
  * the current state saved as color
- * Meanings are BLACK (ok), WHITE (no convois), YELLOW (no vehicle moved), RED (last month income minus), BLUE (at least one convoi vehicle is obsolete)
+ * Meanings are BLACK (ok), WHITE (no consists), YELLOW (no vehicle moved), RED (last month income minus), BLUE (at least one consist vehicle is obsolete)
  */
 void simline_t::recalc_status()
 {
 	if(financial_history[0][LINE_CONVOIS]==0) {
-		// noconvois assigned to this line
+		// noconsists assigned to this line
 		state_color = SYSCOL_TEXT_HIGHLIGHT;
 		withdraw = false;
 	}
@@ -402,9 +402,9 @@
 		state_color = COL_YELLOW;
 	}
 	else if(welt->use_timeline()) {
-		// convois has obsolete vehicles?
+		// consists has obsolete vehicles?
 		bool has_obsolete = false;
-		FOR(vector_tpl<convoihandle_t>, const i, line_managed_convoys) {
+		FOR(vector_tpl<consist_handle_t>, const i, line_managed_consists) {
 			has_obsolete = i->has_obsolete_vehicles();
 			if (has_obsolete) break;
 		}
@@ -428,14 +428,14 @@
 		old_goods_catg_index.append(i);
 	}
 	goods_catg_index.clear();
-	withdraw = !line_managed_convoys.empty();
+	withdraw = !line_managed_consists.empty();
 	// then recreate current
-	FOR(vector_tpl<convoihandle_t>, const i, line_managed_convoys) {
+	FOR(vector_tpl<consist_handle_t>, const i, line_managed_consists) {
 		// what goods can this line transport?
-		convoi_t const& cnv = *i;
-		withdraw &= cnv.get_withdraw();
+		consist_t const& cnst = *i;
+		withdraw &= cnst.get_withdraw();
 
-		FOR(minivec_tpl<uint8>, const catg_index, cnv.get_goods_catg_index()) {
+		FOR(minivec_tpl<uint8>, const catg_index, cnst.get_goods_catg_index()) {
 			goods_catg_index.append_unique( catg_index );
 		}
 	}
@@ -460,11 +460,11 @@
 
 void simline_t::set_withdraw( bool yes_no )
 {
-	withdraw = yes_no && !line_managed_convoys.empty();
-	// convois in depots will be immeadiately destroyed, thus we go backwards
-	for (size_t i = line_managed_convoys.get_count(); i-- != 0;) {
-		line_managed_convoys[i]->set_no_load(yes_no);	// must be first, since set withdraw might destroy convoi if in depot!
-		line_managed_convoys[i]->set_withdraw(yes_no);
+	withdraw = yes_no && !line_managed_consists.empty();
+	// consists in depots will be immeadiately destroyed, thus we go backwards
+	for (size_t i = line_managed_consists.get_count(); i-- != 0;) {
+		line_managed_consists[i]->set_no_load(yes_no);	// must be first, since set withdraw might destroy consist if in depot!
+		line_managed_consists[i]->set_withdraw(yes_no);
 	}
 }
 
Index: simline.h
===================================================================
--- simline.h	(revision 7957)
+++ simline.h	(working copy)
@@ -8,7 +8,7 @@
 
 #include "simtypes.h"
 #include "simcolor.h"
-#include "convoihandle_t.h"
+#include "consist_handle_t.h"
 #include "linehandle_t.h"
 
 #include "tpl/minivec_tpl.h"
@@ -19,12 +19,12 @@
 
 #define LINE_CAPACITY   0 // the amount of ware that could be transported, theoretically
 #define LINE_TRANSPORTED_GOODS 1 // the amount of ware that has been transported
-#define LINE_CONVOIS		2 // number of convois for this line
+#define LINE_CONVOIS		2 // number of consists for this line
 #define LINE_REVENUE		3 // the income this line generated
 #define LINE_OPERATIONS     4 // the cost of operations this line generated
 #define LINE_PROFIT         5 // total profit of line
-#define LINE_DISTANCE       6 // distance covered by all convois
-#define LINE_MAXSPEED       7 // maximum speed for bonus calculation of all convois
+#define LINE_DISTANCE       6 // distance covered by all consists
+#define LINE_MAXSPEED       7 // maximum speed for bonus calculation of all consists
 #define LINE_WAYTOLL        8 // way toll paid by vehicles of line
 #define MAX_LINE_COST   9 // Total number of cost items
 
@@ -58,15 +58,15 @@
 
 	/*
 	 * the current state saved as color
-	 * Meanings are BLACK (ok), WHITE (no convois), YELLOW (no vehicle moved), RED (last month income minus), BLUE (at least one convoi vehicle is obsolete)
+	 * Meanings are BLACK (ok), WHITE (no consists), YELLOW (no vehicle moved), RED (last month income minus), BLUE (at least one consist vehicle is obsolete)
 	 */
 	COLOR_VAL state_color;
 
 	/*
-	 * a list of all convoys assigned to this line
+	 * a list of all consists assigned to this line
 	 * @author hsiegeln
 	 */
-	vector_tpl<convoihandle_t> line_managed_convoys;
+	vector_tpl<consist_handle_t> line_managed_consists;
 
 	/*
 	 * a list of all catg_index, which can be transported by this line.
@@ -97,30 +97,30 @@
 	linehandle_t get_handle() const { return self; }
 
 	/*
-	 * add convoy to route
+	 * add consist to route
 	 * @author hsiegeln
 	 */
-	void add_convoy(convoihandle_t cnv);
+	void add_consist(consist_handle_t cnst);
 
 	/*
-	 * remove convoy from route
+	 * remove consist from route
 	 * @author hsiegeln
 	 */
-	void remove_convoy(convoihandle_t cnv);
+	void remove_consist(consist_handle_t cnst);
 
 	/*
-	 * get convoy
+	 * get consist
 	 * @author hsiegeln
 	 */
-	convoihandle_t get_convoy(int i) const { return line_managed_convoys[i]; }
+	consist_handle_t get_consist(int i) const { return line_managed_consists[i]; }
 
 	/*
-	 * return number of manages convoys in this line
+	 * return number of manages consists in this line
 	 * @author hsiegeln
 	 */
-	uint32 count_convoys() const { return line_managed_convoys.get_count(); }
+	uint32 count_consists() const { return line_managed_consists.get_count(); }
 
-	vector_tpl<convoihandle_t> const& get_convoys() const { return line_managed_convoys; }
+	vector_tpl<consist_handle_t> const& get_consists() const { return line_managed_consists; }
 
 	/*
 	 * returns the state of the line
@@ -171,7 +171,7 @@
 	 */
 	void renew_stops();
 
-	// called after tiles are removed from stations to change the load of connected convois
+	// called after tiles are removed from stations to change the load of connected consists
 	void check_freight();
 
 	sint64* get_finance_history() { return *financial_history; }
@@ -181,7 +181,7 @@
 
 	void book(sint64 amount, int cost_type) { financial_history[0][cost_type] += amount; }
 
-	static uint8 convoi_to_line_catgory(uint8 convoi_cost_type);
+	static uint8 consist_to_line_catgory(uint8 consist_cost_type);
 
 	void new_month();
 
Index: simlinemgmt.cc
===================================================================
--- simlinemgmt.cc	(revision 7957)
+++ simlinemgmt.cc	(working copy)
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include "simlinemgmt.h"
 #include "simline.h"
-#include "simconvoi.h"
+#include "simconsist.h"
 #include "gui/simwin.h"
 #include "simworld.h"
 #include "simtypes.h"
@@ -51,13 +51,13 @@
 
 void simlinemgmt_t::update_line(linehandle_t line)
 {
-	// when a line is updated, all managed convoys must get the new fahrplan!
-	const int count = line->count_convoys();
+	// when a line is updated, all managed consists must get the new fahrplan!
+	const int count = line->count_consists();
 	for(  int i = 0;  i<count;  i++  ) {
-		const convoihandle_t cnv = line->get_convoy(i);
-		cnv->set_update_line(line);
-		if(  cnv->in_depot()  ) {
-			cnv->check_pending_updates(); // apply new schedule immediately for convoys in depot
+		const consist_handle_t cnst = line->get_consist(i);
+		cnst->set_update_line(line);
+		if(  cnst->in_depot()  ) {
+			cnst->check_pending_updates(); // apply new schedule immediately for consists in depot
 		}
 	}
 	// finally de/register all stops
Index: simlinemgmt.h
===================================================================
--- simlinemgmt.h	(revision 7957)
+++ simlinemgmt.h	(working copy)
@@ -34,7 +34,7 @@
 	void delete_line(linehandle_t line);
 
 	/*
-	 * update a line -> apply updated fahrplan to all convoys
+	 * update a line -> apply updated fahrplan to all consists
 	 * @author hsiegeln
 	 */
 	void update_line(linehandle_t line);
Index: simmain.cc
===================================================================
--- simmain.cc	(revision 7957)
+++ simmain.cc	(working copy)
@@ -928,7 +928,7 @@
 	env_t::pak_height_conversion_factor = pak_height_conversion_factor;
 	TILE_HEIGHT_STEP = pak_tile_height;
 
-	convoihandle_t::init( 1024 );
+	consist_handle_t::init( 1024 );
 	linehandle_t::init( 1024 );
 	halthandle_t::init( 1024 );
 
Index: simmenu.cc
===================================================================
--- simmenu.cc	(revision 7957)
+++ simmenu.cc	(working copy)
@@ -153,7 +153,7 @@
 		case TOOL_TOOGLE_PAX:        tool = new tool_toggle_pax_station_t(); break;
 		case TOOL_TOOGLE_PEDESTRIANS:tool = new tool_toggle_pedestrians_t(); break;
 		case TOOL_TRAFFIC_LEVEL:     tool = new tool_traffic_level_t(); break;
-		case TOOL_CHANGE_CONVOI:       tool = new tool_change_convoi_t(); break;
+		case TOOL_CHANGE_CONVOI:       tool = new tool_change_consist_t(); break;
 		case TOOL_CHANGE_LINE:         tool = new tool_change_line_t(); break;
 		case TOOL_CHANGE_DEPOT:        tool = new tool_change_depot_t(); break;
 		case UNUSED_WKZ_PWDHASH_TOOL: dbg->warning("create_simple_tool()","deprecated tool [%i] requested", toolnr); return NULL;
@@ -192,7 +192,7 @@
 		case DIALOG_LOAD:           tool = new dialog_load_t(); break;
 		case DIALOG_SAVE:           tool = new dialog_save_t(); break;
 		case DIALOG_LIST_HALT:      tool = new dialog_list_halt_t(); break;
-		case DIALOG_LIST_CONVOI:    tool = new dialog_list_convoi_t(); break;
+		case DIALOG_LIST_CONVOI:    tool = new dialog_list_consist_t(); break;
 		case DIALOG_LIST_TOWN:      tool = new dialog_list_town_t(); break;
 		case DIALOG_LIST_GOODS:     tool = new dialog_list_goods_t(); break;
 		case DIALOG_LIST_FACTORY:   tool = new dialog_list_factory_t(); break;
Index: simobj.h
===================================================================
--- simobj.h	(revision 7957)
+++ simobj.h	(working copy)
@@ -335,7 +335,7 @@
 #ifdef MULTI_THREAD
 	/**
 	 * Draw overlays
-	 * (convoi tooltips)
+	 * (consist tooltips)
 	 */
 	virtual void display_overlay(int /*xpos*/, int /*ypos*/) const { return; }
 #endif
Index: simtool-dialogs.h
===================================================================
--- simtool-dialogs.h	(revision 7957)
+++ simtool-dialogs.h	(working copy)
@@ -33,7 +33,7 @@
 #include "gui/help_frame.h"
 #include "gui/message_frame_t.h"
 #include "gui/messagebox.h"
-#include "gui/convoi_frame.h"
+#include "gui/consist_frame.h"
 #include "gui/halt_list_frame.h"
 #include "gui/citylist_frame_t.h"
 #include "gui/goods_frame_t.h"
@@ -279,16 +279,16 @@
 };
 
 /* open the list of vehicle */
-class dialog_list_convoi_t : public tool_t {
+class dialog_list_consist_t : public tool_t {
 public:
-	dialog_list_convoi_t() : tool_t(DIALOG_LIST_CONVOI | DIALOGE_TOOL) {}
+	dialog_list_consist_t() : tool_t(DIALOG_LIST_CONVOI | DIALOGE_TOOL) {}
 	char const* get_tooltip(player_t const*) const OVERRIDE{ return translator::translate("cl_title"); }
-	bool is_selected() const OVERRIDE{ return win_get_magic(magic_convoi_list + welt->get_active_player_nr()); }
+	bool is_selected() const OVERRIDE{ return win_get_magic(magic_consist_list + welt->get_active_player_nr()); }
 		bool init(player_t* player_) OVERRIDE{
-		create_win(new convoi_frame_t(player_), w_info, magic_convoi_list + player_->get_player_nr());
+		create_win(new consist_frame_t(player_), w_info, magic_consist_list + player_->get_player_nr());
 		return false;
 	}
-	bool exit(player_t* const player) OVERRIDE{ destroy_win(magic_convoi_list + player->get_player_nr()); return false; }
+	bool exit(player_t* const player) OVERRIDE{ destroy_win(magic_consist_list + player->get_player_nr()); return false; }
 	bool is_init_network_save() const OVERRIDE{ return true; }
 	bool is_work_network_save() const OVERRIDE{ return true; }
 };
Index: simtool.cc
===================================================================
--- simtool.cc	(revision 7957)
+++ simtool.cc	(working copy)
@@ -15,7 +15,7 @@
 #include "simevent.h"
 #include "simcity.h"
 #include "simmesg.h"
-#include "simconvoi.h"
+#include "simconsist.h"
 #include "gui/simwin.h"
 #include "display/viewport.h"
 
@@ -1443,20 +1443,20 @@
 			// is this a reserved track?
 			if(w!=NULL  &&  w->is_reserved()) {
 				/* now we do a very crude procedure:
-				 * - we search all ways for reservations of this convoi and remove them
-				 * - we set the convoi state to ROUTING_1; it must reserve again its ways then
+				 * - we search all ways for reservations of this consist and remove them
+				 * - we set the consist state to ROUTING_1; it must reserve again its ways then
 				 */
 				const waytype_t waytype = w->get_waytype();
-				const convoihandle_t cnv = w->get_reserved_convoi();
-				if(cnv->get_state()==convoi_t::DRIVING) {
+				const consist_handle_t cnst = w->get_reserved_consist();
+				if(cnst->get_state()==consist_t::DRIVING) {
 					// reset driving state
-					cnv->suche_neue_route();
+					cnst->suche_neue_route();
 				}
 				FOR(slist_tpl<weg_t*>, const w, weg_t::get_alle_wege()) {
 					if (w->get_waytype() == waytype) {
 						schiene_t* const sch = obj_cast<schiene_t>(w);
-						if (sch->get_reserved_convoi() == cnv) {
-							vehicle_t& v = *cnv->front();
+						if (sch->get_reserved_consist() == cnst) {
+							vehicle_t& v = *cnst->front();
 							if (!gr->suche_obj(v.get_typ())) {
 								// force free
 								sch->unreserve(&v);
@@ -5977,16 +5977,16 @@
 				}
 			}
 
-			// first, check convoi without line
-			FOR(vector_tpl<convoihandle_t>, const cnv, welt->convoys()) {
+			// first, check consist without line
+			FOR(vector_tpl<consist_handle_t>, const cnst, welt->consists()) {
 				// check line and owner
-				if(!cnv->get_line().is_bound()  &&  cnv->get_owner()==player) {
-					schedule_t *fpl = cnv->get_schedule();
+				if(!cnst->get_line().is_bound()  &&  cnst->get_owner()==player) {
+					schedule_t *fpl = cnst->get_schedule();
 					// check waytype
 					if(fpl  &&  fpl->ist_halt_erlaubt(bd)) {
 						bool updated = false;
 						FOR(minivec_tpl<linieneintrag_t>, & k, fpl->eintrag) {
-							if ((catch_all_halt && haltestelle_t::get_halt( k.pos, cnv->get_owner()) == last_halt) ||
+							if ((catch_all_halt && haltestelle_t::get_halt( k.pos, cnst->get_owner()) == last_halt) ||
 									old_platform.is_contained(k.pos)) {
 								k.pos   = pos;
 								updated = true;
@@ -5994,18 +5994,18 @@
 						}
 						if(updated) {
 							fpl->cleanup();
-							// Knightly : remove lineless convoy from old stop
+							// Knightly : remove lineless consist from old stop
 							if(  last_halt.is_bound()  ) {
-								last_halt->remove_convoy(cnv);
+								last_halt->remove_consist(cnst);
 							}
-							// Knightly : register lineless convoy at new stop
+							// Knightly : register lineless consist at new stop
 							if(  new_halt.is_bound()  ) {
-								new_halt->add_convoy(cnv);
+								new_halt->add_consist(cnst);
 							}
 							if(  !fpl->ist_abgeschlossen()  ) {
 								// schedule is not owned by schedule window ...
 								// ... thus we can set this schedule
-								cnv->set_schedule(fpl);
+								cnst->set_schedule(fpl);
 								// otherwise the schedule window will reset it
 							}
 						}
@@ -6573,8 +6573,8 @@
 }
 
 
-/* Handles all action of convois in depots. Needs a default param:
- * [function],[convoi_id],addition stuff
+/* Handles all action of consists in depots. Needs a default param:
+ * [function],[consist_id],addition stuff
  * following simple command exists:
  * 'x' : self destruct
  * 'f' : open the schedule window
@@ -6585,10 +6585,10 @@
  * 'l' : apply new line [number]
  * 'd' : go to nearest depot
  */
-bool tool_change_convoi_t::init( player_t *player )
+bool tool_change_consist_t::init( player_t *player )
 {
 	char tool=0;
-	uint16 convoi_id = 0;
+	uint16 consist_id = 0;
 
 	// skip the rest of the command
 	const char *p = default_param;
@@ -6595,7 +6595,7 @@
 	while(  *p  &&  *p<=' '  ) {
 		p++;
 	}
-	sscanf( p, "%c,%hi", &tool, &convoi_id );
+	sscanf( p, "%c,%hi", &tool, &consist_id );
 
 	// skip to the commands ...
 	for(  int z = 2;  *p  &&  z>0;  p++  ) {
@@ -6604,22 +6604,22 @@
 		}
 	}
 
-	convoihandle_t cnv;
-	cnv.set_id( convoi_id );
+	consist_handle_t cnst;
+	cnst.set_id( consist_id );
 	// double click on remove button will send two such commands
-	// the first will delete the convoi, the second should not trigger an assertion
+	// the first will delete the consist, the second should not trigger an assertion
 	// catch such commands here
-	if( !cnv.is_bound()) {
+	if( !cnst.is_bound()) {
 #if DEBUG>=4
 		if (can_use_gui()) {
 			create_win( new news_img("Convoy already deleted!"), w_time_delete, magic_none);
 		}
 #endif
-		dbg->warning("tool_change_convoi_t::init", "no convoy with id=%d found", convoi_id);
+		dbg->warning("tool_change_consist_t::init", "no consist with id=%d found", consist_id);
 		return false;
 	}
 	// ownership check for network games
-	if (cnv.is_bound()  &&  env_t::networkmode  &&  !player_t::check_owner(cnv->get_owner(), player)) {
+	if (cnst.is_bound()  &&  env_t::networkmode  &&  !player_t::check_owner(cnst->get_owner(), player)) {
 		return false;
 	}
 
@@ -6626,17 +6626,17 @@
 	// first letter is now the actual command
 	switch(  tool  ) {
 		case 'x': // self destruction ...
-			if(cnv.is_bound()) {
-				if (cnv->get_state()==convoi_t::INITIAL) {
-					// delete cnv in depot
-					if (grund_t *gr = welt->lookup(cnv->get_pos())) {
+			if(cnst.is_bound()) {
+				if (cnst->get_state()==consist_t::INITIAL) {
+					// delete cnst in depot
+					if (grund_t *gr = welt->lookup(cnst->get_pos())) {
 						if (depot_t *dep = gr->get_depot()) {
-							dep->disassemble_convoi(cnv, true);
+							dep->disassemble_consist(cnst, true);
 							return false;
 						}
 					}
 				}
-				cnv->self_destruct();
+				cnst->self_destruct();
 			}
 			return false;
 
@@ -6644,16 +6644,16 @@
 			{
 				// we open the window only when executed on the same client that triggered the tool
 				// but the all clients must call the function anyway
-				cnv->open_schedule_window( can_use_gui() );
+				cnst->open_schedule_window( can_use_gui() );
 			}
 			break;
 
 		case 'g': // change schedule
 			{
-				schedule_t *fpl = cnv->create_schedule()->copy();
+				schedule_t *fpl = cnst->create_schedule()->copy();
 				fpl->eingabe_abschliessen();
 				if (fpl->sscanf_schedule( p )  &&  scenario_check_schedule(welt, player, fpl, can_use_gui())) {
-					cnv->set_schedule( fpl );
+					cnst->set_schedule( fpl );
 				}
 				else {
 					// could not read schedule, do not assign
@@ -6671,9 +6671,9 @@
 				l.set_id( id );
 				if(  l.is_bound()  ) {
 					// sanity check for right line-type (compare schedule types ..)
-					schedule_t *fpl = cnv->create_schedule();
+					schedule_t *fpl = cnst->create_schedule();
 					if(  fpl  &&  l->get_schedule()  &&  fpl->get_type()!=l->get_schedule()->get_type()  ) {
-						dbg->warning("tool_change_convoi_t::init", "types of convoi and line do not match");
+						dbg->warning("tool_change_consist_t::init", "types of consist and line do not match");
 						return false;
 					}
 					if(  count==1 ) {
@@ -6680,17 +6680,17 @@
 						// aktuell was not supplied -> take it from line schedule
 						aktuell = l->get_schedule()->get_aktuell();
 					}
-					cnv->set_line( l );
-					cnv->get_schedule()->set_aktuell((uint8)aktuell);
-					cnv->get_schedule()->eingabe_abschliessen();
+					cnst->set_line( l );
+					cnst->get_schedule()->set_aktuell((uint8)aktuell);
+					cnst->get_schedule()->eingabe_abschliessen();
 				}
 			}
 			break;
 
 		case 'n': // change no_load
-			cnv->set_no_load( !cnv->get_no_load() );
-			if(  !cnv->get_no_load()  ) {
-				cnv->set_withdraw( false );
+			cnst->set_no_load( !cnst->get_no_load() );
+			if(  !cnst->get_no_load()  ) {
+				cnst->set_withdraw( false );
 			}
 			break;
 
@@ -6698,9 +6698,9 @@
 			{
 				int new_state = atoi(p);
 				if(  new_state>0  ) {
-					cnv->set_state( new_state );
-					if(  new_state==convoi_t::FAHRPLANEINGABE  ) {
-						cnv->get_schedule()->eingabe_beginnen();
+					cnst->set_state( new_state );
+					if(  new_state==consist_t::FAHRPLANEINGABE  ) {
+						cnst->get_schedule()->eingabe_beginnen();
 					}
 				}
 			}
@@ -6707,13 +6707,13 @@
 			break;
 
 		case 'w': // change withdraw
-			cnv->set_withdraw( !cnv->get_withdraw() );
-			cnv->set_no_load( cnv->get_withdraw() );
+			cnst->set_withdraw( !cnst->get_withdraw() );
+			cnst->set_no_load( cnst->get_withdraw() );
 			break;
 
 		case 'd': // goto depot
 		{
-			const char* msg = cnv->send_to_depot(is_local_execution());
+			const char* msg = cnst->send_to_depot(is_local_execution());
 
 			if (is_local_execution()) {
 				create_win( new news_img(msg), w_time_delete, magic_none);
@@ -6721,8 +6721,8 @@
 		}
 	}
 
-	if(  cnv->in_depot()  &&  (tool=='g'  ||  tool=='l')  ) {
-		const grund_t *const ground = welt->lookup( cnv->get_home_depot() );
+	if(  cnst->in_depot()  &&  (tool=='g'  ||  tool=='l')  ) {
+		const grund_t *const ground = welt->lookup( cnst->get_home_depot() );
 		if(  ground  ) {
 			const depot_t *const depot = ground->get_depot();
 			if(  depot  ) {
@@ -6809,7 +6809,7 @@
 
 		case 'd':	// delete line
 			{
-				if (line.is_bound()  &&  line->count_convoys()==0) {
+				if (line.is_bound()  &&  line->count_consists()==0) {
 					// close a schedule window, if still active
 					gui_frame_t *w = win_get_magic( (ptrdiff_t)line.get_rep() );
 					if(w) {
@@ -6837,7 +6837,7 @@
 			}
 			break;
 
-		case 't':	// trims away convois on all lines of linetype with this default parameter
+		case 't':	// trims away consists on all lines of linetype with this default parameter
 			{
 				vector_tpl<linehandle_t> const& lines = player->simlinemgmt.get_line_list();
 				// what kind of lines to trim
@@ -6851,7 +6851,7 @@
 				}
 
 				FOR(vector_tpl<linehandle_t>,line,lines) {
-					if(  line->get_linetype() == linetype  &&  line->get_convoys().get_count() > 2  ) {
+					if(  line->get_linetype() == linetype  &&  line->get_consists().get_count() > 2  ) {
 						// correct waytpe and more than one,n now some up usage for the last six months
 						sint64 transported = 0, capacity = 0;
 						for(  int i=0;  i<6;  i++  ) {
@@ -6865,14 +6865,14 @@
 
 						if(  (transported*100) / capacity < percentage  ) {
 							// less than 33 % usage => remove concois
-							vector_tpl<convoihandle_t> const& cnvs = line->get_convoys();
+							vector_tpl<consist_handle_t> const& cnvs = line->get_consists();
 							sint64 old_sum_capacity = 0;
-							FOR(vector_tpl<convoihandle_t>,cnv,cnvs) {
-								for(  int i=0;  i<cnv->get_vehicle_count();  i++  ) {
-									old_sum_capacity += cnv->get_vehikel(i)->get_besch()->get_zuladung();
+							FOR(vector_tpl<consist_handle_t>,cnst,cnvs) {
+								for(  int i=0;  i<cnst->get_vehicle_count();  i++  ) {
+									old_sum_capacity += cnst->get_vehikel(i)->get_besch()->get_zuladung();
 								}
 							}
-							/* now we have the total capacity. We will now remove convois until this capacity
+							/* now we have the total capacity. We will now remove consists until this capacity
 							 * is reduced by the ration suggested from transported = 1/3 of total capacity
 							 * x is the percentage of used capacity
 							 * Then is the new target sum_capacity = x*old_sum_capacity
@@ -6879,36 +6879,36 @@
 							 */
 							sint64 new_sum_capacity = (transported * 1000 * old_sum_capacity) / (capacity * percentage * 10);
 
-							// first we remove the totally empty convois (nowbody will miss them)
+							// first we remove the totally empty consists (nowbody will miss them)
 							int destroyed = 0;
-							const int initial = line->get_convoys().get_count();
+							const int initial = line->get_consists().get_count();
 							const int max_left = (initial+2) / 2;
 
 							for(  int j=initial-1;  j >= 0  &&  initial-destroyed > max_left  &&  new_sum_capacity < old_sum_capacity;  j--  ) {
-								convoihandle_t cnv = line->get_convoy(j);
-								if(  cnv->get_state() == convoi_t::INITIAL  ||  cnv->get_state() >= convoi_t::WAITING_FOR_CLEARANCE_ONE_MONTH  ) {
-									for(  int i=0;  i<cnv->get_vehicle_count();  i++  ) {
-										old_sum_capacity -= cnv->get_vehikel(i)->get_besch()->get_zuladung();
+								consist_handle_t cnst = line->get_consist(j);
+								if(  cnst->get_state() == consist_t::INITIAL  ||  cnst->get_state() >= consist_t::WAITING_FOR_CLEARANCE_ONE_MONTH  ) {
+									for(  int i=0;  i<cnst->get_vehicle_count();  i++  ) {
+										old_sum_capacity -= cnst->get_vehikel(i)->get_besch()->get_zuladung();
 									}
-									cnv->self_destruct();
+									cnst->self_destruct();
 									destroyed ++;
 								}
 							}
 
 							// not enough? Then remove from the end ...
-							for(  uint j=0;  j < line->get_convoys().get_count()  &&  initial-destroyed > max_left  &&  new_sum_capacity < old_sum_capacity;  j++  ) {
-								convoihandle_t cnv = line->get_convoy(j);
-								if(  cnv->get_state() != convoi_t::SELF_DESTRUCT  ) {
-									for(  int i=0;  i<cnv->get_vehicle_count();  i++  ) {
-										old_sum_capacity -= cnv->get_vehikel(i)->get_besch()->get_zuladung();
+							for(  uint j=0;  j < line->get_consists().get_count()  &&  initial-destroyed > max_left  &&  new_sum_capacity < old_sum_capacity;  j++  ) {
+								consist_handle_t cnst = line->get_consist(j);
+								if(  cnst->get_state() != consist_t::SELF_DESTRUCT  ) {
+									for(  int i=0;  i<cnst->get_vehicle_count();  i++  ) {
+										old_sum_capacity -= cnst->get_vehikel(i)->get_besch()->get_zuladung();
 									}
-									cnv->self_destruct();
+									cnst->self_destruct();
 									destroyed ++;
 								}
 							}
 							// done
 							if(  destroyed  ) {
-								dbg->message( "tool_change_line_t::init", "trim line %s: Reduced from %d to %d convois", line->get_name(), initial, initial-destroyed );
+								dbg->message( "tool_change_line_t::init", "trim line %s: Reduced from %d to %d consists", line->get_name(), initial, initial-destroyed );
 							}
 						}
 					}
@@ -6916,20 +6916,20 @@
 			}
 			break;
 
-		case 'u':	// unite all lineless convois with similar schedules
+		case 'u':	// unite all lineless consists with similar schedules
 			{
-				array_tpl<vector_tpl<convoihandle_t> > cnvs(welt->convoys().get_count());
+				array_tpl<vector_tpl<consist_handle_t> > cnvs(welt->consists().get_count());
 				uint32 max_cnvs=0;
-				FOR(vector_tpl<convoihandle_t>, cnv, welt->convoys()) {
-					// only check lineless convoys
-					if(  !cnv->get_line().is_bound()  ) {
+				FOR(vector_tpl<consist_handle_t>, cnst, welt->consists()) {
+					// only check lineless consists
+					if(  !cnst->get_line().is_bound()  ) {
 						bool found = false;
-						// check, if already matches existing convois schedule
+						// check, if already matches existing consists schedule
 						for(  uint32 i=0;  i<max_cnvs  &&  !found;  i++  ) {
-							FOR(vector_tpl<convoihandle_t>, cnvcomp, cnvs[i] ) {
-								if(  cnvcomp->get_schedule()->matches( welt, cnv->get_schedule() )  ) {
+							FOR(vector_tpl<consist_handle_t>, cnvcomp, cnvs[i] ) {
+								if(  cnvcomp->get_schedule()->matches( welt, cnst->get_schedule() )  ) {
 									found = true;
-									cnvs[i].append( cnv );
+									cnvs[i].append( cnst );
 									break;
 								}
 							}
@@ -6936,18 +6936,18 @@
 						}
 						// not added: then may be new line for this?
 						if(  !found  ) {
-							cnvs[max_cnvs++].append( cnv );
+							cnvs[max_cnvs++].append( cnst );
 						}
 					}
 				}
-				// now we have an array of one or more lineless convois
+				// now we have an array of one or more lineless consists
 				for(  uint32 i=0;  i<max_cnvs;  i++  ) {
-					// if there is more than one convois => new line
+					// if there is more than one consists => new line
 					if(  cnvs[i].get_count()>1  ) {
 						line = player->simlinemgmt.create_line( cnvs[i][0]->get_schedule()->get_type(), player, cnvs[i][0]->get_schedule() );
-						FOR(vector_tpl<convoihandle_t>, cnv, cnvs[i] ) {
-							line->add_convoy( cnv );
-							cnv->set_line( line );
+						FOR(vector_tpl<consist_handle_t>, cnst, cnvs[i] ) {
+							line->add_consist( cnst );
+							cnst->set_line( line );
 						}
 					}
 				}
@@ -6967,20 +6967,20 @@
 
 
 
-/* Handles all action of convois in depots. Needs a default param:
- * [function],[depot_pos_3d],[convoi_id],addition stuff
+/* Handles all action of consists in depots. Needs a default param:
+ * [function],[depot_pos_3d],[consist_id],addition stuff
  * following simple command exists:
- * 'l' : creates a new line (convoi_id might be invalid) (+printf'd initial schedule)
- * 'b' : starts the convoi
- * 'B' : starts all convoys
- * 'c' : copies this convoi
- * 'd' : disassembles convoi
- * 's' : sells convoi
+ * 'l' : creates a new line (consist_id might be invalid) (+printf'd initial schedule)
+ * 'b' : starts the consist
+ * 'B' : starts all consists
+ * 'c' : copies this consist
+ * 'd' : disassembles consist
+ * 's' : sells consist
  * 'a' : appends a vehicle (+vehikel_name) uses the oldest
  * 'i' : inserts a vehicle in front (+vehikel_name) uses the oldest
  * 's' : sells a vehikel (+vehikel_name) uses the newest
- * 'r' : removes a vehikel (+number in convoi)
- * 'R' : removes all vehikels including (+number in convoi) to end
+ * 'r' : removes a vehikel (+number in consist)
+ * 'R' : removes all vehikels including (+number in consist) to end
  */
 bool tool_change_depot_t::init( player_t *player )
 {
@@ -6987,7 +6987,7 @@
 	char tool=0;
 	koord3d pos = koord3d::invalid;
 	sint16 z;
-	uint16 convoi_id;
+	uint16 consist_id;
 
 	// skip the rest of the command
 	const char *p = default_param;
@@ -6994,7 +6994,7 @@
 	while(  *p  &&  *p<=' '  ) {
 		p++;
 	}
-	sscanf( p, "%c,%hi,%hi,%hi,%hi", &tool, &pos.x, &pos.y, &z, &convoi_id );
+	sscanf( p, "%c,%hi,%hi,%hi,%hi", &tool, &pos.x, &pos.y, &z, &consist_id );
 	pos.z = (sint8)z;
 
 	// skip to the commands ...
@@ -7017,8 +7017,8 @@
 		return false;
 	}
 
-	convoihandle_t cnv;
-	cnv.set_id( convoi_id );
+	consist_handle_t cnst;
+	cnst.set_id( consist_id );
 
 	// ok now do our stuff
 	switch(  tool  ) {
@@ -7049,30 +7049,30 @@
 			DBG_MESSAGE("depot_frame_t::new_line()","id=%d",selected_line.get_id() );
 			break;
 		}
-		case 'b': { // start a convoi from the depot
-			if(  cnv.is_bound()  ) {
-				depot->start_convoi(cnv, can_use_gui());
+		case 'b': { // start a consist from the depot
+			if(  cnst.is_bound()  ) {
+				depot->start_consist(cnst, can_use_gui());
 			}
 			break;
 		}
-		case 'B': { // start all convoys
-			depot->start_all_convoys();
+		case 'B': { // start all consists
+			depot->start_all_consists();
 			break;
 		}
-		case 'd':   // disassemble convoi
-		case 'v': { // sell convoi
-			depot->disassemble_convoi( cnv, tool=='v' );
+		case 'd':   // disassemble consist
+		case 'v': { // sell consist
+			depot->disassemble_consist( cnst, tool=='v' );
 			break;
 		}
-		case 'c': { // copy this convoi
-			if(  cnv.is_bound()  ) {
-				if(  convoihandle_t::is_exhausted()  ) {
+		case 'c': { // copy this consist
+			if(  cnst.is_bound()  ) {
+				if(  consist_handle_t::is_exhausted()  ) {
 					if(  can_use_gui()  ) {
 						create_win( new news_img("Convoi handles exhausted!"), w_time_delete, magic_none );
 					}
 					return false;
 				}
-				depot->copy_convoi( cnv, can_use_gui() );
+				depot->copy_consist( cnst, can_use_gui() );
 			}
 			break;
 		}
@@ -7084,28 +7084,28 @@
 			if(  tool=='r'  ||  tool=='R'  ) {
 				// test may fail after double-click on the button:
 				// two remove cmds are sent, only the first will remove, the second should not trigger assertion failure
-				if ( cnv.is_bound() ) {
+				if ( cnst.is_bound() ) {
 					int start_nr = atoi(p);
 					int nr = start_nr;
 
 					// find end
-					while(nr<cnv->get_vehicle_count()) {
-						const vehikel_besch_t *info = cnv->get_vehikel(nr)->get_besch();
+					while(nr<cnst->get_vehicle_count()) {
+						const vehikel_besch_t *info = cnst->get_vehikel(nr)->get_besch();
 						nr ++;
-						if(info->get_nachfolger_count()!=1) {
+						if(info->get_trailing_count()!=1) {
 							break;
 						}
 					}
 					// now remove the vehicles
-					if(  cnv->get_vehicle_count()==nr-start_nr  ||  (tool=='R'  &&  start_nr==0)  ) {
-						depot->disassemble_convoi(cnv, false);
+					if(  cnst->get_vehicle_count()==nr-start_nr  ||  (tool=='R'  &&  start_nr==0)  ) {
+						depot->disassemble_consist(cnst, false);
 					}
 					else if(  tool=='R'  ) {
-						depot->remove_vehicles_to_end( cnv, start_nr );
+						depot->remove_vehicles_to_end( cnst, start_nr );
 					}
 					else {
 						for(  int i=start_nr;  i<nr;  i++  ) {
-							depot->remove_vehicle(cnv, start_nr);
+							depot->remove_vehicle(cnst, start_nr);
 						}
 					}
 				}
@@ -7121,8 +7121,8 @@
 
 					if(tool!='a') {
 						// start of composition
-						while(  info->get_vorgaenger_count() == 1  &&  info->get_vorgaenger(0) != NULL  &&  !new_vehicle_info.is_contained(info)  ) {
-							info = info->get_vorgaenger(0);
+						while(  info->get_leading_count() == 1  &&  info->get_leading(0) != NULL  &&  !new_vehicle_info.is_contained(info)  ) {
+							info = info->get_leading(0);
 							new_vehicle_info.insert(info);
 						}
 						info = start_info;
@@ -7129,10 +7129,10 @@
 					}
 					while(info) {
 						new_vehicle_info.append( info );
-						if(info->get_nachfolger_count() != 1  ||  (tool == 'i'  &&  info == start_info)  ||  new_vehicle_info.is_contained(info->get_nachfolger(0))  ) {
+						if(info->get_trailing_count() != 1  ||  (tool == 'i'  &&  info == start_info)  ||  new_vehicle_info.is_contained(info->get_trailing(0))  ) {
 							break;
 						}
-						info = info->get_nachfolger(0);
+						info = info->get_trailing(0);
 					}
 					// now we have a valid composition together
 					if(  tool=='s'  ) {
@@ -7155,22 +7155,22 @@
 							}
 						}
 
-						// append/insert into convoi; create one if needed
+						// append/insert into consist; create one if needed
 						depot->clear_command_pending();
-						if(  !cnv.is_bound()  ) {
-							if(  convoihandle_t::is_exhausted()  ) {
+						if(  !cnst.is_bound()  ) {
+							if(  consist_handle_t::is_exhausted()  ) {
 								if(  can_use_gui()  ) {
 									create_win( new news_img("Convoi handles exhausted!"), w_time_delete, magic_none);
 								}
 								return false;
 							}
-							// create a new convoi
-							cnv = depot->add_convoi( can_use_gui() );
-							cnv->set_name( new_vehicle_info.front()->get_name() );
+							// create a new consist
+							cnst = depot->add_consist( can_use_gui() );
+							cnst->set_name( new_vehicle_info.front()->get_name() );
 						}
 
-						// now we have a valid cnv
-						if(  cnv->get_vehicle_count()+new_vehicle_info.get_count() <= depot->get_max_convoi_length()  ) {
+						// now we have a valid cnst
+						if(  cnst->get_vehicle_count()+new_vehicle_info.get_count() <= depot->get_max_consist_length()  ) {
 
 							for(  unsigned i=0;  i<new_vehicle_info.get_count();  i++  ) {
 								// insert/append needs reverse order
@@ -7182,7 +7182,7 @@
 									// nothing there => we buy it
 									veh = depot->buy_vehicle(vb);
 								}
-								depot->append_vehicle( cnv, veh, tool=='i', can_use_gui() );
+								depot->append_vehicle( cnst, veh, tool=='i', can_use_gui() );
 							}
 						}
 					}
@@ -7346,7 +7346,7 @@
 
 /* Handles renaming of ingame entities. Needs a default param:
  * [object='c|h|l|m|t|p|f'][id|pos],[name]
- * c=convoi, h=halt, l=line,  m=marker, t=town, p=player, f=factory
+ * c=consist, h=halt, l=line,  m=marker, t=town, p=player, f=factory
  * in case of marker / factory, id is a pos3d string
  */
 bool tool_rename_t::init(player_t *player)
@@ -7418,11 +7418,11 @@
 
 		case 'c':
 		{
-			convoihandle_t cnv;
-			cnv.set_id( id );
-			if(  cnv.is_bound()  &&  (!env_t::networkmode  ||  player_t::check_owner(cnv->get_owner(), player))  ) {
+			consist_handle_t cnst;
+			cnst.set_id( id );
+			if(  cnst.is_bound()  &&  (!env_t::networkmode  ||  player_t::check_owner(cnst->get_owner(), player))  ) {
 				//  set name without ID
-				cnv->set_name( p, false );
+				cnst->set_name( p, false );
 				return false;
 			}
 			break;
Index: simtool.h
===================================================================
--- simtool.h	(revision 7957)
+++ simtool.h	(working copy)
@@ -993,9 +993,9 @@
 	bool is_init_network_save() const OVERRIDE { return false; }
 };
 
-class tool_change_convoi_t : public tool_t {
+class tool_change_consist_t : public tool_t {
 public:
-	tool_change_convoi_t() : tool_t(TOOL_CHANGE_CONVOI | SIMPLE_TOOL) {}
+	tool_change_consist_t() : tool_t(TOOL_CHANGE_CONVOI | SIMPLE_TOOL) {}
 	bool init(player_t*) OVERRIDE;
 	bool is_init_network_save() const OVERRIDE { return false; }
 };
Index: simtypes.h
===================================================================
--- simtypes.h	(revision 7957)
+++ simtypes.h	(working copy)
@@ -147,6 +147,7 @@
 #	define NORETURN      __attribute__ ((noreturn))
 #endif
 
+
 template<typename T> static inline int sgn(T x)
 {
 		if (x < 0) return -1;
@@ -154,15 +155,19 @@
 		return 0;
 }
 
+#ifndef min
 static inline int min(const int a, const int b)
 {
 	return a < b ? a : b;
 }
+#endif
 
+#ifndef max
 static inline int max(const int a, const int b)
 {
 	return a > b ? a : b;
 }
+#endif
 
 // endian coversion routines
 
Index: Simutrans.vcxproj
===================================================================
--- Simutrans.vcxproj	(revision 7957)
+++ Simutrans.vcxproj	(working copy)
@@ -1,5 +1,5 @@
 ï»¿<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -14,6 +14,7 @@
     <ProjectGuid>{0621B295-BEB7-4767-82F1-F27995610323}</ProjectGuid>
     <RootNamespace>Simutrans</RootNamespace>
     <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
@@ -20,11 +21,13 @@
     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>NotSet</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>NotSet</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v140</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -38,7 +41,7 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\simutrans</OutDir>
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>
     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
     <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
@@ -45,6 +48,8 @@
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>
     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
     <EmbedManifest Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</EmbedManifest>
+    <IncludePath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">C:\Users\James\Documents\Development\Simutrans\OpenTTD\shared\include;C:\Users\James\Documents\Development\Simutrans\OpenTTD\win32\include;$(IncludePath)</IncludePath>
+    <LibraryPath Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">C:\Users\James\Documents\Development\Simutrans\Bzip\lib;C:\Users\James\Documents\Development\Simutrans\OpenTTD\win32\library;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <PreBuildEvent>
@@ -55,7 +60,7 @@
       <InlineFunctionExpansion>Default</InlineFunctionExpansion>
       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
       <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>NOMINMAX;WIN32_LEAN_AND_MEAN;WINVER=_WIN32_WINNT_WINXP;ZLIB_WINAPI;REVISION_FROM_FILE;LITTLE_ENDIAN;DEBUG=3;COLOUR_DEPTH=16;MULTI_THREAD=2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NOMINMAX;WIN32_LEAN_AND_MEAN;WINVER=_WIN32_WINNT_WINXP;ZLIB_WINAPI;LITTLE_ENDIAN;DEBUG=3;COLOUR_DEPTH=16;MULTI_THREAD=2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
@@ -68,7 +73,7 @@
       <DisableSpecificWarnings>4996;4373;%(DisableSpecificWarnings)</DisableSpecificWarnings>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;shell32.lib;winmm.lib;zlibstat.lib;advapi32.lib;ws2_32.lib;imm32.lib;libbz2.lib;pthreadVC2.lib;libfreetype2.lib</AdditionalDependencies>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;shell32.lib;winmm.lib;zlibstat.lib;advapi32.lib;ws2_32.lib;imm32.lib;libbz2.lib;pthreadVCE2.lib;libfreetype2.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
       <IgnoreSpecificDefaultLibraries>libcmt.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
@@ -133,7 +138,7 @@
     <ClCompile Include="gui\base_info.cc" />
     <ClCompile Include="gui\city_info.cc" />
     <ClCompile Include="gui\components\gui_container.cc" />
-    <ClCompile Include="gui\components\gui_convoiinfo.cc" />
+    <ClCompile Include="gui\components\gui_consistinfo.cc" />
     <ClCompile Include="gui\components\gui_image.cc" />
     <ClCompile Include="gui\components\gui_komponente.cc" />
     <ClCompile Include="gui\components\gui_map_preview.cc" />
@@ -157,7 +162,7 @@
     <ClCompile Include="script\api_class.cc" />
     <ClCompile Include="script\api\api_const.cc" />
     <ClCompile Include="script\api\api_control.cc" />
-    <ClCompile Include="script\api\api_convoy.cc" />
+    <ClCompile Include="script\api\api_consist.cc" />
     <ClCompile Include="script\api\api_factory.cc" />
     <ClCompile Include="script\api_function.cc" />
     <ClCompile Include="script\api\api_halt.cc" />
@@ -190,11 +195,11 @@
     <ClCompile Include="gui\citylist_stats_t.cc" />
     <ClCompile Include="gui\climates.cc" />
     <ClCompile Include="clipboard_w32.cc" />
-    <ClCompile Include="gui\convoi_detail_t.cc" />
-    <ClCompile Include="gui\convoi_filter_frame.cc" />
-    <ClCompile Include="gui\convoi_frame.cc" />
-    <ClCompile Include="gui\convoi_info_t.cc" />
-    <ClCompile Include="gui\convoy_item.cc" />
+    <ClCompile Include="gui\consist_detail_t.cc" />
+    <ClCompile Include="gui\consist_filter_frame.cc" />
+    <ClCompile Include="gui\consist_frame.cc" />
+    <ClCompile Include="gui\consist_info_t.cc" />
+    <ClCompile Include="gui\consist_item.cc" />
     <ClCompile Include="obj\crossing.cc" />
     <ClCompile Include="dataobj\crossing_logic.cc" />
     <ClCompile Include="besch\reader\crossing_reader.cc" />
@@ -342,7 +347,7 @@
     <ClCompile Include="gui\signal_spacing.cc" />
     <ClCompile Include="besch\reader\sim_reader.cc" />
     <ClCompile Include="simcity.cc" />
-    <ClCompile Include="simconvoi.cc" />
+    <ClCompile Include="simconsist.cc" />
     <ClCompile Include="simdebug.cc" />
     <ClCompile Include="simdepot.cc" />
     <ClCompile Include="simobj.cc" />
@@ -446,7 +451,8 @@
     <ClInclude Include="gui\city_info.h" />
     <ClInclude Include="gui\components\action_listener.h" />
     <ClInclude Include="gui\components\gui_container.h" />
-    <ClInclude Include="gui\components\gui_convoiinfo.h" />
+    <ClInclude Include="gui\components\gui_consistinfo.h" />
+    <ClInclude Include="gui\consist_item.h" />
     <ClInclude Include="gui\gui_theme.h" />
     <ClInclude Include="gui\simwin.h" />
     <ClInclude Include="gui\themeselector.h" />
@@ -461,8 +467,17 @@
     <ClInclude Include="script\api\api_command.h" />
     <ClInclude Include="script\api\api_doc.h" />
     <ClInclude Include="script\api\api_obj_desc_base.h" />
+    <ClInclude Include="script\api_param.h" />
     <ClInclude Include="siminteraction.h" />
     <ClInclude Include="simloadingscreen.h" />
+    <ClInclude Include="squirrel\sqconfig.h" />
+    <ClInclude Include="squirrel\sqstdaux.h" />
+    <ClInclude Include="squirrel\sqstdblob.h" />
+    <ClInclude Include="squirrel\sqstdio.h" />
+    <ClInclude Include="squirrel\sqstdmath.h" />
+    <ClInclude Include="squirrel\sqstdstring.h" />
+    <ClInclude Include="squirrel\sqstdsystem.h" />
+    <ClInclude Include="squirrel\squirrel.h" />
     <ClInclude Include="tpl\array2d_tpl.h" />
     <ClInclude Include="tpl\array_tpl.h" />
     <ClInclude Include="gui\banner.h" />
@@ -488,11 +503,11 @@
     <ClInclude Include="gui\citylist_frame_t.h" />
     <ClInclude Include="gui\citylist_stats_t.h" />
     <ClInclude Include="gui\climates.h" />
-    <ClInclude Include="gui\convoi_detail_t.h" />
-    <ClInclude Include="gui\convoi_filter_frame.h" />
-    <ClInclude Include="gui\convoi_frame.h" />
-    <ClInclude Include="gui\convoi_info_t.h" />
-    <ClInclude Include="convoihandle_t.h" />
+    <ClInclude Include="gui\consist_detail_t.h" />
+    <ClInclude Include="gui\consist_filter_frame.h" />
+    <ClInclude Include="gui\consist_frame.h" />
+    <ClInclude Include="gui\consist_info_t.h" />
+    <ClInclude Include="consist_handle_t.h" />
     <ClInclude Include="obj\crossing.h" />
     <ClInclude Include="dataobj\crossing_logic.h" />
     <ClInclude Include="besch\reader\crossing_reader.h" />
@@ -668,7 +683,7 @@
     <ClInclude Include="simcity.h" />
     <ClInclude Include="simcolor.h" />
     <ClInclude Include="simconst.h" />
-    <ClInclude Include="simconvoi.h" />
+    <ClInclude Include="simconsist.h" />
     <ClInclude Include="simdebug.h" />
     <ClInclude Include="simdepot.h" />
     <ClInclude Include="simobj.h" />
Index: simversion.h
===================================================================
--- simversion.h	(revision 7957)
+++ simversion.h	(working copy)
@@ -6,6 +6,13 @@
 #include "revision.h"
 #endif
 
+#ifdef MAKEOBJ
+#ifdef _MSC_VER
+FILE _iob[] = { *stdin, *stdout, *stderr };
+extern "C" FILE * __cdecl __iob_func(void) { return _iob; }
+#endif
+#endif
+
 #define SIM_BUILD_NIGHTLY           0
 #define SIM_BUILD_RELEASE_CANDIDATE 1
 #define SIM_BUILD_RELEASE           2
Index: simware.h
===================================================================
--- simware.h	(revision 7957)
+++ simware.h	(working copy)
@@ -39,7 +39,7 @@
 	halthandle_t ziel;
 
 	/**
-	 * Handle of station, where the packet has to leave convoy.
+	 * Handle of station, where the packet has to leave consist.
 	 * @author Hj. Malthaner
 	 */
 	halthandle_t zwischenziel;
Index: simworld.cc
===================================================================
--- simworld.cc	(revision 7957)
+++ simworld.cc	(working copy)
@@ -21,7 +21,7 @@
 
 #include "simcity.h"
 #include "simcolor.h"
-#include "simconvoi.h"
+#include "simconsist.h"
 #include "simdebug.h"
 #include "simdepot.h"
 #include "simfab.h"
@@ -279,13 +279,13 @@
 	buffer->rdwr_long(random_seed);
 	buffer->rdwr_short(halt_entry);
 	buffer->rdwr_short(line_entry);
-	buffer->rdwr_short(convoy_entry);
+	buffer->rdwr_short(consist_entry);
 }
 
 
 int checklist_t::print(char *buffer, const char *entity) const
 {
-	return sprintf(buffer, "%s=[rand=%u halt=%u line=%u cnvy=%u] ", entity, random_seed, halt_entry, line_entry, convoy_entry);
+	return sprintf(buffer, "%s=[rand=%u halt=%u line=%u cnvy=%u] ", entity, random_seed, halt_entry, line_entry, consist_entry);
 }
 
 
@@ -296,7 +296,7 @@
 
 	// calculate snowline with day precision
 	// use linear interpolation
-	const sint32 ticks_this_month = get_zeit_ms() & (karte_t::ticks_per_world_month - 1);
+	const sint32 ticks_this_month = get_ticks() & (karte_t::ticks_per_world_month - 1);
 	const sint32 faktor = mfactor[last_month] + (  ( (mfactor[(last_month + 1) % 12] - mfactor[last_month]) * (ticks_this_month >> 12) ) >> (karte_t::ticks_per_world_month_shift - 12) );
 
 	// just remember them
@@ -441,7 +441,7 @@
 	destroying = true;
 DBG_MESSAGE("karte_t::destroy()", "destroying world");
 
-	uint32 max_display_progress = 256+stadt.get_count()*10 + haltestelle_t::get_alle_haltestellen().get_count() + convoi_array.get_count() + (cached_size.x*cached_size.y)*2;
+	uint32 max_display_progress = 256+stadt.get_count()*10 + haltestelle_t::get_alle_haltestellen().get_count() + consist_array.get_count() + (cached_size.x*cached_size.y)*2;
 	uint32 old_progress = 0;
 
 	loadingscreen_t ls( translator::translate("Destroying map ..."), max_display_progress, true );
@@ -484,17 +484,17 @@
 	ls.set_progress( old_progress );
 DBG_MESSAGE("karte_t::destroy()", "sync list cleared");
 
-	// alle convois aufraeumen
-	while (!convoi_array.empty()) {
-		convoihandle_t cnv = convoi_array.back();
-		cnv->destroy();
+	// alle consists aufraeumen
+	while (!consist_array.empty()) {
+		consist_handle_t cnst = consist_array.back();
+		cnst->destroy();
 		old_progress ++;
 		if(  (old_progress&0x00FF) == 0  ) {
 			ls.set_progress( old_progress );
 		}
 	}
-	convoi_array.clear();
-DBG_MESSAGE("karte_t::destroy()", "convois destroyed");
+	consist_array.clear();
+DBG_MESSAGE("karte_t::destroy()", "consists destroyed");
 
 	// alle haltestellen aufraeumen
 	old_progress += haltestelle_t::get_alle_haltestellen().get_count();
@@ -570,16 +570,16 @@
 }
 
 
-void karte_t::add_convoi(convoihandle_t const cnv)
+void karte_t::add_consist(consist_handle_t const cnst)
 {
-	assert(cnv.is_bound());
-	convoi_array.append_unique(cnv);
+	assert(cnst.is_bound());
+	consist_array.append_unique(cnst);
 }
 
 
-void karte_t::rem_convoi(convoihandle_t const cnv)
+void karte_t::rem_consist(consist_handle_t const cnst)
 {
-	convoi_array.remove(cnv);
+	consist_array.remove(cnst);
 }
 
 
@@ -688,7 +688,7 @@
 
 	tile_counter = 0;
 
-	convoihandle_t::init( 1024 );
+	consist_handle_t::init( 1024 );
 	linehandle_t::init( 1024 );
 
 	halthandle_t::init( 1024 );
@@ -1980,7 +1980,7 @@
 
 karte_t::karte_t() :
 	settings(env_t::default_settings),
-	convoi_array(0),
+	consist_array(0),
 	ausflugsziele(16),
 	stadt(0)
 {
@@ -3249,16 +3249,16 @@
 		i->rotate90(cached_size.x);
 	}
 
-	// fixed order fabrik, halts, convois
+	// fixed order fabrik, halts, consists
 	FOR(slist_tpl<fabrik_t*>, const f, fab_list) {
 		f->rotate90(cached_size.x);
 	}
-	// after rotation of factories, rotate everything that holds freight: stations and convoys
+	// after rotation of factories, rotate everything that holds freight: stations and consists
 	FOR(vector_tpl<halthandle_t>, const s, haltestelle_t::get_alle_haltestellen()) {
 		s->rotate90(cached_size.x);
 	}
 
-	FOR(vector_tpl<convoihandle_t>, const i, convoi_array) {
+	FOR(vector_tpl<consist_handle_t>, const i, consist_array) {
 		i->rotate90(cached_size.x);
 	}
 
@@ -3528,10 +3528,10 @@
 			}
 		}
 
-		// change view due to following a convoi?
-		convoihandle_t follow_convoi = viewport->get_follow_convoi();
-		if(follow_convoi.is_bound()  &&  follow_convoi->get_vehicle_count()>0) {
-			vehicle_t const& v       = *follow_convoi->front();
+		// change view due to following a consist?
+		consist_handle_t follow_consist = viewport->get_follow_consist();
+		if(follow_consist.is_bound()  &&  follow_consist->get_vehicle_count()>0) {
+			vehicle_t const& v       = *follow_consist->front();
 			koord3d   const  new_pos = v.get_pos();
 			if(new_pos!=koord3d::invalid) {
 				const sint16 rw = get_tile_raster_width();
@@ -3718,10 +3718,10 @@
 
 	INT_CHECK("simworld 1701");
 
-//	DBG_MESSAGE("karte_t::new_month()","convois");
-	// hsiegeln - call new month for convois
-	FOR(vector_tpl<convoihandle_t>, const cnv, convoi_array) {
-		cnv->new_month();
+//	DBG_MESSAGE("karte_t::new_month()","consists");
+	// hsiegeln - call new month for consists
+	FOR(vector_tpl<consist_handle_t>, const cnst, consist_array) {
+		cnst->new_month();
 	}
 
 	INT_CHECK("simworld 1701");
@@ -3819,8 +3819,8 @@
 	buf.printf( translator::translate("Year %i has started."), last_year );
 	msg->add_message(buf,koord::invalid,message_t::general,COL_BLACK,skinverwaltung_t::neujahrsymbol->get_bild_nr(0));
 
-	FOR(vector_tpl<convoihandle_t>, const cnv, convoi_array) {
-		cnv->new_year();
+	FOR(vector_tpl<consist_handle_t>, const cnst, consist_array) {
+		cnst->new_year();
 	}
 
 	for(int i=0; i<MAX_PLAYER_COUNT; i++) {
@@ -3925,9 +3925,9 @@
 
 
 // sets the new speed record
-void karte_t::notify_record( convoihandle_t cnv, sint32 max_speed, koord k )
+void karte_t::notify_record( consist_handle_t cnst, sint32 max_speed, koord k )
 {
-	records->notify_record(cnv, max_speed, k, current_month);
+	records->notify_record(cnst, max_speed, k, current_month);
 }
 
 
@@ -4047,11 +4047,11 @@
 	// to make sure the tick counter will be updated
 	INT_CHECK("karte_t::step");
 
-	DBG_DEBUG4("karte_t::step", "step convois");
-	// since convois will be deleted during stepping, we need to step backwards
-	for (size_t i = convoi_array.get_count(); i-- != 0;) {
-		convoihandle_t cnv = convoi_array[i];
-		cnv->step();
+	DBG_DEBUG4("karte_t::step", "step consists");
+	// since consists will be deleted during stepping, we need to step backwards
+	for (size_t i = consist_array.get_count(); i-- != 0;) {
+		consist_handle_t cnst = consist_array[i];
+		cnst->step();
 		if((i&7)==0) {
 			INT_CHECK("simworld 1947");
 		}
@@ -4231,7 +4231,7 @@
 
 void karte_t::update_history()
 {
-	finance_history_year[0][WORLD_CONVOIS] = finance_history_month[0][WORLD_CONVOIS] = convoi_array.get_count();
+	finance_history_year[0][WORLD_CONVOIS] = finance_history_month[0][WORLD_CONVOIS] = consist_array.get_count();
 	finance_history_year[0][WORLD_FACTORIES] = finance_history_month[0][WORLD_FACTORIES] = fab_list.get_count();
 
 	// now step all towns (to generate passengers)
@@ -4698,14 +4698,14 @@
 	}
 DBG_MESSAGE("karte_t::speichern(loadsave_t *file)", "saved stops");
 
-	// svae number of convois
+	// svae number of consists
 	if(  file->get_version()>=101000  ) {
-		uint16 i=convoi_array.get_count();
+		uint16 i=consist_array.get_count();
 		file->rdwr_short(i);
 	}
-	FOR(vector_tpl<convoihandle_t>, const cnv, convoi_array) {
-		// one MUST NOT call INT_CHECK here or else the convoi will be broken during reloading!
-		cnv->rdwr(file);
+	FOR(vector_tpl<consist_handle_t>, const cnst, consist_array) {
+		// one MUST NOT call INT_CHECK here or else the consist will be broken during reloading!
+		cnst->rdwr(file);
 	}
 	if(  file->get_version()<101000  ) {
 		file->wr_obj_id("Ende Convois");
@@ -4713,7 +4713,7 @@
 	if(silent) {
 		INT_CHECK("saving");
 	}
-DBG_MESSAGE("karte_t::speichern(loadsave_t *file)", "saved %i convois",convoi_array.get_count());
+DBG_MESSAGE("karte_t::speichern(loadsave_t *file)", "saved %i consists",consist_array.get_count());
 
 	for(int i=0; i<MAX_PLAYER_COUNT; i++) {
 // **** REMOVE IF SOON! *********
@@ -5363,14 +5363,14 @@
 		}
 	}
 
-	DBG_MESSAGE("karte_t::laden()", "load convois");
-	uint16 convoi_nr = 65535;
-	uint16 max_convoi = 65535;
+	DBG_MESSAGE("karte_t::laden()", "load consists");
+	uint16 consist_nr = 65535;
+	uint16 max_consist = 65535;
 	if(  file->get_version()>=101000  ) {
-		file->rdwr_short(convoi_nr);
-		max_convoi = convoi_nr;
+		file->rdwr_short(consist_nr);
+		max_consist = consist_nr;
 	}
-	while(  convoi_nr-->0  ) {
+	while(  consist_nr-->0  ) {
 
 		if(  file->get_version()<101000  ) {
 			file->rd_obj_id(buf, 79);
@@ -5378,28 +5378,28 @@
 				break;
 			}
 		}
-		convoi_t *cnv = new convoi_t(file);
-		convoi_array.append(cnv->self);
+		consist_t *cnst = new consist_t(file);
+		consist_array.append(cnst->self);
 
-		if(cnv->in_depot()) {
-			grund_t * gr = lookup(cnv->get_pos());
+		if(cnst->in_depot()) {
+			grund_t * gr = lookup(cnst->get_pos());
 			depot_t *dep = gr ? gr->get_depot() : 0;
 			if(dep) {
-				cnv->betrete_depot(dep);
+				cnst->betrete_depot(dep);
 			}
 			else {
-				dbg->error("karte_t::laden()", "no depot for convoi, blocks may now be wrongly reserved!");
-				cnv->destroy();
+				dbg->error("karte_t::laden()", "no depot for consist, blocks may now be wrongly reserved!");
+				cnst->destroy();
 			}
 		}
 		else {
-			sync.add( cnv );
+			sync.add( cnst );
 		}
-		if(  (convoi_array.get_count()&7) == 0  ) {
-			ls.set_progress( get_size().y+(get_size().y*convoi_array.get_count())/(2*max_convoi)+128 );
+		if(  (consist_array.get_count()&7) == 0  ) {
+			ls.set_progress( get_size().y+(get_size().y*consist_array.get_count())/(2*max_consist)+128 );
 		}
 	}
-DBG_MESSAGE("karte_t::laden()", "%d convois/trains loaded", convoi_array.get_count());
+DBG_MESSAGE("karte_t::laden()", "%d consists/trains loaded", consist_array.get_count());
 
 	// now the player can be loaded
 	for(int i=0; i<MAX_PLAYER_COUNT; i++) {
@@ -5506,12 +5506,12 @@
 
 	ls.set_progress( (get_size().y*3)/2+256+(get_size().y*3)/8 );
 
-	// adding lines and other stuff for convois
-	for(unsigned i=0;  i<convoi_array.get_count();  i++ ) {
-		convoihandle_t cnv = convoi_array[i];
-		cnv->finish_rd();
+	// adding lines and other stuff for consists
+	for(unsigned i=0;  i<consist_array.get_count();  i++ ) {
+		consist_handle_t cnst = consist_array[i];
+		cnst->finish_rd();
 		// was deleted during loading => use same position again
-		if(!cnv.is_bound()) {
+		if(!cnst.is_bound()) {
 			i--;
 		}
 	}
@@ -6618,7 +6618,7 @@
 						network_frame_count = 0;
 					}
 					sync_steps = steps * settings.get_frames_per_step() + network_frame_count;
-					LCHKLST(sync_steps) = checklist_t(get_random_seed(), halthandle_t::get_next_check(), linehandle_t::get_next_check(), convoihandle_t::get_next_check());
+					LCHKLST(sync_steps) = checklist_t(get_random_seed(), halthandle_t::get_next_check(), linehandle_t::get_next_check(), consist_handle_t::get_next_check());
 					// some serverside tasks
 					if(  env_t::networkmode  &&  env_t::server  ) {
 						// broadcast sync info regularly and when lagged
@@ -6689,7 +6689,7 @@
 {
 	DBG_DEBUG( "announce_server()", "status: %i",  status );
 	// Announce game info to server, format is:
-	// st=on&dns=server.com&port=13353&rev=1234&pak=pak128&name=some+name&time=3,1923&size=256,256&active=[0-16]&locked=[0-16]&clients=[0-16]&towns=15&citizens=3245&factories=33&convoys=56&stops=17
+	// st=on&dns=server.com&port=13353&rev=1234&pak=pak128&name=some+name&time=3,1923&size=256,256&active=[0-16]&locked=[0-16]&clients=[0-16]&towns=15&citizens=3245&factories=33&consists=56&stops=17
 	// (This is the data part of an HTTP POST)
 	if(  env_t::server_announce  ) {
 		cbuffer_t buf;
@@ -6759,7 +6759,7 @@
 			buf.printf( "&towns=%u",     stadt.get_count() );
 			buf.printf( "&citizens=%u",  stadt.get_sum_weight() );
 			buf.printf( "&factories=%u", fab_list.get_count() );
-			buf.printf( "&convoys=%u",   convoys().get_count());
+			buf.printf( "&consists=%u",   consists().get_count());
 			buf.printf( "&stops=%u",     haltestelle_t::get_alle_haltestellen().get_count() );
 		}
 		else {
Index: simworld.h
===================================================================
--- simworld.h	(revision 7957)
+++ simworld.h	(working copy)
@@ -17,7 +17,7 @@
 #include "simtypes.h"
 #include "simunits.h"
 
-#include "convoihandle_t.h"
+#include "consist_handle_t.h"
 #include "halthandle_t.h"
 
 #include "tpl/weighted_vector_tpl.h"
@@ -57,15 +57,15 @@
 	uint32 random_seed;
 	uint16 halt_entry;
 	uint16 line_entry;
-	uint16 convoy_entry;
+	uint16 consist_entry;
 
-	checklist_t() : random_seed(0), halt_entry(0), line_entry(0), convoy_entry(0) { }
-	checklist_t(uint32 _random_seed, uint16 _halt_entry, uint16 _line_entry, uint16 _convoy_entry)
-		: random_seed(_random_seed), halt_entry(_halt_entry), line_entry(_line_entry), convoy_entry(_convoy_entry) { }
+	checklist_t() : random_seed(0), halt_entry(0), line_entry(0), consist_entry(0) { }
+	checklist_t(uint32 _random_seed, uint16 _halt_entry, uint16 _line_entry, uint16 _consist_entry)
+		: random_seed(_random_seed), halt_entry(_halt_entry), line_entry(_line_entry), consist_entry(_consist_entry) { }
 
 	bool operator == (const checklist_t &other) const
 	{
-		return ( random_seed==other.random_seed && halt_entry==other.halt_entry && line_entry==other.line_entry && convoy_entry==other.convoy_entry );
+		return ( random_seed==other.random_seed && halt_entry==other.halt_entry && line_entry==other.line_entry && consist_entry==other.consist_entry );
 	}
 	bool operator != (const checklist_t &other) const { return !( (*this)==other ); }
 
@@ -112,7 +112,7 @@
 		WORLD_GROWTH,			//!< growth (just for convenience)
 		WORLD_TOWNS,			//!< number of all cities
 		WORLD_FACTORIES,		//!< number of all consuming only factories
-		WORLD_CONVOIS,			//!< total number of convois
+		WORLD_CONVOIS,			//!< total number of consists
 		WORLD_CITYCARS,			//!< number of citycars generated
 		WORLD_PAS_RATIO,		//!< percentage of passengers that started successful
 		WORLD_PAS_GENERATED,	//!< total number generated
@@ -270,9 +270,9 @@
 	uint8 height_to_climate[32];
 
 	/**
-	 * Array containing the convois.
+	 * Array containing the consists.
 	 */
-	vector_tpl<convoihandle_t> convoi_array;
+	vector_tpl<consist_handle_t> consist_array;
 
 	/**
 	 * Array containing the factories.
@@ -845,7 +845,7 @@
 
 	/// speed record management
 	sint32 get_record_speed( waytype_t w ) const;
-	void notify_record( convoihandle_t cnv, sint32 max_speed, koord k );
+	void notify_record( consist_handle_t cnst, sint32 max_speed, koord k );
 
 	/// time lapse mode ...
 	bool is_paused() const { return step_mode&PAUSE_FLAG; }
@@ -1021,7 +1021,7 @@
 	 * Time since map creation or the last load in ms.
 	 * @author Hj. Malthaner
 	 */
-	uint32 get_zeit_ms() const { return ticks; }
+	uint32 get_ticks() const { return ticks; }
 
 
 	uint32 get_next_month_ticks() const { return next_month_ticks; }
@@ -1048,7 +1048,7 @@
 	 * Idle time. Nur zur Anzeige verwenden!
 	 * @author Hj. Malthaner
 	 */
-	uint32 get_schlaf_zeit() const { return idle_time; }
+	uint32 get_idle_time() const { return idle_time; }
 
 	/**
 	 * Number of frames displayed in the last real time second.
@@ -1489,10 +1489,10 @@
 
 public:
 
-	// the convois are also handled each step => thus we keep track of them too
-	void add_convoi(convoihandle_t);
-	void rem_convoi(convoihandle_t);
-	vector_tpl<convoihandle_t> const& convoys() const { return convoi_array; }
+	// the consists are also handled each step => thus we keep track of them too
+	void add_consist(consist_handle_t);
+	void rem_consist(consist_handle_t);
+	vector_tpl<consist_handle_t> const& consists() const { return consist_array; }
 
 	/**
 	 * To access the cities array.
Index: vehicle/movingobj.cc
===================================================================
--- vehicle/movingobj.cc	(revision 7957)
+++ vehicle/movingobj.cc	(working copy)
@@ -140,7 +140,7 @@
 			}
 			else {
 				// resolution 1/8th month (0..95)
-				const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_zeit_ms()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
+				const uint32 yearsteps = (welt->get_current_month()%12)*8 + ((welt->get_ticks()>>(welt->ticks_per_world_month_shift-3))&7) + 1;
 				season = (seasons * yearsteps - 1) / 96;
 			}
 			break;
Index: vehicle/overtaker.h
===================================================================
--- vehicle/overtaker.h	(revision 7957)
+++ vehicle/overtaker.h	(working copy)
@@ -3,7 +3,7 @@
 
 /**
  * All vehicles that can overtake must include this class
- * These are convois and city cars
+ * These are consists and city cars
  *
  * Oct 2008
  */
@@ -12,7 +12,7 @@
 
 /**
  * Class dealing with overtaking
- * It is the superclass of convois and city cars (private_car_t)
+ * It is the superclass of consists and city cars (private_car_t)
  *
  * @author isidoro
  */
@@ -56,7 +56,7 @@
 		}
 	}
 
-	// since citycars and convois can react quite different
+	// since citycars and consists can react quite different
 	virtual bool can_overtake(overtaker_t *other_overtaker, sint32 other_speed, sint16 steps_other) = 0;
 
 	sint32 get_max_power_speed() const { return max_power_speed; }
Index: vehicle/simroadtraffic.cc
===================================================================
--- vehicle/simroadtraffic.cc	(revision 7957)
+++ vehicle/simroadtraffic.cc	(working copy)
@@ -17,7 +17,7 @@
 #include "../display/simimg.h"
 #include "../simunits.h"
 #include "../simtypes.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 
 #include "simroadtraffic.h"
 #ifdef DESTINATION_CITYCARS
@@ -532,8 +532,8 @@
 							if(!over->is_overtaking()) {
 								// otherwise the overtaken car would stop for us ...
 								if(  road_vehicle_t const* const car = obj_cast<road_vehicle_t>(dt)  ) {
-									convoi_t* const ocnv = car->get_convoi();
-									if(  ocnv==NULL  ||  !can_overtake( ocnv, (ocnv->get_state()==convoi_t::LOADING ? 0 : over->get_max_power_speed()), ocnv->get_length_in_steps()+ocnv->get_vehikel(0)->get_steps())  ) {
+									consist_t* const ocnv = car->get_consist();
+									if(  ocnv==NULL  ||  !can_overtake( ocnv, (ocnv->get_state()==consist_t::LOADING ? 0 : over->get_max_power_speed()), ocnv->get_length_in_steps()+ocnv->get_vehikel(0)->get_steps())  ) {
 										frei = false;
 									}
 								} else if(  private_car_t* const caut = obj_cast<private_car_t>(dt)  ) {
@@ -867,7 +867,7 @@
 	}
 
 	if(  other_speed == 0  ) {
-		/* overtaking a loading convoi
+		/* overtaking a loading consist
 		 * => we can do a lazy check, since halts are always straight
 		 */
 		grund_t *gr = welt->lookup(get_pos());
@@ -932,8 +932,8 @@
 
 	/* Distance it takes overtaking (unit: vehicle steps) = my_speed * time_overtaking
 	 * time_overtaking = tiles_to_overtake/diff_speed
-	 * tiles_to_overtake = convoi_length + pos_other_convoi
-	 * convoi_length for city cars? ==> a bit over half a tile (10)
+	 * tiles_to_overtake = consist_length + pos_other_consist
+	 * consist_length for city cars? ==> a bit over half a tile (10)
 	 */
 	sint32 time_overtaking = 0;
 	sint32 distance = current_speed*((10<<4)+steps_other)/max(besch->get_geschw()-other_speed,diff_speed);
Index: vehicle/simvehicle.cc
===================================================================
--- vehicle/simvehicle.cc	(revision 7957)
+++ vehicle/simvehicle.cc	(working copy)
@@ -28,7 +28,7 @@
 #include "../simworld.h"
 #include "../simdebug.h"
 #include "../simdepot.h"
-#include "../simconvoi.h"
+#include "../simconsist.h"
 #include "../simunits.h"
 
 #include "../player/simplay.h"
@@ -107,7 +107,7 @@
 }
 
 
-// if true, convoi, must restart!
+// if true, consist, must restart!
 bool vehicle_base_t::need_realignment() const
 {
 	return old_diagonal_vehicle_steps_per_tile!=diagonal_vehicle_steps_per_tile  &&  ribi_t::is_bend(direction);
@@ -524,7 +524,7 @@
 /* true, if one could pass through this field
  * also used for citycars, thus defined here
  */
-vehicle_base_t *vehicle_base_t::no_cars_blocking( const grund_t *gr, const convoi_t *cnv, const uint8 current_direction, const uint8 next_direction, const uint8 next_90direction )
+vehicle_base_t *vehicle_base_t::no_cars_blocking( const grund_t *gr, const consist_t *cnst, const uint8 current_direction, const uint8 next_direction, const uint8 next_90direction )
 {
 	// Search vehicle
 	for(  uint8 pos=1;  pos<(volatile uint8)gr->get_top();  pos++  ) {
@@ -538,11 +538,11 @@
 			bool other_moving = false;
 			if(  road_vehicle_t const* const at = obj_cast<road_vehicle_t>(v)  ) {
 				// ignore ourself
-				if(  cnv == at->get_convoi()  ) {
+				if(  cnst == at->get_consist()  ) {
 					continue;
 				}
 				other_direction = at->get_direction();
-				other_moving = at->get_convoi()->get_akt_speed() > kmh_to_speed(1);
+				other_moving = at->get_consist()->get_akt_speed() > kmh_to_speed(1);
 			}
 			// check for city car
 			else if(  v->get_waytype() == road_wt  ) {
@@ -621,27 +621,27 @@
 }
 
 
-void vehicle_t::set_convoi(convoi_t *c)
+void vehicle_t::set_consist(consist_t *c)
 {
-	/* cnv can have three values:
+	/* cnst can have three values:
 	 * NULL: not previously assigned
-	 * 1 (only during loading): convoi wants to reserve the whole route
-	 * other: previous convoi (in this case, currently always c==cnv)
+	 * 1 (only during loading): consist wants to reserve the whole route
+	 * other: previous consist (in this case, currently always c==cnst)
 	 *
-	 * if c is NULL, then the vehicle is removed from the convoi
-	 * (the rail_vehicle_t::set_convoi etc. routines must then remove a
+	 * if c is NULL, then the vehicle is removed from the consist
+	 * (the rail_vehicle_t::set_consist etc. routines must then remove a
 	 *  possibly pending reservation of stops/tracks)
 	 */
-	assert(  c==NULL  ||  cnv==NULL  ||  cnv==(convoi_t *)1  ||  c==cnv);
-	cnv = c;
-	if(cnv) {
+	assert(  c==NULL  ||  cnst==NULL  ||  cnst==(consist_t *)1  ||  c==cnst);
+	cnst = c;
+	if(cnst) {
 		// we need to re-establish the finish flag after loading
 		if(leading) {
-			route_t const& r = *cnv->get_route();
+			route_t const& r = *cnst->get_route();
 			check_for_finish = r.empty() || route_index >= r.get_count() || get_pos() == r.position_bei(route_index);
 		}
 		if(  pos_next != koord3d::invalid  ) {
-			route_t const& r = *cnv->get_route();
+			route_t const& r = *cnst->get_route();
 			if (!r.empty() && route_index < r.get_count() - 1) {
 				grund_t const* const gr = welt->lookup(pos_next);
 				if (!gr || !gr->get_weg(get_waytype())) {
@@ -727,7 +727,7 @@
 		}
 
 		// add delivered goods to statistics
-		cnv->book( sum_menge, convoi_t::CONVOI_TRANSPORTED_GOODS );
+		cnst->book( sum_menge, consist_t::CONVOI_TRANSPORTED_GOODS );
 
 		// add delivered goods to halt's statistics
 		halt->book( sum_menge, HALT_ARRIVED );
@@ -752,7 +752,7 @@
 		const uint16 hinein = besch->get_zuladung() - total_freight;
 
 		slist_tpl<ware_t> zuladung;
-		halt->fetch_goods( zuladung, besch->get_ware(), hinein, cnv->get_schedule(), cnv->get_owner() );
+		halt->fetch_goods( zuladung, besch->get_ware(), hinein, cnst->get_schedule(), cnst->get_owner() );
 
 		if(  zuladung.empty()  ) {
 			// now empty, but usually, we can get it here ...
@@ -815,8 +815,8 @@
 
 			if(  tmp.get_zwischenziel().is_bound()  ) {
 				// the original halt exists, but does we still go there?
-				FOR(minivec_tpl<linieneintrag_t>, const& i, cnv->get_schedule()->eintrag) {
-					if(  haltestelle_t::get_halt( i.pos, cnv->get_owner()) == tmp.get_zwischenziel()  ) {
+				FOR(minivec_tpl<linieneintrag_t>, const& i, cnst->get_schedule()->eintrag) {
+					if(  haltestelle_t::get_halt( i.pos, cnst->get_owner()) == tmp.get_zwischenziel()  ) {
 						found = true;
 						break;
 					}
@@ -824,11 +824,11 @@
 			}
 			if(  !found  ) {
 				// the target halt may have been joined or there is a closer one now, thus our original target is no longer valid
-				const int offset = cnv->get_schedule()->get_aktuell();
-				const int max_count = cnv->get_schedule()->eintrag.get_count();
+				const int offset = cnst->get_schedule()->get_aktuell();
+				const int max_count = cnst->get_schedule()->eintrag.get_count();
 				for(  int i=0;  i<max_count;  i++  ) {
 					// try to unload on next stop
-					halthandle_t halt = haltestelle_t::get_halt( cnv->get_schedule()->eintrag[ (i+offset)%max_count ].pos, cnv->get_owner() );
+					halthandle_t halt = haltestelle_t::get_halt( cnst->get_schedule()->eintrag[ (i+offset)%max_count ].pos, cnst->get_owner() );
 					if(  halt.is_bound()  ) {
 						if(  halt->is_enabled(tmp.get_index())  ) {
 							// ok, lets change here, since goods are accepted here
@@ -890,7 +890,7 @@
 		mark_image_dirty( get_image(), 0 );
 	}
 
-	route_t const& r = *cnv->get_route();
+	route_t const& r = *cnst->get_route();
 	if(!recalc) {
 		// always set pos_next
 		pos_next = r.position_bei(route_index);
@@ -935,7 +935,7 @@
 
 	set_owner( player_ );
 	purchase_time = welt->get_current_month();
-	cnv = NULL;
+	cnst = NULL;
 	speed_limit = SPEED_UNLIMITED;
 
 	route_index = 1;
@@ -963,7 +963,7 @@
 	smoke = true;
 
 	besch = NULL;
-	cnv = NULL;
+	cnst = NULL;
 
 	route_index = 1;
 	current_friction = 4;
@@ -990,8 +990,8 @@
 	if(leading) {
 		if(check_for_finish) {
 			// so we are there yet?
-			cnv->ziel_erreicht();
-			if(cnv->get_state()==convoi_t::INITIAL) {
+			cnst->ziel_erreicht();
+			if(cnst->get_state()==consist_t::INITIAL) {
 				// to avoid crashes with airplanes
 				use_calc_height = false;
 			}
@@ -1000,24 +1000,24 @@
 
 		// now check, if we can go here
 		grund_t *bd = welt->lookup(pos_next);
-		if(bd==NULL  ||  !check_next_tile(bd)  ||  cnv->get_route()->empty()) {
+		if(bd==NULL  ||  !check_next_tile(bd)  ||  cnst->get_route()->empty()) {
 			// way (weg) not existent (likely destroyed) or no route ...
-			cnv->suche_neue_route();
+			cnst->suche_neue_route();
 			return NULL;
 		}
 
 		// check for one-way sign etc.
 		const waytype_t wt = get_waytype();
-		if(  air_wt != wt  &&  route_index < cnv->get_route()->get_count()-1  ) {
+		if(  air_wt != wt  &&  route_index < cnst->get_route()->get_count()-1  ) {
 			uint8 dir = get_ribi(bd);
-			koord3d nextnext_pos = cnv->get_route()->position_bei(route_index+1);
+			koord3d nextnext_pos = cnst->get_route()->position_bei(route_index+1);
 			if ( nextnext_pos == get_pos() ) {
-				dbg->error("vehicle_t::hop_check", "route contains point (%s) twice for %s", nextnext_pos.get_str(), cnv->get_name());
+				dbg->error("vehicle_t::hop_check", "route contains point (%s) twice for %s", nextnext_pos.get_str(), cnst->get_name());
 			}
 			uint8 new_dir = ribi_type(nextnext_pos - pos_next);
 			if((dir&new_dir)==0) {
 				// new one way sign here?
-				cnv->suche_neue_route();
+				cnst->suche_neue_route();
 				return NULL;
 			}
 			// check for recently built bridges/tunnels or reverse branches (really slows down the game, so we do this only on slopes)
@@ -1025,7 +1025,7 @@
 				grund_t *from;
 				if(  !bd->get_neighbour( from, get_waytype(), ribi_type( get_pos(), pos_next ) )  ) {
 					// way likely destroyed or altered => reroute
-					cnv->suche_neue_route();
+					cnst->suche_neue_route();
 					return NULL;
 				}
 			}
@@ -1035,8 +1035,8 @@
 		// ist_weg_frei() berechnet auch die Geschwindigkeit
 		// mit der spaeter weitergefahren wird
 		if(  !can_enter_tile( bd, restart_speed, 0 )  ) {
-			// stop convoi, when the way is not free
-			cnv->warten_bis_weg_frei(restart_speed);
+			// stop consist, when the way is not free
+			cnst->warten_bis_weg_frei(restart_speed);
 
 			// don't continue
 			return NULL;
@@ -1045,7 +1045,7 @@
 		return bd;
 	}
 	else {
-		// this is needed since in convoi_t::vorfahren the flag ist_erstes is set to null
+		// this is needed since in consist_t::vorfahren the flag ist_erstes is set to null
 		if(check_for_finish) {
 			return NULL;
 		}
@@ -1062,7 +1062,7 @@
 	}
 	else {
 		if(  !second_check_count  ) {
-			cnv->suche_neue_route();
+			cnst->suche_neue_route();
 		}
 		return false;
 	}
@@ -1099,9 +1099,9 @@
 
 	koord3d pos_prev = get_pos();
 	set_pos( pos_next );  // next field
-	if(route_index<cnv->get_route()->get_count()-1) {
+	if(route_index<cnst->get_route()->get_count()-1) {
 		route_index ++;
-		pos_next = cnv->get_route()->position_bei(route_index);
+		pos_next = cnst->get_route()->position_bei(route_index);
 	}
 	else {
 		route_index ++;
@@ -1111,16 +1111,16 @@
 
 	// check if arrived at waypoint, and update schedule to next destination
 	// route search through the waypoint is already complete
-//	if(  ist_erstes  &&  get_pos()==cnv->get_fpl_target()  ) { // ist_erstes turned off in vorfahren when reversing
-	if(  get_pos()==cnv->get_fpl_target()  ) {
-		if(  route_index >= cnv->get_route()->get_count()  ) {
+//	if(  ist_erstes  &&  get_pos()==cnst->get_fpl_target()  ) { // ist_erstes turned off in vorfahren when reversing
+	if(  get_pos()==cnst->get_fpl_target()  ) {
+		if(  route_index >= cnst->get_route()->get_count()  ) {
 			// we end up here after loading a game or when a waypoint is reached which crosses next itself
-			cnv->set_fpl_target( koord3d::invalid );
+			cnst->set_fpl_target( koord3d::invalid );
 		}
 		else {
-			cnv->get_schedule()->advance();
-			const koord3d ziel = cnv->get_schedule()->get_current_eintrag().pos;
-			cnv->set_fpl_target( cnv->is_waypoint(ziel) ? ziel : koord3d::invalid );
+			cnst->get_schedule()->advance();
+			const koord3d ziel = cnst->get_schedule()->get_current_eintrag().pos;
+			cnst->set_fpl_target( cnst->is_waypoint(ziel) ? ziel : koord3d::invalid );
 		}
 	}
 
@@ -1162,30 +1162,30 @@
 		if(  check_for_finish  &&  (direction==ribi_t::north  ||  direction==ribi_t::west)  ) {
 			steps_next = (steps_next/2)+1;
 		}
-		cnv->add_running_cost( weg );
-		cnv->must_recalc_data_front();
+		cnst->add_running_cost( weg );
+		cnst->must_recalc_data_front();
 	}
 
-	// update friction and friction weight of convoy
+	// update friction and friction weight of consist
 	sint16 old_friction = current_friction;
 	calc_friction(gr);
 
 	if (old_friction != current_friction) {
-		cnv->update_friction_weight( (current_friction-old_friction) * (sint64)sum_weight);
+		cnst->update_friction_weight( (current_friction-old_friction) * (sint64)sum_weight);
 	}
 
-	// if speed limit changed, then cnv must recalc
+	// if speed limit changed, then cnst must recalc
 	if (speed_limit != old_speed_limit) {
 		if (speed_limit < old_speed_limit) {
-			if (speed_limit < cnv->get_speed_limit()) {
+			if (speed_limit < cnst->get_speed_limit()) {
 				// update
-				cnv->set_speed_limit(speed_limit);
+				cnst->set_speed_limit(speed_limit);
 			}
 		}
 		else {
-			if (old_speed_limit == cnv->get_speed_limit()) {
-				// convoy's speed limit may be larger now
-				cnv->must_recalc_speed_limit();
+			if (old_speed_limit == cnst->get_speed_limit()) {
+				// consist's speed limit may be larger now
+				cnst->must_recalc_speed_limit();
 			}
 		}
 	}
@@ -1228,7 +1228,7 @@
 	// does it smoke at all?
 	if(  smoke  &&  besch->get_rauch()  ) {
 		// Hajo: only produce smoke when heavily accelerating or steam engine
-		if(  cnv->get_akt_speed() < (sint32)((cnv->get_speed_limit() * 7u) >> 3)  ||  besch->get_engine_type() == vehikel_besch_t::steam  ) {
+		if(  cnst->get_akt_speed() < (sint32)((cnst->get_speed_limit() * 7u) >> 3)  ||  besch->get_engine_type() == vehikel_besch_t::steam  ) {
 			grund_t* const gr = welt->lookup( get_pos() );
 			if(  gr  ) {
 				wolke_t* const abgas =  new wolke_t( get_pos(), get_xoff() + ((dx * (sint16)((uint16)steps * OBJECT_OFFSET_STEPS)) >> 8), get_yoff() + ((dy * (sint16)((uint16)steps * OBJECT_OFFSET_STEPS)) >> 8) + get_hoff(), besch->get_rauch() );
@@ -1260,7 +1260,7 @@
 	}
 
 	// cnv_kmh = lesser of min_top_speed, power limited top speed, and average way speed limits on trip, except aircraft which are not power limited and don't have speed limits
-	sint32 cnv_kmh = cnv->get_speedbonus_kmh();
+	sint32 cnv_kmh = cnst->get_speedbonus_kmh();
 
 	sint64 value = 0;
 
@@ -1403,7 +1403,7 @@
 // true, if this vehicle did not moved for some time
 bool vehicle_t::is_stuck()
 {
-	return cnv==NULL  ||  cnv->is_waiting();
+	return cnst==NULL  ||  cnst->is_waiting();
 }
 
 
@@ -1414,7 +1414,7 @@
 }
 
 
-void vehicle_t::rdwr_from_convoi(loadsave_t *file)
+void vehicle_t::rdwr_from_consist(loadsave_t *file)
 {
 	xml_tag_t r( file, "vehikel_t" );
 
@@ -1457,7 +1457,7 @@
 		file->rdwr_long(l);
 		route_index = (uint16)l;
 		purchase_time = (purchase_time >> welt->ticks_per_world_month_shift) + welt->get_settings().get_starting_year();
-DBG_MESSAGE("vehicle_t::rdwr_from_convoi()","bought at %i/%i.",(purchase_time%12)+1,purchase_time/12);
+DBG_MESSAGE("vehicle_t::rdwr_from_consist()","bought at %i/%i.",(purchase_time%12)+1,purchase_time/12);
 	}
 	else {
 		// prissi: changed several data types to save runtime memory
@@ -1470,7 +1470,7 @@
 			file->rdwr_byte(steps);
 			file->rdwr_byte(steps_next);
 			if(steps_next==old_diagonal_vehicle_steps_per_tile - 1  &&  file->is_loading()) {
-				// reset diagonal length (convoi will be reset anyway, if game diagonal is different)
+				// reset diagonal length (consist will be reset anyway, if game diagonal is different)
 				steps_next = diagonal_vehicle_steps_per_tile - 1;
 			}
 		}
@@ -1506,7 +1506,7 @@
 				steps_next = VEHICLE_STEPS_PER_TILE - 1;
 			}
 			else {
-				// will be corrected anyway, if in a convoi
+				// will be corrected anyway, if in a consist
 				steps = min( diagonal_vehicle_steps_per_tile - 1, diagonal_vehicle_steps_per_tile - 1-(uint8)(((uint16)i*(uint16)(diagonal_vehicle_steps_per_tile - 1))/8) );
 				steps_next = diagonal_vehicle_steps_per_tile - 1;
 			}
@@ -1518,7 +1518,7 @@
 		bool target_info;
 		if(file->is_loading()) {
 			file->rdwr_bool(target_info);
-			cnv = (convoi_t *)target_info;	// will be checked during convoi reassignment
+			cnst = (consist_t *)target_info;	// will be checked during consist reassignment
 		}
 		else {
 			target_info = target_halt.is_bound();
@@ -1527,7 +1527,7 @@
 	}
 	else {
 		if(file->is_loading()) {
-			cnv = NULL;	// no reservation too
+			cnst = NULL;	// no reservation too
 		}
 	}
 	if(file->get_version()<=112008) {
@@ -1554,7 +1554,7 @@
 		}
 		if(besch==NULL) {
 			welt->add_missing_paks( s, karte_t::MISSING_VEHICLE );
-			dbg->warning("vehicle_t::rdwr_from_convoi()","no vehicle pak for '%s' search for something similar", s);
+			dbg->warning("vehicle_t::rdwr_from_consist()","no vehicle pak for '%s' search for something similar", s);
 		}
 	}
 
@@ -1588,16 +1588,16 @@
 			}
 			else if(  ware.menge>0  ) {
 				if(  ware.get_besch()  ) {
-					dbg->error( "vehicle_t::rdwr_from_convoi()", "%i of %s to %s ignored!", ware.menge, ware.get_name(), ware.get_zielpos().get_str() );
+					dbg->error( "vehicle_t::rdwr_from_consist()", "%i of %s to %s ignored!", ware.menge, ware.get_name(), ware.get_zielpos().get_str() );
 				}
 				else {
-					dbg->error( "vehicle_t::rdwr_from_convoi()", "%i of unknown to %s ignored!", ware.menge, ware.get_zielpos().get_str() );
+					dbg->error( "vehicle_t::rdwr_from_consist()", "%i of unknown to %s ignored!", ware.menge, ware.get_zielpos().get_str() );
 				}
 			}
 		}
 	}
 
-	// skip first last info (the convoi will know this better than we!)
+	// skip first last info (the consist will know this better than we!)
 	if(file->get_version()<88007) {
 		bool dummy = 0;
 		file->rdwr_bool(dummy);
@@ -1633,7 +1633,7 @@
 	}
 
 	if(file->is_loading()) {
-		leading = last = false;	// dummy, will be set by convoi afterwards
+		leading = last = false;	// dummy, will be set by consist afterwards
 		if(besch) {
 			calc_image();
 
@@ -1674,10 +1674,10 @@
 
 void vehicle_t::show_info()
 {
-	if(  cnv != NULL  ) {
-		cnv->open_info_window();
+	if(  cnst != NULL  ) {
+		cnst->open_info_window();
 	} else {
-		dbg->warning("vehicle_t::show_info()","cnv is null, can't open convoi window!");
+		dbg->warning("vehicle_t::show_info()","cnst is null, can't open consist window!");
 	}
 }
 
@@ -1684,8 +1684,8 @@
 
 void vehicle_t::info(cbuffer_t & buf) const
 {
-	if(cnv) {
-		cnv->info(buf);
+	if(cnst) {
+		cnst->info(buf);
 	}
 }
 
@@ -1706,11 +1706,11 @@
 #ifdef MULTI_THREAD
 void vehicle_t::display_overlay(int xpos, int ypos) const
 {
-	if(  cnv  &&  leading  ) {
+	if(  cnst  &&  leading  ) {
 #else
 void vehicle_t::display_after(int xpos, int ypos, bool is_gobal) const
 {
-	if(  is_gobal  &&  cnv  &&  leading  ) {
+	if(  is_gobal  &&  cnst  &&  leading  ) {
 #endif
 		COLOR_VAL color = COL_GREEN; // not used, but stop compiler warning about uninitialized
 		char tooltip_text[1024];
@@ -1727,11 +1727,11 @@
 		}
 
 		// now find out what has happened
-		switch(cnv->get_state()) {
-			case convoi_t::WAITING_FOR_CLEARANCE_ONE_MONTH:
-			case convoi_t::WAITING_FOR_CLEARANCE:
-			case convoi_t::CAN_START:
-			case convoi_t::CAN_START_ONE_MONTH:
+		switch(cnst->get_state()) {
+			case consist_t::WAITING_FOR_CLEARANCE_ONE_MONTH:
+			case consist_t::WAITING_FOR_CLEARANCE:
+			case consist_t::CAN_START:
+			case consist_t::CAN_START_ONE_MONTH:
 				if(  state>=2  ) {
 					tstrncpy( tooltip_text, translator::translate("Waiting for clearance!"), lengthof(tooltip_text) );
 					color = COL_YELLOW;
@@ -1738,15 +1738,15 @@
 				}
 				break;
 
-			case convoi_t::LOADING:
+			case consist_t::LOADING:
 				if(  state>=1  ) {
-					sprintf( tooltip_text, translator::translate("Loading (%i->%i%%)!"), cnv->get_loading_level(), cnv->get_loading_limit() );
+					sprintf( tooltip_text, translator::translate("Loading (%i->%i%%)!"), cnst->get_loading_level(), cnst->get_loading_limit() );
 					color = COL_YELLOW;
 				}
 				break;
 
-			case convoi_t::FAHRPLANEINGABE:
-//			case convoi_t::ROUTING_1:
+			case consist_t::FAHRPLANEINGABE:
+//			case consist_t::ROUTING_1:
 				if(  state>=2  ) {
 					tstrncpy( tooltip_text, translator::translate("Schedule changing!"), lengthof(tooltip_text) );
 					color = COL_YELLOW;
@@ -1753,14 +1753,14 @@
 				}
 				break;
 
-			case convoi_t::DRIVING:
+			case consist_t::DRIVING:
 				if(  state>=1  ) {
-					grund_t const* const gr = welt->lookup(cnv->get_route()->back());
+					grund_t const* const gr = welt->lookup(cnst->get_route()->back());
 					if(  gr  &&  gr->get_depot()  ) {
 						tstrncpy( tooltip_text, translator::translate("go home"), lengthof(tooltip_text) );
 						color = COL_GREEN;
 					}
-					else if(  cnv->get_no_load()  ) {
+					else if(  cnst->get_no_load()  ) {
 						tstrncpy( tooltip_text, translator::translate("no load"), lengthof(tooltip_text) );
 						color = COL_GREEN;
 					}
@@ -1767,7 +1767,7 @@
 				}
 				break;
 
-			case convoi_t::LEAVING_DEPOT:
+			case consist_t::LEAVING_DEPOT:
 				if(  state>=2  ) {
 					tstrncpy( tooltip_text, translator::translate("Leaving depot!"), lengthof(tooltip_text) );
 					color = COL_GREEN;
@@ -1774,13 +1774,13 @@
 				}
 				break;
 
-			case convoi_t::WAITING_FOR_CLEARANCE_TWO_MONTHS:
-			case convoi_t::CAN_START_TWO_MONTHS:
+			case consist_t::WAITING_FOR_CLEARANCE_TWO_MONTHS:
+			case consist_t::CAN_START_TWO_MONTHS:
 				tstrncpy( tooltip_text, translator::translate("clf_chk_stucked"), lengthof(tooltip_text) );
 				color = COL_ORANGE;
 				break;
 
-			case convoi_t::NO_ROUTE:
+			case consist_t::NO_ROUTE:
 				tstrncpy( tooltip_text, translator::translate("clf_chk_noroute"), lengthof(tooltip_text) );
 				color = COL_RED;
 				break;
@@ -1802,16 +1802,16 @@
 
 
 
-road_vehicle_t::road_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cn) :
+road_vehicle_t::road_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cn) :
 	vehicle_t(pos, besch, player_)
 {
-	cnv = cn;
+	cnst = cn;
 }
 
 
 road_vehicle_t::road_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : vehicle_t()
 {
-	rdwr_from_convoi(file);
+	rdwr_from_consist(file);
 
 	if(  file->is_loading()  ) {
 		static const vehikel_besch_t *last_besch = NULL;
@@ -1844,20 +1844,20 @@
 // need to reset halt reservation (if there was one)
 bool road_vehicle_t::calc_route(koord3d start, koord3d ziel, sint32 max_speed, route_t* route)
 {
-	assert(cnv);
+	assert(cnst);
 	// free target reservation
-	if(leading   &&  previous_direction!=ribi_t::none  &&  cnv  &&  target_halt.is_bound() ) {
+	if(leading   &&  previous_direction!=ribi_t::none  &&  cnst  &&  target_halt.is_bound() ) {
 		// now reserve our choice (beware: might be longer than one tile!)
-		for(  uint32 length=0;  length<cnv->get_tile_length()  &&  length+1<cnv->get_route()->get_count();  length++  ) {
-			target_halt->unreserve_position( welt->lookup( cnv->get_route()->position_bei( cnv->get_route()->get_count()-length-1) ), cnv->self );
+		for(  uint32 length=0;  length<cnst->get_tile_length()  &&  length+1<cnst->get_route()->get_count();  length++  ) {
+			target_halt->unreserve_position( welt->lookup( cnst->get_route()->position_bei( cnst->get_route()->get_count()-length-1) ), cnst->self );
 		}
 	}
 	target_halt = halthandle_t();	// no block reserved
-	route_t::route_result_t r = route->calc_route(welt, start, ziel, this, max_speed, cnv->get_tile_length() );
+	route_t::route_result_t r = route->calc_route(welt, start, ziel, this, max_speed, cnst->get_tile_length() );
 	if(  r == route_t::valid_route_halt_too_short  ) {
 		cbuffer_t buf;
-		buf.printf( translator::translate("Vehicle %s cannot choose because stop too short!"), cnv->get_name());
-		welt->get_message()->add_message( (const char *)buf, ziel.get_2d(), message_t::traffic_jams, PLAYER_FLAG | cnv->get_owner()->get_player_nr(), cnv->front()->get_base_image() );
+		buf.printf( translator::translate("Vehicle %s cannot choose because stop too short!"), cnst->get_name());
+		welt->get_message()->add_message( (const char *)buf, ziel.get_2d(), message_t::traffic_jams, PLAYER_FLAG | cnst->get_owner()->get_player_nr(), cnst->front()->get_base_image() );
 	}
 	return r;
 }
@@ -1869,7 +1869,7 @@
 	if(str==NULL  ||  str->get_max_speed()==0) {
 		return false;
 	}
-	bool electric = cnv!=NULL  ?  cnv->needs_electrification() : besch->get_engine_type()==vehikel_besch_t::electric;
+	bool electric = cnst!=NULL  ?  cnst->needs_electrification() : besch->get_engine_type()==vehikel_besch_t::electric;
 	if(electric  &&  !str->is_electrified()) {
 		return false;
 	}
@@ -1885,7 +1885,7 @@
 				return false;
 			}
 			// do not search further for a free stop beyond here
-			if(target_halt.is_bound()  &&  cnv->is_waiting()  &&  rs->get_besch()->get_flags()&roadsign_besch_t::END_OF_CHOOSE_AREA) {
+			if(target_halt.is_bound()  &&  cnst->is_waiting()  &&  rs->get_besch()->get_flags()&roadsign_besch_t::END_OF_CHOOSE_AREA) {
 				return false;
 			}
 		}
@@ -1928,7 +1928,7 @@
 bool road_vehicle_t::is_target(const grund_t *gr, const grund_t *prev_gr) const
 {
 	//  just check, if we reached a free stop position of this halt
-	if(gr->is_halt()  &&  gr->get_halt()==target_halt  &&  target_halt->is_reservable(gr,cnv->self)) {
+	if(gr->is_halt()  &&  gr->get_halt()==target_halt  &&  target_halt->is_reservable(gr,cnst->self)) {
 		// now we must check the predecessor => try to advance as much as possible
 		if(prev_gr!=NULL) {
 			const koord dir=gr->get_pos().get_2d()-prev_gr->get_pos().get_2d();
@@ -1938,11 +1938,11 @@
 				return false;
 			}
 			grund_t *to;
-			if(  !gr->get_neighbour(to,road_wt,ribi)  ||  !(to->get_halt()==target_halt)  ||  (gr->get_weg(get_waytype())->get_ribi_maske() & ribi_type(dir))!=0  ||  !target_halt->is_reservable(to,cnv->self)  ) {
+			if(  !gr->get_neighbour(to,road_wt,ribi)  ||  !(to->get_halt()==target_halt)  ||  (gr->get_weg(get_waytype())->get_ribi_maske() & ribi_type(dir))!=0  ||  !target_halt->is_reservable(to,cnst->self)  ) {
 				// end of stop: Is it long enough?
-				uint16 tiles = cnv->get_tile_length();
+				uint16 tiles = cnst->get_tile_length();
 				while(  tiles>1  ) {
-					if(  !gr->get_neighbour(to,get_waytype(),ribi_t::backward(ribi))  ||  !(to->get_halt()==target_halt)  ||  !target_halt->is_reservable(to,cnv->self)  ) {
+					if(  !gr->get_neighbour(to,get_waytype(),ribi_t::backward(ribi))  ||  !(to->get_halt()==target_halt)  ||  !target_halt->is_reservable(to,cnst->self)  ) {
 						return false;
 					}
 					gr = to;
@@ -1972,12 +1972,12 @@
 	}
 
 	// eventually shift position to take care of overtaking
-	if(cnv) {
-		if(  cnv->is_overtaking()  ) {
+	if(cnst) {
+		if(  cnst->is_overtaking()  ) {
 			xoff += tile_raster_scale_x(overtaking_base_offsets[ribi_t::get_dir(get_direction())][0], raster_width);
 			yoff += tile_raster_scale_x(overtaking_base_offsets[ribi_t::get_dir(get_direction())][1], raster_width);
 		}
-		else if(  cnv->is_overtaken()  ) {
+		else if(  cnst->is_overtaken()  ) {
 			xoff -= tile_raster_scale_x(overtaking_base_offsets[ribi_t::get_dir(get_direction())][0], raster_width)/5;
 			yoff -= tile_raster_scale_x(overtaking_base_offsets[ribi_t::get_dir(get_direction())][1], raster_width)/5;
 		}
@@ -1988,23 +1988,23 @@
 // chooses a route at a choose sign; returns true on success
 bool road_vehicle_t::choose_route(sint32 &restart_speed, ribi_t::ribi start_direction, uint16 index)
 {
-	if(  cnv->get_fpl_target()!=koord3d::invalid  ) {
+	if(  cnst->get_fpl_target()!=koord3d::invalid  ) {
 		// destination is a waypoint!
 		return true;
 	}
 
 	// are we heading to a target?
-	route_t *rt = cnv->access_route();
+	route_t *rt = cnst->access_route();
 	target_halt = haltestelle_t::get_halt( rt->back(), get_owner() );
 	if(  target_halt.is_bound()  ) {
 
-		// since convois can long than one tile, check is more difficult
+		// since consists can long than one tile, check is more difficult
 		bool can_go_there = true;
-		bool original_route = (rt->back() == cnv->get_schedule()->get_current_eintrag().pos);
-		for(  uint32 length=0;  can_go_there  &&  length<cnv->get_tile_length()  &&  length+1<rt->get_count();  length++  ) {
+		bool original_route = (rt->back() == cnst->get_schedule()->get_current_eintrag().pos);
+		for(  uint32 length=0;  can_go_there  &&  length<cnst->get_tile_length()  &&  length+1<rt->get_count();  length++  ) {
 			if(  grund_t *gr = welt->lookup( rt->position_bei( rt->get_count()-length-1) )  ) {
 				if (gr->get_halt().is_bound()) {
-					can_go_there &= target_halt->is_reservable( gr, cnv->self );
+					can_go_there &= target_halt->is_reservable( gr, cnst->self );
 				}
 				else {
 					// if this is the original stop, it is too short!
@@ -2014,8 +2014,8 @@
 		}
 		if(  can_go_there  ) {
 			// then reserve it ...
-			for(  uint32 length=0;  length<cnv->get_tile_length()  &&  length+1<rt->get_count();  length++  ) {
-				target_halt->reserve_position( welt->lookup( rt->position_bei( rt->get_count()-length-1) ), cnv->self );
+			for(  uint32 length=0;  length<cnst->get_tile_length()  &&  length+1<rt->get_count();  length++  ) {
+				target_halt->reserve_position( welt->lookup( rt->position_bei( rt->get_count()-length-1) ), cnst->self );
 			}
 		}
 		else {
@@ -2022,7 +2022,7 @@
 			// cannot go there => need slot search
 
 			// if we fail, we will wait in a step, much more simulation friendly
-			if(!cnv->is_waiting()) {
+			if(!cnst->is_waiting()) {
 				restart_speed = -1;
 				target_halt = halthandle_t();
 				return false;
@@ -2030,7 +2030,7 @@
 
 			// check if there is a free position
 			// this is much faster than waysearch
-			if(  !target_halt->find_free_position(road_wt,cnv->self,obj_t::road_vehicle  )) {
+			if(  !target_halt->find_free_position(road_wt,cnst->self,obj_t::road_vehicle  )) {
 				restart_speed = 0;
 				target_halt = halthandle_t();
 				return false;
@@ -2039,7 +2039,7 @@
 			// now it make sense to search a route
 			route_t target_rt;
 			koord3d next3d = rt->position_bei(index);
-			if(  !target_rt.find_route( welt, next3d, this, speed_to_kmh(cnv->get_min_top_speed()), start_direction, welt->get_settings().get_max_choose_route_steps() )  ) {
+			if(  !target_rt.find_route( welt, next3d, this, speed_to_kmh(cnst->get_min_top_speed()), start_direction, welt->get_settings().get_max_choose_route_steps() )  ) {
 				// nothing empty or not route with less than 33 tiles
 				target_halt = halthandle_t();
 				restart_speed = 0;
@@ -2047,8 +2047,8 @@
 			}
 
 			// now reserve our choice (beware: might be longer than one tile!)
-			for(  uint32 length=0;  length<cnv->get_tile_length()  &&  length+1<target_rt.get_count();  length++  ) {
-				target_halt->reserve_position( welt->lookup( target_rt.position_bei( target_rt.get_count()-length-1) ), cnv->self );
+			for(  uint32 length=0;  length<cnst->get_tile_length()  &&  length+1<target_rt.get_count();  length++  ) {
+				target_halt->reserve_position( welt->lookup( target_rt.position_bei( target_rt.get_count()-length-1) ), cnst->self );
 			}
 			rt->remove_koord_from( index );
 			rt->append( &target_rt );
@@ -2060,7 +2060,7 @@
 
 bool road_vehicle_t::can_enter_tile(const grund_t *gr, sint32 &restart_speed, uint8 second_check_count)
 {
-	// check for traffic lights (only relevant for the first car in a convoi)
+	// check for traffic lights (only relevant for the first car in a consist)
 	if(  leading  ) {
 		// no further check, when already entered a crossing (to allow leaving it)
 		if(  !second_check_count  ) {
@@ -2082,7 +2082,7 @@
 		const roadsign_t *rs = NULL;
 		if(  str->has_sign()  ) {
 			rs = gr->find<roadsign_t>();
-			route_t const& r = *cnv->get_route();
+			route_t const& r = *cnst->get_route();
 
 			if(  rs  &&  (route_index + 1u < r.get_count())  ) {
 				// since at the corner, our direction may be diagonal, we make it straight
@@ -2116,15 +2116,15 @@
 		uint32 test_index = route_index + 1u;
 
 		// way should be clear for overtaking: we checked previously
-		if(  !cnv->is_overtaking()  ) {
+		if(  !cnst->is_overtaking()  ) {
 			// calculate new direction
-			route_t const& r = *cnv->get_route();
+			route_t const& r = *cnst->get_route();
 			koord3d next = route_index < r.get_count() - 1u ? r.position_bei(route_index + 1u) : pos_next;
 			ribi_t::ribi curr_direction   = get_direction();
 			ribi_t::ribi curr_90direction = calc_direction(get_pos(), pos_next);
 			ribi_t::ribi next_direction   = calc_direction(get_pos(), next);
 			ribi_t::ribi next_90direction = calc_direction(pos_next, next);
-			obj = no_cars_blocking( gr, cnv, curr_direction, next_direction, next_90direction );
+			obj = no_cars_blocking( gr, cnst, curr_direction, next_direction, next_90direction );
 
 			// do not block intersections
 			const bool drives_on_left = welt->get_settings().is_drive_left();
@@ -2145,7 +2145,7 @@
 				if(  !gr  ) {
 					// way (weg) not existent (likely destroyed)
 					if(  !second_check_count  ) {
-						cnv->suche_neue_route();
+						cnst->suche_neue_route();
 					}
 					return false;
 				}
@@ -2154,7 +2154,7 @@
 				if(  !str  ||  gr->get_top() > 250  ) {
 					// too many cars here or no street
 					if(  !second_check_count  &&  !str) {
-						cnv->suche_neue_route();
+						cnst->suche_neue_route();
 					}
 					return false;
 				}
@@ -2166,7 +2166,7 @@
 					next                 = r.position_bei(test_index + 1u);
 					next_direction   = calc_direction(r.position_bei(test_index - 1u), next);
 					next_90direction = calc_direction(r.position_bei(test_index),      next);
-					obj = no_cars_blocking( gr, cnv, curr_direction, next_direction, next_90direction );
+					obj = no_cars_blocking( gr, cnst, curr_direction, next_direction, next_90direction );
 				}
 				else {
 					next                 = r.position_bei(test_index);
@@ -2174,7 +2174,7 @@
 					if(  curr_direction == next_90direction  ||  !gr->is_halt()  ) {
 						// check cars but allow to enter intersection if we are turning even when a car is blocking the halt on the last tile of our route
 						// preserves old bus terminal behaviour
-						obj = no_cars_blocking( gr, cnv, curr_direction, next_90direction, ribi_t::none );
+						obj = no_cars_blocking( gr, cnst, curr_direction, next_90direction, ribi_t::none );
 					}
 				}
 
@@ -2218,7 +2218,7 @@
 					return false;
 				}
 				if(  road_vehicle_t const* const car = obj_cast<road_vehicle_t>(obj)  ) {
-					const convoi_t* const ocnv = car->get_convoi();
+					const consist_t* const ocnv = car->get_consist();
 					sint32 dummy;
 					if(  ocnv->front()->get_route_index() < ocnv->get_route()->get_count()  &&  ocnv->front()->can_enter_tile( dummy, second_check_count + 1 )  ) {
 						return true;
@@ -2232,8 +2232,8 @@
 			if(  obj->is_stuck()  ) {
 				// end of traffic jam, but no stuck message, because previous vehicle is stuck too
 				restart_speed = 0;
-				cnv->set_tiles_overtaking(0);
-				cnv->reset_waiting();
+				cnst->set_tiles_overtaking(0);
+				cnst->reset_waiting();
 			}
 			else {
 				if(  test_index == route_index + 1u  ) {
@@ -2246,13 +2246,13 @@
 						}
 						// not overtaking/being overtake: we need to make a more thought test!
 						if(  road_vehicle_t const* const car = obj_cast<road_vehicle_t>(obj)  ) {
-							convoi_t* const ocnv = car->get_convoi();
-							if(  cnv->can_overtake( ocnv, (ocnv->get_state()==convoi_t::LOADING ? 0 : over->get_max_power_speed()), ocnv->get_length_in_steps()+ocnv->get_vehikel(0)->get_steps())  ) {
+							consist_t* const ocnv = car->get_consist();
+							if(  cnst->can_overtake( ocnv, (ocnv->get_state()==consist_t::LOADING ? 0 : over->get_max_power_speed()), ocnv->get_length_in_steps()+ocnv->get_vehikel(0)->get_steps())  ) {
 								return true;
 							}
 						}
 						else if(  private_car_t* const caut = obj_cast<private_car_t>(obj)  ) {
-							if(  cnv->can_overtake(caut, caut->get_besch()->get_geschw(), VEHICLE_STEPS_PER_TILE)  ) {
+							if(  cnst->can_overtake(caut, caut->get_besch()->get_geschw(), VEHICLE_STEPS_PER_TILE)  ) {
 								return true;
 							}
 						}
@@ -2259,8 +2259,8 @@
 					}
 				}
 				// we have to wait ...
-				restart_speed = (cnv->get_akt_speed()*3)/4;
-				cnv->set_tiles_overtaking(0);
+				restart_speed = (cnst->get_akt_speed()*3)/4;
+				cnst->set_tiles_overtaking(0);
 			}
 		}
 
@@ -2273,7 +2273,7 @@
 
 overtaker_t* road_vehicle_t::get_overtaker()
 {
-	return cnv;
+	return cnst;
 }
 
 
@@ -2286,7 +2286,7 @@
 	str->book(cargo, WAY_STAT_GOODS);
 	if (leading)  {
 		str->book(1, WAY_STAT_CONVOIS);
-		cnv->update_tiles_overtaking();
+		cnst->update_tiles_overtaking();
 	}
 }
 
@@ -2297,32 +2297,32 @@
 }
 
 
-void road_vehicle_t::set_convoi(convoi_t *c)
+void road_vehicle_t::set_consist(consist_t *c)
 {
-	DBG_MESSAGE("road_vehicle_t::set_convoi()","%p",c);
+	DBG_MESSAGE("road_vehicle_t::set_consist()","%p",c);
 	if(c!=NULL) {
-		bool target=(bool)cnv;	// only during loadtype: cnv==1 indicates, that the convoi did reserve a stop
-		vehicle_t::set_convoi(c);
+		bool target=(bool)cnst;	// only during loadtype: cnst==1 indicates, that the consist did reserve a stop
+		vehicle_t::set_consist(c);
 		if(target  &&  leading  &&  c->get_route()->empty()) {
 			// reinitialize the target halt
-			const route_t *rt = cnv->get_route();
+			const route_t *rt = cnst->get_route();
 			target_halt = haltestelle_t::get_halt( rt->back(), get_owner() );
 			if(  target_halt.is_bound()  ) {
 				for(  uint32 i=0;  i<c->get_tile_length()  &&  i+1<rt->get_count();  i++  ) {
-					target_halt->reserve_position( welt->lookup( rt->position_bei(rt->get_count()-i-1) ), cnv->self );
+					target_halt->reserve_position( welt->lookup( rt->position_bei(rt->get_count()-i-1) ), cnst->self );
 				}
 			}
 		}
 	}
 	else {
-		if(  cnv  &&  leading  &&  target_halt.is_bound()  ) {
+		if(  cnst  &&  leading  &&  target_halt.is_bound()  ) {
 			// now reserve our choice (beware: might be longer than one tile!)
-			for(  uint32 length=0;  length<cnv->get_tile_length()  &&  length+1<cnv->get_route()->get_count();  length++  ) {
-				target_halt->unreserve_position( welt->lookup( cnv->get_route()->position_bei( cnv->get_route()->get_count()-length-1) ), cnv->self );
+			for(  uint32 length=0;  length<cnst->get_tile_length()  &&  length+1<cnst->get_route()->get_count();  length++  ) {
+				target_halt->unreserve_position( welt->lookup( cnst->get_route()->position_bei( cnst->get_route()->get_count()-length-1) ), cnst->self );
 			}
 			target_halt = halthandle_t();
 		}
-		cnv = NULL;
+		cnst = NULL;
 	}
 }
 
@@ -2330,7 +2330,7 @@
 /* from now on rail vehicles (and other vehicles using blocks) */
 rail_vehicle_t::rail_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : vehicle_t()
 {
-	vehicle_t::rdwr_from_convoi(file);
+	vehicle_t::rdwr_from_consist(file);
 
 	if(  file->is_loading()  ) {
 		static const vehikel_besch_t *last_besch = NULL;
@@ -2343,7 +2343,7 @@
 			int power = (is_first || fracht.empty() || fracht.front() == warenbauer_t::nichts) ? 500 : 0;
 			const ware_besch_t* w = fracht.empty() ? warenbauer_t::nichts : fracht.front().get_besch();
 			dbg->warning("rail_vehicle_t::rail_vehicle_t()","try to find a fitting vehicle for %s.", power>0 ? "engine": w->get_name() );
-			if(last_besch!=NULL  &&  last_besch->can_follow(last_besch)  &&  last_besch->get_ware()==w  &&  (!is_last  ||  last_besch->get_nachfolger(0)==NULL)) {
+			if(last_besch!=NULL  &&  last_besch->can_follow(last_besch)  &&  last_besch->get_ware()==w  &&  (!is_last  ||  last_besch->get_trailing(0)==NULL)) {
 				// same as previously ...
 				besch = last_besch;
 			}
@@ -2371,21 +2371,21 @@
 }
 
 
-rail_vehicle_t::rail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cn) :
+rail_vehicle_t::rail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cn) :
 	vehicle_t(pos, besch, player_)
 {
-    cnv = cn;
+    cnst = cn;
 }
 
 
 rail_vehicle_t::~rail_vehicle_t()
 {
-	if (cnv && leading) {
-		route_t const& r = *cnv->get_route();
+	if (cnst && leading) {
+		route_t const& r = *cnst->get_route();
 		if (!r.empty() && route_index < r.get_count()) {
 			// free all reserved blocks
 			uint16 dummy;
-			block_reserver(&r, cnv->back()->get_route_index(), dummy, dummy, target_halt.is_bound() ? 100000 : 1, false, false);
+			block_reserver(&r, cnst->back()->get_route_index(), dummy, dummy, target_halt.is_bound() ? 100000 : 1, false, false);
 		}
 	}
 	grund_t *gr = welt->lookup(get_pos());
@@ -2398,17 +2398,17 @@
 }
 
 
-void rail_vehicle_t::set_convoi(convoi_t *c)
+void rail_vehicle_t::set_consist(consist_t *c)
 {
-	if(c!=cnv) {
-		DBG_MESSAGE("rail_vehicle_t::set_convoi()","new=%p old=%p",c,cnv);
+	if(c!=cnst) {
+		DBG_MESSAGE("rail_vehicle_t::set_consist()","new=%p old=%p",c,cnst);
 		if(leading) {
-			if(cnv!=NULL  &&  cnv!=(convoi_t *)1) {
-				// free route from old convoi
-				route_t const& r = *cnv->get_route();
+			if(cnst!=NULL  &&  cnst!=(consist_t *)1) {
+				// free route from old consist
+				route_t const& r = *cnst->get_route();
 				if(  !r.empty()  &&  route_index + 1U < r.get_count() - 1  ) {
 					uint16 dummy;
-					block_reserver(&r, cnv->back()->get_route_index(), dummy, dummy, 100000, false, false);
+					block_reserver(&r, cnst->back()->get_route_index(), dummy, dummy, 100000, false, false);
 					target_halt = halthandle_t();
 				}
 			}
@@ -2416,17 +2416,17 @@
 				assert(c!=NULL);
 				// eventually search new route
 				route_t const& r = *c->get_route();
-				if(  (r.get_count()<=route_index  ||  r.empty()  ||  get_pos()==r.back())  &&  c->get_state()!=convoi_t::INITIAL  &&  c->get_state()!=convoi_t::LOADING  &&  c->get_state()!=convoi_t::SELF_DESTRUCT  ) {
+				if(  (r.get_count()<=route_index  ||  r.empty()  ||  get_pos()==r.back())  &&  c->get_state()!=consist_t::INITIAL  &&  c->get_state()!=consist_t::LOADING  &&  c->get_state()!=consist_t::SELF_DESTRUCT  ) {
 					check_for_finish = true;
-					dbg->warning("rail_vehicle_t::set_convoi()", "convoi %i had a too high route index! (%i of max %i)", c->self.get_id(), route_index, r.get_count() - 1);
+					dbg->warning("rail_vehicle_t::set_consist()", "consist %i had a too high route index! (%i of max %i)", c->self.get_id(), route_index, r.get_count() - 1);
 				}
 				// set default next stop index
 				c->set_next_stop_index( max(route_index,1)-1 );
 				// need to reserve new route?
-				if(  !check_for_finish  &&  c->get_state()!=convoi_t::SELF_DESTRUCT  &&  (c->get_state()==convoi_t::DRIVING  ||  c->get_state()>=convoi_t::LEAVING_DEPOT)  ) {
-					sint32 num_index = cnv==(convoi_t *)1 ? 1001 : 0; 	// only during loadtype: cnv==1 indicates, that the convoi did reserve a stop
+				if(  !check_for_finish  &&  c->get_state()!=consist_t::SELF_DESTRUCT  &&  (c->get_state()==consist_t::DRIVING  ||  c->get_state()>=consist_t::LEAVING_DEPOT)  ) {
+					sint32 num_index = cnst==(consist_t *)1 ? 1001 : 0; 	// only during loadtype: cnst==1 indicates, that the consist did reserve a stop
 					uint16 next_signal, next_crossing;
-					cnv = c;
+					cnst = c;
 					if(  block_reserver(&r, max(route_index,1)-1, next_signal, next_crossing, num_index, true, false)  ) {
 						c->set_next_stop_index( next_signal>next_crossing ? next_crossing : next_signal );
 					}
@@ -2433,7 +2433,7 @@
 				}
 			}
 		}
-		vehicle_t::set_convoi(c);
+		vehicle_t::set_consist(c);
 	}
 }
 
@@ -2441,15 +2441,15 @@
 // need to reset halt reservation (if there was one)
 bool rail_vehicle_t::calc_route(koord3d start, koord3d ziel, sint32 max_speed, route_t* route)
 {
-	if(leading  &&  route_index<cnv->get_route()->get_count()) {
+	if(leading  &&  route_index<cnst->get_route()->get_count()) {
 		// free all reserved blocks
 		uint16 dummy;
-		block_reserver(cnv->get_route(), cnv->back()->get_route_index(), dummy, dummy, target_halt.is_bound() ? 100000 : 1, false, true);
+		block_reserver(cnst->get_route(), cnst->back()->get_route_index(), dummy, dummy, target_halt.is_bound() ? 100000 : 1, false, true);
 	}
-	cnv->set_next_reservation_index( 0 );	// nothing to reserve
+	cnst->set_next_reservation_index( 0 );	// nothing to reserve
 	target_halt = halthandle_t();	// no block reserved
 	// use length 8888 tiles to advance to the end of all stations
-	return route->calc_route(welt, start, ziel, this, max_speed, 8888 /*cnv->get_tile_length()*/ );
+	return route->calc_route(welt, start, ziel, this, max_speed, 8888 /*cnst->get_tile_length()*/ );
 }
 
 
@@ -2462,7 +2462,7 @@
 
 	// Hajo: diesel and steam engines can use electrified track as well.
 	// also allow driving on foreign tracks ...
-	const bool needs_no_electric = !(cnv!=NULL ? cnv->needs_electrification() : besch->get_engine_type()==vehikel_besch_t::electric);
+	const bool needs_no_electric = !(cnst!=NULL ? cnst->needs_electrification() : besch->get_engine_type()==vehikel_besch_t::electric);
 	if(  (!needs_no_electric  &&  !sch->is_electrified())  ||  sch->get_max_speed() == 0  ) {
 		return false;
 	}
@@ -2476,7 +2476,7 @@
 	if(sch->has_sign()) {
 		const roadsign_t* rs = bd->find<roadsign_t>();
 		if(  rs->get_besch()->get_wtyp()==get_waytype()  ) {
-			if(  cnv != NULL  &&  rs->get_besch()->get_min_speed() > 0  &&  rs->get_besch()->get_min_speed() > cnv->get_min_top_speed()  ) {
+			if(  cnst != NULL  &&  rs->get_besch()->get_min_speed() > 0  &&  rs->get_besch()->get_min_speed() > cnst->get_min_top_speed()  ) {
 				// below speed limit
 				return false;
 			}
@@ -2487,7 +2487,7 @@
 		}
 	}
 
-	if(  target_halt.is_bound()  &&  cnv->is_waiting()  ) {
+	if(  target_halt.is_bound()  &&  cnst->is_waiting()  ) {
 		// we are searching a stop here:
 		// ok, we can go where we already are ...
 		if(bd->get_pos()==get_pos()) {
@@ -2504,7 +2504,7 @@
 		}
 		// but we can only use empty blocks ...
 		// now check, if we could enter here
-		return sch->can_reserve(cnv->self);
+		return sch->can_reserve(cnst->self);
 	}
 
 	return true;
@@ -2543,7 +2543,7 @@
 {
 	const schiene_t * sch1 = (const schiene_t *) gr->get_weg(get_waytype());
 	// first check blocks, if we can go there
-	if(  sch1->can_reserve(cnv->self)  ) {
+	if(  sch1->can_reserve(cnst->self)  ) {
 		//  just check, if we reached a free stop position of this halt
 		if(  gr->is_halt()  &&  gr->get_halt()==target_halt  ) {
 			// now we must check the predecessor ...
@@ -2558,7 +2558,7 @@
 				if(  !gr->get_neighbour(to,get_waytype(),ribi)  ||  !(to->get_halt()==target_halt)  ||  (to->get_weg(get_waytype())->get_ribi_maske() & ribi_type(dir))!=0  ) {
 					// end of stop: Is it long enough?
 					// end of stop could be also signal!
-					uint16 tiles = cnv->get_tile_length();
+					uint16 tiles = cnst->get_tile_length();
 					while(  tiles>1  ) {
 						if(  gr->get_weg(get_waytype())->get_ribi_maske() & ribi  ||  !gr->get_neighbour(to,get_waytype(),ribi_t::backward(ribi))  ||  !(to->get_halt()==target_halt)  ) {
 							return false;
@@ -2579,7 +2579,7 @@
 {
 	// longblock signal: first check, whether there is a signal coming up on the route => just like normal signal
 	uint16 next_signal, next_crossing;
-	if(  !block_reserver( cnv->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
+	if(  !block_reserver( cnst->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
 		// not even the "Normal" signal route part is free => no bother checking further on
 		sig->set_zustand( roadsign_t::rot );
 		restart_speed = 0;
@@ -2589,12 +2589,12 @@
 	if(  next_signal != INVALID_INDEX  ) {
 		// success, and there is a signal before end of route => finished
 		sig->set_zustand( roadsign_t::gruen );
-		cnv->set_next_stop_index( min( next_crossing, next_signal ) );
+		cnst->set_next_stop_index( min( next_crossing, next_signal ) );
 		return true;
 	}
 
 	// no signal before end_of_route => need to do route search in a step
-	if(  !cnv->is_waiting()  ) {
+	if(  !cnst->is_waiting()  ) {
 		restart_speed = -1;
 		return false;
 	}
@@ -2601,17 +2601,17 @@
 
 	// now we can use the route search array
 	// (route until end is already reserved at this point!)
-	uint8 fahrplan_index = cnv->get_schedule()->get_aktuell()+1;
+	uint8 fahrplan_index = cnst->get_schedule()->get_aktuell()+1;
 	route_t target_rt;
-	koord3d cur_pos = cnv->get_route()->back();
+	koord3d cur_pos = cnst->get_route()->back();
 	uint16 dummy, next_next_signal;
-	if(fahrplan_index >= cnv->get_schedule()->get_count()) {
+	if(fahrplan_index >= cnst->get_schedule()->get_count()) {
 		fahrplan_index = 0;
 	}
-	while(  fahrplan_index != cnv->get_schedule()->get_aktuell()  ) {
+	while(  fahrplan_index != cnst->get_schedule()->get_aktuell()  ) {
 		// now search
 		// search for route
-		bool success = target_rt.calc_route( welt, cur_pos, cnv->get_schedule()->eintrag[fahrplan_index].pos, this, speed_to_kmh(cnv->get_min_top_speed()), 8888 /*cnv->get_tile_length()*/ );
+		bool success = target_rt.calc_route( welt, cur_pos, cnst->get_schedule()->eintrag[fahrplan_index].pos, this, speed_to_kmh(cnst->get_min_top_speed()), 8888 /*cnst->get_tile_length()*/ );
 		if(  success  ) {
 			success = block_reserver( &target_rt, 1, next_next_signal, dummy, 0, true, false );
 			block_reserver( &target_rt, 1, dummy, dummy, 0, false, false );
@@ -2622,17 +2622,17 @@
 			if(  next_next_signal<target_rt.get_count()  ) {
 				// and here is a signal => finished
 				// (however, if it is this signal, we need to renew reservation ...
-				if(  target_rt.position_bei(next_next_signal) == cnv->get_route()->position_bei( next_block )  ) {
-					block_reserver( cnv->get_route(), next_block+1, next_signal, next_crossing, 0, true, false );
+				if(  target_rt.position_bei(next_next_signal) == cnst->get_route()->position_bei( next_block )  ) {
+					block_reserver( cnst->get_route(), next_block+1, next_signal, next_crossing, 0, true, false );
 				}
 				sig->set_zustand( roadsign_t::gruen );
-				cnv->set_next_stop_index( min( min( next_crossing, next_signal ), cnv->get_route()->get_count() ) );
+				cnst->set_next_stop_index( min( min( next_crossing, next_signal ), cnst->get_route()->get_count() ) );
 				return true;
 			}
 		}
 
 		if(  !success  ) {
-			block_reserver( cnv->get_route(), next_block+1, next_next_signal, dummy, 0, false, false );
+			block_reserver( cnst->get_route(), next_block+1, next_next_signal, dummy, 0, false, false );
 			sig->set_zustand( roadsign_t::rot );
 			restart_speed = 0;
 			return false;
@@ -2640,12 +2640,12 @@
 		// prepare for next leg of schedule
 		cur_pos = target_rt.back();
 		fahrplan_index ++;
-		if(fahrplan_index >= cnv->get_schedule()->get_count()) {
+		if(fahrplan_index >= cnst->get_schedule()->get_count()) {
 			fahrplan_index = 0;
 		}
 	}
-	if(  cnv->get_next_stop_index()-1 <= route_index  ) {
-		cnv->set_next_stop_index( cnv->get_route()->get_count()-1 );
+	if(  cnst->get_next_stop_index()-1 <= route_index  ) {
+		cnst->set_next_stop_index( cnst->get_route()->get_count()-1 );
 	}
 	return true;
 }
@@ -2657,15 +2657,15 @@
 	target_halt = halthandle_t();
 
 	uint16 next_signal, next_crossing;
-	grund_t const* const target = welt->lookup(cnv->get_route()->back());
+	grund_t const* const target = welt->lookup(cnst->get_route()->back());
 
-	if(  cnv->get_fpl_target()!=koord3d::invalid  ) {
+	if(  cnst->get_fpl_target()!=koord3d::invalid  ) {
 		// destination is a waypoint!
 		goto skip_choose;
 	}
 
 	if(  target==NULL  ) {
-		cnv->suche_neue_route();
+		cnst->suche_neue_route();
 		return false;
 	}
 
@@ -2678,8 +2678,8 @@
 	choose_ok = true;
 
 	// check, if there is another choose signal or end_of_choose on the route
-	for(  uint32 idx=start_block+1;  choose_ok  &&  idx<cnv->get_route()->get_count();  idx++  ) {
-		grund_t *gr = welt->lookup(cnv->get_route()->position_bei(idx));
+	for(  uint32 idx=start_block+1;  choose_ok  &&  idx<cnst->get_route()->get_count();  idx++  ) {
+		grund_t *gr = welt->lookup(cnst->get_route()->position_bei(idx));
 		if(  gr==0  ) {
 			choose_ok = false;
 			break;
@@ -2714,9 +2714,9 @@
 skip_choose:
 	if(  !choose_ok  ) {
 		// just act as normal signal
-		if(  block_reserver( cnv->get_route(), start_block+1, next_signal, next_crossing, 0, true, false )  ) {
+		if(  block_reserver( cnst->get_route(), start_block+1, next_signal, next_crossing, 0, true, false )  ) {
 			sig->set_zustand(  roadsign_t::gruen );
-			cnv->set_next_stop_index( min( next_crossing, next_signal ) );
+			cnst->set_next_stop_index( min( next_crossing, next_signal ) );
 			return true;
 		}
 		// not free => wait here if directly in front
@@ -2726,12 +2726,12 @@
 	}
 
 	target_halt = target->get_halt();
-	if(  !block_reserver( cnv->get_route(), start_block+1, next_signal, next_crossing, 100000, true, false )  ) {
+	if(  !block_reserver( cnst->get_route(), start_block+1, next_signal, next_crossing, 100000, true, false )  ) {
 		// no free route to target!
 		// note: any old reservations should be invalid after the block reserver call.
 		// => We can now start freshly all over
 
-		if(!cnv->is_waiting()) {
+		if(!cnst->is_waiting()) {
 			restart_speed = -1;
 			target_halt = halthandle_t();
 			return false;
@@ -2741,7 +2741,7 @@
 		// now it we are in a step and can use the route search
 		route_t target_rt;
 		const int richtung = ribi_type(get_pos(), pos_next);	// to avoid confusion at diagonals
-		if(  !target_rt.find_route( welt, cnv->get_route()->position_bei(start_block), this, speed_to_kmh(cnv->get_min_top_speed()), richtung, welt->get_settings().get_max_choose_route_steps() )  ) {
+		if(  !target_rt.find_route( welt, cnst->get_route()->position_bei(start_block), this, speed_to_kmh(cnst->get_min_top_speed()), richtung, welt->get_settings().get_max_choose_route_steps() )  ) {
 			// nothing empty or not route with less than get_max_choose_route_steps() tiles
 			target_halt = halthandle_t();
 			sig->set_zustand(  roadsign_t::rot );
@@ -2750,9 +2750,9 @@
 		}
 		else {
 			// try to alloc the whole route
-			cnv->access_route()->remove_koord_from(start_block);
-			cnv->access_route()->append( &target_rt );
-			if(  !block_reserver( cnv->get_route(), start_block+1, next_signal, next_crossing, 100000, true, false )  ) {
+			cnst->access_route()->remove_koord_from(start_block);
+			cnst->access_route()->append( &target_rt );
+			if(  !block_reserver( cnst->get_route(), start_block+1, next_signal, next_crossing, 100000, true, false )  ) {
 				dbg->error( "rail_vehicle_t::is_choose_signal_clear()", "could not reserved route after find_route!" );
 				target_halt = halthandle_t();
 				sig->set_zustand(  roadsign_t::rot );
@@ -2763,7 +2763,7 @@
 		// reserved route to target
 	}
 	sig->set_zustand(  roadsign_t::gruen );
-	cnv->set_next_stop_index( min( next_crossing, next_signal ) );
+	cnst->set_next_stop_index( min( next_crossing, next_signal ) );
 	return true;
 }
 
@@ -2772,16 +2772,16 @@
 {
 	// parse to next signal; if needed recurse, since we allow cascading
 	uint16 next_signal, next_crossing;
-	if(  block_reserver( cnv->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
-		if(  next_signal == INVALID_INDEX  ||  cnv->get_route()->position_bei(next_signal) == cnv->get_route()->back()  ||  is_signal_clear( next_signal, restart_speed )  ) {
+	if(  block_reserver( cnst->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
+		if(  next_signal == INVALID_INDEX  ||  cnst->get_route()->position_bei(next_signal) == cnst->get_route()->back()  ||  is_signal_clear( next_signal, restart_speed )  ) {
 			// ok, end of route => we can go
 			sig->set_zustand( roadsign_t::gruen );
-			cnv->set_next_stop_index( min( next_signal, next_crossing ) );
+			cnst->set_next_stop_index( min( next_signal, next_crossing ) );
 			return true;
 		}
 		// when we reached here, the way is apparently not free => release reservation and set state to next free
 		sig->set_zustand( roadsign_t::naechste_rot );
-		block_reserver( cnv->get_route(), next_block+1, next_signal, next_crossing, 0, false, false );
+		block_reserver( cnst->get_route(), next_block+1, next_signal, next_crossing, 0, false, false );
 		restart_speed = 0;
 		return false;
 	}
@@ -2795,10 +2795,10 @@
 bool rail_vehicle_t::is_signal_clear(uint16 next_block, sint32 &restart_speed)
 {
 	// called, when there is a signal; will call other signal routines if needed
-	grund_t *gr_next_block = welt->lookup(cnv->get_route()->position_bei(next_block));
+	grund_t *gr_next_block = welt->lookup(cnst->get_route()->position_bei(next_block));
 	signal_t *sig = gr_next_block->find<signal_t>();
 	if(  sig==NULL  ) {
-		dbg->error( "rail_vehicle_t::is_signal_clear()", "called at %s without a signal!", cnv->get_route()->position_bei(next_block).get_str() );
+		dbg->error( "rail_vehicle_t::is_signal_clear()", "called at %s without a signal!", cnst->get_route()->position_bei(next_block).get_str() );
 		return true;
 	}
 
@@ -2809,9 +2809,9 @@
 	if(  !sig_besch->is_longblock_signal()  &&  !sig_besch->is_choose_sign()  &&  !sig_besch->is_pre_signal()  ) {
 
 		uint16 next_signal, next_crossing;
-		if(  block_reserver( cnv->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
+		if(  block_reserver( cnst->get_route(), next_block+1, next_signal, next_crossing, 0, true, false )  ) {
 			sig->set_zustand(  roadsign_t::gruen );
-			cnv->set_next_stop_index( min( next_crossing, next_signal ) );
+			cnst->set_next_stop_index( min( next_crossing, next_signal ) );
 			return true;
 		}
 		// not free => wait here if directly in front
@@ -2832,7 +2832,7 @@
 		return is_choose_signal_clear( sig, next_block, restart_speed );
 	}
 
-	dbg->error( "rail_vehicle_t::is_signal_clear()", "felt through at signal at %s", cnv->get_route()->position_bei(next_block).get_str() );
+	dbg->error( "rail_vehicle_t::is_signal_clear()", "felt through at signal at %s", cnst->get_route()->position_bei(next_block).get_str() );
 	return false;
 }
 
@@ -2841,20 +2841,20 @@
 {
 	assert(leading);
 	uint16 next_signal, next_crossing;
-	if(  cnv->get_state()==convoi_t::CAN_START  ||  cnv->get_state()==convoi_t::CAN_START_ONE_MONTH  ||  cnv->get_state()==convoi_t::CAN_START_TWO_MONTHS  ) {
+	if(  cnst->get_state()==consist_t::CAN_START  ||  cnst->get_state()==consist_t::CAN_START_ONE_MONTH  ||  cnst->get_state()==consist_t::CAN_START_TWO_MONTHS  ) {
 		// reserve first block at the start until the next signal
 		grund_t *gr_current = welt->lookup( get_pos() );
 		weg_t *w = gr_current ? gr_current->get_weg(get_waytype()) : NULL;
 		if(  w==NULL  ||  !(w->has_signal()  ||  w->is_crossing())  ) {
 			// free track => reserve up to next signal
-			if(  !block_reserver(cnv->get_route(), max(route_index,1)-1, next_signal, next_crossing, 0, true, false )  ) {
+			if(  !block_reserver(cnst->get_route(), max(route_index,1)-1, next_signal, next_crossing, 0, true, false )  ) {
 				restart_speed = 0;
 				return false;
 			}
-			cnv->set_next_stop_index( next_crossing<next_signal ? next_crossing : next_signal );
+			cnst->set_next_stop_index( next_crossing<next_signal ? next_crossing : next_signal );
 			return true;
 		}
-		cnv->set_next_stop_index( max(route_index,1)-1 );
+		cnst->set_next_stop_index( max(route_index,1)-1 );
 		if(  steps<steps_next  ) {
 			// not yet at tile border => can drive to signal safely
 			return true;
@@ -2876,14 +2876,14 @@
 	/* this should happen only before signals ...
 	 * but if it is already reserved, we can save lots of other checks later
 	 */
-	if(  !w->can_reserve(cnv->self)  ) {
+	if(  !w->can_reserve(cnst->self)  ) {
 		restart_speed = 0;
 		return false;
 	}
 
 	// is there any signal/crossing to be reserved?
-	uint16 next_block = cnv->get_next_stop_index()-1;
-	if(  next_block >= cnv->get_route()->get_count()  ) {
+	uint16 next_block = cnst->get_next_stop_index()-1;
+	if(  next_block >= cnst->get_route()->get_count()  ) {
 		// no obstacle in the way => drive on ...
 		return true;
 	}
@@ -2891,9 +2891,9 @@
 	// signal disappeared, train passes the tile of former signal
 	if(  next_block+1 < route_index  ) {
 		// we need to reserve the next block even if there is no signal present anymore
-		bool ok = block_reserver( cnv->get_route(), route_index, next_signal, next_crossing, 0, true, false );
+		bool ok = block_reserver( cnst->get_route(), route_index, next_signal, next_crossing, 0, true, false );
 		if (ok) {
-			cnv->set_next_stop_index( min( next_crossing, next_signal ) );
+			cnst->set_next_stop_index( min( next_crossing, next_signal ) );
 		}
 		return ok;
 		// if reservation was not possible the train will wait on the track until block is free
@@ -2900,12 +2900,12 @@
 	}
 
 	if(  next_block <= route_index+3  ) {
-		koord3d block_pos=cnv->get_route()->position_bei(next_block);
+		koord3d block_pos=cnst->get_route()->position_bei(next_block);
 		grund_t *gr_next_block = welt->lookup(block_pos);
 		const schiene_t *sch1 = gr_next_block ? (const schiene_t *)gr_next_block->get_weg(get_waytype()) : NULL;
 		if(sch1==NULL) {
 			// way (weg) not existent (likely destroyed)
-			cnv->suche_neue_route();
+			cnst->suche_neue_route();
 			return false;
 		}
 
@@ -2919,20 +2919,20 @@
 				if(!ok) {
 					// cannot cross => wait here
 					restart_speed = 0;
-					return cnv->get_next_stop_index()>route_index+1;
+					return cnst->get_next_stop_index()>route_index+1;
 				}
 				else if(  !sch1->has_signal()  ) {
 					// can reserve: find next place to do something and drive on
-					if(  block_pos == cnv->get_route()->back()  ) {
+					if(  block_pos == cnst->get_route()->back()  ) {
 						// is also last tile => go on ...
-						cnv->set_next_stop_index( INVALID_INDEX );
+						cnst->set_next_stop_index( INVALID_INDEX );
 						return true;
 					}
-					else if(  !block_reserver( cnv->get_route(), cnv->get_next_stop_index(), next_signal, next_crossing, 0, true, false )  ) {
+					else if(  !block_reserver( cnst->get_route(), cnst->get_next_stop_index(), next_signal, next_crossing, 0, true, false )  ) {
 						dbg->error( "rail_vehicle_t::can_enter_tile()", "block not free but was reserved!" );
 						return false;
 					}
-					cnv->set_next_stop_index( next_crossing<next_signal ? next_crossing : next_signal );
+					cnst->set_next_stop_index( next_crossing<next_signal ? next_crossing : next_signal );
 				}
 			}
 		}
@@ -2941,7 +2941,7 @@
 		if(  sch1->has_signal()  ) {
 			if(  !is_signal_clear( next_block, restart_speed )  ) {
 				// only return false, if we are directly in front of the signal
-				return cnv->get_next_stop_index()>route_index;
+				return cnst->get_next_stop_index()>route_index;
 			}
 		}
 	}
@@ -2966,7 +2966,7 @@
 	slist_tpl<grund_t *> signs;	// switch all signals on their way too ...
 
 	if(start_index>=route->get_count()) {
-		cnv->set_next_reservation_index( max(route->get_count(),1)-1 );
+		cnst->set_next_reservation_index( max(route->get_count(),1)-1 );
 		return 0;
 	}
 
@@ -2975,7 +2975,7 @@
 	}
 
 	if(  !reserve  ) {
-		cnv->set_next_reservation_index( start_index );
+		cnst->set_next_reservation_index( start_index );
 	}
 
 	// find next block segment en route
@@ -3008,7 +3008,7 @@
 				count --;
 				next_signal_index = i;
 			}
-			if(  !sch1->reserve( cnv->self, ribi_type( route->position_bei(max(1u,i)-1u), route->position_bei(min(route->get_count()-1u,i+1u)) ) )  ) {
+			if(  !sch1->reserve( cnst->self, ribi_type( route->position_bei(max(1u,i)-1u), route->position_bei(min(route->get_count()-1u,i+1u)) ) )  ) {
 				success = false;
 			}
 			if(next_crossing_index==INVALID_INDEX  &&  sch1->is_crossing()) {
@@ -3016,7 +3016,7 @@
 			}
 		}
 		else if(sch1) {
-			if(!sch1->unreserve(cnv->self)) {
+			if(!sch1->unreserve(cnst->self)) {
 				if(unreserve_now) {
 					// reached an reserved or free track => finished
 					return false;
@@ -3050,9 +3050,9 @@
 		// free reservation
 		for ( int j=start_index; j<i; j++) {
 			schiene_t * sch1 = (schiene_t *)welt->lookup( route->position_bei(j))->get_weg(get_waytype());
-			sch1->unreserve(cnv->self);
+			sch1->unreserve(cnst->self);
 		}
-		cnv->set_next_reservation_index( start_index );
+		cnst->set_next_reservation_index( start_index );
 		return false;
 	}
 
@@ -3062,7 +3062,7 @@
 			signal->set_zustand(roadsign_t::gruen);
 		}
 	}
-	cnv->set_next_reservation_index( i );
+	cnst->set_next_reservation_index( i );
 
 	return true;
 }
@@ -3103,7 +3103,7 @@
 		sch0->book(cargo, WAY_STAT_GOODS);
 		if(leading) {
 			sch0->book(1, WAY_STAT_CONVOIS);
-			sch0->reserve( cnv->self, get_direction() );
+			sch0->reserve( cnst->self, get_direction() );
 		}
 	}
 }
@@ -3133,16 +3133,16 @@
 }
 
 
-water_vehicle_t::water_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cn) :
+water_vehicle_t::water_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cn) :
 	vehicle_t(pos, besch, player_)
 {
-	cnv = cn;
+	cnst = cn;
 }
 
 
 water_vehicle_t::water_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : vehicle_t()
 {
-	vehicle_t::rdwr_from_convoi(file);
+	vehicle_t::rdwr_from_consist(file);
 
 	if(  file->is_loading()  ) {
 		static const vehikel_besch_t *last_besch = NULL;
@@ -3191,7 +3191,7 @@
 	if(  w  &&  w->has_sign()  ) {
 		const roadsign_t* rs = bd->find<roadsign_t>();
 		if(  rs->get_besch()->get_wtyp()==get_waytype()  ) {
-			if(  cnv !=NULL  &&  rs->get_besch()->get_min_speed() > 0  &&  rs->get_besch()->get_min_speed() > cnv->get_min_top_speed()  ) {
+			if(  cnst !=NULL  &&  rs->get_besch()->get_min_speed() > 0  &&  rs->get_besch()->get_min_speed() > cnst->get_min_top_speed()  ) {
 				// below speed limit
 				return false;
 			}
@@ -3352,7 +3352,7 @@
 		case flying:
 		case circling:
 		{
-//DBG_MESSAGE("air_vehicle_t::check_next_tile()","(cnv %i) in idx %i",cnv->self.get_id(),route_index );
+//DBG_MESSAGE("air_vehicle_t::check_next_tile()","(cnst %i) in idx %i",cnst->self.get_id(),route_index );
 			// prissi: here a height check could avoid too high mountains
 			return true;
 		}
@@ -3379,7 +3379,7 @@
 	}
 	else {
 		// otherwise we just check, if we reached a free stop position of this halt
-		if(gr->get_halt()==target_halt  &&  target_halt->is_reservable(gr,cnv->self)) {
+		if(gr->get_halt()==target_halt  &&  target_halt->is_reservable(gr,cnst->self)) {
 			return true;
 		}
 	}
@@ -3393,14 +3393,14 @@
 bool air_vehicle_t::find_route_to_stop_position()
 {
 	if(target_halt.is_bound()) {
-//DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","bound! (cnv %i)",cnv->self.get_id());
+//DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","bound! (cnst %i)",cnst->self.get_id());
 		return true;	// already searched with success
 	}
 
 	// check for skipping circle
-	route_t *rt=cnv->access_route();
+	route_t *rt=cnst->access_route();
 
-//DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","can approach? (cnv %i)",cnv->self.get_id());
+//DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","can approach? (cnst %i)",cnst->self.get_id());
 
 	grund_t const* const last = welt->lookup(rt->back());
 	target_halt = last ? last->get_halt() : halthandle_t();
@@ -3418,7 +3418,7 @@
 
 	// is our target occupied?
 //	DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","state %i",state);
-	if(!target_halt->find_free_position(air_wt,cnv->self,obj_t::air_vehicle)  ) {
+	if(!target_halt->find_free_position(air_wt,cnst->self,obj_t::air_vehicle)  ) {
 		target_halt = halthandle_t();
 		DBG_MESSAGE("aircraft_t::find_route_to_stop_position()","no free position found!");
 		return false;
@@ -3428,7 +3428,7 @@
 
 		// if we fail, we will wait in a step, much more simulation friendly
 		// and the route finder is not re-entrant!
-		if(!cnv->is_waiting()) {
+		if(!cnst->is_waiting()) {
 			target_halt = halthandle_t();
 			return false;
 		}
@@ -3448,7 +3448,7 @@
 		state = prev_state;
 
 		// now reserve our choice ...
-		target_halt->reserve_position(welt->lookup(target_rt.back()), cnv->self);
+		target_halt->reserve_position(welt->lookup(target_rt.back()), cnst->self);
 		//DBG_MESSAGE("aircraft_t::find_route_to_stop_position()", "found free stop near %i,%i,%i", target_rt.back().x, target_rt.back().y, target_rt.back().z);
 		rt->remove_koord_from(searchforstop);
 		rt->append( &target_rt );
@@ -3463,11 +3463,11 @@
 {
 //DBG_MESSAGE("aircraft_t::calc_route()","search route from %i,%i,%i to %i,%i,%i",start.x,start.y,start.z,ziel.x,ziel.y,ziel.z);
 
-	if(leading  &&  cnv) {
+	if(leading  &&  cnst) {
 		// free target reservation
 		if(  target_halt.is_bound() ) {
-			if (grund_t* const target = welt->lookup(cnv->get_route()->back())) {
-				target_halt->unreserve_position(target,cnv->self);
+			if (grund_t* const target = welt->lookup(cnst->get_route()->back())) {
+				target_halt->unreserve_position(target,cnst->self);
 			}
 		}
 		// free runway reservation
@@ -3711,7 +3711,7 @@
 	bool start_now = false;
 	bool success = true;
 
-	const route_t *route = cnv->get_route();
+	const route_t *route = cnst->get_route();
 	if(route->empty()) {
 		return false;
 	}
@@ -3737,7 +3737,7 @@
 			// we un-reserve also nonexistent tiles! (may happen during deletion)
 			if(reserve) {
 				start_now = true;
-				if(  !sch1->reserve(cnv->self,ribi_t::none)  ) {
+				if(  !sch1->reserve(cnst->self,ribi_t::none)  ) {
 					// unsuccessful => must un-reserve all
 					success = false;
 					end = i;
@@ -3748,7 +3748,7 @@
 					return true;
 				}
 			}
-			else if(  !sch1->unreserve(cnv->self)  ) {
+			else if(  !sch1->unreserve(cnst->self)  ) {
 				if(start_now) {
 					// reached an reserved or free track => finished
 					return true;
@@ -3768,7 +3768,7 @@
 			if (gr) {
 				runway_t* sch1 = (runway_t *)gr->get_weg(air_wt);
 				if (sch1) {
-					sch1->unreserve(cnv->self);
+					sch1->unreserve(cnst->self);
 				}
 			}
 		}
@@ -3788,7 +3788,7 @@
 		return false;
 	}
 
-	if(  route_index < takeoff  &&  route_index > 1  &&  takeoff<cnv->get_route()->get_count()-1  ) {
+	if(  route_index < takeoff  &&  route_index > 1  &&  takeoff<cnst->get_route()->get_count()-1  ) {
 		// check, if tile occupied by a plane on ground
 		if(  route_index > 1  ) {
 			for(  uint8 i = 1;  i<gr->get_top();  i++  ) {
@@ -3802,7 +3802,7 @@
 		// need to reserve runway?
 		runway_t *rw = (runway_t *)gr->get_weg(air_wt);
 		if(rw==NULL) {
-			cnv->suche_neue_route();
+			cnst->suche_neue_route();
 			return false;
 		}
 		// next tile a runway => then reserve
@@ -3865,9 +3865,9 @@
 		else {
 			// circle slowly next round
 			state = circling;
-			cnv->must_recalc_data();
+			cnst->must_recalc_data();
 			if(  leading  ) {
-				cnv->must_recalc_data_front();
+				cnst->must_recalc_data_front();
 			}
 		}
 	}
@@ -3876,7 +3876,7 @@
 
 		// if we fail, we will wait in a step, much more simulation friendly
 		// and the route finder is not re-entrant!
-		if(!cnv->is_waiting()) {
+		if(!cnst->is_waiting()) {
 			return false;
 		}
 
@@ -3924,7 +3924,7 @@
 
 air_vehicle_t::air_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : vehicle_t()
 {
-	rdwr_from_convoi(file);
+	rdwr_from_consist(file);
 
 	if(  file->is_loading()  ) {
 		static const vehikel_besch_t *last_besch = NULL;
@@ -3948,10 +3948,10 @@
 }
 
 
-air_vehicle_t::air_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cn) :
+air_vehicle_t::air_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cn) :
 	vehicle_t(pos, besch, player_)
 {
-	cnv = cn;
+	cnst = cn;
 	state = taxiing;
 	flying_height = 0;
 	target_height = pos.z;
@@ -3969,14 +3969,14 @@
 }
 
 
-void air_vehicle_t::set_convoi(convoi_t *c)
+void air_vehicle_t::set_consist(consist_t *c)
 {
-	DBG_MESSAGE("aircraft_t::set_convoi()","%p",c);
-	if(leading  &&  (unsigned long)cnv > 1) {
+	DBG_MESSAGE("aircraft_t::set_consist()","%p",c);
+	if(leading  &&  (unsigned long)cnst > 1) {
 		// free stop reservation
-		route_t const& r = *cnv->get_route();
+		route_t const& r = *cnst->get_route();
 		if(target_halt.is_bound()) {
-			target_halt->unreserve_position(welt->lookup(r.back()), cnv->self);
+			target_halt->unreserve_position(welt->lookup(r.back()), cnst->self);
 			target_halt = halthandle_t();
 		}
 		if (!r.empty()) {
@@ -3991,15 +3991,15 @@
 	}
 	// maybe need to restore state?
 	if(c!=NULL) {
-		bool target=(bool)cnv;
-		vehicle_t::set_convoi(c);
+		bool target=(bool)cnst;
+		vehicle_t::set_consist(c);
 		if(leading) {
 			if(target) {
 				// reinitialize the target halt
-				grund_t* const target=welt->lookup(cnv->get_route()->back());
+				grund_t* const target=welt->lookup(cnst->get_route()->back());
 				target_halt = target->get_halt();
 				if(target_halt.is_bound()) {
-					target_halt->reserve_position(target,cnv->self);
+					target_halt->reserve_position(target,cnst->self);
 				}
 			}
 			// restore reservation
@@ -4019,7 +4019,7 @@
 		}
 	}
 	else {
-		vehicle_t::set_convoi(NULL);
+		vehicle_t::set_consist(NULL);
 	}
 }
 
@@ -4030,16 +4030,16 @@
 }
 
 
-void air_vehicle_t::rdwr_from_convoi(loadsave_t *file)
+void air_vehicle_t::rdwr_from_consist(loadsave_t *file)
 {
 	xml_tag_t t( file, "aircraft_t" );
 
-	// initialize as vehicle_t::rdwr_from_convoi calls get_bild()
+	// initialize as vehicle_t::rdwr_from_consist calls get_bild()
 	if (file->is_loading()) {
 		state = taxiing;
 		flying_height = 0;
 	}
-	vehicle_t::rdwr_from_convoi(file);
+	vehicle_t::rdwr_from_consist(file);
 
 	file->rdwr_enum(state);
 	file->rdwr_short(flying_height);
@@ -4088,7 +4088,7 @@
 			if(  (weg==NULL  ||  // end of runway (broken runway)
 				 weg->get_besch()->get_styp()!=1  ||  // end of runway (grass now ... )
 				 (route_index>takeoff+1  &&  ribi_t::is_single(weg->get_ribi_unmasked())) )  ||  // single ribi at end of runway
-				 cnv->get_akt_speed()>kmh_to_speed(besch->get_geschw())/3 // fast enough
+				 cnst->get_akt_speed()>kmh_to_speed(besch->get_geschw())/3 // fast enough
 			) {
 				state = flying;
 				new_friction = 1;
@@ -4145,7 +4145,7 @@
 				// touchdown!
 				if (flying_height==h_next) {
 					const sint32 taxi_speed = kmh_to_speed( min( 60, besch->get_geschw()/4 ) );
-					if(  cnv->get_akt_speed() <= taxi_speed  ) {
+					if(  cnst->get_akt_speed() <= taxi_speed  ) {
 						new_speed_limit = taxi_speed;
 						new_friction = 16;
 					}
@@ -4159,7 +4159,7 @@
 			}
 			else {
 				// runway is on this height
-				const sint16 runway_height = cnv->get_route()->position_bei(touchdown).z*TILE_HEIGHT_STEP;
+				const sint16 runway_height = cnst->get_route()->position_bei(touchdown).z*TILE_HEIGHT_STEP;
 
 				// we are too low, ascent asap
 				if (flying_height < runway_height + TILE_HEIGHT_STEP) {
@@ -4190,7 +4190,7 @@
 
 	// friction factors and speed limit may have changed
 	// TODO use the same logic as in vehicle_t::hop
-	cnv->must_recalc_data();
+	cnst->must_recalc_data();
 }
 
 
Index: vehicle/simvehicle.h
===================================================================
--- vehicle/simvehicle.h	(revision 7957)
+++ vehicle/simvehicle.h	(working copy)
@@ -15,7 +15,7 @@
 #include "../simtypes.h"
 #include "../simobj.h"
 #include "../halthandle_t.h"
-#include "../convoihandle_t.h"
+#include "../consist_handle_t.h"
 #include "../ifc/simtestdriver.h"
 #include "../boden/grund.h"
 #include "../besch/vehikel_besch.h"
@@ -22,7 +22,7 @@
 #include "../vehicle/overtaker.h"
 #include "../tpl/slist_tpl.h"
 
-class convoi_t;
+class consist_t;
 class schedule_t;
 class signal_t;
 class ware_t;
@@ -97,7 +97,7 @@
 	virtual void calc_image() = 0;
 
 	// check for road vehicle, if next tile is free
-	vehicle_base_t *no_cars_blocking( const grund_t *gr, const convoi_t *cnv, const uint8 current_direction, const uint8 next_direction, const uint8 next_90direction );
+	vehicle_base_t *no_cars_blocking( const grund_t *gr, const consist_t *cnst, const uint8 current_direction, const uint8 next_direction, const uint8 next_90direction );
 
 	// only needed for old way of moving vehicles to determine position at loading time
 	bool is_about_to_hop( const sint8 neu_xoff, const sint8 neu_yoff ) const;
@@ -110,7 +110,7 @@
 
 	static void set_overtaking_offsets( bool driving_on_the_left );
 
-	// if true, this convoi needs to restart for correct alignment
+	// if true, this consist needs to restart for correct alignment
 	bool need_realignment() const;
 
 	uint32 do_drive(uint32 dist);	// basis movement code
@@ -233,10 +233,10 @@
 
 	const vehikel_besch_t *besch;
 
-	convoi_t *cnv;		// != NULL if the vehicle is part of a Convoi
+	consist_t *cnst;		// != NULL if the vehicle is part of a Convoi
 
-	bool leading:1;	// true, if vehicle is first vehicle of a convoi
-	bool last:1;	// true, if vehicle is last vehicle of a convoi
+	bool leading:1;	// true, if vehicle is first vehicle of a consist
+	bool last:1;	// true, if vehicle is last vehicle of a consist
 	bool smoke:1;
 	bool check_for_finish:1;		// true, if on the last tile
 	bool has_driven:1;
@@ -249,7 +249,7 @@
 	// the coordinates, where the vehicle was loaded the last time
 	koord3d last_stop_pos;
 
-	convoi_t *get_convoi() const { return cnv; }
+	consist_t *get_consist() const { return cnst; }
 
 	virtual void rotate90();
 
@@ -344,8 +344,8 @@
 	*/
 	inline uint32 get_total_weight() const { return sum_weight; }
 
-	// returns speedlimit of ways (and if convoi enters station etc)
-	// the convoi takes care of the max_speed of the vehicle
+	// returns speedlimit of ways (and if consist enters station etc)
+	// the consist takes care of the max_speed of the vehicle
 	sint32 get_speed_limit() const { return speed_limit; }
 
 	const slist_tpl<ware_t> & get_cargo() const { return fracht;}   // list of goods being transported
@@ -402,7 +402,7 @@
 	*/
 	sint64  calc_revenue(koord start, koord end) const;
 
-	// sets or query begin and end of convois
+	// sets or query begin and end of consists
 	void set_leading(bool janein) {leading = janein;}
 	bool is_leading() {return leading;}
 
@@ -412,7 +412,7 @@
 	// marks the vehicle as really used
 	void set_driven() { has_driven = true; }
 
-	virtual void set_convoi(convoi_t *c);
+	virtual void set_consist(consist_t *c);
 
 	/**
 	 * Unload freight to halt
@@ -442,7 +442,7 @@
 	const char *is_deletable(const player_t *player);
 
 	void rdwr(loadsave_t *file);
-	virtual void rdwr_from_convoi(loadsave_t *file);
+	virtual void rdwr_from_consist(loadsave_t *file);
 
 	uint32 calc_sale_value() const;
 
@@ -487,9 +487,9 @@
 	virtual waytype_t get_waytype() const { return road_wt; }
 
 	road_vehicle_t(loadsave_t *file, bool first, bool last);
-	road_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv); // start and schedule
+	road_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst); // start and schedule
 
-	virtual void set_convoi(convoi_t *c);
+	virtual void set_consist(consist_t *c);
 
 	// how expensive to go here (for way search)
 	virtual int get_cost(const grund_t *, const sint32, koord) const;
@@ -559,10 +559,10 @@
 	typ get_typ() const { return rail_vehicle; }
 
 	rail_vehicle_t(loadsave_t *file, bool is_first, bool is_last);
-	rail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t *cnv);
+	rail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t *cnst);
 	~rail_vehicle_t();
 
-	virtual void set_convoi(convoi_t *c);
+	virtual void set_consist(consist_t *c);
 
 	virtual schedule_t * generate_new_schedule() const;
 };
@@ -581,7 +581,7 @@
 
 	// all handled by rail_vehicle_t
 	monorail_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : rail_vehicle_t(file,is_first, is_last) {}
-	monorail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv) : rail_vehicle_t(pos, besch, player_, cnv) {}
+	monorail_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst) : rail_vehicle_t(pos, besch, player_, cnst) {}
 
 	typ get_typ() const { return monorail_vehicle; }
 
@@ -602,7 +602,7 @@
 
 	// all handled by rail_vehicle_t
 	maglev_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : rail_vehicle_t(file, is_first, is_last) {}
-	maglev_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv) : rail_vehicle_t(pos, besch, player_, cnv) {}
+	maglev_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst) : rail_vehicle_t(pos, besch, player_, cnst) {}
 
 	typ get_typ() const { return maglev_vehicle; }
 
@@ -623,7 +623,7 @@
 
 	// all handled by rail_vehicle_t
 	narrowgauge_vehicle_t(loadsave_t *file, bool is_first, bool is_last) : rail_vehicle_t(file, is_first, is_last) {}
-	narrowgauge_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv) : rail_vehicle_t(pos, besch, player_, cnv) {}
+	narrowgauge_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst) : rail_vehicle_t(pos, besch, player_, cnst) {}
 
 	typ get_typ() const { return narrowgauge_vehicle; }
 
@@ -660,7 +660,7 @@
 	virtual bool is_target(const grund_t *,const grund_t *) const {return 0;}
 
 	water_vehicle_t(loadsave_t *file, bool is_first, bool is_last);
-	water_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv);
+	water_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst);
 
 	obj_t::typ get_typ() const { return water_vehicle; }
 
@@ -711,7 +711,7 @@
 
 public:
 	air_vehicle_t(loadsave_t *file, bool is_first, bool is_last);
-	air_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, convoi_t* cnv); // start and schedule
+	air_vehicle_t(koord3d pos, const vehikel_besch_t* besch, player_t* player_, consist_t* cnst); // start and schedule
 
 	// to shift the events around properly
 	void get_event_index( flight_state &state_, uint32 &takeoff_, uint32 &stopsearch_, uint32 &landing_ ) { state_ = state; takeoff_ = takeoff; stopsearch_ = searchforstop; landing_ = touchdown; }
@@ -733,7 +733,7 @@
 
 	virtual bool can_enter_tile(const grund_t *gr_next, sint32 &restart_speed, uint8);
 
-	virtual void set_convoi(convoi_t *c);
+	virtual void set_consist(consist_t *c);
 
 	bool calc_route(koord3d start, koord3d ziel, sint32 max_speed, route_t* route);
 
@@ -741,7 +741,7 @@
 
 	schedule_t *generate_new_schedule() const;
 
-	void rdwr_from_convoi(loadsave_t *file);
+	void rdwr_from_consist(loadsave_t *file);
 
 	int get_flyingheight() const {return flying_height-get_hoff()-2;}
 
