Merge branch 'auto_timetables' into auto_timetables-sx

config.lib

@@ -29,6 +29,7 @@ set_default() {
 	strip=""
 	lipo=""
 	awk="awk"
+	pkg_config="pkg-config"
 	os="DETECT"
 	endian="AUTO"
 	cpu_type="DETECT"
@@ -105,6 +106,7 @@ set_default() {
 		strip
 		lipo
 		awk
+		pkg_config
 		os
 		endian
 		cpu_type
@@ -213,6 +215,8 @@ detect_params() {
 			--windres=*)                  windres="$optarg";;
 			--awk)                        prev_p="awk";;
 			--awk=*)                      awk="$optarg";;
+			--pkg-config)                 prev_p="pkg_config";;
+			--pkg-config=*)               pkg_config="$optarg";;
 			--strip)                      prev_p="strip";;
 			--strip=*)                    strip="$optarg";;
 			--lipo)                       prev_p="lipo";;
@@ -1938,9 +1942,26 @@ check_compiler() {
 		log 2 "  exit code $ret"
 
 		if ( [ -z "$machine" ] && [ "$8" != "3" ] ) || [ "$ret" != "0" ]; then
-			log 1 "checking $1... $compiler not found"
+			if [ -z "$5" ]; then
-			log 1 "I couldn't detect any $6 binary for $3"
+				log 1 "checking $1... $compiler not found"
-			exit 1
+				log 1 "I couldn't detect any $6 binary for $3"
+				exit 1
+			else
+				compiler="$3-$5"
+			fi
+			machine=`eval $compiler $9 2>/dev/null`
+			ret=$?
+			eval "$2=\"$compiler\""
+
+			log 2 "executing $compiler $9"
+			log 2 "  returned $machine"
+			log 2 "  exit code $ret"
+
+			if ( [ -z "$machine" ] && [ "$8" != "3" ] ) || [ "$ret" != "0" ]; then
+				log 1 "checking $1... $compiler not found"
+				log 1 "I couldn't detect any $5 binary for $3"
+				exit 1
+			fi
 		fi
 
 		if [ "$machine" != "$3" ] && ( [ "$8" = "0" ] || [ "$8" = "1" ] ); then
@@ -2736,7 +2757,7 @@ detect_pkg_config() {
 	log 2 "detecting $2"
 
 	if [ "$1" = "1" ] || [ "$1" = "" ] || [ "$1" = "2" ]; then
-		pkg_config_call="pkg-config $2"
+		pkg_config_call="$pkg_config $2"
 	else
 		pkg_config_call="$1"
 	fi
@@ -2758,7 +2779,7 @@ detect_pkg_config() {
 
 		# It was forced, so it should be found.
 		if [ "$1" != "1" ]; then
-			log 1 "configure: error: pkg-config $2 couldn't be found"
+			log 1 "configure: error: $pkg_config $2 couldn't be found"
 			log 1 "configure: error: you supplied '$1', but it seems invalid"
 			exit 1
 		fi
@@ -3588,6 +3609,7 @@ showhelp() {
 	echo "  --windres=WINDRES              the windres to use [HOST-windres]"
 	echo "  --strip=STRIP                  the strip to use [HOST-strip]"
 	echo "  --awk=AWK                      the awk to use in configure [awk]"
+	echo "  --pkg-config=PKG-CONFIG        the pkg-config to use in configure [pkg-config]"
 	echo "  --lipo=LIPO                    the lipo to use (OSX ONLY) [HOST-lipo]"
 	echo "  --os=OS                        the OS we are compiling for [DETECT]"
 	echo "                                 DETECT/UNIX/OSX/FREEBSD/DRAGONFLY/OPENBSD/"

src/lang/czech.txt

@@ -1390,7 +1390,7 @@ STR_CONFIG_SETTING_OIL_REF_EDGE_DISTANCE_HELPTEXT               :Ropné rafineri
 STR_CONFIG_SETTING_SNOWLINE_HEIGHT                              :Výška sněhové čáry: {STRING}
 STR_CONFIG_SETTING_SNOWLINE_HEIGHT_HELPTEXT                     :Určuje o jaké výšky se vyskytuje sníh u subarktického klimatu. Sníh rovněž ovlivňuje vytváření průmyslu a požadavky na růst měst
 STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN                         :Členitost krajiny: {STRING}
-STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN_HELPTEXT                :(Pouze TerraGenesis) Zvol množství hor: Rovinatý terén má méně hor, které jsou však rozlehlejší. Členitý terén má mnoho hor, u kterých se může zdát, že se upakují
+STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN_HELPTEXT                :(Pouze TerraGenesis) Zvol množství hor: Rovinatý terén má méně hor, které jsou však rozlehlejší. Členitý terén má mnoho hor, u kterých se může zdát, že se opakují
 STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN_VERY_SMOOTH             :velmi rovná
 STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN_SMOOTH                  :rovná
 STR_CONFIG_SETTING_ROUGHNESS_OF_TERRAIN_ROUGH                   :členitá

src/lang/dutch.txt

@@ -1143,7 +1143,7 @@ STR_CONFIG_SETTING_MAXIMUM_INITIAL_LOAN                         :Maximale beginl
 STR_CONFIG_SETTING_MAXIMUM_INITIAL_LOAN_HELPTEXT                :Maximale bedrag een bedrijf kan lenen (zonder rekening te houden met de inflatie)
 STR_CONFIG_SETTING_INTEREST_RATE                                :Rente van lening: {STRING}
 STR_CONFIG_SETTING_INTEREST_RATE_HELPTEXT                       :Percentage rente op lening; bepaald ook het inflatiecijfer wanneer ingeschakeld
-STR_CONFIG_SETTING_RUNNING_COSTS                                :Brandstofkosten: {STRING}
+STR_CONFIG_SETTING_RUNNING_COSTS                                :Onderhoudskosten: {STRING}
 STR_CONFIG_SETTING_RUNNING_COSTS_HELPTEXT                       :Het niveau van onderhoud en bedrijfskosten van voertuigen en infrastuctuur
 STR_CONFIG_SETTING_CONSTRUCTION_SPEED                           :Bouwsnelheid: {STRING}
 STR_CONFIG_SETTING_CONSTRUCTION_SPEED_HELPTEXT                  :Beperk de hoeveelheid bouwactiviteiten voor computerspeler
@@ -3184,16 +3184,16 @@ STR_FINANCES_EXPENDITURE_INCOME_TITLE                           :{WHITE}Uitgaven
 STR_FINANCES_YEAR                                               :{WHITE}{NUM}
 STR_FINANCES_SECTION_CONSTRUCTION                               :{GOLD}Bouwkosten
 STR_FINANCES_SECTION_NEW_VEHICLES                               :{GOLD}Nieuwe voertuigen
-STR_FINANCES_SECTION_TRAIN_RUNNING_COSTS                        :{GOLD}Treinbrandstofkosten
+STR_FINANCES_SECTION_TRAIN_RUNNING_COSTS                        :{GOLD}Treinonderhoudskosten
 STR_FINANCES_SECTION_ROAD_VEHICLE_RUNNING_COSTS                 :{GOLD}Wegvoertuigbrandstofkosten
-STR_FINANCES_SECTION_AIRCRAFT_RUNNING_COSTS                     :{GOLD}Vliegtuigbrandstofkosten
+STR_FINANCES_SECTION_AIRCRAFT_RUNNING_COSTS                     :{GOLD}Vliegtuigonderhoudskosten
-STR_FINANCES_SECTION_SHIP_RUNNING_COSTS                         :{GOLD}Schipbrandstofkosten
+STR_FINANCES_SECTION_SHIP_RUNNING_COSTS                         :{GOLD}Schiponderhoudskosten
 STR_FINANCES_SECTION_PROPERTY_MAINTENANCE                       :{GOLD}Eigendomsonderhoud
 STR_FINANCES_SECTION_TRAIN_INCOME                               :{GOLD}Treininkomsten
 STR_FINANCES_SECTION_ROAD_VEHICLE_INCOME                        :{GOLD}Wegvoertuiginkomsten
 STR_FINANCES_SECTION_AIRCRAFT_INCOME                            :{GOLD}Vliegtuiginkomsten
 STR_FINANCES_SECTION_SHIP_INCOME                                :{GOLD}Schipinkomsten
-STR_FINANCES_SECTION_LOAN_INTEREST                              :{GOLD}Rente van lening
+STR_FINANCES_SECTION_LOAN_INTEREST                              :{GOLD} De rente van de lening
 STR_FINANCES_SECTION_OTHER                                      :{GOLD}Overig
 STR_FINANCES_NEGATIVE_INCOME                                    :{BLACK}-{CURRENCY_LONG}
 STR_FINANCES_POSITIVE_INCOME                                    :{BLACK}+{CURRENCY_LONG}
@@ -3598,12 +3598,12 @@ STR_VEHICLE_VIEW_SHIP_REFIT_TOOLTIP                             :{BLACK}Bouw sch
 STR_VEHICLE_VIEW_AIRCRAFT_REFIT_TOOLTIP                         :{BLACK}Bouw vliegtuig om voor een ander goederentype
 
 STR_VEHICLE_VIEW_TRAIN_REVERSE_TOOLTIP                          :{BLACK}Keer trein om
-STR_VEHICLE_VIEW_ROAD_VEHICLE_REVERSE_TOOLTIP                   :{BLACK}Dwing het wegvoertuig om om te draaien
+STR_VEHICLE_VIEW_ROAD_VEHICLE_REVERSE_TOOLTIP                   :{BLACK}Dwing het wegvoertuig te keren.
 
-STR_VEHICLE_VIEW_TRAIN_ORDERS_TOOLTIP                           :{BLACK}Toon orders van trein. Ctrl+klik toont het tijdschema van de trein
+STR_VEHICLE_VIEW_TRAIN_ORDERS_TOOLTIP                           :{BLACK}Toon orders van de trein. Ctrl+klik toont het tijdschema van de trein
-STR_VEHICLE_VIEW_ROAD_VEHICLE_ORDERS_TOOLTIP                    :{BLACK}Toon orders van wegvoertuig. Ctrl+klik toont tijdschema van het voertuig
+STR_VEHICLE_VIEW_ROAD_VEHICLE_ORDERS_TOOLTIP                    :{BLACK}Toon orders van het wegvoertuig. Ctrl+klik toont tijdschema van het voertuig
-STR_VEHICLE_VIEW_SHIP_ORDERS_TOOLTIP                            :{BLACK}Toon orders van schip. Ctrl+klik toont tijdschema van het schip
+STR_VEHICLE_VIEW_SHIP_ORDERS_TOOLTIP                            :{BLACK}Toon orders van het schip. Ctrl+klik toont tijdschema van het schip
-STR_VEHICLE_VIEW_AIRCRAFT_ORDERS_TOOLTIP                        :{BLACK}Toon orders van vliegtuig. Ctrl+klik toont het tijdschema van het vliegtuig
+STR_VEHICLE_VIEW_AIRCRAFT_ORDERS_TOOLTIP                        :{BLACK}Toon orders van het vliegtuig. Ctrl+klik toont het tijdschema van het vliegtuig
 
 STR_VEHICLE_VIEW_TRAIN_SHOW_DETAILS_TOOLTIP                     :{BLACK}Toon details van trein
 STR_VEHICLE_VIEW_ROAD_VEHICLE_SHOW_DETAILS_TOOLTIP              :{BLACK}Toon details van wegvoertuig
@@ -4153,9 +4153,9 @@ STR_ERROR_MAXIMUM_PERMITTED_LOAN                                :{WHITE}... maxi
 STR_ERROR_CAN_T_BORROW_ANY_MORE_MONEY                           :{WHITE}Kan geen geld meer lenen...
 STR_ERROR_LOAN_ALREADY_REPAYED                                  :{WHITE}... geen lening om af te betalen
 STR_ERROR_CURRENCY_REQUIRED                                     :{WHITE}... {CURRENCY_LONG} benodigd
-STR_ERROR_CAN_T_REPAY_LOAN                                      :{WHITE}Kan geen lening afbetalen...
+STR_ERROR_CAN_T_REPAY_LOAN                                      :{WHITE}Kan de lening niet afbetalen..
 STR_ERROR_INSUFFICIENT_FUNDS                                    :{WHITE}Kan geen geld weggeven dat van de bank geleend is...
-STR_ERROR_CAN_T_BUY_COMPANY                                     :{WHITE}Kan bedrijf niet kopen...
+STR_ERROR_CAN_T_BUY_COMPANY                                     :{WHITE}Kan het bedrijf niet kopen...
 STR_ERROR_CAN_T_BUILD_COMPANY_HEADQUARTERS                      :{WHITE}Kan bedrijfshoofdkantoor niet bouwen...
 STR_ERROR_CAN_T_BUY_25_SHARE_IN_THIS                            :{WHITE}Kan geen 25% aandeel in dit bedrijf kopen...
 STR_ERROR_CAN_T_SELL_25_SHARE_IN                                :{WHITE}Kan geen 25% aandeel in dit bedrijf verkopen...

src/lang/swedish.txt

@@ -3848,7 +3848,7 @@ STR_ORDER_NO_LOAD                                               :(Ingen lastning
 STR_ORDER_UNLOAD                                                :(Lasta av och lasta gods)
 STR_ORDER_UNLOAD_FULL_LOAD                                      :(Lasta av och vänta på full last)
 STR_ORDER_UNLOAD_FULL_LOAD_ANY                                  :(Lasta av och vänta på någon full last)
-STR_ORDER_UNLOAD_NO_LOAD                                        :(Ladda av och lämna tom)
+STR_ORDER_UNLOAD_NO_LOAD                                        :(Lasta av och lämna tom)
 STR_ORDER_TRANSFER                                              :(Överför och lasta gods)
 STR_ORDER_TRANSFER_FULL_LOAD                                    :(Överför och vänta på full last)
 STR_ORDER_TRANSFER_FULL_LOAD_ANY                                :(Överför och vänta på full last av någon godstyp)

src/misc/array.hpp

@@ -34,7 +34,7 @@ protected:
 	{
 		uint super_size = data.Length();
 		if (super_size > 0) {
-			SubArray& s = data[super_size - 1];
+			SubArray &s = data[super_size - 1];
 			if (!s.IsFull()) return s;
 		}
 		return *data.AppendC();
@@ -42,9 +42,16 @@ protected:
 
 public:
 	/** implicit constructor */
-	inline SmallArray() { }
+	inline SmallArray()
+	{
+	}
+
 	/** Clear (destroy) all items */
-	inline void Clear() {data.Clear();}
+	inline void Clear()
+	{
+		data.Clear();
+	}
+
 	/** Return actual number of items */
 	inline uint Length() const
 	{
@@ -54,25 +61,41 @@ public:
 		return (super_size - 1) * B + sub_size;
 	}
 	/** return true if array is empty */
-	inline bool IsEmpty() { return data.IsEmpty(); }
+	inline bool IsEmpty()
-	/** return true if array is full */
-	inline bool IsFull() { return data.IsFull() && data[N - 1].IsFull(); }
-	/** allocate but not construct new item */
-	inline T *Append() { return FirstFreeSubArray().Append(); }
-	/** allocate and construct new item */
-	inline T *AppendC() { return FirstFreeSubArray().AppendC(); }
-	/** indexed access (non-const) */
-	inline T& operator [] (uint index)
 	{
-		const SubArray& s = data[index / B];
+		return data.IsEmpty();
-		T& item = s[index % B];
+	}
+
+	/** return true if array is full */
+	inline bool IsFull()
+	{
+		return data.IsFull() && data[N - 1].IsFull();
+	}
+
+	/** allocate but not construct new item */
+	inline T *Append()
+	{
+		return FirstFreeSubArray().Append();
+	}
+
+	/** allocate and construct new item */
+	inline T *AppendC()
+	{
+		return FirstFreeSubArray().AppendC();
+	}
+
+	/** indexed access (non-const) */
+	inline T& operator[](uint index)
+	{
+		const SubArray &s = data[index / B];
+		T &item = s[index % B];
 		return item;
 	}
 	/** indexed access (const) */
-	inline const T& operator [] (uint index) const
+	inline const T& operator[](uint index) const
 	{
-		const SubArray& s = data[index / B];
+		const SubArray &s = data[index / B];
-		const T& item = s[index % B];
+		const T &item = s[index % B];
 		return item;
 	}
 
@@ -87,7 +110,7 @@ public:
 		dmp.WriteLine("num_items = %d", num_items);
 		CStrA name;
 		for (uint i = 0; i < num_items; i++) {
-			const T& item = (*this)[i];
+			const T &item = (*this)[i];
 			name.Format("item[%d]", i);
 			dmp.WriteStructT(name.Data(), &item);
 		}

src/misc/binaryheap.hpp

@@ -157,21 +157,30 @@ public:
 	 *
 	 *  @return The number of items in the queue
 	 */
-	inline uint Length() const { return this->items; }
+	inline uint Length() const
+	{
+		return this->items;
+	}
 
 	/**
 	 * Test if the priority queue is empty.
 	 *
 	 * @return True if empty
 	 */
-	inline bool IsEmpty() const { return this->items == 0; }
+	inline bool IsEmpty() const
+	{
+		return this->items == 0;
+	}
 
 	/**
 	 * Test if the priority queue is full.
 	 *
 	 * @return True if full.
 	 */
-	inline bool IsFull() const { return this->items >= this->capacity; }
+	inline bool IsFull() const
+	{
+		return this->items >= this->capacity;
+	}
 
 	/**
 	 * Get the smallest item in the binary tree.
@@ -287,7 +296,10 @@ public:
 	 * Make the priority queue empty.
 	 * All remaining items will remain untouched.
 	 */
-	inline void Clear() { this->items = 0; }
+	inline void Clear()
+	{
+		this->items = 0;
+	}
 };
 
 #endif /* BINARYHEAP_HPP */

src/misc/blob.hpp

@@ -71,7 +71,10 @@ public:
 	static const size_t header_size = sizeof(BlobHeader);
 
 	/** default constructor - initializes empty blob */
-	inline ByteBlob() { InitEmpty(); }
+	inline ByteBlob()
+	{
+		InitEmpty();
+	}
 
 	/** copy constructor */
 	inline ByteBlob(const ByteBlob &src)
@@ -311,9 +314,22 @@ public:
 
 	struct OnTransfer {
 		typename base::BlobHeader *header;
-		OnTransfer(const OnTransfer& src) : header(src.header) {assert(src.header != NULL); *const_cast<typename base::BlobHeader**>(&src.header) = NULL;}
+
-		OnTransfer(CBlobT& src) : header(src.header) {src.InitEmpty();}
+		OnTransfer(const OnTransfer& src) : header(src.header)
-		~OnTransfer() {assert(header == NULL);}
+		{
+			assert(src.header != NULL);
+			*const_cast<typename base::BlobHeader**>(&src.header) = NULL;
+		}
+
+		OnTransfer(CBlobT& src) : header(src.header)
+		{
+			src.InitEmpty();
+		}
+
+		~OnTransfer()
+		{
+			assert(header == NULL);
+		}
 	};
 
 	/** Default constructor - makes new Blob ready to accept any data */

src/misc/countedptr.hpp

@@ -35,60 +35,118 @@ protected:
 
 public:
 	/** default (NULL) construct or construct from a raw pointer */
-	inline CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj) {AddRef();}
+	inline CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj)
+	{
+		AddRef();
+	}
 
 	/** copy constructor (invoked also when initializing from another smart ptr) */
-	inline CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();}
+	inline CCountedPtr(const CCountedPtr &src) : m_pT(src.m_pT)
+	{
+		AddRef();
+	}
 
 	/** destructor releasing the reference */
-	inline ~CCountedPtr() {Release();}
+	inline ~CCountedPtr()
+	{
+		Release();
+	}
 
 protected:
 	/** add one ref to the underlaying object */
-	inline void AddRef() {if (m_pT != NULL) m_pT->AddRef();}
+	inline void AddRef()
+	{
+		if (m_pT != NULL) m_pT->AddRef();
+	}
 
 public:
 	/** release smart pointer (and decrement ref count) if not null */
-	inline void Release() {if (m_pT != NULL) {Tcls *pT = m_pT; m_pT = NULL; pT->Release();}}
+	inline void Release()
+	{
+		if (m_pT != NULL) {
+			Tcls *pT = m_pT;
+			m_pT = NULL;
+			pT->Release();
+		}
+	}
 
 	/** dereference of smart pointer - const way */
-	inline const Tcls *operator -> () const {assert(m_pT != NULL); return m_pT;}
+	inline const Tcls *operator->() const
+	{
+		assert(m_pT != NULL);
+		return m_pT;
+	}
 
 	/** dereference of smart pointer - non const way */
-	inline Tcls *operator -> () {assert(m_pT != NULL); return m_pT;}
+	inline Tcls *operator->()
+	{
+		assert(m_pT != NULL);
+		return m_pT;
+	}
 
 	/** raw pointer casting operator - const way */
-	inline operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
+	inline operator const Tcls*() const
+	{
+		assert(m_pT == NULL);
+		return m_pT;
+	}
 
 	/** raw pointer casting operator - non-const way */
-	inline operator Tcls*() {return m_pT;}
+	inline operator Tcls*()
+	{
+		return m_pT;
+	}
 
 	/** operator & to support output arguments */
-	inline Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
+	inline Tcls** operator&()
+	{
+		assert(m_pT == NULL);
+		return &m_pT;
+	}
 
 	/** assignment operator from raw ptr */
-	inline CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
+	inline CCountedPtr& operator=(Tcls *pT)
+	{
+		Assign(pT);
+		return *this;
+	}
 
 	/** assignment operator from another smart ptr */
-	inline CCountedPtr& operator = (const CCountedPtr& src) {Assign(src.m_pT); return *this;}
+	inline CCountedPtr& operator=(const CCountedPtr &src)
+	{
+		Assign(src.m_pT);
+		return *this;
+	}
 
 	/** assignment operator helper */
 	inline void Assign(Tcls *pT);
 
 	/** one way how to test for NULL value */
-	inline bool IsNull() const {return m_pT == NULL;}
+	inline bool IsNull() const
+	{
+		return m_pT == NULL;
+	}
 
 	/** another way how to test for NULL value */
-	//inline bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}
+	//inline bool operator == (const CCountedPtr &sp) const {return m_pT == sp.m_pT;}
 
 	/** yet another way how to test for NULL value */
-	//inline bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;}
+	//inline bool operator != (const CCountedPtr &sp) const {return m_pT != sp.m_pT;}
 
 	/** assign pointer w/o incrementing ref count */
-	inline void Attach(Tcls *pT) {Release(); m_pT = pT;}
+	inline void Attach(Tcls *pT)
+	{
+		Release();
+		m_pT = pT;
+	}
 
 	/** detach pointer w/o decrementing ref count */
-	inline Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;}
+	inline Tcls *Detach()
+	{
+		Tcls *pT = m_pT;
+		m_pT = NULL;
+		return pT;
+	}
 };
 
 template <class Tcls_>
@@ -136,7 +194,6 @@ template <class T> struct AdaptT {
 	}
 };
 
-
 /**
  * Simple counted object. Use it as base of your struct/class if you want to use
  *  basic reference counting. Your struct/class will destroy and free itself when
@@ -161,7 +218,4 @@ struct SimpleCountedObject {
 	virtual void FinalRelease() {};
 };
 
-
-
-
 #endif /* COUNTEDPTR_HPP */

src/misc/dbg_helpers.h

@@ -111,7 +111,7 @@ struct DumpTarget {
 			m_ptr = src.m_ptr;
 		}
 
-		bool operator < (const KnownStructKey &other) const
+		bool operator<(const KnownStructKey &other) const
 		{
 			if ((size_t)m_ptr < (size_t)other.m_ptr) return true;
 			if ((size_t)m_ptr > (size_t)other.m_ptr) return false;

src/misc/fixedsizearray.hpp

@@ -41,13 +41,28 @@ protected:
 	T *data;
 
 	/** return reference to the array header (non-const) */
-	inline ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
+	inline ArrayHeader& Hdr()
+	{
+		return *(ArrayHeader*)(((byte*)data) - HeaderSize);
+	}
+
 	/** return reference to the array header (const) */
-	inline const ArrayHeader& Hdr() const { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
+	inline const ArrayHeader& Hdr() const
+	{
+		return *(ArrayHeader*)(((byte*)data) - HeaderSize);
+	}
+
 	/** return reference to the block reference counter */
-	inline uint& RefCnt() { return Hdr().reference_count; }
+	inline uint& RefCnt()
+	{
+		return Hdr().reference_count;
+	}
+
 	/** return reference to number of used items */
-	inline uint& SizeRef() { return Hdr().items; }
+	inline uint& SizeRef()
+	{
+		return Hdr().items;
+	}
 
 public:
 	/** Default constructor. Preallocate space for items and header, then initialize header. */
@@ -63,7 +78,7 @@ public:
 	}
 
 	/** Copy constructor. Preallocate space for items and header, then initialize header. */
-	FixedSizeArray(const FixedSizeArray<T, C>& src)
+	FixedSizeArray(const FixedSizeArray<T, C> &src)
 	{
 		/* share block (header + items) with the source array */
 		data = src.data;
@@ -96,19 +111,50 @@ public:
 	}
 
 	/** return number of used items */
-	inline uint Length() const { return Hdr().items; }
+	inline uint Length() const
+	{
+		return Hdr().items;
+	}
+
 	/** return true if array is full */
-	inline bool IsFull() const { return Length() >= C; }
+	inline bool IsFull() const
+	{
+		return Length() >= C;
+	}
+
 	/** return true if array is empty */
-	inline bool IsEmpty() const { return Length() <= 0; }
+	inline bool IsEmpty() const
+	{
+		return Length() <= 0;
+	}
+
 	/** add (allocate), but don't construct item */
-	inline T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
+	inline T *Append()
+	{
+		assert(!IsFull());
+		return &data[SizeRef()++];
+	}
+
 	/** add and construct item using default constructor */
-	inline T *AppendC() { T *item = Append(); new(item)T; return item; }
+	inline T *AppendC()
+	{
+		T *item = Append();
+		new(item)T;
+		return item;
+	}
 	/** return item by index (non-const version) */
-	inline T& operator [] (uint index) { assert(index < Length()); return data[index]; }
+	inline T& operator[](uint index)
+	{
+		assert(index < Length());
+		return data[index];
+	}
+
 	/** return item by index (const version) */
-	inline const T& operator [] (uint index) const { assert(index < Length()); return data[index]; }
+	inline const T& operator[](uint index) const
+	{
+		assert(index < Length());
+		return data[index];
+	}
 };
 
 #endif /* FIXEDSIZEARRAY_HPP */

src/misc/hashtable.hpp

@@ -24,10 +24,13 @@ struct CHashTableSlotT
 	inline CHashTableSlotT() : m_pFirst(NULL) {}
 
 	/** hash table slot helper - clears the slot by simple forgetting its items */
-	inline void Clear() {m_pFirst = NULL;}
+	inline void Clear()
+	{
+		m_pFirst = NULL;
+	}
 
 	/** hash table slot helper - linear search for item with given key through the given blob - const version */
-	inline const Titem_ *Find(const Key& key) const
+	inline const Titem_ *Find(const Key &key) const
 	{
 		for (const Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
 			if (pItem->GetKey() == key) {
@@ -39,7 +42,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - linear search for item with given key through the given blob - non-const version */
-	inline Titem_ *Find(const Key& key)
+	inline Titem_ *Find(const Key &key)
 	{
 		for (Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
 			if (pItem->GetKey() == key) {
@@ -51,7 +54,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - add new item to the slot */
-	inline void Attach(Titem_& new_item)
+	inline void Attach(Titem_ &new_item)
 	{
 		assert(new_item.GetHashNext() == NULL);
 		new_item.SetHashNext(m_pFirst);
@@ -59,7 +62,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - remove item from a slot */
-	inline bool Detach(Titem_& item_to_remove)
+	inline bool Detach(Titem_ &item_to_remove)
 	{
 		if (m_pFirst == &item_to_remove) {
 			m_pFirst = item_to_remove.GetHashNext();
@@ -81,7 +84,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - remove and return item from a slot */
-	inline Titem_ *Detach(const Key& key)
+	inline Titem_ *Detach(const Key &key)
 	{
 		/* do we have any items? */
 		if (m_pFirst == NULL) {
@@ -89,7 +92,7 @@ struct CHashTableSlotT
 		}
 		/* is it our first item? */
 		if (m_pFirst->GetKey() == key) {
-			Titem_& ret_item = *m_pFirst;
+			Titem_ &ret_item = *m_pFirst;
 			m_pFirst = m_pFirst->GetHashNext();
 			ret_item.SetHashNext(NULL);
 			return &ret_item;
@@ -128,7 +131,7 @@ struct CHashTableSlotT
  *    - public method that calculates key's hash:
  *        int CalcHash() const;
  *    - public 'equality' operator to compare the key with another one
- *        bool operator == (const Key& other) const;
+ *        bool operator==(const Key &other) const;
  */
 template <class Titem_, int Thash_bits_>
 class CHashTableT {
@@ -156,7 +159,7 @@ public:
 
 protected:
 	/** static helper - return hash for the given key modulo number of slots */
-	inline static int CalcHash(const Tkey& key)
+	inline static int CalcHash(const Tkey &key)
 	{
 		int32 hash = key.CalcHash();
 		if ((8 * Thash_bits) < 32) hash ^= hash >> (min(8 * Thash_bits, 31));
@@ -168,38 +171,47 @@ protected:
 	}
 
 	/** static helper - return hash for the given item modulo number of slots */
-	inline static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
+	inline static int CalcHash(const Titem_ &item)
+	{
+		return CalcHash(item.GetKey());
+	}
 
 public:
 	/** item count */
-	inline int Count() const {return m_num_items;}
+	inline int Count() const
+	{
+		return m_num_items;
+	}
 
 	/** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */
-	inline void Clear() {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();}
+	inline void Clear()
+	{
+		for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();
+	}
 
 	/** const item search */
-	const Titem_ *Find(const Tkey& key) const
+	const Titem_ *Find(const Tkey &key) const
 	{
 		int hash = CalcHash(key);
-		const Slot& slot = m_slots[hash];
+		const Slot &slot = m_slots[hash];
 		const Titem_ *item = slot.Find(key);
 		return item;
 	}
 
 	/** non-const item search */
-	Titem_ *Find(const Tkey& key)
+	Titem_ *Find(const Tkey &key)
 	{
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		Titem_ *item = slot.Find(key);
 		return item;
 	}
 
 	/** non-const item search & optional removal (if found) */
-	Titem_ *TryPop(const Tkey& key)
+	Titem_ *TryPop(const Tkey &key)
 	{
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		Titem_ *item = slot.Detach(key);
 		if (item != NULL) {
 			m_num_items--;
@@ -208,7 +220,7 @@ public:
 	}
 
 	/** non-const item search & removal */
-	Titem_& Pop(const Tkey& key)
+	Titem_& Pop(const Tkey &key)
 	{
 		Titem_ *item = TryPop(key);
 		assert(item != NULL);
@@ -216,11 +228,11 @@ public:
 	}
 
 	/** non-const item search & optional removal (if found) */
-	bool TryPop(Titem_& item)
+	bool TryPop(Titem_ &item)
 	{
-		const Tkey& key = item.GetKey();
+		const Tkey &key = item.GetKey();
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		bool ret = slot.Detach(item);
 		if (ret) {
 			m_num_items--;
@@ -229,17 +241,17 @@ public:
 	}
 
 	/** non-const item search & removal */
-	void Pop(Titem_& item)
+	void Pop(Titem_ &item)
 	{
 		bool ret = TryPop(item);
 		assert(ret);
 	}
 
 	/** add one item - copy it from the given item */
-	void Push(Titem_& new_item)
+	void Push(Titem_ &new_item)
 	{
 		int hash = CalcHash(new_item);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		assert(slot.Find(new_item.GetKey()) == NULL);
 		slot.Attach(new_item);
 		m_num_items++;

src/misc/str.hpp

@@ -35,7 +35,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Take over ownership constructor */
-	inline CStrA(const OnTransfer& ot)
+	inline CStrA(const OnTransfer &ot)
 		: base(ot)
 	{
 	}
@@ -67,7 +67,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Assignment from C string. */
-	inline CStrA &operator = (const char *src)
+	inline CStrA &operator=(const char *src)
 	{
 		base::Clear();
 		AppendStr(src);
@@ -75,7 +75,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Assignment from another CStrA. */
-	inline CStrA &operator = (const CStrA &src)
+	inline CStrA &operator=(const CStrA &src)
 	{
 		if (&src != this) {
 			base::Clear();
@@ -86,7 +86,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Lower-than operator (to support stl collections) */
-	inline bool operator < (const CStrA &other) const
+	inline bool operator<(const CStrA &other) const
 	{
 		return strcmp(base::Data(), other.Data()) < 0;
 	}

src/pathfinder/yapf/nodelist.hpp

@@ -24,34 +24,23 @@
 template <class Titem_, int Thash_bits_open_, int Thash_bits_closed_>
 class CNodeList_HashTableT {
 public:
-	/** make Titem_ visible from outside of class */
+	typedef Titem_ Titem;                                        ///< Make #Titem_ visible from outside of class.
-	typedef Titem_ Titem;
+	typedef typename Titem_::Key Key;                            ///< Make Titem_::Key a property of #HashTable.
-	/** make Titem_::Key a property of HashTable */
+	typedef SmallArray<Titem_, 65536, 256> CItemArray;           ///< Type that we will use as item container.
-	typedef typename Titem_::Key Key;
+	typedef CHashTableT<Titem_, Thash_bits_open_  > COpenList;   ///< How pointers to open nodes will be stored.
-	/** type that we will use as item container */
+	typedef CHashTableT<Titem_, Thash_bits_closed_> CClosedList; ///< How pointers to closed nodes will be stored.
-	typedef SmallArray<Titem_, 65536, 256> CItemArray;
+	typedef CBinaryHeapT<Titem_> CPriorityQueue;                 ///< How the priority queue will be managed.
-	/** how pointers to open nodes will be stored */
-	typedef CHashTableT<Titem_, Thash_bits_open_  > COpenList;
-	/** how pointers to closed nodes will be stored */
-	typedef CHashTableT<Titem_, Thash_bits_closed_> CClosedList;
-	/** how the priority queue will be managed */
-	typedef CBinaryHeapT<Titem_> CPriorityQueue;
 
 protected:
-	/** here we store full item data (Titem_) */
+	CItemArray      m_arr;        ///< Here we store full item data (Titem_).
-	CItemArray            m_arr;
+	COpenList       m_open;       ///< Hash table of pointers to open item data.
-	/** hash table of pointers to open item data */
+	CClosedList     m_closed;     ///< Hash table of pointers to closed item data.
-	COpenList             m_open;
+	CPriorityQueue  m_open_queue; ///< Priority queue of pointers to open item data.
-	/** hash table of pointers to closed item data */
+	Titem          *m_new_node;   ///< New open node under construction.
-	CClosedList           m_closed;
+
-	/** priority queue of pointers to open item data */
-	CPriorityQueue        m_open_queue;
-	/** new open node under construction */
-	Titem                *m_new_node;
 public:
 	/** default constructor */
-	CNodeList_HashTableT()
+	CNodeList_HashTableT() : m_open_queue(2048)
-		: m_open_queue(2048)
 	{
 		m_new_node = NULL;
 	}
@@ -81,7 +70,7 @@ public:
 	}
 
 	/** Notify the nodelist that we don't want to discard the given node. */
-	inline void FoundBestNode(Titem_& item)
+	inline void FoundBestNode(Titem_ &item)
 	{
 		/* for now it is enough to invalidate m_new_node if it is our given node */
 		if (&item == m_new_node) {
@@ -91,7 +80,7 @@ public:
 	}
 
 	/** insert given item as open node (into m_open and m_open_queue) */
-	inline void InsertOpenNode(Titem_& item)
+	inline void InsertOpenNode(Titem_ &item)
 	{
 		assert(m_closed.Find(item.GetKey()) == NULL);
 		m_open.Push(item);
@@ -122,39 +111,46 @@ public:
 	}
 
 	/** return the open node specified by a key or NULL if not found */
-	inline Titem_ *FindOpenNode(const Key& key)
+	inline Titem_ *FindOpenNode(const Key &key)
 	{
 		Titem_ *item = m_open.Find(key);
 		return item;
 	}
 
 	/** remove and return the open node specified by a key */
-	inline Titem_& PopOpenNode(const Key& key)
+	inline Titem_& PopOpenNode(const Key &key)
 	{
-		Titem_& item = m_open.Pop(key);
+		Titem_ &item = m_open.Pop(key);
 		uint idxPop = m_open_queue.FindIndex(item);
 		m_open_queue.Remove(idxPop);
 		return item;
 	}
 
 	/** close node */
-	inline void InsertClosedNode(Titem_& item)
+	inline void InsertClosedNode(Titem_ &item)
 	{
 		assert(m_open.Find(item.GetKey()) == NULL);
 		m_closed.Push(item);
 	}
 
 	/** return the closed node specified by a key or NULL if not found */
-	inline Titem_ *FindClosedNode(const Key& key)
+	inline Titem_ *FindClosedNode(const Key &key)
 	{
 		Titem_ *item = m_closed.Find(key);
 		return item;
 	}
 
 	/** The number of items. */
-	inline int TotalCount() {return m_arr.Length();}
+	inline int TotalCount()
+	{
+		return m_arr.Length();
+	}
+
 	/** Get a particular item. */
-	inline Titem_& ItemAt(int idx) {return m_arr[idx];}
+	inline Titem_& ItemAt(int idx)
+	{
+		return m_arr[idx];
+	}
 
 	/** Helper for creating output of this array. */
 	template <class D> void Dump(D &dmp) const

src/pathfinder/yapf/yapf_base.hpp

@@ -38,10 +38,10 @@ extern int _total_pf_time_us;
  *  --------------------------------------------------------------
  *  Your pathfinder derived class needs to implement following methods:
  *    inline void PfSetStartupNodes()
- *    inline void PfFollowNode(Node& org)
+ *    inline void PfFollowNode(Node &org)
- *    inline bool PfCalcCost(Node& n)
+ *    inline bool PfCalcCost(Node &n)
- *    inline bool PfCalcEstimate(Node& n)
+ *    inline bool PfCalcEstimate(Node &n)
- *    inline bool PfDetectDestination(Node& n)
+ *    inline bool PfDetectDestination(Node &n)
  *
  *  For more details about those methods, look at the end of CYapfBaseT
  *  declaration. There are some examples. For another example look at
@@ -99,7 +99,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -193,12 +193,12 @@ public:
 	 */
 	inline Node& CreateNewNode()
 	{
-		Node& node = *m_nodes.CreateNewNode();
+		Node &node = *m_nodes.CreateNewNode();
 		return node;
 	}
 
 	/** Add new node (created by CreateNewNode and filled with data) into open list */
-	inline void AddStartupNode(Node& n)
+	inline void AddStartupNode(Node &n)
 	{
 		Yapf().PfNodeCacheFetch(n);
 		/* insert the new node only if it is not there */
@@ -217,7 +217,7 @@ public:
 		bool is_choice = (KillFirstBit(tf.m_new_td_bits) != TRACKDIR_BIT_NONE);
 		for (TrackdirBits rtds = tf.m_new_td_bits; rtds != TRACKDIR_BIT_NONE; rtds = KillFirstBit(rtds)) {
 			Trackdir td = (Trackdir)FindFirstBit2x64(rtds);
-			Node& n = Yapf().CreateNewNode();
+			Node &n = Yapf().CreateNewNode();
 			n.Set(parent, tf.m_new_tile, td, is_choice);
 			Yapf().AddNewNode(n, tf);
 		}
@@ -333,7 +333,7 @@ public:
 	inline void PfSetStartupNodes()
 	{
 		/* example: */
-		Node& n1 = *base::m_nodes.CreateNewNode();
+		Node &n1 = *base::m_nodes.CreateNewNode();
 		.
 		. // setup node members here
 		.
@@ -341,10 +341,10 @@ public:
 	}
 
 	/** Example: PfFollowNode() - set following (child) nodes of the given node */
-	inline void PfFollowNode(Node& org)
+	inline void PfFollowNode(Node &org)
 	{
 		for (each follower of node org) {
-			Node& n = *base::m_nodes.CreateNewNode();
+			Node &n = *base::m_nodes.CreateNewNode();
 			.
 			. // setup node members here
 			.
@@ -354,7 +354,7 @@ public:
 	}
 
 	/** Example: PfCalcCost() - set path cost from origin to the given node */
-	inline bool PfCalcCost(Node& n)
+	inline bool PfCalcCost(Node &n)
 	{
 		/* evaluate last step cost */
 		int cost = ...;
@@ -364,7 +364,7 @@ public:
 	}
 
 	/** Example: PfCalcEstimate() - set path cost estimate from origin to the target through given node */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		/* evaluate the distance to our destination */
 		int distance = ...;
@@ -374,7 +374,7 @@ public:
 	}
 
 	/** Example: PfDetectDestination() - return true if the given node is our destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = (n.m_key.m_x == m_x2) && (n.m_key.m_y == m_y2);
 		return bDest;

src/pathfinder/yapf/yapf_common.hpp

@@ -28,7 +28,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -45,7 +45,7 @@ public:
 		bool is_choice = (KillFirstBit(m_orgTrackdirs) != TRACKDIR_BIT_NONE);
 		for (TrackdirBits tdb = m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = KillFirstBit(tdb)) {
 			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);
-			Node& n1 = Yapf().CreateNewNode();
+			Node &n1 = Yapf().CreateNewNode();
 			n1.Set(NULL, m_orgTile, td, is_choice);
 			Yapf().AddStartupNode(n1);
 		}
@@ -72,7 +72,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -91,12 +91,12 @@ public:
 	void PfSetStartupNodes()
 	{
 		if (m_orgTile != INVALID_TILE && m_orgTd != INVALID_TRACKDIR) {
-			Node& n1 = Yapf().CreateNewNode();
+			Node &n1 = Yapf().CreateNewNode();
 			n1.Set(NULL, m_orgTile, m_orgTd, false);
 			Yapf().AddStartupNode(n1);
 		}
 		if (m_revTile != INVALID_TILE && m_revTd != INVALID_TRACKDIR) {
-			Node& n2 = Yapf().CreateNewNode();
+			Node &n2 = Yapf().CreateNewNode();
 			n2.Set(NULL, m_revTile, m_revTd, false);
 			n2.m_cost = m_reverse_penalty;
 			Yapf().AddStartupNode(n2);
@@ -135,12 +135,12 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = (n.m_key.m_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetTrackdir())) != TRACKDIR_BIT_NONE);
 		return bDest;
@@ -150,7 +150,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};

src/pathfinder/yapf/yapf_costcache.hpp

@@ -30,7 +30,7 @@ public:
 	 * Called by YAPF to attach cached or local segment cost data to the given node.
 	 *  @return true if globally cached data were used or false if local data was used
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		return false;
 	}
@@ -39,7 +39,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };
@@ -67,7 +67,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -75,7 +75,7 @@ public:
 	 * Called by YAPF to attach cached or local segment cost data to the given node.
 	 *  @return true if globally cached data were used or false if local data was used
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		CacheKey key(n.GetKey());
 		Yapf().ConnectNodeToCachedData(n, *new (m_local_cache.Append()) CachedData(key));
@@ -86,7 +86,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };
@@ -121,9 +121,7 @@ struct CSegmentCostCacheBase
  *  Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example
  */
 template <class Tsegment>
-struct CSegmentCostCacheT
+struct CSegmentCostCacheT : public CSegmentCostCacheBase {
-	: public CSegmentCostCacheBase
-{
 	static const int C_HASH_BITS = 14;
 
 	typedef CHashTableT<Tsegment, C_HASH_BITS> HashTable;
@@ -142,7 +140,7 @@ struct CSegmentCostCacheT
 		m_heap.Clear();
 	}
 
-	inline Tsegment& Get(Key& key, bool *found)
+	inline Tsegment& Get(Key &key, bool *found)
 	{
 		Tsegment *item = m_map.Find(key);
 		if (item == NULL) {
@@ -162,9 +160,7 @@ struct CSegmentCostCacheT
  *  segment cost caching services for your Nodes.
  */
 template <class Types>
-class CYapfSegmentCostCacheGlobalT
+class CYapfSegmentCostCacheGlobalT : public CYapfSegmentCostCacheLocalT<Types> {
-	: public CYapfSegmentCostCacheLocalT<Types>
-{
 public:
 	typedef CYapfSegmentCostCacheLocalT<Types> Tlocal;
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
@@ -175,14 +171,14 @@ public:
 	typedef CSegmentCostCacheT<CachedData> Cache;
 
 protected:
-	Cache&      m_global_cache;
+	Cache &m_global_cache;
 
 	inline CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};
 
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	inline static Cache& stGetGlobalCache()
@@ -211,14 +207,14 @@ public:
 	 * Called by YAPF to attach cached or local segment cost data to the given node.
 	 *  @return true if globally cached data were used or false if local data was used
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		if (!Yapf().CanUseGlobalCache(n)) {
 			return Tlocal::PfNodeCacheFetch(n);
 		}
 		CacheKey key(n.GetKey());
 		bool found;
-		CachedData& item = m_global_cache.Get(key, &found);
+		CachedData &item = m_global_cache.Get(key, &found);
 		Yapf().ConnectNodeToCachedData(n, item);
 		return found;
 	}
@@ -227,7 +223,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };

src/pathfinder/yapf/yapf_costrail.hpp

@@ -15,9 +15,7 @@
 #include "../../pbs.h"
 
 template <class Types>
-class CYapfCostRailT
+class CYapfCostRailT : public CYapfCostBase {
-	: public CYapfCostBase
-{
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	typedef typename Types::TrackFollower TrackFollower;
@@ -74,10 +72,7 @@ protected:
 
 	static const int s_max_segment_cost = 10000;
 
-	CYapfCostRailT()
+	CYapfCostRailT() : m_max_cost(0), m_disable_cache(false), m_stopped_on_first_two_way_signal(false)
-		: m_max_cost(0)
-		, m_disable_cache(false)
-		, m_stopped_on_first_two_way_signal(false)
 	{
 		/* pre-compute look-ahead penalties into array */
 		int p0 = Yapf().PfGetSettings().rail_look_ahead_signal_p0;
@@ -92,7 +87,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -130,7 +125,7 @@ public:
 	}
 
 	/** Return one tile cost (base cost + level crossing penalty). */
-	inline int OneTileCost(TileIndex& tile, Trackdir trackdir)
+	inline int OneTileCost(TileIndex &tile, Trackdir trackdir)
 	{
 		int cost = 0;
 		/* set base cost */
@@ -165,7 +160,7 @@ public:
 	}
 
 	/** The cost for reserved tiles, including skipped ones. */
-	inline int ReservationCost(Node& n, TileIndex tile, Trackdir trackdir, int skipped)
+	inline int ReservationCost(Node &n, TileIndex tile, Trackdir trackdir, int skipped)
 	{
 		if (n.m_num_signals_passed >= m_sig_look_ahead_costs.Size() / 2) return 0;
 		if (!IsPbsSignal(n.m_last_signal_type)) return 0;
@@ -180,7 +175,7 @@ public:
 		return 0;
 	}
 
-	int SignalCost(Node& n, TileIndex tile, Trackdir trackdir)
+	int SignalCost(Node &n, TileIndex tile, Trackdir trackdir)
 	{
 		int cost = 0;
 		/* if there is one-way signal in the opposite direction, then it is not our way */
@@ -614,14 +609,14 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
 		return true;
 	}
 
-	inline bool CanUseGlobalCache(Node& n) const
+	inline bool CanUseGlobalCache(Node &n) const
 	{
 		return !m_disable_cache
 			&& (n.m_parent != NULL)
 			&& (n.m_parent->m_num_signals_passed >= m_sig_look_ahead_costs.Size());
 	}
 
-	inline void ConnectNodeToCachedData(Node& n, CachedData& ci)
+	inline void ConnectNodeToCachedData(Node &n, CachedData &ci)
 	{
 		n.m_segment = &ci;
 		if (n.m_segment->m_cost < 0) {

src/pathfinder/yapf/yapf_destrail.hpp

@@ -12,8 +12,7 @@
 #ifndef YAPF_DESTRAIL_HPP
 #define YAPF_DESTRAIL_HPP
 
-class CYapfDestinationRailBase
+class CYapfDestinationRailBase {
-{
 protected:
 	RailTypes m_compatible_railtypes;
 
@@ -36,9 +35,7 @@ public:
 };
 
 template <class Types>
-class CYapfDestinationAnyDepotRailT
+class CYapfDestinationAnyDepotRailT : public CYapfDestinationRailBase {
-	: public CYapfDestinationRailBase
-{
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
@@ -47,11 +44,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -67,7 +64,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -75,9 +72,7 @@ public:
 };
 
 template <class Types>
-class CYapfDestinationAnySafeTileRailT
+class CYapfDestinationAnySafeTileRailT : public CYapfDestinationRailBase {
-	: public CYapfDestinationRailBase
-{
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
@@ -87,11 +82,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -107,7 +102,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate.
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -115,9 +110,7 @@ public:
 };
 
 template <class Types>
-class CYapfDestinationTileOrStationRailT
+class CYapfDestinationTileOrStationRailT : public CYapfDestinationRailBase {
-	: public CYapfDestinationRailBase
-{
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
@@ -131,7 +124,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -164,7 +157,7 @@ public:
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -188,7 +181,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};

src/pathfinder/yapf/yapf_node.hpp

@@ -25,8 +25,15 @@ struct CYapfNodeKeyExitDir {
 		m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td);
 	}
 
-	inline int CalcHash() const {return m_exitdir | (m_tile << 2);}
+	inline int CalcHash() const
-	inline bool operator == (const CYapfNodeKeyExitDir& other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);}
+	{
+		return m_exitdir | (m_tile << 2);
+	}
+
+	inline bool operator==(const CYapfNodeKeyExitDir &other) const
+	{
+		return m_tile == other.m_tile && m_exitdir == other.m_exitdir;
+	}
 
 	void Dump(DumpTarget &dmp) const
 	{
@@ -38,8 +45,15 @@ struct CYapfNodeKeyExitDir {
 
 struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir
 {
-	inline int CalcHash() const {return m_td | (m_tile << 4);}
+	inline int CalcHash() const
-	inline bool operator == (const CYapfNodeKeyTrackDir& other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);}
+	{
+		return m_td | (m_tile << 4);
+	}
+
+	inline bool operator==(const CYapfNodeKeyTrackDir &other) const
+	{
+		return m_tile == other.m_tile && m_td == other.m_td;
+	}
 };
 
 /** Yapf Node base */
@@ -63,14 +77,45 @@ struct CYapfNodeT {
 		m_estimate = 0;
 	}
 
-	inline Node *GetHashNext() {return m_hash_next;}
+	inline Node *GetHashNext()
-	inline void SetHashNext(Node *pNext) {m_hash_next = pNext;}
+	{
-	inline TileIndex GetTile() const {return m_key.m_tile;}
+		return m_hash_next;
-	inline Trackdir GetTrackdir() const {return m_key.m_td;}
+	}
-	inline const Tkey_& GetKey() const {return m_key;}
+
-	inline int GetCost() const {return m_cost;}
+	inline void SetHashNext(Node *pNext)
-	inline int GetCostEstimate() const {return m_estimate;}
+	{
-	inline bool operator < (const Node& other) const {return m_estimate < other.m_estimate;}
+		m_hash_next = pNext;
+	}
+
+	inline TileIndex GetTile() const
+	{
+		return m_key.m_tile;
+	}
+
+	inline Trackdir GetTrackdir() const
+	{
+		return m_key.m_td;
+	}
+
+	inline const Tkey_& GetKey() const
+	{
+		return m_key;
+	}
+
+	inline int GetCost() const
+	{
+		return m_cost;
+	}
+
+	inline int GetCostEstimate() const
+	{
+		return m_estimate;
+	}
+
+	inline bool operator<(const Node &other) const
+	{
+		return m_estimate < other.m_estimate;
+	}
 
 	void Dump(DumpTarget &dmp) const
 	{

src/pathfinder/yapf/yapf_node_rail.hpp

@@ -17,19 +17,19 @@ struct CYapfRailSegmentKey
 {
 	uint32    m_value;
 
-	inline CYapfRailSegmentKey(const CYapfRailSegmentKey& src) : m_value(src.m_value) {}
+	inline CYapfRailSegmentKey(const CYapfRailSegmentKey &src) : m_value(src.m_value) {}
 
-	inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir& node_key)
+	inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir &node_key)
 	{
 		Set(node_key);
 	}
 
-	inline void Set(const CYapfRailSegmentKey& src)
+	inline void Set(const CYapfRailSegmentKey &src)
 	{
 		m_value = src.m_value;
 	}
 
-	inline void Set(const CYapfNodeKeyTrackDir& node_key)
+	inline void Set(const CYapfNodeKeyTrackDir &node_key)
 	{
 		m_value = (((int)node_key.m_tile) << 4) | node_key.m_td;
 	}
@@ -49,7 +49,7 @@ struct CYapfRailSegmentKey
 		return (Trackdir)(m_value & 0x0F);
 	}
 
-	inline bool operator == (const CYapfRailSegmentKey& other) const
+	inline bool operator==(const CYapfRailSegmentKey &other) const
 	{
 		return m_value == other.m_value;
 	}
@@ -75,7 +75,7 @@ struct CYapfRailSegment
 	EndSegmentReasonBits   m_end_segment_reason;
 	CYapfRailSegment      *m_hash_next;
 
-	inline CYapfRailSegment(const CYapfRailSegmentKey& key)
+	inline CYapfRailSegment(const CYapfRailSegmentKey &key)
 		: m_key(key)
 		, m_last_tile(INVALID_TILE)
 		, m_last_td(INVALID_TRACKDIR)

src/pathfinder/yapf/yapf_node_road.hpp

@@ -14,13 +14,11 @@
 
 /** Yapf Node for road YAPF */
 template <class Tkey_>
-struct CYapfRoadNodeT
+struct CYapfRoadNodeT : CYapfNodeT<Tkey_, CYapfRoadNodeT<Tkey_> > {
-	: CYapfNodeT<Tkey_, CYapfRoadNodeT<Tkey_> >
-{
 	typedef CYapfNodeT<Tkey_, CYapfRoadNodeT<Tkey_> > base;
 
-	TileIndex       m_segment_last_tile;
+	TileIndex m_segment_last_tile;
-	Trackdir        m_segment_last_td;
+	Trackdir  m_segment_last_td;
 
 	void Set(CYapfRoadNodeT *parent, TileIndex tile, Trackdir td, bool is_choice)
 	{

src/pathfinder/yapf/yapf_node_ship.hpp

@@ -14,11 +14,7 @@
 
 /** Yapf Node for ships */
 template <class Tkey_>
-struct CYapfShipNodeT
+struct CYapfShipNodeT : CYapfNodeT<Tkey_, CYapfShipNodeT<Tkey_> > { };
-	: CYapfNodeT<Tkey_, CYapfShipNodeT<Tkey_> >
-{
-
-};
 
 /* now define two major node types (that differ by key type) */
 typedef CYapfShipNodeT<CYapfNodeKeyExitDir>  CYapfShipNodeExitDir;
@@ -28,5 +24,4 @@ typedef CYapfShipNodeT<CYapfNodeKeyTrackDir> CYapfShipNodeTrackDir;
 typedef CNodeList_HashTableT<CYapfShipNodeExitDir , 10, 12> CShipNodeListExitDir;
 typedef CNodeList_HashTableT<CYapfShipNodeTrackDir, 10, 12> CShipNodeListTrackDir;
 
-
 #endif /* YAPF_NODE_SHIP_HPP */

src/pathfinder/yapf/yapf_rail.cpp

@@ -48,7 +48,7 @@ protected:
 	/** to access inherited pathfinder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 private:
@@ -200,7 +200,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -209,7 +209,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
@@ -296,7 +296,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -305,7 +305,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks()) {
@@ -379,7 +379,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -388,7 +388,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
@@ -453,7 +453,7 @@ public:
 				this->FindSafePositionOnNode(pPrev);
 			}
 			/* return trackdir from the best origin node (one of start nodes) */
-			Node& best_next_node = *pPrev;
+			Node &best_next_node = *pPrev;
 			next_trackdir = best_next_node.GetTrackdir();
 
 			if (reserve_track && path_found) this->TryReservePath(target, pNode->GetLastTile());
@@ -502,7 +502,7 @@ public:
 		}
 
 		/* check if it was reversed origin */
-		Node& best_org_node = *pNode;
+		Node &best_org_node = *pNode;
 		bool reversed = (best_org_node.m_cost != 0);
 		return reversed;
 	}

src/pathfinder/yapf/yapf_road.cpp

@@ -30,7 +30,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	int SlopeCost(TileIndex tile, TileIndex next_tile, Trackdir trackdir)
@@ -102,7 +102,7 @@ public:
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member
 	 */
-	inline bool PfCalcCost(Node& n, const TrackFollower *tf)
+	inline bool PfCalcCost(Node &n, const TrackFollower *tf)
 	{
 		int segment_cost = 0;
 		uint tiles = 0;
@@ -179,11 +179,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = IsRoadDepotTile(n.m_segment_last_tile);
 		return bDest;
@@ -198,7 +198,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -242,12 +242,12 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
 	}
@@ -268,7 +268,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
@@ -309,7 +309,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -319,7 +319,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.m_segment_last_tile, old_node.m_segment_last_td)) {
@@ -373,7 +373,7 @@ public:
 				pNode = pNode->m_parent;
 			}
 			/* return trackdir from the best origin node (one of start nodes) */
-			Node& best_next_node = *pNode;
+			Node &best_next_node = *pNode;
 			assert(best_next_node.GetTile() == tile);
 			next_trackdir = best_next_node.GetTrackdir();
 		}

src/pathfinder/yapf/yapf_ship.cpp

@@ -31,7 +31,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -40,7 +40,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.m_key.m_tile, old_node.m_key.m_td)) {
@@ -97,7 +97,7 @@ public:
 				pNode = pNode->m_parent;
 			}
 			/* return trackdir from the best next node (direct child of origin) */
-			Node& best_next_node = *pPrevNode;
+			Node &best_next_node = *pPrevNode;
 			assert(best_next_node.GetTile() == tile);
 			next_trackdir = best_next_node.GetTrackdir();
 		}
@@ -155,7 +155,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -164,7 +164,7 @@ public:
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member
 	 */
-	inline bool PfCalcCost(Node& n, const TrackFollower *tf)
+	inline bool PfCalcCost(Node &n, const TrackFollower *tf)
 	{
 		/* base tile cost depending on distance */
 		int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH;

src/timetable_cmd.cpp

@@ -95,6 +95,7 @@ static void ChangeTimetable(Vehicle *v, VehicleOrderID order_number, uint16 val,
  * - p1 = (bit  0-19) - Vehicle with the orders to change.
  * - p1 = (bit 20-27) - Order index to modify.
  * - p1 = (bit 28-29) - Timetable data to change (@see ModifyTimetableFlags)
+ * - p1 = (bit    30) - 0 to set timetable wait/travel time, 1 to clear it
  * @param p2 The amount of time to wait.
  * - p2 = (bit  0-15) - The data to modify as specified by p1 bits 28-29.
  *                      0 to clear times, UINT16_MAX to clear speed limit.
@@ -118,16 +119,20 @@ CommandCost CmdChangeTimetable(TileIndex tile, DoCommandFlag flags, uint32 p1, u
 	ModifyTimetableFlags mtf = Extract<ModifyTimetableFlags, 28, 2>(p1);
 	if (mtf >= MTF_END) return CMD_ERROR;
 
+	bool clear_field = GB(p1, 30, 1) == 1;
+
 	int wait_time   = order->GetWaitTime();
 	int travel_time = order->GetTravelTime();
 	int max_speed   = order->GetMaxSpeed();
 	switch (mtf) {
 		case MTF_WAIT_TIME:
 			wait_time = GB(p2, 0, 16);
+			if (clear_field) assert(wait_time == 0);
 			break;
 
 		case MTF_TRAVEL_TIME:
 			travel_time = GB(p2, 0, 16);
+			if (clear_field) assert(travel_time == 0);
 			break;
 
 		case MTF_TRAVEL_SPEED:
@@ -159,15 +164,15 @@ CommandCost CmdChangeTimetable(TileIndex tile, DoCommandFlag flags, uint32 p1, u
 		switch (mtf) {
 			case MTF_WAIT_TIME:
 				/* Set time if changing the value or confirming an estimated time as timetabled. */
-				if (wait_time != order->GetWaitTime() || (wait_time > 0 && !order->IsWaitTimetabled())) {
+				if (wait_time != order->GetWaitTime() || (clear_field == order->IsWaitTimetabled())) {
-					ChangeTimetable(v, order_number, wait_time, MTF_WAIT_TIME, wait_time > 0);
+					ChangeTimetable(v, order_number, wait_time, MTF_WAIT_TIME, !clear_field);
 				}
 				break;
 
 			case MTF_TRAVEL_TIME:
 				/* Set time if changing the value or confirming an estimated time as timetabled. */
-				if (travel_time != order->GetTravelTime() || (travel_time > 0 && !order->IsTravelTimetabled())) {
+				if (travel_time != order->GetTravelTime() || (clear_field == order->IsTravelTimetabled())) {
-					ChangeTimetable(v, order_number, travel_time, MTF_TRAVEL_TIME, travel_time > 0);
+					ChangeTimetable(v, order_number, travel_time, MTF_TRAVEL_TIME, !clear_field);
 				}
 				break;
 
@@ -436,6 +441,27 @@ CommandCost CmdAutomateTimetable(TileIndex index, DoCommandFlag flags, uint32 p1
 	return CommandCost();
 }
 
+static inline bool IsOrderUsableForSeparation(const Order *order)
+{
+	if (order->IsType(OT_CONDITIONAL)) {
+		// Auto separation is unlikely to useful work at all if one of these is present, so give up
+		return false;
+	}
+
+	if (order->GetWaitTime() == 0 && order->IsType(OT_GOTO_STATION)) {
+		// non-station orders are permitted to have 0 wait times
+		return false;
+	}
+
+	if (order->GetTravelTime() == 0 && !order->IsTravelTimetabled()) {
+		// 0 travel times are permitted, if explicitly timetabled
+		// this is useful for depot service orders
+		return false;
+	}
+
+	return true;
+}
+
 int TimeToFinishOrder(Vehicle *v, int n)
 {
 	int left;
@@ -443,8 +469,8 @@ int TimeToFinishOrder(Vehicle *v, int n)
 	int wait_time   = order->GetWaitTime();
 	int travel_time = order->GetTravelTime();
 	assert(order != NULL);
+	if (!IsOrderUsableForSeparation(order)) return -1;
 	if ((v->cur_real_order_index == n) && (v->last_station_visited == order->GetDestination())) {
-		if (wait_time == 0) return -1;
 		if (v->current_loading_time > 0) {
 			left = wait_time - v->current_order_time;
 		} else {
@@ -454,7 +480,6 @@ int TimeToFinishOrder(Vehicle *v, int n)
 	} else {
 		left = travel_time;
 		if (v->cur_real_order_index == n) left -= v->current_order_time;
-		if (travel_time == 0 || wait_time == 0) return -1;
 		if (left < 0) left = 0;
 		left +=wait_time;
 	}
@@ -481,10 +506,8 @@ int SeparationBetween(Vehicle *v1, Vehicle *v2)
 	if (time < 0) {
 		for (n = 0; n < v1->GetNumOrders(); n++) {
 			Order *order = v1->GetOrder(n);
-			int wait_time   = order->GetWaitTime();
+			if (!IsOrderUsableForSeparation(order)) return -1;
-			int travel_time = order->GetTravelTime();
+			time += order->GetTravelTime() + order->GetWaitTime();
-			if (travel_time == 0 || wait_time == 0) return -1;
-			time += travel_time + wait_time;
 		}
 	}
 	separation += time;

src/timetable_gui.cpp

@@ -510,14 +510,14 @@ struct TimetableWindow : Window {
 		}
 	}
 
-	static inline uint32 PackTimetableArgs(const Vehicle *v, uint selected, bool speed)
+	static inline uint32 PackTimetableArgs(const Vehicle *v, uint selected, bool speed, bool clear = false)
 	{
 		uint order_number = (selected + 1) / 2;
 		ModifyTimetableFlags mtf = (selected % 2 == 1) ? (speed ? MTF_TRAVEL_SPEED : MTF_TRAVEL_TIME) : MTF_WAIT_TIME;
 
 		if (order_number >= v->GetNumOrders()) order_number = 0;
 
-		return v->index | (order_number << 20) | (mtf << 28);
+		return v->index | (order_number << 20) | (mtf << 28) | (clear ? 1 << 30 : 0);
 	}
 
 	virtual void OnClick(Point pt, int widget, int click_count)
@@ -586,7 +586,7 @@ struct TimetableWindow : Window {
 			}
 
 			case WID_VT_CLEAR_TIME: { // Clear waiting time.
-				uint32 p1 = PackTimetableArgs(v, this->sel_index, false);
+				uint32 p1 = PackTimetableArgs(v, this->sel_index, false, true);
 				DoCommandP(0, p1, 0, CMD_CHANGE_TIMETABLE | CMD_MSG(STR_ERROR_CAN_T_TIMETABLE_VEHICLE));
 				break;
 			}